✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverClient.h

@@ -0,0 +1,952 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverErrors.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/route53resolver/model/AssociateResolverEndpointIpAddressResult.h>
+#include <aws/route53resolver/model/AssociateResolverRuleResult.h>
+#include <aws/route53resolver/model/CreateResolverEndpointResult.h>
+#include <aws/route53resolver/model/CreateResolverRuleResult.h>
+#include <aws/route53resolver/model/DeleteResolverEndpointResult.h>
+#include <aws/route53resolver/model/DeleteResolverRuleResult.h>
+#include <aws/route53resolver/model/DisassociateResolverEndpointIpAddressResult.h>
+#include <aws/route53resolver/model/DisassociateResolverRuleResult.h>
+#include <aws/route53resolver/model/GetResolverEndpointResult.h>
+#include <aws/route53resolver/model/GetResolverRuleResult.h>
+#include <aws/route53resolver/model/GetResolverRuleAssociationResult.h>
+#include <aws/route53resolver/model/GetResolverRulePolicyResult.h>
+#include <aws/route53resolver/model/ListResolverEndpointIpAddressesResult.h>
+#include <aws/route53resolver/model/ListResolverEndpointsResult.h>
+#include <aws/route53resolver/model/ListResolverRuleAssociationsResult.h>
+#include <aws/route53resolver/model/ListResolverRulesResult.h>
+#include <aws/route53resolver/model/ListTagsForResourceResult.h>
+#include <aws/route53resolver/model/PutResolverRulePolicyResult.h>
+#include <aws/route53resolver/model/TagResourceResult.h>
+#include <aws/route53resolver/model/UntagResourceResult.h>
+#include <aws/route53resolver/model/UpdateResolverEndpointResult.h>
+#include <aws/route53resolver/model/UpdateResolverRuleResult.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/http/HttpTypes.h>
+#include <future>
+#include <functional>
+
+namespace Aws
+{
+
+namespace Http
+{
+  class HttpClient;
+  class HttpClientFactory;
+} // namespace Http
+
+namespace Utils
+{
+  template< typename R, typename E> class Outcome;
+namespace Threading
+{
+  class Executor;
+} // namespace Threading
+} // namespace Utils
+
+namespace Auth
+{
+  class AWSCredentials;
+  class AWSCredentialsProvider;
+} // namespace Auth
+
+namespace Client
+{
+  class RetryStrategy;
+} // namespace Client
+
+namespace Route53Resolver
+{
+
+namespace Model
+{
+        class AssociateResolverEndpointIpAddressRequest;
+        class AssociateResolverRuleRequest;
+        class CreateResolverEndpointRequest;
+        class CreateResolverRuleRequest;
+        class DeleteResolverEndpointRequest;
+        class DeleteResolverRuleRequest;
+        class DisassociateResolverEndpointIpAddressRequest;
+        class DisassociateResolverRuleRequest;
+        class GetResolverEndpointRequest;
+        class GetResolverRuleRequest;
+        class GetResolverRuleAssociationRequest;
+        class GetResolverRulePolicyRequest;
+        class ListResolverEndpointIpAddressesRequest;
+        class ListResolverEndpointsRequest;
+        class ListResolverRuleAssociationsRequest;
+        class ListResolverRulesRequest;
+        class ListTagsForResourceRequest;
+        class PutResolverRulePolicyRequest;
+        class TagResourceRequest;
+        class UntagResourceRequest;
+        class UpdateResolverEndpointRequest;
+        class UpdateResolverRuleRequest;
+
+        typedef Aws::Utils::Outcome<AssociateResolverEndpointIpAddressResult, Route53ResolverError> AssociateResolverEndpointIpAddressOutcome;
+        typedef Aws::Utils::Outcome<AssociateResolverRuleResult, Route53ResolverError> AssociateResolverRuleOutcome;
+        typedef Aws::Utils::Outcome<CreateResolverEndpointResult, Route53ResolverError> CreateResolverEndpointOutcome;
+        typedef Aws::Utils::Outcome<CreateResolverRuleResult, Route53ResolverError> CreateResolverRuleOutcome;
+        typedef Aws::Utils::Outcome<DeleteResolverEndpointResult, Route53ResolverError> DeleteResolverEndpointOutcome;
+        typedef Aws::Utils::Outcome<DeleteResolverRuleResult, Route53ResolverError> DeleteResolverRuleOutcome;
+        typedef Aws::Utils::Outcome<DisassociateResolverEndpointIpAddressResult, Route53ResolverError> DisassociateResolverEndpointIpAddressOutcome;
+        typedef Aws::Utils::Outcome<DisassociateResolverRuleResult, Route53ResolverError> DisassociateResolverRuleOutcome;
+        typedef Aws::Utils::Outcome<GetResolverEndpointResult, Route53ResolverError> GetResolverEndpointOutcome;
+        typedef Aws::Utils::Outcome<GetResolverRuleResult, Route53ResolverError> GetResolverRuleOutcome;
+        typedef Aws::Utils::Outcome<GetResolverRuleAssociationResult, Route53ResolverError> GetResolverRuleAssociationOutcome;
+        typedef Aws::Utils::Outcome<GetResolverRulePolicyResult, Route53ResolverError> GetResolverRulePolicyOutcome;
+        typedef Aws::Utils::Outcome<ListResolverEndpointIpAddressesResult, Route53ResolverError> ListResolverEndpointIpAddressesOutcome;
+        typedef Aws::Utils::Outcome<ListResolverEndpointsResult, Route53ResolverError> ListResolverEndpointsOutcome;
+        typedef Aws::Utils::Outcome<ListResolverRuleAssociationsResult, Route53ResolverError> ListResolverRuleAssociationsOutcome;
+        typedef Aws::Utils::Outcome<ListResolverRulesResult, Route53ResolverError> ListResolverRulesOutcome;
+        typedef Aws::Utils::Outcome<ListTagsForResourceResult, Route53ResolverError> ListTagsForResourceOutcome;
+        typedef Aws::Utils::Outcome<PutResolverRulePolicyResult, Route53ResolverError> PutResolverRulePolicyOutcome;
+        typedef Aws::Utils::Outcome<TagResourceResult, Route53ResolverError> TagResourceOutcome;
+        typedef Aws::Utils::Outcome<UntagResourceResult, Route53ResolverError> UntagResourceOutcome;
+        typedef Aws::Utils::Outcome<UpdateResolverEndpointResult, Route53ResolverError> UpdateResolverEndpointOutcome;
+        typedef Aws::Utils::Outcome<UpdateResolverRuleResult, Route53ResolverError> UpdateResolverRuleOutcome;
+
+        typedef std::future<AssociateResolverEndpointIpAddressOutcome> AssociateResolverEndpointIpAddressOutcomeCallable;
+        typedef std::future<AssociateResolverRuleOutcome> AssociateResolverRuleOutcomeCallable;
+        typedef std::future<CreateResolverEndpointOutcome> CreateResolverEndpointOutcomeCallable;
+        typedef std::future<CreateResolverRuleOutcome> CreateResolverRuleOutcomeCallable;
+        typedef std::future<DeleteResolverEndpointOutcome> DeleteResolverEndpointOutcomeCallable;
+        typedef std::future<DeleteResolverRuleOutcome> DeleteResolverRuleOutcomeCallable;
+        typedef std::future<DisassociateResolverEndpointIpAddressOutcome> DisassociateResolverEndpointIpAddressOutcomeCallable;
+        typedef std::future<DisassociateResolverRuleOutcome> DisassociateResolverRuleOutcomeCallable;
+        typedef std::future<GetResolverEndpointOutcome> GetResolverEndpointOutcomeCallable;
+        typedef std::future<GetResolverRuleOutcome> GetResolverRuleOutcomeCallable;
+        typedef std::future<GetResolverRuleAssociationOutcome> GetResolverRuleAssociationOutcomeCallable;
+        typedef std::future<GetResolverRulePolicyOutcome> GetResolverRulePolicyOutcomeCallable;
+        typedef std::future<ListResolverEndpointIpAddressesOutcome> ListResolverEndpointIpAddressesOutcomeCallable;
+        typedef std::future<ListResolverEndpointsOutcome> ListResolverEndpointsOutcomeCallable;
+        typedef std::future<ListResolverRuleAssociationsOutcome> ListResolverRuleAssociationsOutcomeCallable;
+        typedef std::future<ListResolverRulesOutcome> ListResolverRulesOutcomeCallable;
+        typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
+        typedef std::future<PutResolverRulePolicyOutcome> PutResolverRulePolicyOutcomeCallable;
+        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
+        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
+        typedef std::future<UpdateResolverEndpointOutcome> UpdateResolverEndpointOutcomeCallable;
+        typedef std::future<UpdateResolverRuleOutcome> UpdateResolverRuleOutcomeCallable;
+} // namespace Model
+
+  class Route53ResolverClient;
+
+    typedef std::function<void(const Route53ResolverClient*, const Model::AssociateResolverEndpointIpAddressRequest&, const Model::AssociateResolverEndpointIpAddressOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AssociateResolverEndpointIpAddressResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::AssociateResolverRuleRequest&, const Model::AssociateResolverRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AssociateResolverRuleResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::CreateResolverEndpointRequest&, const Model::CreateResolverEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateResolverEndpointResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::CreateResolverRuleRequest&, const Model::CreateResolverRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateResolverRuleResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::DeleteResolverEndpointRequest&, const Model::DeleteResolverEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteResolverEndpointResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::DeleteResolverRuleRequest&, const Model::DeleteResolverRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteResolverRuleResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::DisassociateResolverEndpointIpAddressRequest&, const Model::DisassociateResolverEndpointIpAddressOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisassociateResolverEndpointIpAddressResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::DisassociateResolverRuleRequest&, const Model::DisassociateResolverRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisassociateResolverRuleResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::GetResolverEndpointRequest&, const Model::GetResolverEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetResolverEndpointResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::GetResolverRuleRequest&, const Model::GetResolverRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetResolverRuleResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::GetResolverRuleAssociationRequest&, const Model::GetResolverRuleAssociationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetResolverRuleAssociationResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::GetResolverRulePolicyRequest&, const Model::GetResolverRulePolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetResolverRulePolicyResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::ListResolverEndpointIpAddressesRequest&, const Model::ListResolverEndpointIpAddressesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResolverEndpointIpAddressesResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::ListResolverEndpointsRequest&, const Model::ListResolverEndpointsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResolverEndpointsResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::ListResolverRuleAssociationsRequest&, const Model::ListResolverRuleAssociationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResolverRuleAssociationsResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::ListResolverRulesRequest&, const Model::ListResolverRulesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResolverRulesResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::PutResolverRulePolicyRequest&, const Model::PutResolverRulePolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutResolverRulePolicyResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::UpdateResolverEndpointRequest&, const Model::UpdateResolverEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateResolverEndpointResponseReceivedHandler;
+    typedef std::function<void(const Route53ResolverClient*, const Model::UpdateResolverRuleRequest&, const Model::UpdateResolverRuleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateResolverRuleResponseReceivedHandler;
+
+  /**
+   * <p>Here's how you set up to query an Amazon Route 53 private hosted zone from
+   * your network:</p> <ol> <li> <p>Connect your network to a VPC using AWS Direct
+   * Connect or a VPN.</p> </li> <li> <p>Run the following AWS CLI command to create
+   * a Resolver endpoint:</p> <p> <code>create-resolver-endpoint --name
+   * [endpoint_name] --direction INBOUND --creator-request-id [unique_string]
+   * --security-group-ids [security_group_with_inbound_rules] --ip-addresses
+   * SubnetId=[subnet_id] SubnetId=[subnet_id_in_different_AZ]</code> </p> <p>Note
+   * the resolver endpoint ID that appears in the response. You'll use it in step
+   * 3.</p> </li> <li> <p>Get the IP addresses for the Resolver endpoints:</p> <p>
+   * <code>get-resolver-endpoint --resolver-endpoint-id [resolver_endpoint_id]</code>
+   * </p> </li> <li> <p>In your network configuration, define the IP addresses that
+   * you got in step 3 as DNS servers.</p> <p>You can now query instance names in
+   * your VPCs and the names of records in your private hosted zone.</p> </li> </ol>
+   * <p>You can also perform the following operations using the AWS CLI:</p> <ul>
+   * <li> <p> <code>list-resolver-endpoints</code>: List all endpoints. The syntax
+   * includes options for pagination and filtering.</p> </li> <li> <p>
+   * <code>update-resolver-endpoints</code>: Add IP addresses to an endpoint or
+   * remove IP addresses from an endpoint. </p> </li> </ul> <p>To delete an endpoint,
+   * use the following AWS CLI command:</p> <p> <code>delete-resolver-endpoint
+   * --resolver-endpoint-id [resolver_endpoint_id]</code> </p>
+   */
+  class AWS_ROUTE53RESOLVER_API Route53ResolverClient : public Aws::Client::AWSJsonClient
+  {
+    public:
+      typedef Aws::Client::AWSJsonClient BASECLASS;
+
+       /**
+        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        Route53ResolverClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        Route53ResolverClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
+        * the default http client factory will be used
+        */
+        Route53ResolverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~Route53ResolverClient();
+
+
+        /**
+         * <p>Adds IP addresses to an inbound or an outbound resolver endpoint. If you want
+         * to adding more than one IP address, submit one
+         * <code>AssociateResolverEndpointIpAddress</code> request for each IP address.</p>
+         * <p>To remove an IP address from an endpoint, see
+         * <a>DisassociateResolverEndpointIpAddress</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/AssociateResolverEndpointIpAddress">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::AssociateResolverEndpointIpAddressOutcome AssociateResolverEndpointIpAddress(const Model::AssociateResolverEndpointIpAddressRequest& request) const;
+
+        /**
+         * <p>Adds IP addresses to an inbound or an outbound resolver endpoint. If you want
+         * to adding more than one IP address, submit one
+         * <code>AssociateResolverEndpointIpAddress</code> request for each IP address.</p>
+         * <p>To remove an IP address from an endpoint, see
+         * <a>DisassociateResolverEndpointIpAddress</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/AssociateResolverEndpointIpAddress">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::AssociateResolverEndpointIpAddressOutcomeCallable AssociateResolverEndpointIpAddressCallable(const Model::AssociateResolverEndpointIpAddressRequest& request) const;
+
+        /**
+         * <p>Adds IP addresses to an inbound or an outbound resolver endpoint. If you want
+         * to adding more than one IP address, submit one
+         * <code>AssociateResolverEndpointIpAddress</code> request for each IP address.</p>
+         * <p>To remove an IP address from an endpoint, see
+         * <a>DisassociateResolverEndpointIpAddress</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/AssociateResolverEndpointIpAddress">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void AssociateResolverEndpointIpAddressAsync(const Model::AssociateResolverEndpointIpAddressRequest& request, const AssociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Associates a resolver rule with a VPC. When you associate a rule with a VPC,
+         * Resolver forwards all DNS queries for the domain name that is specified in the
+         * rule and that originate in the VPC. The queries are forwarded to the IP
+         * addresses for the DNS resolvers that are specified in the rule. For more
+         * information about rules, see <a>CreateResolverRule</a>. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/AssociateResolverRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::AssociateResolverRuleOutcome AssociateResolverRule(const Model::AssociateResolverRuleRequest& request) const;
+
+        /**
+         * <p>Associates a resolver rule with a VPC. When you associate a rule with a VPC,
+         * Resolver forwards all DNS queries for the domain name that is specified in the
+         * rule and that originate in the VPC. The queries are forwarded to the IP
+         * addresses for the DNS resolvers that are specified in the rule. For more
+         * information about rules, see <a>CreateResolverRule</a>. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/AssociateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::AssociateResolverRuleOutcomeCallable AssociateResolverRuleCallable(const Model::AssociateResolverRuleRequest& request) const;
+
+        /**
+         * <p>Associates a resolver rule with a VPC. When you associate a rule with a VPC,
+         * Resolver forwards all DNS queries for the domain name that is specified in the
+         * rule and that originate in the VPC. The queries are forwarded to the IP
+         * addresses for the DNS resolvers that are specified in the rule. For more
+         * information about rules, see <a>CreateResolverRule</a>. </p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/AssociateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void AssociateResolverRuleAsync(const Model::AssociateResolverRuleRequest& request, const AssociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Creates a resolver endpoint. There are two types of resolver endpoints,
+         * inbound and outbound:</p> <ul> <li> <p>An <i>inbound resolver endpoint</i>
+         * forwards DNS queries to the DNS service for a VPC from your network or another
+         * VPC.</p> </li> <li> <p>An <i>outbound resolver endpoint</i> forwards DNS queries
+         * from the DNS service for a VPC to your network or another VPC.</p> </li>
+         * </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/CreateResolverEndpoint">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateResolverEndpointOutcome CreateResolverEndpoint(const Model::CreateResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Creates a resolver endpoint. There are two types of resolver endpoints,
+         * inbound and outbound:</p> <ul> <li> <p>An <i>inbound resolver endpoint</i>
+         * forwards DNS queries to the DNS service for a VPC from your network or another
+         * VPC.</p> </li> <li> <p>An <i>outbound resolver endpoint</i> forwards DNS queries
+         * from the DNS service for a VPC to your network or another VPC.</p> </li>
+         * </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/CreateResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateResolverEndpointOutcomeCallable CreateResolverEndpointCallable(const Model::CreateResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Creates a resolver endpoint. There are two types of resolver endpoints,
+         * inbound and outbound:</p> <ul> <li> <p>An <i>inbound resolver endpoint</i>
+         * forwards DNS queries to the DNS service for a VPC from your network or another
+         * VPC.</p> </li> <li> <p>An <i>outbound resolver endpoint</i> forwards DNS queries
+         * from the DNS service for a VPC to your network or another VPC.</p> </li>
+         * </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/CreateResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateResolverEndpointAsync(const Model::CreateResolverEndpointRequest& request, const CreateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>For DNS queries that originate in your VPCs, specifies which resolver
+         * endpoint the queries pass through, one domain name that you want to forward to
+         * your network, and the IP addresses of the DNS resolvers in your
+         * network.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/CreateResolverRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateResolverRuleOutcome CreateResolverRule(const Model::CreateResolverRuleRequest& request) const;
+
+        /**
+         * <p>For DNS queries that originate in your VPCs, specifies which resolver
+         * endpoint the queries pass through, one domain name that you want to forward to
+         * your network, and the IP addresses of the DNS resolvers in your
+         * network.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/CreateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateResolverRuleOutcomeCallable CreateResolverRuleCallable(const Model::CreateResolverRuleRequest& request) const;
+
+        /**
+         * <p>For DNS queries that originate in your VPCs, specifies which resolver
+         * endpoint the queries pass through, one domain name that you want to forward to
+         * your network, and the IP addresses of the DNS resolvers in your
+         * network.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/CreateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateResolverRuleAsync(const Model::CreateResolverRuleRequest& request, const CreateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a resolver endpoint. The effect of deleting a resolver endpoint
+         * depends on whether it's an inbound or an outbound resolver endpoint:</p> <ul>
+         * <li> <p> <b>Inbound</b>: DNS queries from your network or another VPC are no
+         * longer routed to the DNS service for the specified VPC.</p> </li> <li> <p>
+         * <b>Outbound</b>: DNS queries from a VPC are no longer routed to your network or
+         * to another VPC.</p> </li> </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DeleteResolverEndpoint">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteResolverEndpointOutcome DeleteResolverEndpoint(const Model::DeleteResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Deletes a resolver endpoint. The effect of deleting a resolver endpoint
+         * depends on whether it's an inbound or an outbound resolver endpoint:</p> <ul>
+         * <li> <p> <b>Inbound</b>: DNS queries from your network or another VPC are no
+         * longer routed to the DNS service for the specified VPC.</p> </li> <li> <p>
+         * <b>Outbound</b>: DNS queries from a VPC are no longer routed to your network or
+         * to another VPC.</p> </li> </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DeleteResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteResolverEndpointOutcomeCallable DeleteResolverEndpointCallable(const Model::DeleteResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Deletes a resolver endpoint. The effect of deleting a resolver endpoint
+         * depends on whether it's an inbound or an outbound resolver endpoint:</p> <ul>
+         * <li> <p> <b>Inbound</b>: DNS queries from your network or another VPC are no
+         * longer routed to the DNS service for the specified VPC.</p> </li> <li> <p>
+         * <b>Outbound</b>: DNS queries from a VPC are no longer routed to your network or
+         * to another VPC.</p> </li> </ul><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DeleteResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteResolverEndpointAsync(const Model::DeleteResolverEndpointRequest& request, const DeleteResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Deletes a resolver rule. Before you can delete a resolver rule, you must
+         * disassociate it from all the VPCs that you associated the resolver rule with.
+         * For more infomation, see <a>DisassociateResolverRule</a>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DeleteResolverRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DeleteResolverRuleOutcome DeleteResolverRule(const Model::DeleteResolverRuleRequest& request) const;
+
+        /**
+         * <p>Deletes a resolver rule. Before you can delete a resolver rule, you must
+         * disassociate it from all the VPCs that you associated the resolver rule with.
+         * For more infomation, see <a>DisassociateResolverRule</a>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DeleteResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DeleteResolverRuleOutcomeCallable DeleteResolverRuleCallable(const Model::DeleteResolverRuleRequest& request) const;
+
+        /**
+         * <p>Deletes a resolver rule. Before you can delete a resolver rule, you must
+         * disassociate it from all the VPCs that you associated the resolver rule with.
+         * For more infomation, see <a>DisassociateResolverRule</a>.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DeleteResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DeleteResolverRuleAsync(const Model::DeleteResolverRuleRequest& request, const DeleteResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes IP addresses from an inbound or an outbound resolver endpoint. If you
+         * want to remove more than one IP address, submit one
+         * <code>DisassociateResolverEndpointIpAddress</code> request for each IP
+         * address.</p> <p>To add an IP address to an endpoint, see
+         * <a>AssociateResolverEndpointIpAddress</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DisassociateResolverEndpointIpAddress">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DisassociateResolverEndpointIpAddressOutcome DisassociateResolverEndpointIpAddress(const Model::DisassociateResolverEndpointIpAddressRequest& request) const;
+
+        /**
+         * <p>Removes IP addresses from an inbound or an outbound resolver endpoint. If you
+         * want to remove more than one IP address, submit one
+         * <code>DisassociateResolverEndpointIpAddress</code> request for each IP
+         * address.</p> <p>To add an IP address to an endpoint, see
+         * <a>AssociateResolverEndpointIpAddress</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DisassociateResolverEndpointIpAddress">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DisassociateResolverEndpointIpAddressOutcomeCallable DisassociateResolverEndpointIpAddressCallable(const Model::DisassociateResolverEndpointIpAddressRequest& request) const;
+
+        /**
+         * <p>Removes IP addresses from an inbound or an outbound resolver endpoint. If you
+         * want to remove more than one IP address, submit one
+         * <code>DisassociateResolverEndpointIpAddress</code> request for each IP
+         * address.</p> <p>To add an IP address to an endpoint, see
+         * <a>AssociateResolverEndpointIpAddress</a>.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DisassociateResolverEndpointIpAddress">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DisassociateResolverEndpointIpAddressAsync(const Model::DisassociateResolverEndpointIpAddressRequest& request, const DisassociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes the association between a specified resolver rule and a specified
+         * VPC.</p>  <p>If you disassociate a resolver rule from a VPC, Resolver
+         * stops forwarding DNS queries for the domain name that you specified in the
+         * resolver rule. </p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DisassociateResolverRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DisassociateResolverRuleOutcome DisassociateResolverRule(const Model::DisassociateResolverRuleRequest& request) const;
+
+        /**
+         * <p>Removes the association between a specified resolver rule and a specified
+         * VPC.</p>  <p>If you disassociate a resolver rule from a VPC, Resolver
+         * stops forwarding DNS queries for the domain name that you specified in the
+         * resolver rule. </p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DisassociateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DisassociateResolverRuleOutcomeCallable DisassociateResolverRuleCallable(const Model::DisassociateResolverRuleRequest& request) const;
+
+        /**
+         * <p>Removes the association between a specified resolver rule and a specified
+         * VPC.</p>  <p>If you disassociate a resolver rule from a VPC, Resolver
+         * stops forwarding DNS queries for the domain name that you specified in the
+         * resolver rule. </p> <p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/DisassociateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DisassociateResolverRuleAsync(const Model::DisassociateResolverRuleRequest& request, const DisassociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets information about a specified resolver endpoint, such as whether it's an
+         * inbound or an outbound resolver endpoint, and the current status of the
+         * endpoint.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverEndpoint">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetResolverEndpointOutcome GetResolverEndpoint(const Model::GetResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Gets information about a specified resolver endpoint, such as whether it's an
+         * inbound or an outbound resolver endpoint, and the current status of the
+         * endpoint.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetResolverEndpointOutcomeCallable GetResolverEndpointCallable(const Model::GetResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Gets information about a specified resolver endpoint, such as whether it's an
+         * inbound or an outbound resolver endpoint, and the current status of the
+         * endpoint.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetResolverEndpointAsync(const Model::GetResolverEndpointRequest& request, const GetResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets information about a specified resolver rule, such as the domain name
+         * that the rule forwards DNS queries for and the ID of the outbound resolver
+         * endpoint that the rule is associated with.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetResolverRuleOutcome GetResolverRule(const Model::GetResolverRuleRequest& request) const;
+
+        /**
+         * <p>Gets information about a specified resolver rule, such as the domain name
+         * that the rule forwards DNS queries for and the ID of the outbound resolver
+         * endpoint that the rule is associated with.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetResolverRuleOutcomeCallable GetResolverRuleCallable(const Model::GetResolverRuleRequest& request) const;
+
+        /**
+         * <p>Gets information about a specified resolver rule, such as the domain name
+         * that the rule forwards DNS queries for and the ID of the outbound resolver
+         * endpoint that the rule is associated with.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetResolverRuleAsync(const Model::GetResolverRuleRequest& request, const GetResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets information about an association between a specified resolver rule and a
+         * VPC. You associate a resolver rule and a VPC using <a>AssociateResolverRule</a>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRuleAssociation">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetResolverRuleAssociationOutcome GetResolverRuleAssociation(const Model::GetResolverRuleAssociationRequest& request) const;
+
+        /**
+         * <p>Gets information about an association between a specified resolver rule and a
+         * VPC. You associate a resolver rule and a VPC using <a>AssociateResolverRule</a>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRuleAssociation">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetResolverRuleAssociationOutcomeCallable GetResolverRuleAssociationCallable(const Model::GetResolverRuleAssociationRequest& request) const;
+
+        /**
+         * <p>Gets information about an association between a specified resolver rule and a
+         * VPC. You associate a resolver rule and a VPC using <a>AssociateResolverRule</a>.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRuleAssociation">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetResolverRuleAssociationAsync(const Model::GetResolverRuleAssociationRequest& request, const GetResolverRuleAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets information about a resolver rule policy. A resolver rule policy
+         * specifies the Resolver operations and resources that you want to allow another
+         * AWS account to be able to use. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRulePolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetResolverRulePolicyOutcome GetResolverRulePolicy(const Model::GetResolverRulePolicyRequest& request) const;
+
+        /**
+         * <p>Gets information about a resolver rule policy. A resolver rule policy
+         * specifies the Resolver operations and resources that you want to allow another
+         * AWS account to be able to use. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRulePolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetResolverRulePolicyOutcomeCallable GetResolverRulePolicyCallable(const Model::GetResolverRulePolicyRequest& request) const;
+
+        /**
+         * <p>Gets information about a resolver rule policy. A resolver rule policy
+         * specifies the Resolver operations and resources that you want to allow another
+         * AWS account to be able to use. </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/GetResolverRulePolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetResolverRulePolicyAsync(const Model::GetResolverRulePolicyRequest& request, const GetResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Gets the IP addresses for a specified resolver endpoint.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverEndpointIpAddresses">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListResolverEndpointIpAddressesOutcome ListResolverEndpointIpAddresses(const Model::ListResolverEndpointIpAddressesRequest& request) const;
+
+        /**
+         * <p>Gets the IP addresses for a specified resolver endpoint.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverEndpointIpAddresses">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListResolverEndpointIpAddressesOutcomeCallable ListResolverEndpointIpAddressesCallable(const Model::ListResolverEndpointIpAddressesRequest& request) const;
+
+        /**
+         * <p>Gets the IP addresses for a specified resolver endpoint.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverEndpointIpAddresses">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListResolverEndpointIpAddressesAsync(const Model::ListResolverEndpointIpAddressesRequest& request, const ListResolverEndpointIpAddressesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Lists all the resolver endpoints that were created using the current AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverEndpoints">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListResolverEndpointsOutcome ListResolverEndpoints(const Model::ListResolverEndpointsRequest& request) const;
+
+        /**
+         * <p>Lists all the resolver endpoints that were created using the current AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverEndpoints">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListResolverEndpointsOutcomeCallable ListResolverEndpointsCallable(const Model::ListResolverEndpointsRequest& request) const;
+
+        /**
+         * <p>Lists all the resolver endpoints that were created using the current AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverEndpoints">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListResolverEndpointsAsync(const Model::ListResolverEndpointsRequest& request, const ListResolverEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Lists the associations that were created between resolver rules and VPCs
+         * using the current AWS account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverRuleAssociations">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListResolverRuleAssociationsOutcome ListResolverRuleAssociations(const Model::ListResolverRuleAssociationsRequest& request) const;
+
+        /**
+         * <p>Lists the associations that were created between resolver rules and VPCs
+         * using the current AWS account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverRuleAssociations">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListResolverRuleAssociationsOutcomeCallable ListResolverRuleAssociationsCallable(const Model::ListResolverRuleAssociationsRequest& request) const;
+
+        /**
+         * <p>Lists the associations that were created between resolver rules and VPCs
+         * using the current AWS account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverRuleAssociations">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListResolverRuleAssociationsAsync(const Model::ListResolverRuleAssociationsRequest& request, const ListResolverRuleAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Lists the resolver rules that were created using the current AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverRules">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListResolverRulesOutcome ListResolverRules(const Model::ListResolverRulesRequest& request) const;
+
+        /**
+         * <p>Lists the resolver rules that were created using the current AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverRules">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListResolverRulesOutcomeCallable ListResolverRulesCallable(const Model::ListResolverRulesRequest& request) const;
+
+        /**
+         * <p>Lists the resolver rules that were created using the current AWS
+         * account.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListResolverRules">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListResolverRulesAsync(const Model::ListResolverRulesRequest& request, const ListResolverRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Lists the tags that you associated with the specified resource.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListTagsForResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Lists the tags that you associated with the specified resource.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListTagsForResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const Model::ListTagsForResourceRequest& request) const;
+
+        /**
+         * <p>Lists the tags that you associated with the specified resource.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ListTagsForResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void ListTagsForResourceAsync(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Specifies the Resolver operations and resources that you want to allow
+         * another AWS account to be able to use.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/PutResolverRulePolicy">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::PutResolverRulePolicyOutcome PutResolverRulePolicy(const Model::PutResolverRulePolicyRequest& request) const;
+
+        /**
+         * <p>Specifies the Resolver operations and resources that you want to allow
+         * another AWS account to be able to use.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/PutResolverRulePolicy">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::PutResolverRulePolicyOutcomeCallable PutResolverRulePolicyCallable(const Model::PutResolverRulePolicyRequest& request) const;
+
+        /**
+         * <p>Specifies the Resolver operations and resources that you want to allow
+         * another AWS account to be able to use.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/PutResolverRulePolicy">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void PutResolverRulePolicyAsync(const Model::PutResolverRulePolicyRequest& request, const PutResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Adds one or more tags to a specified resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/TagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Adds one or more tags to a specified resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/TagResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const;
+
+        /**
+         * <p>Adds one or more tags to a specified resource.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/TagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Removes one or more tags from a specified resource.</p><p><h3>See Also:</h3> 
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UntagResource">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes one or more tags from a specified resource.</p><p><h3>See Also:</h3> 
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;
+
+        /**
+         * <p>Removes one or more tags from a specified resource.</p><p><h3>See Also:</h3> 
+         * <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UntagResource">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Updates the name of an inbound or an outbound resolver endpoint.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UpdateResolverEndpoint">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateResolverEndpointOutcome UpdateResolverEndpoint(const Model::UpdateResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Updates the name of an inbound or an outbound resolver endpoint.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UpdateResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateResolverEndpointOutcomeCallable UpdateResolverEndpointCallable(const Model::UpdateResolverEndpointRequest& request) const;
+
+        /**
+         * <p>Updates the name of an inbound or an outbound resolver endpoint.
+         * </p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UpdateResolverEndpoint">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateResolverEndpointAsync(const Model::UpdateResolverEndpointRequest& request, const UpdateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Updates settings for a specified resolver rule. <code>ResolverRuleId</code>
+         * is required, and all other parameters are optional. If you don't specify a
+         * parameter, it retains its current value.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UpdateResolverRule">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::UpdateResolverRuleOutcome UpdateResolverRule(const Model::UpdateResolverRuleRequest& request) const;
+
+        /**
+         * <p>Updates settings for a specified resolver rule. <code>ResolverRuleId</code>
+         * is required, and all other parameters are optional. If you don't specify a
+         * parameter, it retains its current value.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UpdateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::UpdateResolverRuleOutcomeCallable UpdateResolverRuleCallable(const Model::UpdateResolverRuleRequest& request) const;
+
+        /**
+         * <p>Updates settings for a specified resolver rule. <code>ResolverRuleId</code>
+         * is required, and all other parameters are optional. If you don't specify a
+         * parameter, it retains its current value.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/UpdateResolverRule">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void UpdateResolverRuleAsync(const Model::UpdateResolverRuleRequest& request, const UpdateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+
+      void OverrideEndpoint(const Aws::String& endpoint);
+    private:
+      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
+        void AssociateResolverEndpointIpAddressAsyncHelper(const Model::AssociateResolverEndpointIpAddressRequest& request, const AssociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void AssociateResolverRuleAsyncHelper(const Model::AssociateResolverRuleRequest& request, const AssociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateResolverEndpointAsyncHelper(const Model::CreateResolverEndpointRequest& request, const CreateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void CreateResolverRuleAsyncHelper(const Model::CreateResolverRuleRequest& request, const CreateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteResolverEndpointAsyncHelper(const Model::DeleteResolverEndpointRequest& request, const DeleteResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DeleteResolverRuleAsyncHelper(const Model::DeleteResolverRuleRequest& request, const DeleteResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DisassociateResolverEndpointIpAddressAsyncHelper(const Model::DisassociateResolverEndpointIpAddressRequest& request, const DisassociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DisassociateResolverRuleAsyncHelper(const Model::DisassociateResolverRuleRequest& request, const DisassociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetResolverEndpointAsyncHelper(const Model::GetResolverEndpointRequest& request, const GetResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetResolverRuleAsyncHelper(const Model::GetResolverRuleRequest& request, const GetResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetResolverRuleAssociationAsyncHelper(const Model::GetResolverRuleAssociationRequest& request, const GetResolverRuleAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetResolverRulePolicyAsyncHelper(const Model::GetResolverRulePolicyRequest& request, const GetResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListResolverEndpointIpAddressesAsyncHelper(const Model::ListResolverEndpointIpAddressesRequest& request, const ListResolverEndpointIpAddressesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListResolverEndpointsAsyncHelper(const Model::ListResolverEndpointsRequest& request, const ListResolverEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListResolverRuleAssociationsAsyncHelper(const Model::ListResolverRuleAssociationsRequest& request, const ListResolverRuleAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListResolverRulesAsyncHelper(const Model::ListResolverRulesRequest& request, const ListResolverRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void ListTagsForResourceAsyncHelper(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void PutResolverRulePolicyAsyncHelper(const Model::PutResolverRulePolicyRequest& request, const PutResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateResolverEndpointAsyncHelper(const Model::UpdateResolverEndpointRequest& request, const UpdateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void UpdateResolverRuleAsyncHelper(const Model::UpdateResolverRuleRequest& request, const UpdateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+
+      Aws::String m_uri;
+      Aws::String m_configScheme;
+      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
+  };
+
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverEndpoint.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace Route53Resolver
+{
+namespace Route53ResolverEndpoint
+{
+AWS_ROUTE53RESOLVER_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace Route53ResolverEndpoint
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverErrorMarshaller.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_ROUTE53RESOLVER_API Route53ResolverErrorMarshaller : public Aws::Client::JsonErrorMarshaller
+{
+public:
+  Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
+};
+
+} // namespace Client
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverErrors.h

@@ -0,0 +1,82 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+enum class Route53ResolverErrors
+{
+  //From Core//
+  //////////////////////////////////////////////////////////////////////////////////////////
+  INCOMPLETE_SIGNATURE = 0,
+  INTERNAL_FAILURE = 1,
+  INVALID_ACTION = 2,
+  INVALID_CLIENT_TOKEN_ID = 3,
+  INVALID_PARAMETER_COMBINATION = 4,
+  INVALID_QUERY_PARAMETER = 5,
+  INVALID_PARAMETER_VALUE = 6,
+  MISSING_ACTION = 7, // SDK should never allow
+  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
+  MISSING_PARAMETER = 9, // SDK should never allow
+  OPT_IN_REQUIRED = 10,
+  REQUEST_EXPIRED = 11,
+  SERVICE_UNAVAILABLE = 12,
+  THROTTLING = 13,
+  VALIDATION = 14,
+  ACCESS_DENIED = 15,
+  RESOURCE_NOT_FOUND = 16,
+  UNRECOGNIZED_CLIENT = 17,
+  MALFORMED_QUERY_STRING = 18,
+  SLOW_DOWN = 19,
+  REQUEST_TIME_TOO_SKEWED = 20,
+  INVALID_SIGNATURE = 21,
+  SIGNATURE_DOES_NOT_MATCH = 22,
+  INVALID_ACCESS_KEY_ID = 23,
+  REQUEST_TIMEOUT = 24,
+  NETWORK_CONNECTION = 99,
+
+  UNKNOWN = 100,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  INTERNAL_SERVICE_ERROR= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  INVALID_NEXT_TOKEN,
+  INVALID_PARAMETER,
+  INVALID_POLICY_DOCUMENT,
+  INVALID_REQUEST,
+  INVALID_TAG,
+  LIMIT_EXCEEDED,
+  RESOURCE_EXISTS,
+  RESOURCE_IN_USE,
+  RESOURCE_UNAVAILABLE,
+  UNKNOWN_RESOURCE
+};
+
+class AWS_ROUTE53RESOLVER_API Route53ResolverError : public Aws::Client::AWSError<Route53ResolverErrors>
+{
+public:
+  Route53ResolverError() {}
+  Route53ResolverError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<Route53ResolverErrors>(rhs) {}
+  Route53ResolverError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<Route53ResolverErrors>(rhs) {}
+  Route53ResolverError(const Aws::Client::AWSError<Route53ResolverErrors>& rhs) : Aws::Client::AWSError<Route53ResolverErrors>(rhs) {}
+  Route53ResolverError(Aws::Client::AWSError<Route53ResolverErrors>&& rhs) : Aws::Client::AWSError<Route53ResolverErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace Route53ResolverErrorMapper
+{
+  AWS_ROUTE53RESOLVER_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverRequest.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+  class AWS_ROUTE53RESOLVER_API Route53ResolverRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~Route53ResolverRequest () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_1 ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2018-04-01"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53Resolver_EXPORTS.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#ifdef _MSC_VER
+    //disable windows complaining about max template size.
+    #pragma warning (disable : 4503)
+#endif // _MSC_VER
+
+#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
+    #ifdef _MSC_VER
+        #pragma warning(disable : 4251)
+    #endif // _MSC_VER
+
+    #ifdef USE_IMPORT_EXPORT
+        #ifdef AWS_ROUTE53RESOLVER_EXPORTS
+            #define AWS_ROUTE53RESOLVER_API __declspec(dllexport)
+        #else
+            #define AWS_ROUTE53RESOLVER_API __declspec(dllimport)
+        #endif /* AWS_ROUTE53RESOLVER_EXPORTS */
+    #else
+        #define AWS_ROUTE53RESOLVER_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_ROUTE53RESOLVER_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/AssociateResolverEndpointIpAddressRequest.h

@@ -0,0 +1,140 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/IpAddressUpdate.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API AssociateResolverEndpointIpAddressRequest : public Route53ResolverRequest
+  {
+  public:
+    AssociateResolverEndpointIpAddressRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "AssociateResolverEndpointIpAddress"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline AssociateResolverEndpointIpAddressRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline AssociateResolverEndpointIpAddressRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to associate IP addresses
+     * with.</p>
+     */
+    inline AssociateResolverEndpointIpAddressRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+
+    /**
+     * <p>Either the IPv4 address that you want to add to a resolver endpoint or a
+     * subnet ID. If you specify a subnet ID, Resolver chooses an IP address for you
+     * from the available IPs in the specified subnet.</p>
+     */
+    inline const IpAddressUpdate& GetIpAddress() const{ return m_ipAddress; }
+
+    /**
+     * <p>Either the IPv4 address that you want to add to a resolver endpoint or a
+     * subnet ID. If you specify a subnet ID, Resolver chooses an IP address for you
+     * from the available IPs in the specified subnet.</p>
+     */
+    inline bool IpAddressHasBeenSet() const { return m_ipAddressHasBeenSet; }
+
+    /**
+     * <p>Either the IPv4 address that you want to add to a resolver endpoint or a
+     * subnet ID. If you specify a subnet ID, Resolver chooses an IP address for you
+     * from the available IPs in the specified subnet.</p>
+     */
+    inline void SetIpAddress(const IpAddressUpdate& value) { m_ipAddressHasBeenSet = true; m_ipAddress = value; }
+
+    /**
+     * <p>Either the IPv4 address that you want to add to a resolver endpoint or a
+     * subnet ID. If you specify a subnet ID, Resolver chooses an IP address for you
+     * from the available IPs in the specified subnet.</p>
+     */
+    inline void SetIpAddress(IpAddressUpdate&& value) { m_ipAddressHasBeenSet = true; m_ipAddress = std::move(value); }
+
+    /**
+     * <p>Either the IPv4 address that you want to add to a resolver endpoint or a
+     * subnet ID. If you specify a subnet ID, Resolver chooses an IP address for you
+     * from the available IPs in the specified subnet.</p>
+     */
+    inline AssociateResolverEndpointIpAddressRequest& WithIpAddress(const IpAddressUpdate& value) { SetIpAddress(value); return *this;}
+
+    /**
+     * <p>Either the IPv4 address that you want to add to a resolver endpoint or a
+     * subnet ID. If you specify a subnet ID, Resolver chooses an IP address for you
+     * from the available IPs in the specified subnet.</p>
+     */
+    inline AssociateResolverEndpointIpAddressRequest& WithIpAddress(IpAddressUpdate&& value) { SetIpAddress(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+
+    IpAddressUpdate m_ipAddress;
+    bool m_ipAddressHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/AssociateResolverEndpointIpAddressResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API AssociateResolverEndpointIpAddressResult
+  {
+  public:
+    AssociateResolverEndpointIpAddressResult();
+    AssociateResolverEndpointIpAddressResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    AssociateResolverEndpointIpAddressResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The response to an <code>AssociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline const ResolverEndpoint& GetResolverEndpoint() const{ return m_resolverEndpoint; }
+
+    /**
+     * <p>The response to an <code>AssociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline void SetResolverEndpoint(const ResolverEndpoint& value) { m_resolverEndpoint = value; }
+
+    /**
+     * <p>The response to an <code>AssociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline void SetResolverEndpoint(ResolverEndpoint&& value) { m_resolverEndpoint = std::move(value); }
+
+    /**
+     * <p>The response to an <code>AssociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline AssociateResolverEndpointIpAddressResult& WithResolverEndpoint(const ResolverEndpoint& value) { SetResolverEndpoint(value); return *this;}
+
+    /**
+     * <p>The response to an <code>AssociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline AssociateResolverEndpointIpAddressResult& WithResolverEndpoint(ResolverEndpoint&& value) { SetResolverEndpoint(std::move(value)); return *this;}
+
+  private:
+
+    ResolverEndpoint m_resolverEndpoint;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/AssociateResolverRuleRequest.h

@@ -0,0 +1,189 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API AssociateResolverRuleRequest : public Route53ResolverRequest
+  {
+  public:
+    AssociateResolverRuleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "AssociateResolverRule"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline const Aws::String& GetResolverRuleId() const{ return m_resolverRuleId; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline bool ResolverRuleIdHasBeenSet() const { return m_resolverRuleIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline void SetResolverRuleId(const Aws::String& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = value; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline void SetResolverRuleId(Aws::String&& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline void SetResolverRuleId(const char* value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline AssociateResolverRuleRequest& WithResolverRuleId(const Aws::String& value) { SetResolverRuleId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline AssociateResolverRuleRequest& WithResolverRuleId(Aws::String&& value) { SetResolverRuleId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to associate with the VPC. To list
+     * the existing resolver rules, use <a>ListResolverRules</a>.</p>
+     */
+    inline AssociateResolverRuleRequest& WithResolverRuleId(const char* value) { SetResolverRuleId(value); return *this;}
+
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline AssociateResolverRuleRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline AssociateResolverRuleRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>A name for the association that you're creating between a resolver rule and a
+     * VPC.</p>
+     */
+    inline AssociateResolverRuleRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline const Aws::String& GetVPCId() const{ return m_vPCId; }
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline bool VPCIdHasBeenSet() const { return m_vPCIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline void SetVPCId(const Aws::String& value) { m_vPCIdHasBeenSet = true; m_vPCId = value; }
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline void SetVPCId(Aws::String&& value) { m_vPCIdHasBeenSet = true; m_vPCId = std::move(value); }
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline void SetVPCId(const char* value) { m_vPCIdHasBeenSet = true; m_vPCId.assign(value); }
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline AssociateResolverRuleRequest& WithVPCId(const Aws::String& value) { SetVPCId(value); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline AssociateResolverRuleRequest& WithVPCId(Aws::String&& value) { SetVPCId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you want to associate the resolver rule with.</p>
+     */
+    inline AssociateResolverRuleRequest& WithVPCId(const char* value) { SetVPCId(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverRuleId;
+    bool m_resolverRuleIdHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_vPCId;
+    bool m_vPCIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/AssociateResolverRuleResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRuleAssociation.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API AssociateResolverRuleResult
+  {
+  public:
+    AssociateResolverRuleResult();
+    AssociateResolverRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    AssociateResolverRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the <code>AssociateResolverRule</code> request, including
+     * the status of the request.</p>
+     */
+    inline const ResolverRuleAssociation& GetResolverRuleAssociation() const{ return m_resolverRuleAssociation; }
+
+    /**
+     * <p>Information about the <code>AssociateResolverRule</code> request, including
+     * the status of the request.</p>
+     */
+    inline void SetResolverRuleAssociation(const ResolverRuleAssociation& value) { m_resolverRuleAssociation = value; }
+
+    /**
+     * <p>Information about the <code>AssociateResolverRule</code> request, including
+     * the status of the request.</p>
+     */
+    inline void SetResolverRuleAssociation(ResolverRuleAssociation&& value) { m_resolverRuleAssociation = std::move(value); }
+
+    /**
+     * <p>Information about the <code>AssociateResolverRule</code> request, including
+     * the status of the request.</p>
+     */
+    inline AssociateResolverRuleResult& WithResolverRuleAssociation(const ResolverRuleAssociation& value) { SetResolverRuleAssociation(value); return *this;}
+
+    /**
+     * <p>Information about the <code>AssociateResolverRule</code> request, including
+     * the status of the request.</p>
+     */
+    inline AssociateResolverRuleResult& WithResolverRuleAssociation(ResolverRuleAssociation&& value) { SetResolverRuleAssociation(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRuleAssociation m_resolverRuleAssociation;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/CreateResolverEndpointRequest.h

@@ -0,0 +1,411 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/ResolverEndpointDirection.h>
+#include <aws/route53resolver/model/IpAddressRequest.h>
+#include <aws/route53resolver/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API CreateResolverEndpointRequest : public Route53ResolverRequest
+  {
+  public:
+    CreateResolverEndpointRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateResolverEndpoint"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline const Aws::String& GetCreatorRequestId() const{ return m_creatorRequestId; }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline bool CreatorRequestIdHasBeenSet() const { return m_creatorRequestIdHasBeenSet; }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline void SetCreatorRequestId(const Aws::String& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = value; }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline void SetCreatorRequestId(Aws::String&& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = std::move(value); }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline void SetCreatorRequestId(const char* value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId.assign(value); }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline CreateResolverEndpointRequest& WithCreatorRequestId(const Aws::String& value) { SetCreatorRequestId(value); return *this;}
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline CreateResolverEndpointRequest& WithCreatorRequestId(Aws::String&& value) { SetCreatorRequestId(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline CreateResolverEndpointRequest& WithCreatorRequestId(const char* value) { SetCreatorRequestId(value); return *this;}
+
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline CreateResolverEndpointRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline CreateResolverEndpointRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>A friendly name that lets you easily find a configuration in the Resolver
+     * dashboard in the Route 53 console.</p>
+     */
+    inline CreateResolverEndpointRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const{ return m_securityGroupIds; }
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline void SetSecurityGroupIds(const Aws::Vector<Aws::String>& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = value; }
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline void SetSecurityGroupIds(Aws::Vector<Aws::String>&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = std::move(value); }
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline CreateResolverEndpointRequest& WithSecurityGroupIds(const Aws::Vector<Aws::String>& value) { SetSecurityGroupIds(value); return *this;}
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline CreateResolverEndpointRequest& WithSecurityGroupIds(Aws::Vector<Aws::String>&& value) { SetSecurityGroupIds(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline CreateResolverEndpointRequest& AddSecurityGroupIds(const Aws::String& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline CreateResolverEndpointRequest& AddSecurityGroupIds(Aws::String&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The ID of one or more security groups that you want to use to control access
+     * to this VPC. The security group that you specify must include one or more
+     * inbound rules (for inbound resolver endpoints) or outbound rules (for outbound
+     * resolver endpoints).</p>
+     */
+    inline CreateResolverEndpointRequest& AddSecurityGroupIds(const char* value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>Specify the applicable value:</p> <ul> <li> <p> <code>INBOUND</code>:
+     * Resolver forwards DNS queries to the DNS service for a VPC from your network or
+     * another VPC</p> </li> <li> <p> <code>OUTBOUND</code>: Resolver forwards DNS
+     * queries from the DNS service for a VPC to your network or another VPC</p> </li>
+     * </ul>
+     */
+    inline const ResolverEndpointDirection& GetDirection() const{ return m_direction; }
+
+    /**
+     * <p>Specify the applicable value:</p> <ul> <li> <p> <code>INBOUND</code>:
+     * Resolver forwards DNS queries to the DNS service for a VPC from your network or
+     * another VPC</p> </li> <li> <p> <code>OUTBOUND</code>: Resolver forwards DNS
+     * queries from the DNS service for a VPC to your network or another VPC</p> </li>
+     * </ul>
+     */
+    inline bool DirectionHasBeenSet() const { return m_directionHasBeenSet; }
+
+    /**
+     * <p>Specify the applicable value:</p> <ul> <li> <p> <code>INBOUND</code>:
+     * Resolver forwards DNS queries to the DNS service for a VPC from your network or
+     * another VPC</p> </li> <li> <p> <code>OUTBOUND</code>: Resolver forwards DNS
+     * queries from the DNS service for a VPC to your network or another VPC</p> </li>
+     * </ul>
+     */
+    inline void SetDirection(const ResolverEndpointDirection& value) { m_directionHasBeenSet = true; m_direction = value; }
+
+    /**
+     * <p>Specify the applicable value:</p> <ul> <li> <p> <code>INBOUND</code>:
+     * Resolver forwards DNS queries to the DNS service for a VPC from your network or
+     * another VPC</p> </li> <li> <p> <code>OUTBOUND</code>: Resolver forwards DNS
+     * queries from the DNS service for a VPC to your network or another VPC</p> </li>
+     * </ul>
+     */
+    inline void SetDirection(ResolverEndpointDirection&& value) { m_directionHasBeenSet = true; m_direction = std::move(value); }
+
+    /**
+     * <p>Specify the applicable value:</p> <ul> <li> <p> <code>INBOUND</code>:
+     * Resolver forwards DNS queries to the DNS service for a VPC from your network or
+     * another VPC</p> </li> <li> <p> <code>OUTBOUND</code>: Resolver forwards DNS
+     * queries from the DNS service for a VPC to your network or another VPC</p> </li>
+     * </ul>
+     */
+    inline CreateResolverEndpointRequest& WithDirection(const ResolverEndpointDirection& value) { SetDirection(value); return *this;}
+
+    /**
+     * <p>Specify the applicable value:</p> <ul> <li> <p> <code>INBOUND</code>:
+     * Resolver forwards DNS queries to the DNS service for a VPC from your network or
+     * another VPC</p> </li> <li> <p> <code>OUTBOUND</code>: Resolver forwards DNS
+     * queries from the DNS service for a VPC to your network or another VPC</p> </li>
+     * </ul>
+     */
+    inline CreateResolverEndpointRequest& WithDirection(ResolverEndpointDirection&& value) { SetDirection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline const Aws::Vector<IpAddressRequest>& GetIpAddresses() const{ return m_ipAddresses; }
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline bool IpAddressesHasBeenSet() const { return m_ipAddressesHasBeenSet; }
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline void SetIpAddresses(const Aws::Vector<IpAddressRequest>& value) { m_ipAddressesHasBeenSet = true; m_ipAddresses = value; }
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline void SetIpAddresses(Aws::Vector<IpAddressRequest>&& value) { m_ipAddressesHasBeenSet = true; m_ipAddresses = std::move(value); }
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline CreateResolverEndpointRequest& WithIpAddresses(const Aws::Vector<IpAddressRequest>& value) { SetIpAddresses(value); return *this;}
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline CreateResolverEndpointRequest& WithIpAddresses(Aws::Vector<IpAddressRequest>&& value) { SetIpAddresses(std::move(value)); return *this;}
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline CreateResolverEndpointRequest& AddIpAddresses(const IpAddressRequest& value) { m_ipAddressesHasBeenSet = true; m_ipAddresses.push_back(value); return *this; }
+
+    /**
+     * <p>The subnets and IP addresses in your VPC that you want DNS queries to pass
+     * through on the way from your VPCs to your network (for outbound endpoints) or on
+     * the way from your network to your VPCs (for inbound resolver endpoints). </p>
+     */
+    inline CreateResolverEndpointRequest& AddIpAddresses(IpAddressRequest&& value) { m_ipAddressesHasBeenSet = true; m_ipAddresses.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverEndpointRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverEndpointRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverEndpointRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverEndpointRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_creatorRequestId;
+    bool m_creatorRequestIdHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_securityGroupIds;
+    bool m_securityGroupIdsHasBeenSet;
+
+    ResolverEndpointDirection m_direction;
+    bool m_directionHasBeenSet;
+
+    Aws::Vector<IpAddressRequest> m_ipAddresses;
+    bool m_ipAddressesHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/CreateResolverEndpointResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API CreateResolverEndpointResult
+  {
+  public:
+    CreateResolverEndpointResult();
+    CreateResolverEndpointResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateResolverEndpointResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the <code>CreateResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline const ResolverEndpoint& GetResolverEndpoint() const{ return m_resolverEndpoint; }
+
+    /**
+     * <p>Information about the <code>CreateResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline void SetResolverEndpoint(const ResolverEndpoint& value) { m_resolverEndpoint = value; }
+
+    /**
+     * <p>Information about the <code>CreateResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline void SetResolverEndpoint(ResolverEndpoint&& value) { m_resolverEndpoint = std::move(value); }
+
+    /**
+     * <p>Information about the <code>CreateResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline CreateResolverEndpointResult& WithResolverEndpoint(const ResolverEndpoint& value) { SetResolverEndpoint(value); return *this;}
+
+    /**
+     * <p>Information about the <code>CreateResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline CreateResolverEndpointResult& WithResolverEndpoint(ResolverEndpoint&& value) { SetResolverEndpoint(std::move(value)); return *this;}
+
+  private:
+
+    ResolverEndpoint m_resolverEndpoint;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/CreateResolverRuleRequest.h

@@ -0,0 +1,423 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/RuleTypeOption.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/TargetAddress.h>
+#include <aws/route53resolver/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API CreateResolverRuleRequest : public Route53ResolverRequest
+  {
+  public:
+    CreateResolverRuleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateResolverRule"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline const Aws::String& GetCreatorRequestId() const{ return m_creatorRequestId; }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline bool CreatorRequestIdHasBeenSet() const { return m_creatorRequestIdHasBeenSet; }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline void SetCreatorRequestId(const Aws::String& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = value; }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline void SetCreatorRequestId(Aws::String&& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = std::move(value); }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline void SetCreatorRequestId(const char* value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId.assign(value); }
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline CreateResolverRuleRequest& WithCreatorRequestId(const Aws::String& value) { SetCreatorRequestId(value); return *this;}
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline CreateResolverRuleRequest& WithCreatorRequestId(Aws::String&& value) { SetCreatorRequestId(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique string that identifies the request and that allows failed requests
+     * to be retried without the risk of executing the operation twice.
+     * <code>CreatorRequestId</code> can be any unique string, for example, a date/time
+     * stamp. </p>
+     */
+    inline CreateResolverRuleRequest& WithCreatorRequestId(const char* value) { SetCreatorRequestId(value); return *this;}
+
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline CreateResolverRuleRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline CreateResolverRuleRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>A friendly name that lets you easily find a rule in the Resolver dashboard in
+     * the Route 53 console.</p>
+     */
+    inline CreateResolverRuleRequest& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>Specify <code>FORWARD</code>. Other resolver rule types aren't supported.</p>
+     */
+    inline const RuleTypeOption& GetRuleType() const{ return m_ruleType; }
+
+    /**
+     * <p>Specify <code>FORWARD</code>. Other resolver rule types aren't supported.</p>
+     */
+    inline bool RuleTypeHasBeenSet() const { return m_ruleTypeHasBeenSet; }
+
+    /**
+     * <p>Specify <code>FORWARD</code>. Other resolver rule types aren't supported.</p>
+     */
+    inline void SetRuleType(const RuleTypeOption& value) { m_ruleTypeHasBeenSet = true; m_ruleType = value; }
+
+    /**
+     * <p>Specify <code>FORWARD</code>. Other resolver rule types aren't supported.</p>
+     */
+    inline void SetRuleType(RuleTypeOption&& value) { m_ruleTypeHasBeenSet = true; m_ruleType = std::move(value); }
+
+    /**
+     * <p>Specify <code>FORWARD</code>. Other resolver rule types aren't supported.</p>
+     */
+    inline CreateResolverRuleRequest& WithRuleType(const RuleTypeOption& value) { SetRuleType(value); return *this;}
+
+    /**
+     * <p>Specify <code>FORWARD</code>. Other resolver rule types aren't supported.</p>
+     */
+    inline CreateResolverRuleRequest& WithRuleType(RuleTypeOption&& value) { SetRuleType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline CreateResolverRuleRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline CreateResolverRuleRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that you
+     * specify in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), outbound DNS queries are routed using the
+     * resolver rule that contains the most specific domain name (www.example.com).</p>
+     */
+    inline CreateResolverRuleRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline const Aws::Vector<TargetAddress>& GetTargetIps() const{ return m_targetIps; }
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline bool TargetIpsHasBeenSet() const { return m_targetIpsHasBeenSet; }
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline void SetTargetIps(const Aws::Vector<TargetAddress>& value) { m_targetIpsHasBeenSet = true; m_targetIps = value; }
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline void SetTargetIps(Aws::Vector<TargetAddress>&& value) { m_targetIpsHasBeenSet = true; m_targetIps = std::move(value); }
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline CreateResolverRuleRequest& WithTargetIps(const Aws::Vector<TargetAddress>& value) { SetTargetIps(value); return *this;}
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline CreateResolverRuleRequest& WithTargetIps(Aws::Vector<TargetAddress>&& value) { SetTargetIps(std::move(value)); return *this;}
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline CreateResolverRuleRequest& AddTargetIps(const TargetAddress& value) { m_targetIpsHasBeenSet = true; m_targetIps.push_back(value); return *this; }
+
+    /**
+     * <p>The IPs that you want Resolver to forward DNS queries to. You can specify
+     * only IPv4 addresses. Separate IP addresses with a comma.</p>
+     */
+    inline CreateResolverRuleRequest& AddTargetIps(TargetAddress&& value) { m_targetIpsHasBeenSet = true; m_targetIps.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline CreateResolverRuleRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline CreateResolverRuleRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the outbound resolver endpoint that you want to use to route DNS
+     * queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline CreateResolverRuleRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverRuleRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverRuleRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverRuleRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>A list of the tag keys and values that you want to associate with the
+     * endpoint.</p>
+     */
+    inline CreateResolverRuleRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_creatorRequestId;
+    bool m_creatorRequestIdHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    RuleTypeOption m_ruleType;
+    bool m_ruleTypeHasBeenSet;
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    Aws::Vector<TargetAddress> m_targetIps;
+    bool m_targetIpsHasBeenSet;
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/CreateResolverRuleResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API CreateResolverRuleResult
+  {
+  public:
+    CreateResolverRuleResult();
+    CreateResolverRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateResolverRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the <code>CreateResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline const ResolverRule& GetResolverRule() const{ return m_resolverRule; }
+
+    /**
+     * <p>Information about the <code>CreateResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline void SetResolverRule(const ResolverRule& value) { m_resolverRule = value; }
+
+    /**
+     * <p>Information about the <code>CreateResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline void SetResolverRule(ResolverRule&& value) { m_resolverRule = std::move(value); }
+
+    /**
+     * <p>Information about the <code>CreateResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline CreateResolverRuleResult& WithResolverRule(const ResolverRule& value) { SetResolverRule(value); return *this;}
+
+    /**
+     * <p>Information about the <code>CreateResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline CreateResolverRuleResult& WithResolverRule(ResolverRule&& value) { SetResolverRule(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRule m_resolverRule;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DeleteResolverEndpointRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API DeleteResolverEndpointRequest : public Route53ResolverRequest
+  {
+  public:
+    DeleteResolverEndpointRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteResolverEndpoint"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline DeleteResolverEndpointRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline DeleteResolverEndpointRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to delete.</p>
+     */
+    inline DeleteResolverEndpointRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DeleteResolverEndpointResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API DeleteResolverEndpointResult
+  {
+  public:
+    DeleteResolverEndpointResult();
+    DeleteResolverEndpointResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteResolverEndpointResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the <code>DeleteResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline const ResolverEndpoint& GetResolverEndpoint() const{ return m_resolverEndpoint; }
+
+    /**
+     * <p>Information about the <code>DeleteResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline void SetResolverEndpoint(const ResolverEndpoint& value) { m_resolverEndpoint = value; }
+
+    /**
+     * <p>Information about the <code>DeleteResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline void SetResolverEndpoint(ResolverEndpoint&& value) { m_resolverEndpoint = std::move(value); }
+
+    /**
+     * <p>Information about the <code>DeleteResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline DeleteResolverEndpointResult& WithResolverEndpoint(const ResolverEndpoint& value) { SetResolverEndpoint(value); return *this;}
+
+    /**
+     * <p>Information about the <code>DeleteResolverEndpoint</code> request, including
+     * the status of the request.</p>
+     */
+    inline DeleteResolverEndpointResult& WithResolverEndpoint(ResolverEndpoint&& value) { SetResolverEndpoint(std::move(value)); return *this;}
+
+  private:
+
+    ResolverEndpoint m_resolverEndpoint;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DeleteResolverRuleRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API DeleteResolverRuleRequest : public Route53ResolverRequest
+  {
+  public:
+    DeleteResolverRuleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteResolverRule"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline const Aws::String& GetResolverRuleId() const{ return m_resolverRuleId; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline bool ResolverRuleIdHasBeenSet() const { return m_resolverRuleIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline void SetResolverRuleId(const Aws::String& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = value; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline void SetResolverRuleId(Aws::String&& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline void SetResolverRuleId(const char* value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline DeleteResolverRuleRequest& WithResolverRuleId(const Aws::String& value) { SetResolverRuleId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline DeleteResolverRuleRequest& WithResolverRuleId(Aws::String&& value) { SetResolverRuleId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to delete.</p>
+     */
+    inline DeleteResolverRuleRequest& WithResolverRuleId(const char* value) { SetResolverRuleId(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverRuleId;
+    bool m_resolverRuleIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DeleteResolverRuleResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API DeleteResolverRuleResult
+  {
+  public:
+    DeleteResolverRuleResult();
+    DeleteResolverRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DeleteResolverRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the <code>DeleteResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline const ResolverRule& GetResolverRule() const{ return m_resolverRule; }
+
+    /**
+     * <p>Information about the <code>DeleteResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline void SetResolverRule(const ResolverRule& value) { m_resolverRule = value; }
+
+    /**
+     * <p>Information about the <code>DeleteResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline void SetResolverRule(ResolverRule&& value) { m_resolverRule = std::move(value); }
+
+    /**
+     * <p>Information about the <code>DeleteResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline DeleteResolverRuleResult& WithResolverRule(const ResolverRule& value) { SetResolverRule(value); return *this;}
+
+    /**
+     * <p>Information about the <code>DeleteResolverRule</code> request, including the
+     * status of the request.</p>
+     */
+    inline DeleteResolverRuleResult& WithResolverRule(ResolverRule&& value) { SetResolverRule(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRule m_resolverRule;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DisassociateResolverEndpointIpAddressRequest.h

@@ -0,0 +1,128 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/IpAddressUpdate.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API DisassociateResolverEndpointIpAddressRequest : public Route53ResolverRequest
+  {
+  public:
+    DisassociateResolverEndpointIpAddressRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DisassociateResolverEndpointIpAddress"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to disassociate an IP address
+     * from.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+
+    /**
+     * <p>The IPv4 address that you want to remove from a resolver endpoint.</p>
+     */
+    inline const IpAddressUpdate& GetIpAddress() const{ return m_ipAddress; }
+
+    /**
+     * <p>The IPv4 address that you want to remove from a resolver endpoint.</p>
+     */
+    inline bool IpAddressHasBeenSet() const { return m_ipAddressHasBeenSet; }
+
+    /**
+     * <p>The IPv4 address that you want to remove from a resolver endpoint.</p>
+     */
+    inline void SetIpAddress(const IpAddressUpdate& value) { m_ipAddressHasBeenSet = true; m_ipAddress = value; }
+
+    /**
+     * <p>The IPv4 address that you want to remove from a resolver endpoint.</p>
+     */
+    inline void SetIpAddress(IpAddressUpdate&& value) { m_ipAddressHasBeenSet = true; m_ipAddress = std::move(value); }
+
+    /**
+     * <p>The IPv4 address that you want to remove from a resolver endpoint.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressRequest& WithIpAddress(const IpAddressUpdate& value) { SetIpAddress(value); return *this;}
+
+    /**
+     * <p>The IPv4 address that you want to remove from a resolver endpoint.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressRequest& WithIpAddress(IpAddressUpdate&& value) { SetIpAddress(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+
+    IpAddressUpdate m_ipAddress;
+    bool m_ipAddressHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DisassociateResolverEndpointIpAddressResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API DisassociateResolverEndpointIpAddressResult
+  {
+  public:
+    DisassociateResolverEndpointIpAddressResult();
+    DisassociateResolverEndpointIpAddressResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DisassociateResolverEndpointIpAddressResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The response to an <code>DisassociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline const ResolverEndpoint& GetResolverEndpoint() const{ return m_resolverEndpoint; }
+
+    /**
+     * <p>The response to an <code>DisassociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline void SetResolverEndpoint(const ResolverEndpoint& value) { m_resolverEndpoint = value; }
+
+    /**
+     * <p>The response to an <code>DisassociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline void SetResolverEndpoint(ResolverEndpoint&& value) { m_resolverEndpoint = std::move(value); }
+
+    /**
+     * <p>The response to an <code>DisassociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressResult& WithResolverEndpoint(const ResolverEndpoint& value) { SetResolverEndpoint(value); return *this;}
+
+    /**
+     * <p>The response to an <code>DisassociateResolverEndpointIpAddress</code>
+     * request.</p>
+     */
+    inline DisassociateResolverEndpointIpAddressResult& WithResolverEndpoint(ResolverEndpoint&& value) { SetResolverEndpoint(std::move(value)); return *this;}
+
+  private:
+
+    ResolverEndpoint m_resolverEndpoint;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DisassociateResolverRuleRequest.h

@@ -0,0 +1,137 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API DisassociateResolverRuleRequest : public Route53ResolverRequest
+  {
+  public:
+    DisassociateResolverRuleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DisassociateResolverRule"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline const Aws::String& GetVPCId() const{ return m_vPCId; }
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline bool VPCIdHasBeenSet() const { return m_vPCIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline void SetVPCId(const Aws::String& value) { m_vPCIdHasBeenSet = true; m_vPCId = value; }
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline void SetVPCId(Aws::String&& value) { m_vPCIdHasBeenSet = true; m_vPCId = std::move(value); }
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline void SetVPCId(const char* value) { m_vPCIdHasBeenSet = true; m_vPCId.assign(value); }
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline DisassociateResolverRuleRequest& WithVPCId(const Aws::String& value) { SetVPCId(value); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline DisassociateResolverRuleRequest& WithVPCId(Aws::String&& value) { SetVPCId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you want to disassociate the resolver rule from.</p>
+     */
+    inline DisassociateResolverRuleRequest& WithVPCId(const char* value) { SetVPCId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline const Aws::String& GetResolverRuleId() const{ return m_resolverRuleId; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline bool ResolverRuleIdHasBeenSet() const { return m_resolverRuleIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline void SetResolverRuleId(const Aws::String& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = value; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline void SetResolverRuleId(Aws::String&& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline void SetResolverRuleId(const char* value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline DisassociateResolverRuleRequest& WithResolverRuleId(const Aws::String& value) { SetResolverRuleId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline DisassociateResolverRuleRequest& WithResolverRuleId(Aws::String&& value) { SetResolverRuleId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to disassociate from the specified
+     * VPC.</p>
+     */
+    inline DisassociateResolverRuleRequest& WithResolverRuleId(const char* value) { SetResolverRuleId(value); return *this;}
+
+  private:
+
+    Aws::String m_vPCId;
+    bool m_vPCIdHasBeenSet;
+
+    Aws::String m_resolverRuleId;
+    bool m_resolverRuleIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/DisassociateResolverRuleResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRuleAssociation.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API DisassociateResolverRuleResult
+  {
+  public:
+    DisassociateResolverRuleResult();
+    DisassociateResolverRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DisassociateResolverRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the <code>DisassociateResolverRule</code> request,
+     * including the status of the request.</p>
+     */
+    inline const ResolverRuleAssociation& GetResolverRuleAssociation() const{ return m_resolverRuleAssociation; }
+
+    /**
+     * <p>Information about the <code>DisassociateResolverRule</code> request,
+     * including the status of the request.</p>
+     */
+    inline void SetResolverRuleAssociation(const ResolverRuleAssociation& value) { m_resolverRuleAssociation = value; }
+
+    /**
+     * <p>Information about the <code>DisassociateResolverRule</code> request,
+     * including the status of the request.</p>
+     */
+    inline void SetResolverRuleAssociation(ResolverRuleAssociation&& value) { m_resolverRuleAssociation = std::move(value); }
+
+    /**
+     * <p>Information about the <code>DisassociateResolverRule</code> request,
+     * including the status of the request.</p>
+     */
+    inline DisassociateResolverRuleResult& WithResolverRuleAssociation(const ResolverRuleAssociation& value) { SetResolverRuleAssociation(value); return *this;}
+
+    /**
+     * <p>Information about the <code>DisassociateResolverRule</code> request,
+     * including the status of the request.</p>
+     */
+    inline DisassociateResolverRuleResult& WithResolverRuleAssociation(ResolverRuleAssociation&& value) { SetResolverRuleAssociation(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRuleAssociation m_resolverRuleAssociation;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/Filter.h

@@ -0,0 +1,208 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>For <code>List</code> operations, an optional specification to return a
+   * subset of objects, such as resolver endpoints or resolver rules.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/Filter">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API Filter
+  {
+  public:
+    Filter();
+    Filter(Aws::Utils::Json::JsonView jsonValue);
+    Filter& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline Filter& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline Filter& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * name of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>Direction</code> for the
+     * value of <code>Name</code>.</p>
+     */
+    inline Filter& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetValues() const{ return m_values; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline bool ValuesHasBeenSet() const { return m_valuesHasBeenSet; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline void SetValues(const Aws::Vector<Aws::String>& value) { m_valuesHasBeenSet = true; m_values = value; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline void SetValues(Aws::Vector<Aws::String>&& value) { m_valuesHasBeenSet = true; m_values = std::move(value); }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline Filter& WithValues(const Aws::Vector<Aws::String>& value) { SetValues(value); return *this;}
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline Filter& WithValues(Aws::Vector<Aws::String>&& value) { SetValues(std::move(value)); return *this;}
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline Filter& AddValues(const Aws::String& value) { m_valuesHasBeenSet = true; m_values.push_back(value); return *this; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline Filter& AddValues(Aws::String&& value) { m_valuesHasBeenSet = true; m_values.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>When you're using a <code>List</code> operation and you want the operation to
+     * return a subset of objects, such as resolver endpoints or resolver rules, the
+     * value of the parameter that you want to use to filter objects. For example, to
+     * list only inbound resolver endpoints, specify <code>INBOUND</code> for the value
+     * of <code>Values</code>.</p>
+     */
+    inline Filter& AddValues(const char* value) { m_valuesHasBeenSet = true; m_values.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_values;
+    bool m_valuesHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverEndpointRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API GetResolverEndpointRequest : public Route53ResolverRequest
+  {
+  public:
+    GetResolverEndpointRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetResolverEndpoint"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline GetResolverEndpointRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline GetResolverEndpointRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get information about.</p>
+     */
+    inline GetResolverEndpointRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverEndpointResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API GetResolverEndpointResult
+  {
+  public:
+    GetResolverEndpointResult();
+    GetResolverEndpointResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetResolverEndpointResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the resolver endpoint that you specified in a
+     * <code>GetResolverEndpoint</code> request.</p>
+     */
+    inline const ResolverEndpoint& GetResolverEndpoint() const{ return m_resolverEndpoint; }
+
+    /**
+     * <p>Information about the resolver endpoint that you specified in a
+     * <code>GetResolverEndpoint</code> request.</p>
+     */
+    inline void SetResolverEndpoint(const ResolverEndpoint& value) { m_resolverEndpoint = value; }
+
+    /**
+     * <p>Information about the resolver endpoint that you specified in a
+     * <code>GetResolverEndpoint</code> request.</p>
+     */
+    inline void SetResolverEndpoint(ResolverEndpoint&& value) { m_resolverEndpoint = std::move(value); }
+
+    /**
+     * <p>Information about the resolver endpoint that you specified in a
+     * <code>GetResolverEndpoint</code> request.</p>
+     */
+    inline GetResolverEndpointResult& WithResolverEndpoint(const ResolverEndpoint& value) { SetResolverEndpoint(value); return *this;}
+
+    /**
+     * <p>Information about the resolver endpoint that you specified in a
+     * <code>GetResolverEndpoint</code> request.</p>
+     */
+    inline GetResolverEndpointResult& WithResolverEndpoint(ResolverEndpoint&& value) { SetResolverEndpoint(std::move(value)); return *this;}
+
+  private:
+
+    ResolverEndpoint m_resolverEndpoint;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverRuleAssociationRequest.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API GetResolverRuleAssociationRequest : public Route53ResolverRequest
+  {
+  public:
+    GetResolverRuleAssociationRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetResolverRuleAssociation"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline const Aws::String& GetResolverRuleAssociationId() const{ return m_resolverRuleAssociationId; }
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline bool ResolverRuleAssociationIdHasBeenSet() const { return m_resolverRuleAssociationIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline void SetResolverRuleAssociationId(const Aws::String& value) { m_resolverRuleAssociationIdHasBeenSet = true; m_resolverRuleAssociationId = value; }
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline void SetResolverRuleAssociationId(Aws::String&& value) { m_resolverRuleAssociationIdHasBeenSet = true; m_resolverRuleAssociationId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline void SetResolverRuleAssociationId(const char* value) { m_resolverRuleAssociationIdHasBeenSet = true; m_resolverRuleAssociationId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline GetResolverRuleAssociationRequest& WithResolverRuleAssociationId(const Aws::String& value) { SetResolverRuleAssociationId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline GetResolverRuleAssociationRequest& WithResolverRuleAssociationId(Aws::String&& value) { SetResolverRuleAssociationId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule association that you want to get information
+     * about.</p>
+     */
+    inline GetResolverRuleAssociationRequest& WithResolverRuleAssociationId(const char* value) { SetResolverRuleAssociationId(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverRuleAssociationId;
+    bool m_resolverRuleAssociationIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverRuleAssociationResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRuleAssociation.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API GetResolverRuleAssociationResult
+  {
+  public:
+    GetResolverRuleAssociationResult();
+    GetResolverRuleAssociationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetResolverRuleAssociationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the resolver rule association that you specified in a
+     * <code>GetResolverRuleAssociation</code> request.</p>
+     */
+    inline const ResolverRuleAssociation& GetResolverRuleAssociation() const{ return m_resolverRuleAssociation; }
+
+    /**
+     * <p>Information about the resolver rule association that you specified in a
+     * <code>GetResolverRuleAssociation</code> request.</p>
+     */
+    inline void SetResolverRuleAssociation(const ResolverRuleAssociation& value) { m_resolverRuleAssociation = value; }
+
+    /**
+     * <p>Information about the resolver rule association that you specified in a
+     * <code>GetResolverRuleAssociation</code> request.</p>
+     */
+    inline void SetResolverRuleAssociation(ResolverRuleAssociation&& value) { m_resolverRuleAssociation = std::move(value); }
+
+    /**
+     * <p>Information about the resolver rule association that you specified in a
+     * <code>GetResolverRuleAssociation</code> request.</p>
+     */
+    inline GetResolverRuleAssociationResult& WithResolverRuleAssociation(const ResolverRuleAssociation& value) { SetResolverRuleAssociation(value); return *this;}
+
+    /**
+     * <p>Information about the resolver rule association that you specified in a
+     * <code>GetResolverRuleAssociation</code> request.</p>
+     */
+    inline GetResolverRuleAssociationResult& WithResolverRuleAssociation(ResolverRuleAssociation&& value) { SetResolverRuleAssociation(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRuleAssociation m_resolverRuleAssociation;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverRulePolicyRequest.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API GetResolverRulePolicyRequest : public Route53ResolverRequest
+  {
+  public:
+    GetResolverRulePolicyRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetResolverRulePolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline GetResolverRulePolicyRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline GetResolverRulePolicyRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule policy that you want to get information
+     * about.</p>
+     */
+    inline GetResolverRulePolicyRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverRulePolicyResult.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API GetResolverRulePolicyResult
+  {
+  public:
+    GetResolverRulePolicyResult();
+    GetResolverRulePolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetResolverRulePolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline const Aws::String& GetResolverRulePolicy() const{ return m_resolverRulePolicy; }
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline void SetResolverRulePolicy(const Aws::String& value) { m_resolverRulePolicy = value; }
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline void SetResolverRulePolicy(Aws::String&& value) { m_resolverRulePolicy = std::move(value); }
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline void SetResolverRulePolicy(const char* value) { m_resolverRulePolicy.assign(value); }
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline GetResolverRulePolicyResult& WithResolverRulePolicy(const Aws::String& value) { SetResolverRulePolicy(value); return *this;}
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline GetResolverRulePolicyResult& WithResolverRulePolicy(Aws::String&& value) { SetResolverRulePolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>Information about the resolver rule policy that you specified in a
+     * <code>GetResolverRulePolicy</code> request.</p>
+     */
+    inline GetResolverRulePolicyResult& WithResolverRulePolicy(const char* value) { SetResolverRulePolicy(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverRulePolicy;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverRuleRequest.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API GetResolverRuleRequest : public Route53ResolverRequest
+  {
+  public:
+    GetResolverRuleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetResolverRule"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline const Aws::String& GetResolverRuleId() const{ return m_resolverRuleId; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline bool ResolverRuleIdHasBeenSet() const { return m_resolverRuleIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline void SetResolverRuleId(const Aws::String& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = value; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline void SetResolverRuleId(Aws::String&& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline void SetResolverRuleId(const char* value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline GetResolverRuleRequest& WithResolverRuleId(const Aws::String& value) { SetResolverRuleId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline GetResolverRuleRequest& WithResolverRuleId(Aws::String&& value) { SetResolverRuleId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to get information about.</p>
+     */
+    inline GetResolverRuleRequest& WithResolverRuleId(const char* value) { SetResolverRuleId(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverRuleId;
+    bool m_resolverRuleIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/GetResolverRuleResult.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API GetResolverRuleResult
+  {
+  public:
+    GetResolverRuleResult();
+    GetResolverRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetResolverRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Information about the resolver rule that you specified in a
+     * <code>GetResolverRule</code> request.</p>
+     */
+    inline const ResolverRule& GetResolverRule() const{ return m_resolverRule; }
+
+    /**
+     * <p>Information about the resolver rule that you specified in a
+     * <code>GetResolverRule</code> request.</p>
+     */
+    inline void SetResolverRule(const ResolverRule& value) { m_resolverRule = value; }
+
+    /**
+     * <p>Information about the resolver rule that you specified in a
+     * <code>GetResolverRule</code> request.</p>
+     */
+    inline void SetResolverRule(ResolverRule&& value) { m_resolverRule = std::move(value); }
+
+    /**
+     * <p>Information about the resolver rule that you specified in a
+     * <code>GetResolverRule</code> request.</p>
+     */
+    inline GetResolverRuleResult& WithResolverRule(const ResolverRule& value) { SetResolverRule(value); return *this;}
+
+    /**
+     * <p>Information about the resolver rule that you specified in a
+     * <code>GetResolverRule</code> request.</p>
+     */
+    inline GetResolverRuleResult& WithResolverRule(ResolverRule&& value) { SetResolverRule(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRule m_resolverRule;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/InvalidParameterException.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>One or more parameters in this request are not valid.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/InvalidParameterException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API InvalidParameterException
+  {
+  public:
+    InvalidParameterException();
+    InvalidParameterException(Aws::Utils::Json::JsonView jsonValue);
+    InvalidParameterException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    
+    inline InvalidParameterException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    
+    inline InvalidParameterException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    
+    inline InvalidParameterException& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline const Aws::String& GetFieldName() const{ return m_fieldName; }
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline bool FieldNameHasBeenSet() const { return m_fieldNameHasBeenSet; }
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline void SetFieldName(const Aws::String& value) { m_fieldNameHasBeenSet = true; m_fieldName = value; }
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline void SetFieldName(Aws::String&& value) { m_fieldNameHasBeenSet = true; m_fieldName = std::move(value); }
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline void SetFieldName(const char* value) { m_fieldNameHasBeenSet = true; m_fieldName.assign(value); }
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline InvalidParameterException& WithFieldName(const Aws::String& value) { SetFieldName(value); return *this;}
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline InvalidParameterException& WithFieldName(Aws::String&& value) { SetFieldName(std::move(value)); return *this;}
+
+    /**
+     * <p>For an <code>InvalidParameterException</code> error, the name of the
+     * parameter that's invalid.</p>
+     */
+    inline InvalidParameterException& WithFieldName(const char* value) { SetFieldName(value); return *this;}
+
+  private:
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::String m_fieldName;
+    bool m_fieldNameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/IpAddressRequest.h

@@ -0,0 +1,133 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In an <a>CreateResolverEndpoint</a> request, a subnet and IP address that you
+   * want to use for DNS queries.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/IpAddressRequest">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API IpAddressRequest
+  {
+  public:
+    IpAddressRequest();
+    IpAddressRequest(Aws::Utils::Json::JsonView jsonValue);
+    IpAddressRequest& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline const Aws::String& GetSubnetId() const{ return m_subnetId; }
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline bool SubnetIdHasBeenSet() const { return m_subnetIdHasBeenSet; }
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline void SetSubnetId(const Aws::String& value) { m_subnetIdHasBeenSet = true; m_subnetId = value; }
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline void SetSubnetId(Aws::String&& value) { m_subnetIdHasBeenSet = true; m_subnetId = std::move(value); }
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline void SetSubnetId(const char* value) { m_subnetIdHasBeenSet = true; m_subnetId.assign(value); }
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline IpAddressRequest& WithSubnetId(const Aws::String& value) { SetSubnetId(value); return *this;}
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline IpAddressRequest& WithSubnetId(Aws::String&& value) { SetSubnetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The subnet that contains the IP address.</p>
+     */
+    inline IpAddressRequest& WithSubnetId(const char* value) { SetSubnetId(value); return *this;}
+
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline const Aws::String& GetIp() const{ return m_ip; }
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline bool IpHasBeenSet() const { return m_ipHasBeenSet; }
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline void SetIp(const Aws::String& value) { m_ipHasBeenSet = true; m_ip = value; }
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline void SetIp(Aws::String&& value) { m_ipHasBeenSet = true; m_ip = std::move(value); }
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline void SetIp(const char* value) { m_ipHasBeenSet = true; m_ip.assign(value); }
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline IpAddressRequest& WithIp(const Aws::String& value) { SetIp(value); return *this;}
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline IpAddressRequest& WithIp(Aws::String&& value) { SetIp(std::move(value)); return *this;}
+
+    /**
+     * <p>The IP address that you want to use for DNS queries.</p>
+     */
+    inline IpAddressRequest& WithIp(const char* value) { SetIp(value); return *this;}
+
+  private:
+
+    Aws::String m_subnetId;
+    bool m_subnetIdHasBeenSet;
+
+    Aws::String m_ip;
+    bool m_ipHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/IpAddressResponse.h

@@ -0,0 +1,369 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/IpAddressStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In the response to a <a>GetResolverEndpoint</a> request, information about
+   * the IP addresses that the resolver endpoint uses for DNS queries.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/IpAddressResponse">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API IpAddressResponse
+  {
+  public:
+    IpAddressResponse();
+    IpAddressResponse(Aws::Utils::Json::JsonView jsonValue);
+    IpAddressResponse& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline const Aws::String& GetIpId() const{ return m_ipId; }
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline bool IpIdHasBeenSet() const { return m_ipIdHasBeenSet; }
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline void SetIpId(const Aws::String& value) { m_ipIdHasBeenSet = true; m_ipId = value; }
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline void SetIpId(Aws::String&& value) { m_ipIdHasBeenSet = true; m_ipId = std::move(value); }
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline void SetIpId(const char* value) { m_ipIdHasBeenSet = true; m_ipId.assign(value); }
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline IpAddressResponse& WithIpId(const Aws::String& value) { SetIpId(value); return *this;}
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline IpAddressResponse& WithIpId(Aws::String&& value) { SetIpId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of one IP address.</p>
+     */
+    inline IpAddressResponse& WithIpId(const char* value) { SetIpId(value); return *this;}
+
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline const Aws::String& GetSubnetId() const{ return m_subnetId; }
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline bool SubnetIdHasBeenSet() const { return m_subnetIdHasBeenSet; }
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline void SetSubnetId(const Aws::String& value) { m_subnetIdHasBeenSet = true; m_subnetId = value; }
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline void SetSubnetId(Aws::String&& value) { m_subnetIdHasBeenSet = true; m_subnetId = std::move(value); }
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline void SetSubnetId(const char* value) { m_subnetIdHasBeenSet = true; m_subnetId.assign(value); }
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline IpAddressResponse& WithSubnetId(const Aws::String& value) { SetSubnetId(value); return *this;}
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline IpAddressResponse& WithSubnetId(Aws::String&& value) { SetSubnetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of one subnet.</p>
+     */
+    inline IpAddressResponse& WithSubnetId(const char* value) { SetSubnetId(value); return *this;}
+
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline const Aws::String& GetIp() const{ return m_ip; }
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline bool IpHasBeenSet() const { return m_ipHasBeenSet; }
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline void SetIp(const Aws::String& value) { m_ipHasBeenSet = true; m_ip = value; }
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline void SetIp(Aws::String&& value) { m_ipHasBeenSet = true; m_ip = std::move(value); }
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline void SetIp(const char* value) { m_ipHasBeenSet = true; m_ip.assign(value); }
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline IpAddressResponse& WithIp(const Aws::String& value) { SetIp(value); return *this;}
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline IpAddressResponse& WithIp(Aws::String&& value) { SetIp(std::move(value)); return *this;}
+
+    /**
+     * <p>One IP address that the resolver endpoint uses for DNS queries.</p>
+     */
+    inline IpAddressResponse& WithIp(const char* value) { SetIp(value); return *this;}
+
+
+    /**
+     * <p>A status code that gives the current status of the request.</p>
+     */
+    inline const IpAddressStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>A status code that gives the current status of the request.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>A status code that gives the current status of the request.</p>
+     */
+    inline void SetStatus(const IpAddressStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>A status code that gives the current status of the request.</p>
+     */
+    inline void SetStatus(IpAddressStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>A status code that gives the current status of the request.</p>
+     */
+    inline IpAddressResponse& WithStatus(const IpAddressStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>A status code that gives the current status of the request.</p>
+     */
+    inline IpAddressResponse& WithStatus(IpAddressStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline const Aws::String& GetStatusMessage() const{ return m_statusMessage; }
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline void SetStatusMessage(const Aws::String& value) { m_statusMessageHasBeenSet = true; m_statusMessage = value; }
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline void SetStatusMessage(Aws::String&& value) { m_statusMessageHasBeenSet = true; m_statusMessage = std::move(value); }
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline void SetStatusMessage(const char* value) { m_statusMessageHasBeenSet = true; m_statusMessage.assign(value); }
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline IpAddressResponse& WithStatusMessage(const Aws::String& value) { SetStatusMessage(value); return *this;}
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline IpAddressResponse& WithStatusMessage(Aws::String&& value) { SetStatusMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A message that provides additional information about the status of the
+     * request.</p>
+     */
+    inline IpAddressResponse& WithStatusMessage(const char* value) { SetStatusMessage(value); return *this;}
+
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline const Aws::String& GetCreationTime() const{ return m_creationTime; }
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetCreationTime(const Aws::String& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetCreationTime(Aws::String&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetCreationTime(const char* value) { m_creationTimeHasBeenSet = true; m_creationTime.assign(value); }
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline IpAddressResponse& WithCreationTime(const Aws::String& value) { SetCreationTime(value); return *this;}
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline IpAddressResponse& WithCreationTime(Aws::String&& value) { SetCreationTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The date and time that the IP address was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline IpAddressResponse& WithCreationTime(const char* value) { SetCreationTime(value); return *this;}
+
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline const Aws::String& GetModificationTime() const{ return m_modificationTime; }
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline bool ModificationTimeHasBeenSet() const { return m_modificationTimeHasBeenSet; }
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetModificationTime(const Aws::String& value) { m_modificationTimeHasBeenSet = true; m_modificationTime = value; }
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetModificationTime(Aws::String&& value) { m_modificationTimeHasBeenSet = true; m_modificationTime = std::move(value); }
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetModificationTime(const char* value) { m_modificationTimeHasBeenSet = true; m_modificationTime.assign(value); }
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline IpAddressResponse& WithModificationTime(const Aws::String& value) { SetModificationTime(value); return *this;}
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline IpAddressResponse& WithModificationTime(Aws::String&& value) { SetModificationTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The date and time that the IP address was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline IpAddressResponse& WithModificationTime(const char* value) { SetModificationTime(value); return *this;}
+
+  private:
+
+    Aws::String m_ipId;
+    bool m_ipIdHasBeenSet;
+
+    Aws::String m_subnetId;
+    bool m_subnetIdHasBeenSet;
+
+    Aws::String m_ip;
+    bool m_ipHasBeenSet;
+
+    IpAddressStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::String m_statusMessage;
+    bool m_statusMessageHasBeenSet;
+
+    Aws::String m_creationTime;
+    bool m_creationTimeHasBeenSet;
+
+    Aws::String m_modificationTime;
+    bool m_modificationTimeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/IpAddressStatus.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class IpAddressStatus
+  {
+    NOT_SET,
+    CREATING,
+    FAILED_CREATION,
+    ATTACHING,
+    ATTACHED,
+    REMAP_DETACHING,
+    REMAP_ATTACHING,
+    DETACHING,
+    FAILED_RESOURCE_GONE,
+    DELETING,
+    DELETE_FAILED_FAS_EXPIRED
+  };
+
+namespace IpAddressStatusMapper
+{
+AWS_ROUTE53RESOLVER_API IpAddressStatus GetIpAddressStatusForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForIpAddressStatus(IpAddressStatus value);
+} // namespace IpAddressStatusMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/IpAddressUpdate.h

@@ -0,0 +1,201 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In an <a>UpdateResolverEndpoint</a> request, information about an IP address
+   * to update.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/IpAddressUpdate">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API IpAddressUpdate
+  {
+  public:
+    IpAddressUpdate();
+    IpAddressUpdate(Aws::Utils::Json::JsonView jsonValue);
+    IpAddressUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline const Aws::String& GetIpId() const{ return m_ipId; }
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline bool IpIdHasBeenSet() const { return m_ipIdHasBeenSet; }
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline void SetIpId(const Aws::String& value) { m_ipIdHasBeenSet = true; m_ipId = value; }
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline void SetIpId(Aws::String&& value) { m_ipIdHasBeenSet = true; m_ipId = std::move(value); }
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline void SetIpId(const char* value) { m_ipIdHasBeenSet = true; m_ipId.assign(value); }
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline IpAddressUpdate& WithIpId(const Aws::String& value) { SetIpId(value); return *this;}
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline IpAddressUpdate& WithIpId(Aws::String&& value) { SetIpId(std::move(value)); return *this;}
+
+    /**
+     * <p> <i>Only when removing an IP address from a resolver endpoint</i>: The ID of
+     * the IP address that you want to remove. To get this ID, use
+     * <a>GetResolverEndpoint</a>.</p>
+     */
+    inline IpAddressUpdate& WithIpId(const char* value) { SetIpId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline const Aws::String& GetSubnetId() const{ return m_subnetId; }
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline bool SubnetIdHasBeenSet() const { return m_subnetIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline void SetSubnetId(const Aws::String& value) { m_subnetIdHasBeenSet = true; m_subnetId = value; }
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline void SetSubnetId(Aws::String&& value) { m_subnetIdHasBeenSet = true; m_subnetId = std::move(value); }
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline void SetSubnetId(const char* value) { m_subnetIdHasBeenSet = true; m_subnetId.assign(value); }
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline IpAddressUpdate& WithSubnetId(const Aws::String& value) { SetSubnetId(value); return *this;}
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline IpAddressUpdate& WithSubnetId(Aws::String&& value) { SetSubnetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the subnet that includes the IP address that you want to update. To
+     * get this ID, use <a>GetResolverEndpoint</a>.</p>
+     */
+    inline IpAddressUpdate& WithSubnetId(const char* value) { SetSubnetId(value); return *this;}
+
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline const Aws::String& GetIp() const{ return m_ip; }
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline bool IpHasBeenSet() const { return m_ipHasBeenSet; }
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline void SetIp(const Aws::String& value) { m_ipHasBeenSet = true; m_ip = value; }
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline void SetIp(Aws::String&& value) { m_ipHasBeenSet = true; m_ip = std::move(value); }
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline void SetIp(const char* value) { m_ipHasBeenSet = true; m_ip.assign(value); }
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline IpAddressUpdate& WithIp(const Aws::String& value) { SetIp(value); return *this;}
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline IpAddressUpdate& WithIp(Aws::String&& value) { SetIp(std::move(value)); return *this;}
+
+    /**
+     * <p>The new IP address.</p>
+     */
+    inline IpAddressUpdate& WithIp(const char* value) { SetIp(value); return *this;}
+
+  private:
+
+    Aws::String m_ipId;
+    bool m_ipIdHasBeenSet;
+
+    Aws::String m_subnetId;
+    bool m_subnetIdHasBeenSet;
+
+    Aws::String m_ip;
+    bool m_ipHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/LimitExceededException.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>The request caused one or more limits to be exceeded.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/LimitExceededException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API LimitExceededException
+  {
+  public:
+    LimitExceededException();
+    LimitExceededException(Aws::Utils::Json::JsonView jsonValue);
+    LimitExceededException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    
+    inline LimitExceededException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    
+    inline LimitExceededException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    
+    inline LimitExceededException& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline const Aws::String& GetResourceType() const{ return m_resourceType; }
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline LimitExceededException& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline LimitExceededException& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>For a <code>LimitExceededException</code> error, the type of resource that
+     * exceeded the current limit.</p>
+     */
+    inline LimitExceededException& WithResourceType(const char* value) { SetResourceType(value); return *this;}
+
+  private:
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::String m_resourceType;
+    bool m_resourceTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverEndpointIpAddressesRequest.h

@@ -0,0 +1,201 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API ListResolverEndpointIpAddressesRequest : public Route53ResolverRequest
+  {
+  public:
+    ListResolverEndpointIpAddressesRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListResolverEndpointIpAddresses"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to get IP addresses for.</p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of IP addresses that you want to return in the response to
+     * a <code>ListResolverEndpointIpAddresses</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 IP addresses. </p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of IP addresses that you want to return in the response to
+     * a <code>ListResolverEndpointIpAddresses</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 IP addresses. </p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of IP addresses that you want to return in the response to
+     * a <code>ListResolverEndpointIpAddresses</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 IP addresses. </p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of IP addresses that you want to return in the response to
+     * a <code>ListResolverEndpointIpAddresses</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 IP addresses. </p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverEndpointIpAddresses</code> request, omit this
+     * value.</p> <p>If the specified resolver endpoint has more than
+     * <code>MaxResults</code> IP addresses, you can submit another
+     * <code>ListResolverEndpointIpAddresses</code> request to get the next group of IP
+     * addresses. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline ListResolverEndpointIpAddressesRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverEndpointIpAddressesResult.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/IpAddressResponse.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API ListResolverEndpointIpAddressesResult
+  {
+  public:
+    ListResolverEndpointIpAddressesResult();
+    ListResolverEndpointIpAddressesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListResolverEndpointIpAddressesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointIpAddressesResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointIpAddressesResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If the specified endpoint has more than <code>MaxResults</code> IP addresses,
+     * you can submit another <code>ListResolverEndpointIpAddresses</code> request to
+     * get the next group of IP addresses. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointIpAddressesResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResults = value; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline ListResolverEndpointIpAddressesResult& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline const Aws::Vector<IpAddressResponse>& GetIpAddresses() const{ return m_ipAddresses; }
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline void SetIpAddresses(const Aws::Vector<IpAddressResponse>& value) { m_ipAddresses = value; }
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline void SetIpAddresses(Aws::Vector<IpAddressResponse>&& value) { m_ipAddresses = std::move(value); }
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline ListResolverEndpointIpAddressesResult& WithIpAddresses(const Aws::Vector<IpAddressResponse>& value) { SetIpAddresses(value); return *this;}
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline ListResolverEndpointIpAddressesResult& WithIpAddresses(Aws::Vector<IpAddressResponse>&& value) { SetIpAddresses(std::move(value)); return *this;}
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline ListResolverEndpointIpAddressesResult& AddIpAddresses(const IpAddressResponse& value) { m_ipAddresses.push_back(value); return *this; }
+
+    /**
+     * <p>The IP addresses that DNS queries pass through on their way to your network
+     * (outbound endpoint) or on the way to Resolver (inbound endpoint).</p>
+     */
+    inline ListResolverEndpointIpAddressesResult& AddIpAddresses(IpAddressResponse&& value) { m_ipAddresses.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    int m_maxResults;
+
+    Aws::Vector<IpAddressResponse> m_ipAddresses;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverEndpointsRequest.h

@@ -0,0 +1,231 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/Filter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API ListResolverEndpointsRequest : public Route53ResolverRequest
+  {
+  public:
+    ListResolverEndpointsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListResolverEndpoints"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The maximum number of resolver endpoints that you want to return in the
+     * response to a <code>ListResolverEndpoints</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 resolver
+     * endpoints. </p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of resolver endpoints that you want to return in the
+     * response to a <code>ListResolverEndpoints</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 resolver
+     * endpoints. </p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of resolver endpoints that you want to return in the
+     * response to a <code>ListResolverEndpoints</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 resolver
+     * endpoints. </p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of resolver endpoints that you want to return in the
+     * response to a <code>ListResolverEndpoints</code> request. If you don't specify a
+     * value for <code>MaxResults</code>, Resolver returns up to 100 resolver
+     * endpoints. </p>
+     */
+    inline ListResolverEndpointsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverEndpoints</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> resolver endpoints,
+     * you can submit another <code>ListResolverEndpoints</code> request to get the
+     * next group of resolver endpoints. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline const Aws::Vector<Filter>& GetFilters() const{ return m_filters; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline void SetFilters(const Aws::Vector<Filter>& value) { m_filtersHasBeenSet = true; m_filters = value; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline void SetFilters(Aws::Vector<Filter>&& value) { m_filtersHasBeenSet = true; m_filters = std::move(value); }
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverEndpointsRequest& WithFilters(const Aws::Vector<Filter>& value) { SetFilters(value); return *this;}
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverEndpointsRequest& WithFilters(Aws::Vector<Filter>&& value) { SetFilters(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverEndpointsRequest& AddFilters(const Filter& value) { m_filtersHasBeenSet = true; m_filters.push_back(value); return *this; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver endpoints, such as
+     * all inbound resolver endpoints.</p>  <p>If you submit a second or
+     * subsequent <code>ListResolverEndpoints</code> request and specify the
+     * <code>NextToken</code> parameter, you must use the same values for
+     * <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverEndpointsRequest& AddFilters(Filter&& value) { m_filtersHasBeenSet = true; m_filters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    Aws::Vector<Filter> m_filters;
+    bool m_filtersHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverEndpointsResult.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API ListResolverEndpointsResult
+  {
+  public:
+    ListResolverEndpointsResult();
+    ListResolverEndpointsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListResolverEndpointsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> IP addresses match the specified
+     * criteria, you can submit another <code>ListResolverEndpoint</code> request to
+     * get the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverEndpointsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResults = value; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline ListResolverEndpointsResult& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline const Aws::Vector<ResolverEndpoint>& GetResolverEndpoints() const{ return m_resolverEndpoints; }
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline void SetResolverEndpoints(const Aws::Vector<ResolverEndpoint>& value) { m_resolverEndpoints = value; }
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline void SetResolverEndpoints(Aws::Vector<ResolverEndpoint>&& value) { m_resolverEndpoints = std::move(value); }
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline ListResolverEndpointsResult& WithResolverEndpoints(const Aws::Vector<ResolverEndpoint>& value) { SetResolverEndpoints(value); return *this;}
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline ListResolverEndpointsResult& WithResolverEndpoints(Aws::Vector<ResolverEndpoint>&& value) { SetResolverEndpoints(std::move(value)); return *this;}
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline ListResolverEndpointsResult& AddResolverEndpoints(const ResolverEndpoint& value) { m_resolverEndpoints.push_back(value); return *this; }
+
+    /**
+     * <p>The resolver endpoints that were created by using the current AWS account,
+     * and that match the specified filters, if any.</p>
+     */
+    inline ListResolverEndpointsResult& AddResolverEndpoints(ResolverEndpoint&& value) { m_resolverEndpoints.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    int m_maxResults;
+
+    Aws::Vector<ResolverEndpoint> m_resolverEndpoints;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverRuleAssociationsRequest.h

@@ -0,0 +1,231 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/Filter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API ListResolverRuleAssociationsRequest : public Route53ResolverRequest
+  {
+  public:
+    ListResolverRuleAssociationsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListResolverRuleAssociations"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The maximum number of rule associations that you want to return in the
+     * response to a <code>ListResolverRuleAssociations</code> request. If you don't
+     * specify a value for <code>MaxResults</code>, Resolver returns up to 100 rule
+     * associations. </p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of rule associations that you want to return in the
+     * response to a <code>ListResolverRuleAssociations</code> request. If you don't
+     * specify a value for <code>MaxResults</code>, Resolver returns up to 100 rule
+     * associations. </p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of rule associations that you want to return in the
+     * response to a <code>ListResolverRuleAssociations</code> request. If you don't
+     * specify a value for <code>MaxResults</code>, Resolver returns up to 100 rule
+     * associations. </p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of rule associations that you want to return in the
+     * response to a <code>ListResolverRuleAssociations</code> request. If you don't
+     * specify a value for <code>MaxResults</code>, Resolver returns up to 100 rule
+     * associations. </p>
+     */
+    inline ListResolverRuleAssociationsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRuleAssociationsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRuleAssociationsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverRuleAssociation</code> request, omit this
+     * value.</p> <p>If you have more than <code>MaxResults</code> rule associations,
+     * you can submit another <code>ListResolverRuleAssociation</code> request to get
+     * the next group of rule associations. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRuleAssociationsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline const Aws::Vector<Filter>& GetFilters() const{ return m_filters; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline void SetFilters(const Aws::Vector<Filter>& value) { m_filtersHasBeenSet = true; m_filters = value; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline void SetFilters(Aws::Vector<Filter>&& value) { m_filtersHasBeenSet = true; m_filters = std::move(value); }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRuleAssociationsRequest& WithFilters(const Aws::Vector<Filter>& value) { SetFilters(value); return *this;}
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRuleAssociationsRequest& WithFilters(Aws::Vector<Filter>&& value) { SetFilters(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRuleAssociationsRequest& AddFilters(const Filter& value) { m_filtersHasBeenSet = true; m_filters.push_back(value); return *this; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as
+     * resolver rules that are associated with the same VPC ID.</p>  <p>If you
+     * submit a second or subsequent <code>ListResolverRuleAssociations</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRuleAssociationsRequest& AddFilters(Filter&& value) { m_filtersHasBeenSet = true; m_filters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    Aws::Vector<Filter> m_filters;
+    bool m_filtersHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverRuleAssociationsResult.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/ResolverRuleAssociation.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API ListResolverRuleAssociationsResult
+  {
+  public:
+    ListResolverRuleAssociationsResult();
+    ListResolverRuleAssociationsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListResolverRuleAssociationsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRuleAssociationsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRuleAssociationsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> rule associations match the specified
+     * criteria, you can submit another <code>ListResolverRuleAssociation</code>
+     * request to get the next group of results. In the next request, specify the value
+     * of <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRuleAssociationsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResults = value; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline ListResolverRuleAssociationsResult& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline const Aws::Vector<ResolverRuleAssociation>& GetResolverRuleAssociations() const{ return m_resolverRuleAssociations; }
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline void SetResolverRuleAssociations(const Aws::Vector<ResolverRuleAssociation>& value) { m_resolverRuleAssociations = value; }
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline void SetResolverRuleAssociations(Aws::Vector<ResolverRuleAssociation>&& value) { m_resolverRuleAssociations = std::move(value); }
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline ListResolverRuleAssociationsResult& WithResolverRuleAssociations(const Aws::Vector<ResolverRuleAssociation>& value) { SetResolverRuleAssociations(value); return *this;}
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline ListResolverRuleAssociationsResult& WithResolverRuleAssociations(Aws::Vector<ResolverRuleAssociation>&& value) { SetResolverRuleAssociations(std::move(value)); return *this;}
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline ListResolverRuleAssociationsResult& AddResolverRuleAssociations(const ResolverRuleAssociation& value) { m_resolverRuleAssociations.push_back(value); return *this; }
+
+    /**
+     * <p>The associations that were created between resolver rules and VPCs using the
+     * current AWS account, and that match the specified filters, if any.</p>
+     */
+    inline ListResolverRuleAssociationsResult& AddResolverRuleAssociations(ResolverRuleAssociation&& value) { m_resolverRuleAssociations.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    int m_maxResults;
+
+    Aws::Vector<ResolverRuleAssociation> m_resolverRuleAssociations;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverRulesRequest.h

@@ -0,0 +1,227 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/Filter.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API ListResolverRulesRequest : public Route53ResolverRequest
+  {
+  public:
+    ListResolverRulesRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListResolverRules"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The maximum number of resolver rules that you want to return in the response
+     * to a <code>ListResolverRules</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 resolver rules.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of resolver rules that you want to return in the response
+     * to a <code>ListResolverRules</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 resolver rules.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of resolver rules that you want to return in the response
+     * to a <code>ListResolverRules</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 resolver rules.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of resolver rules that you want to return in the response
+     * to a <code>ListResolverRules</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 resolver rules.</p>
+     */
+    inline ListResolverRulesRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline ListResolverRulesRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline ListResolverRulesRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>For the first <code>ListResolverRules</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> resolver rules, you can submit
+     * another <code>ListResolverRules</code> request to get the next group of resolver
+     * rules. In the next request, specify the value of <code>NextToken</code> from the
+     * previous response. </p>
+     */
+    inline ListResolverRulesRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline const Aws::Vector<Filter>& GetFilters() const{ return m_filters; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline void SetFilters(const Aws::Vector<Filter>& value) { m_filtersHasBeenSet = true; m_filters = value; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline void SetFilters(Aws::Vector<Filter>&& value) { m_filtersHasBeenSet = true; m_filters = std::move(value); }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRulesRequest& WithFilters(const Aws::Vector<Filter>& value) { SetFilters(value); return *this;}
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRulesRequest& WithFilters(Aws::Vector<Filter>&& value) { SetFilters(std::move(value)); return *this;}
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRulesRequest& AddFilters(const Filter& value) { m_filtersHasBeenSet = true; m_filters.push_back(value); return *this; }
+
+    /**
+     * <p>An optional specification to return a subset of resolver rules, such as all
+     * resolver rules that are associated with the same resolver endpoint.</p> 
+     * <p>If you submit a second or subsequent <code>ListResolverRules</code> request
+     * and specify the <code>NextToken</code> parameter, you must use the same values
+     * for <code>Filters</code>, if any, as in the previous request.</p> 
+     */
+    inline ListResolverRulesRequest& AddFilters(Filter&& value) { m_filtersHasBeenSet = true; m_filters.push_back(std::move(value)); return *this; }
+
+  private:
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    Aws::Vector<Filter> m_filters;
+    bool m_filtersHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListResolverRulesResult.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/ResolverRule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API ListResolverRulesResult
+  {
+  public:
+    ListResolverRulesResult();
+    ListResolverRulesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListResolverRulesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRulesResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRulesResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> resolver rules match the specified
+     * criteria, you can submit another <code>ListResolverRules</code> request to get
+     * the next group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListResolverRulesResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResults = value; }
+
+    /**
+     * <p>The value that you specified for <code>MaxResults</code> in the request.</p>
+     */
+    inline ListResolverRulesResult& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline const Aws::Vector<ResolverRule>& GetResolverRules() const{ return m_resolverRules; }
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline void SetResolverRules(const Aws::Vector<ResolverRule>& value) { m_resolverRules = value; }
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline void SetResolverRules(Aws::Vector<ResolverRule>&& value) { m_resolverRules = std::move(value); }
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline ListResolverRulesResult& WithResolverRules(const Aws::Vector<ResolverRule>& value) { SetResolverRules(value); return *this;}
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline ListResolverRulesResult& WithResolverRules(Aws::Vector<ResolverRule>&& value) { SetResolverRules(std::move(value)); return *this;}
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline ListResolverRulesResult& AddResolverRules(const ResolverRule& value) { m_resolverRules.push_back(value); return *this; }
+
+    /**
+     * <p>The resolver rules that were created using the current AWS account and that
+     * match the specified filters, if any.</p>
+     */
+    inline ListResolverRulesResult& AddResolverRules(ResolverRule&& value) { m_resolverRules.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_nextToken;
+
+    int m_maxResults;
+
+    Aws::Vector<ResolverRule> m_resolverRules;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListTagsForResourceRequest.h

@@ -0,0 +1,201 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API ListTagsForResourceRequest : public Route53ResolverRequest
+  {
+  public:
+    ListTagsForResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "ListTagsForResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to list tags
+     * for.</p>
+     */
+    inline ListTagsForResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of tags that you want to return in the response to a
+     * <code>ListTagsForResource</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 tags.</p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of tags that you want to return in the response to a
+     * <code>ListTagsForResource</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 tags.</p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of tags that you want to return in the response to a
+     * <code>ListTagsForResource</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 tags.</p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of tags that you want to return in the response to a
+     * <code>ListTagsForResource</code> request. If you don't specify a value for
+     * <code>MaxResults</code>, Resolver returns up to 100 tags.</p>
+     */
+    inline ListTagsForResourceRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>For the first <code>ListTagsForResource</code> request, omit this value.</p>
+     * <p>If you have more than <code>MaxResults</code> tags, you can submit another
+     * <code>ListTagsForResource</code> request to get the next group of tags for the
+     * resource. In the next request, specify the value of <code>NextToken</code> from
+     * the previous response. </p>
+     */
+    inline ListTagsForResourceRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ListTagsForResourceResult.h

@@ -0,0 +1,145 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API ListTagsForResourceResult
+  {
+  public:
+    ListTagsForResourceResult();
+    ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tags = value; }
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tags = std::move(value); }
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline ListTagsForResourceResult& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(const Tag& value) { m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The tags that are associated with the resource that you specified in the
+     * <code>ListTagsForResource</code> request.</p>
+     */
+    inline ListTagsForResourceResult& AddTags(Tag&& value) { m_tags.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>If more than <code>MaxResults</code> tags match the specified criteria, you
+     * can submit another <code>ListTagsForResource</code> request to get the next
+     * group of results. In the next request, specify the value of
+     * <code>NextToken</code> from the previous response. </p>
+     */
+    inline ListTagsForResourceResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<Tag> m_tags;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/PutResolverRulePolicyRequest.h

@@ -0,0 +1,145 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API PutResolverRulePolicyRequest : public Route53ResolverRequest
+  {
+  public:
+    PutResolverRulePolicyRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "PutResolverRulePolicy"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline PutResolverRulePolicyRequest& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline PutResolverRulePolicyRequest& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) of the account that you want to grant
+     * permissions to.</p>
+     */
+    inline PutResolverRulePolicyRequest& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline const Aws::String& GetResolverRulePolicy() const{ return m_resolverRulePolicy; }
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline bool ResolverRulePolicyHasBeenSet() const { return m_resolverRulePolicyHasBeenSet; }
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline void SetResolverRulePolicy(const Aws::String& value) { m_resolverRulePolicyHasBeenSet = true; m_resolverRulePolicy = value; }
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline void SetResolverRulePolicy(Aws::String&& value) { m_resolverRulePolicyHasBeenSet = true; m_resolverRulePolicy = std::move(value); }
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline void SetResolverRulePolicy(const char* value) { m_resolverRulePolicyHasBeenSet = true; m_resolverRulePolicy.assign(value); }
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline PutResolverRulePolicyRequest& WithResolverRulePolicy(const Aws::String& value) { SetResolverRulePolicy(value); return *this;}
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline PutResolverRulePolicyRequest& WithResolverRulePolicy(Aws::String&& value) { SetResolverRulePolicy(std::move(value)); return *this;}
+
+    /**
+     * <p>An AWS Identity and Access Management policy statement that lists the
+     * permissions that you want to grant to another AWS account.</p>
+     */
+    inline PutResolverRulePolicyRequest& WithResolverRulePolicy(const char* value) { SetResolverRulePolicy(value); return *this;}
+
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_resolverRulePolicy;
+    bool m_resolverRulePolicyHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/PutResolverRulePolicyResult.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  /**
+   * <p>The response to a <code>PutResolverRulePolicy</code> request.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/PutResolverRulePolicyResponse">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API PutResolverRulePolicyResult
+  {
+  public:
+    PutResolverRulePolicyResult();
+    PutResolverRulePolicyResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    PutResolverRulePolicyResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Whether the <code>PutResolverRulePolicy</code> request was successful.</p>
+     */
+    inline bool GetReturnValue() const{ return m_returnValue; }
+
+    /**
+     * <p>Whether the <code>PutResolverRulePolicy</code> request was successful.</p>
+     */
+    inline void SetReturnValue(bool value) { m_returnValue = value; }
+
+    /**
+     * <p>Whether the <code>PutResolverRulePolicy</code> request was successful.</p>
+     */
+    inline PutResolverRulePolicyResult& WithReturnValue(bool value) { SetReturnValue(value); return *this;}
+
+  private:
+
+    bool m_returnValue;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverEndpoint.h

@@ -0,0 +1,615 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/ResolverEndpointDirection.h>
+#include <aws/route53resolver/model/ResolverEndpointStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In the response to a <a>CreateResolverEndpoint</a>,
+   * <a>DeleteResolverEndpoint</a>, <a>GetResolverEndpoint</a>,
+   * <a>ListResolverEndpoints</a>, or <a>UpdateResolverEndpoint</a> request, a
+   * complex type that contains settings for an existing inbound or outbound resolver
+   * endpoint.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResolverEndpoint">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResolverEndpoint
+  {
+  public:
+    ResolverEndpoint();
+    ResolverEndpoint(Aws::Utils::Json::JsonView jsonValue);
+    ResolverEndpoint& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline const Aws::String& GetCreatorRequestId() const{ return m_creatorRequestId; }
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline bool CreatorRequestIdHasBeenSet() const { return m_creatorRequestIdHasBeenSet; }
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline void SetCreatorRequestId(const Aws::String& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = value; }
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline void SetCreatorRequestId(Aws::String&& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = std::move(value); }
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline void SetCreatorRequestId(const char* value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId.assign(value); }
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline ResolverEndpoint& WithCreatorRequestId(const Aws::String& value) { SetCreatorRequestId(value); return *this;}
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline ResolverEndpoint& WithCreatorRequestId(Aws::String&& value) { SetCreatorRequestId(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique string that identifies the request that created the resolver
+     * endpoint. The <code>CreatorRequestId</code> allows failed requests to be retried
+     * without the risk of executing the operation twice.</p>
+     */
+    inline ResolverEndpoint& WithCreatorRequestId(const char* value) { SetCreatorRequestId(value); return *this;}
+
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline ResolverEndpoint& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline ResolverEndpoint& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name that you assigned to the resolver endpoint when you submitted a
+     * <a>CreateResolverEndpoint</a> request.</p>
+     */
+    inline ResolverEndpoint& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const{ return m_securityGroupIds; }
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline void SetSecurityGroupIds(const Aws::Vector<Aws::String>& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = value; }
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline void SetSecurityGroupIds(Aws::Vector<Aws::String>&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds = std::move(value); }
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline ResolverEndpoint& WithSecurityGroupIds(const Aws::Vector<Aws::String>& value) { SetSecurityGroupIds(value); return *this;}
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline ResolverEndpoint& WithSecurityGroupIds(Aws::Vector<Aws::String>&& value) { SetSecurityGroupIds(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline ResolverEndpoint& AddSecurityGroupIds(const Aws::String& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline ResolverEndpoint& AddSecurityGroupIds(Aws::String&& value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The ID of one or more security groups that control access to this VPC. The
+     * security group must include one or more inbound resolver rules.</p>
+     */
+    inline ResolverEndpoint& AddSecurityGroupIds(const char* value) { m_securityGroupIdsHasBeenSet = true; m_securityGroupIds.push_back(value); return *this; }
+
+
+    /**
+     * <p>Indicates whether the resolver endpoint allows inbound or outbound DNS
+     * queries:</p> <ul> <li> <p> <code>INBOUND</code>: allows DNS queries to your VPC
+     * from your network or another VPC</p> </li> <li> <p> <code>OUTBOUND</code>:
+     * allows DNS queries from your VPC to your network or another VPC</p> </li> </ul>
+     */
+    inline const ResolverEndpointDirection& GetDirection() const{ return m_direction; }
+
+    /**
+     * <p>Indicates whether the resolver endpoint allows inbound or outbound DNS
+     * queries:</p> <ul> <li> <p> <code>INBOUND</code>: allows DNS queries to your VPC
+     * from your network or another VPC</p> </li> <li> <p> <code>OUTBOUND</code>:
+     * allows DNS queries from your VPC to your network or another VPC</p> </li> </ul>
+     */
+    inline bool DirectionHasBeenSet() const { return m_directionHasBeenSet; }
+
+    /**
+     * <p>Indicates whether the resolver endpoint allows inbound or outbound DNS
+     * queries:</p> <ul> <li> <p> <code>INBOUND</code>: allows DNS queries to your VPC
+     * from your network or another VPC</p> </li> <li> <p> <code>OUTBOUND</code>:
+     * allows DNS queries from your VPC to your network or another VPC</p> </li> </ul>
+     */
+    inline void SetDirection(const ResolverEndpointDirection& value) { m_directionHasBeenSet = true; m_direction = value; }
+
+    /**
+     * <p>Indicates whether the resolver endpoint allows inbound or outbound DNS
+     * queries:</p> <ul> <li> <p> <code>INBOUND</code>: allows DNS queries to your VPC
+     * from your network or another VPC</p> </li> <li> <p> <code>OUTBOUND</code>:
+     * allows DNS queries from your VPC to your network or another VPC</p> </li> </ul>
+     */
+    inline void SetDirection(ResolverEndpointDirection&& value) { m_directionHasBeenSet = true; m_direction = std::move(value); }
+
+    /**
+     * <p>Indicates whether the resolver endpoint allows inbound or outbound DNS
+     * queries:</p> <ul> <li> <p> <code>INBOUND</code>: allows DNS queries to your VPC
+     * from your network or another VPC</p> </li> <li> <p> <code>OUTBOUND</code>:
+     * allows DNS queries from your VPC to your network or another VPC</p> </li> </ul>
+     */
+    inline ResolverEndpoint& WithDirection(const ResolverEndpointDirection& value) { SetDirection(value); return *this;}
+
+    /**
+     * <p>Indicates whether the resolver endpoint allows inbound or outbound DNS
+     * queries:</p> <ul> <li> <p> <code>INBOUND</code>: allows DNS queries to your VPC
+     * from your network or another VPC</p> </li> <li> <p> <code>OUTBOUND</code>:
+     * allows DNS queries from your VPC to your network or another VPC</p> </li> </ul>
+     */
+    inline ResolverEndpoint& WithDirection(ResolverEndpointDirection&& value) { SetDirection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The number of IP addresses that the resolver endpoint can use for DNS
+     * queries.</p>
+     */
+    inline int GetIpAddressCount() const{ return m_ipAddressCount; }
+
+    /**
+     * <p>The number of IP addresses that the resolver endpoint can use for DNS
+     * queries.</p>
+     */
+    inline bool IpAddressCountHasBeenSet() const { return m_ipAddressCountHasBeenSet; }
+
+    /**
+     * <p>The number of IP addresses that the resolver endpoint can use for DNS
+     * queries.</p>
+     */
+    inline void SetIpAddressCount(int value) { m_ipAddressCountHasBeenSet = true; m_ipAddressCount = value; }
+
+    /**
+     * <p>The number of IP addresses that the resolver endpoint can use for DNS
+     * queries.</p>
+     */
+    inline ResolverEndpoint& WithIpAddressCount(int value) { SetIpAddressCount(value); return *this;}
+
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline const Aws::String& GetHostVPCId() const{ return m_hostVPCId; }
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline bool HostVPCIdHasBeenSet() const { return m_hostVPCIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline void SetHostVPCId(const Aws::String& value) { m_hostVPCIdHasBeenSet = true; m_hostVPCId = value; }
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline void SetHostVPCId(Aws::String&& value) { m_hostVPCIdHasBeenSet = true; m_hostVPCId = std::move(value); }
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline void SetHostVPCId(const char* value) { m_hostVPCIdHasBeenSet = true; m_hostVPCId.assign(value); }
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline ResolverEndpoint& WithHostVPCId(const Aws::String& value) { SetHostVPCId(value); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline ResolverEndpoint& WithHostVPCId(Aws::String&& value) { SetHostVPCId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you want to create the resolver endpoint in.</p>
+     */
+    inline ResolverEndpoint& WithHostVPCId(const char* value) { SetHostVPCId(value); return *this;}
+
+
+    /**
+     * <p>A code that specifies the current status of the resolver endpoint.</p>
+     */
+    inline const ResolverEndpointStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>A code that specifies the current status of the resolver endpoint.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>A code that specifies the current status of the resolver endpoint.</p>
+     */
+    inline void SetStatus(const ResolverEndpointStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>A code that specifies the current status of the resolver endpoint.</p>
+     */
+    inline void SetStatus(ResolverEndpointStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>A code that specifies the current status of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithStatus(const ResolverEndpointStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>A code that specifies the current status of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithStatus(ResolverEndpointStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline const Aws::String& GetStatusMessage() const{ return m_statusMessage; }
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline void SetStatusMessage(const Aws::String& value) { m_statusMessageHasBeenSet = true; m_statusMessage = value; }
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline void SetStatusMessage(Aws::String&& value) { m_statusMessageHasBeenSet = true; m_statusMessage = std::move(value); }
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline void SetStatusMessage(const char* value) { m_statusMessageHasBeenSet = true; m_statusMessage.assign(value); }
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithStatusMessage(const Aws::String& value) { SetStatusMessage(value); return *this;}
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithStatusMessage(Aws::String&& value) { SetStatusMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A detailed description of the status of the resolver endpoint.</p>
+     */
+    inline ResolverEndpoint& WithStatusMessage(const char* value) { SetStatusMessage(value); return *this;}
+
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline const Aws::String& GetCreationTime() const{ return m_creationTime; }
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetCreationTime(const Aws::String& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetCreationTime(Aws::String&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetCreationTime(const char* value) { m_creationTimeHasBeenSet = true; m_creationTime.assign(value); }
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline ResolverEndpoint& WithCreationTime(const Aws::String& value) { SetCreationTime(value); return *this;}
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline ResolverEndpoint& WithCreationTime(Aws::String&& value) { SetCreationTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The date and time that the endpoint was created, in Unix time format and
+     * Coordinated Universal Time (UTC).</p>
+     */
+    inline ResolverEndpoint& WithCreationTime(const char* value) { SetCreationTime(value); return *this;}
+
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline const Aws::String& GetModificationTime() const{ return m_modificationTime; }
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline bool ModificationTimeHasBeenSet() const { return m_modificationTimeHasBeenSet; }
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetModificationTime(const Aws::String& value) { m_modificationTimeHasBeenSet = true; m_modificationTime = value; }
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetModificationTime(Aws::String&& value) { m_modificationTimeHasBeenSet = true; m_modificationTime = std::move(value); }
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline void SetModificationTime(const char* value) { m_modificationTimeHasBeenSet = true; m_modificationTime.assign(value); }
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline ResolverEndpoint& WithModificationTime(const Aws::String& value) { SetModificationTime(value); return *this;}
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline ResolverEndpoint& WithModificationTime(Aws::String&& value) { SetModificationTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The date and time that the endpoint was last modified, in Unix time format
+     * and Coordinated Universal Time (UTC).</p>
+     */
+    inline ResolverEndpoint& WithModificationTime(const char* value) { SetModificationTime(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    Aws::String m_creatorRequestId;
+    bool m_creatorRequestIdHasBeenSet;
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<Aws::String> m_securityGroupIds;
+    bool m_securityGroupIdsHasBeenSet;
+
+    ResolverEndpointDirection m_direction;
+    bool m_directionHasBeenSet;
+
+    int m_ipAddressCount;
+    bool m_ipAddressCountHasBeenSet;
+
+    Aws::String m_hostVPCId;
+    bool m_hostVPCIdHasBeenSet;
+
+    ResolverEndpointStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::String m_statusMessage;
+    bool m_statusMessageHasBeenSet;
+
+    Aws::String m_creationTime;
+    bool m_creationTimeHasBeenSet;
+
+    Aws::String m_modificationTime;
+    bool m_modificationTimeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverEndpointDirection.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class ResolverEndpointDirection
+  {
+    NOT_SET,
+    INBOUND,
+    OUTBOUND
+  };
+
+namespace ResolverEndpointDirectionMapper
+{
+AWS_ROUTE53RESOLVER_API ResolverEndpointDirection GetResolverEndpointDirectionForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForResolverEndpointDirection(ResolverEndpointDirection value);
+} // namespace ResolverEndpointDirectionMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverEndpointStatus.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class ResolverEndpointStatus
+  {
+    NOT_SET,
+    CREATING,
+    OPERATIONAL,
+    UPDATING,
+    AUTO_RECOVERING,
+    ACTION_NEEDED,
+    DELETING
+  };
+
+namespace ResolverEndpointStatusMapper
+{
+AWS_ROUTE53RESOLVER_API ResolverEndpointStatus GetResolverEndpointStatusForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForResolverEndpointStatus(ResolverEndpointStatus value);
+} // namespace ResolverEndpointStatusMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverRule.h

@@ -0,0 +1,642 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/ResolverRuleStatus.h>
+#include <aws/route53resolver/model/RuleTypeOption.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/ShareStatus.h>
+#include <aws/route53resolver/model/TargetAddress.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>For queries that originate in your VPC, detailed information about a resolver
+   * rule, which specifies how to route DNS queries out of the VPC. The
+   * <code>ResolverRule</code> parameter appears in the response to a
+   * <a>CreateResolverRule</a>, <a>DeleteResolverRule</a>, <a>GetResolverRule</a>,
+   * <a>ListResolverRules</a>, or <a>UpdateResolverRule</a> request.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResolverRule">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResolverRule
+  {
+  public:
+    ResolverRule();
+    ResolverRule(Aws::Utils::Json::JsonView jsonValue);
+    ResolverRule& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline ResolverRule& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline ResolverRule& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID that Resolver assigned to the resolver rule when you created it.</p>
+     */
+    inline ResolverRule& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline const Aws::String& GetCreatorRequestId() const{ return m_creatorRequestId; }
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline bool CreatorRequestIdHasBeenSet() const { return m_creatorRequestIdHasBeenSet; }
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline void SetCreatorRequestId(const Aws::String& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = value; }
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline void SetCreatorRequestId(Aws::String&& value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId = std::move(value); }
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline void SetCreatorRequestId(const char* value) { m_creatorRequestIdHasBeenSet = true; m_creatorRequestId.assign(value); }
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline ResolverRule& WithCreatorRequestId(const Aws::String& value) { SetCreatorRequestId(value); return *this;}
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline ResolverRule& WithCreatorRequestId(Aws::String&& value) { SetCreatorRequestId(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique string that you specified when you created the resolver rule.
+     * <code>CreatorRequestId</code>identifies the request and allows failed requests
+     * to be retried without the risk of executing the operation twice. </p>
+     */
+    inline ResolverRule& WithCreatorRequestId(const char* value) { SetCreatorRequestId(value); return *this;}
+
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline ResolverRule& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline ResolverRule& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The ARN (Amazon Resource Name) for the resolver rule specified by
+     * <code>Id</code>.</p>
+     */
+    inline ResolverRule& WithArn(const char* value) { SetArn(value); return *this;}
+
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline const Aws::String& GetDomainName() const{ return m_domainName; }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline ResolverRule& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline ResolverRule& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}
+
+    /**
+     * <p>DNS queries for this domain name are forwarded to the IP addresses that are
+     * specified in <code>TargetIps</code>. If a query matches multiple resolver rules
+     * (example.com and www.example.com), the query is routed using the resolver rule
+     * that contains the most specific domain name (www.example.com).</p>
+     */
+    inline ResolverRule& WithDomainName(const char* value) { SetDomainName(value); return *this;}
+
+
+    /**
+     * <p>A code that specifies the current status of the resolver rule.</p>
+     */
+    inline const ResolverRuleStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>A code that specifies the current status of the resolver rule.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>A code that specifies the current status of the resolver rule.</p>
+     */
+    inline void SetStatus(const ResolverRuleStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>A code that specifies the current status of the resolver rule.</p>
+     */
+    inline void SetStatus(ResolverRuleStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>A code that specifies the current status of the resolver rule.</p>
+     */
+    inline ResolverRule& WithStatus(const ResolverRuleStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>A code that specifies the current status of the resolver rule.</p>
+     */
+    inline ResolverRule& WithStatus(ResolverRuleStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline const Aws::String& GetStatusMessage() const{ return m_statusMessage; }
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline void SetStatusMessage(const Aws::String& value) { m_statusMessageHasBeenSet = true; m_statusMessage = value; }
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline void SetStatusMessage(Aws::String&& value) { m_statusMessageHasBeenSet = true; m_statusMessage = std::move(value); }
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline void SetStatusMessage(const char* value) { m_statusMessageHasBeenSet = true; m_statusMessage.assign(value); }
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline ResolverRule& WithStatusMessage(const Aws::String& value) { SetStatusMessage(value); return *this;}
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline ResolverRule& WithStatusMessage(Aws::String&& value) { SetStatusMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A detailed description of the status of a resolver rule.</p>
+     */
+    inline ResolverRule& WithStatusMessage(const char* value) { SetStatusMessage(value); return *this;}
+
+
+    /**
+     * <p>This value is always <code>FORWARD</code>. Other resolver rule types aren't
+     * supported.</p>
+     */
+    inline const RuleTypeOption& GetRuleType() const{ return m_ruleType; }
+
+    /**
+     * <p>This value is always <code>FORWARD</code>. Other resolver rule types aren't
+     * supported.</p>
+     */
+    inline bool RuleTypeHasBeenSet() const { return m_ruleTypeHasBeenSet; }
+
+    /**
+     * <p>This value is always <code>FORWARD</code>. Other resolver rule types aren't
+     * supported.</p>
+     */
+    inline void SetRuleType(const RuleTypeOption& value) { m_ruleTypeHasBeenSet = true; m_ruleType = value; }
+
+    /**
+     * <p>This value is always <code>FORWARD</code>. Other resolver rule types aren't
+     * supported.</p>
+     */
+    inline void SetRuleType(RuleTypeOption&& value) { m_ruleTypeHasBeenSet = true; m_ruleType = std::move(value); }
+
+    /**
+     * <p>This value is always <code>FORWARD</code>. Other resolver rule types aren't
+     * supported.</p>
+     */
+    inline ResolverRule& WithRuleType(const RuleTypeOption& value) { SetRuleType(value); return *this;}
+
+    /**
+     * <p>This value is always <code>FORWARD</code>. Other resolver rule types aren't
+     * supported.</p>
+     */
+    inline ResolverRule& WithRuleType(RuleTypeOption&& value) { SetRuleType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline ResolverRule& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline ResolverRule& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name for the resolver rule, which you specified when you created the
+     * resolver rule.</p>
+     */
+    inline ResolverRule& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline const Aws::Vector<TargetAddress>& GetTargetIps() const{ return m_targetIps; }
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline bool TargetIpsHasBeenSet() const { return m_targetIpsHasBeenSet; }
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline void SetTargetIps(const Aws::Vector<TargetAddress>& value) { m_targetIpsHasBeenSet = true; m_targetIps = value; }
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline void SetTargetIps(Aws::Vector<TargetAddress>&& value) { m_targetIpsHasBeenSet = true; m_targetIps = std::move(value); }
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline ResolverRule& WithTargetIps(const Aws::Vector<TargetAddress>& value) { SetTargetIps(value); return *this;}
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline ResolverRule& WithTargetIps(Aws::Vector<TargetAddress>&& value) { SetTargetIps(std::move(value)); return *this;}
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline ResolverRule& AddTargetIps(const TargetAddress& value) { m_targetIpsHasBeenSet = true; m_targetIps.push_back(value); return *this; }
+
+    /**
+     * <p>An array that contains the IP addresses and ports that you want to forward
+     * </p>
+     */
+    inline ResolverRule& AddTargetIps(TargetAddress&& value) { m_targetIpsHasBeenSet = true; m_targetIps.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline ResolverRule& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline ResolverRule& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the endpoint that the rule is associated with.</p>
+     */
+    inline ResolverRule& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline const Aws::String& GetOwnerId() const{ return m_ownerId; }
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline bool OwnerIdHasBeenSet() const { return m_ownerIdHasBeenSet; }
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline void SetOwnerId(const Aws::String& value) { m_ownerIdHasBeenSet = true; m_ownerId = value; }
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline void SetOwnerId(Aws::String&& value) { m_ownerIdHasBeenSet = true; m_ownerId = std::move(value); }
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline void SetOwnerId(const char* value) { m_ownerIdHasBeenSet = true; m_ownerId.assign(value); }
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline ResolverRule& WithOwnerId(const Aws::String& value) { SetOwnerId(value); return *this;}
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline ResolverRule& WithOwnerId(Aws::String&& value) { SetOwnerId(std::move(value)); return *this;}
+
+    /**
+     * <p>When a rule is shared with another AWS account, the account ID of the account
+     * that the rule is shared with.</p>
+     */
+    inline ResolverRule& WithOwnerId(const char* value) { SetOwnerId(value); return *this;}
+
+
+    /**
+     * <p>Whether the rules is shared and, if so, whether the current account is
+     * sharing the rule with another account, or another account is sharing the rule
+     * with the current account.</p>
+     */
+    inline const ShareStatus& GetShareStatus() const{ return m_shareStatus; }
+
+    /**
+     * <p>Whether the rules is shared and, if so, whether the current account is
+     * sharing the rule with another account, or another account is sharing the rule
+     * with the current account.</p>
+     */
+    inline bool ShareStatusHasBeenSet() const { return m_shareStatusHasBeenSet; }
+
+    /**
+     * <p>Whether the rules is shared and, if so, whether the current account is
+     * sharing the rule with another account, or another account is sharing the rule
+     * with the current account.</p>
+     */
+    inline void SetShareStatus(const ShareStatus& value) { m_shareStatusHasBeenSet = true; m_shareStatus = value; }
+
+    /**
+     * <p>Whether the rules is shared and, if so, whether the current account is
+     * sharing the rule with another account, or another account is sharing the rule
+     * with the current account.</p>
+     */
+    inline void SetShareStatus(ShareStatus&& value) { m_shareStatusHasBeenSet = true; m_shareStatus = std::move(value); }
+
+    /**
+     * <p>Whether the rules is shared and, if so, whether the current account is
+     * sharing the rule with another account, or another account is sharing the rule
+     * with the current account.</p>
+     */
+    inline ResolverRule& WithShareStatus(const ShareStatus& value) { SetShareStatus(value); return *this;}
+
+    /**
+     * <p>Whether the rules is shared and, if so, whether the current account is
+     * sharing the rule with another account, or another account is sharing the rule
+     * with the current account.</p>
+     */
+    inline ResolverRule& WithShareStatus(ShareStatus&& value) { SetShareStatus(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    Aws::String m_creatorRequestId;
+    bool m_creatorRequestIdHasBeenSet;
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet;
+
+    Aws::String m_domainName;
+    bool m_domainNameHasBeenSet;
+
+    ResolverRuleStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::String m_statusMessage;
+    bool m_statusMessageHasBeenSet;
+
+    RuleTypeOption m_ruleType;
+    bool m_ruleTypeHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<TargetAddress> m_targetIps;
+    bool m_targetIpsHasBeenSet;
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+
+    Aws::String m_ownerId;
+    bool m_ownerIdHasBeenSet;
+
+    ShareStatus m_shareStatus;
+    bool m_shareStatusHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverRuleAssociation.h

@@ -0,0 +1,332 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/ResolverRuleAssociationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In the response to an <a>AssociateResolverRule</a>,
+   * <a>DisassociateResolverRule</a>, or <a>ListResolverRuleAssociations</a> request,
+   * information about an association between a resolver rule and a
+   * VPC.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResolverRuleAssociation">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResolverRuleAssociation
+  {
+  public:
+    ResolverRuleAssociation();
+    ResolverRuleAssociation(Aws::Utils::Json::JsonView jsonValue);
+    ResolverRuleAssociation& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline ResolverRuleAssociation& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline ResolverRuleAssociation& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the association between a resolver rule and a VPC. Resolver assigns
+     * this value when you submit an <a>AssociateResolverRule</a> request.</p>
+     */
+    inline ResolverRuleAssociation& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline const Aws::String& GetResolverRuleId() const{ return m_resolverRuleId; }
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline bool ResolverRuleIdHasBeenSet() const { return m_resolverRuleIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline void SetResolverRuleId(const Aws::String& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = value; }
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline void SetResolverRuleId(Aws::String&& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline void SetResolverRuleId(const char* value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline ResolverRuleAssociation& WithResolverRuleId(const Aws::String& value) { SetResolverRuleId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline ResolverRuleAssociation& WithResolverRuleId(Aws::String&& value) { SetResolverRuleId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you associated with the VPC that is
+     * specified by <code>VPCId</code>.</p>
+     */
+    inline ResolverRuleAssociation& WithResolverRuleId(const char* value) { SetResolverRuleId(value); return *this;}
+
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of an association between a resolver rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline const Aws::String& GetVPCId() const{ return m_vPCId; }
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline bool VPCIdHasBeenSet() const { return m_vPCIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline void SetVPCId(const Aws::String& value) { m_vPCIdHasBeenSet = true; m_vPCId = value; }
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline void SetVPCId(Aws::String&& value) { m_vPCIdHasBeenSet = true; m_vPCId = std::move(value); }
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline void SetVPCId(const char* value) { m_vPCIdHasBeenSet = true; m_vPCId.assign(value); }
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline ResolverRuleAssociation& WithVPCId(const Aws::String& value) { SetVPCId(value); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline ResolverRuleAssociation& WithVPCId(Aws::String&& value) { SetVPCId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the VPC that you associated the resolver rule with.</p>
+     */
+    inline ResolverRuleAssociation& WithVPCId(const char* value) { SetVPCId(value); return *this;}
+
+
+    /**
+     * <p>A code that specifies the current status of the association between a
+     * resolver rule and a VPC.</p>
+     */
+    inline const ResolverRuleAssociationStatus& GetStatus() const{ return m_status; }
+
+    /**
+     * <p>A code that specifies the current status of the association between a
+     * resolver rule and a VPC.</p>
+     */
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+
+    /**
+     * <p>A code that specifies the current status of the association between a
+     * resolver rule and a VPC.</p>
+     */
+    inline void SetStatus(const ResolverRuleAssociationStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+
+    /**
+     * <p>A code that specifies the current status of the association between a
+     * resolver rule and a VPC.</p>
+     */
+    inline void SetStatus(ResolverRuleAssociationStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+
+    /**
+     * <p>A code that specifies the current status of the association between a
+     * resolver rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithStatus(const ResolverRuleAssociationStatus& value) { SetStatus(value); return *this;}
+
+    /**
+     * <p>A code that specifies the current status of the association between a
+     * resolver rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithStatus(ResolverRuleAssociationStatus&& value) { SetStatus(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline const Aws::String& GetStatusMessage() const{ return m_statusMessage; }
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline void SetStatusMessage(const Aws::String& value) { m_statusMessageHasBeenSet = true; m_statusMessage = value; }
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline void SetStatusMessage(Aws::String&& value) { m_statusMessageHasBeenSet = true; m_statusMessage = std::move(value); }
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline void SetStatusMessage(const char* value) { m_statusMessageHasBeenSet = true; m_statusMessage.assign(value); }
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithStatusMessage(const Aws::String& value) { SetStatusMessage(value); return *this;}
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithStatusMessage(Aws::String&& value) { SetStatusMessage(std::move(value)); return *this;}
+
+    /**
+     * <p>A detailed description of the status of the association between a resolver
+     * rule and a VPC.</p>
+     */
+    inline ResolverRuleAssociation& WithStatusMessage(const char* value) { SetStatusMessage(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    Aws::String m_resolverRuleId;
+    bool m_resolverRuleIdHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::String m_vPCId;
+    bool m_vPCIdHasBeenSet;
+
+    ResolverRuleAssociationStatus m_status;
+    bool m_statusHasBeenSet;
+
+    Aws::String m_statusMessage;
+    bool m_statusMessageHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverRuleAssociationStatus.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class ResolverRuleAssociationStatus
+  {
+    NOT_SET,
+    CREATING,
+    COMPLETE,
+    DELETING,
+    FAILED,
+    OVERRIDDEN
+  };
+
+namespace ResolverRuleAssociationStatusMapper
+{
+AWS_ROUTE53RESOLVER_API ResolverRuleAssociationStatus GetResolverRuleAssociationStatusForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForResolverRuleAssociationStatus(ResolverRuleAssociationStatus value);
+} // namespace ResolverRuleAssociationStatusMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverRuleConfig.h

@@ -0,0 +1,203 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/TargetAddress.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In an <a>UpdateResolverRule</a> request, information about the changes that
+   * you want to make.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResolverRuleConfig">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResolverRuleConfig
+  {
+  public:
+    ResolverRuleConfig();
+    ResolverRuleConfig(Aws::Utils::Json::JsonView jsonValue);
+    ResolverRuleConfig& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline ResolverRuleConfig& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline ResolverRuleConfig& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The new name for the resolver rule. The name that you specify appears in the
+     * Resolver dashboard in the Route 53 console. </p>
+     */
+    inline ResolverRuleConfig& WithName(const char* value) { SetName(value); return *this;}
+
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline const Aws::Vector<TargetAddress>& GetTargetIps() const{ return m_targetIps; }
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline bool TargetIpsHasBeenSet() const { return m_targetIpsHasBeenSet; }
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline void SetTargetIps(const Aws::Vector<TargetAddress>& value) { m_targetIpsHasBeenSet = true; m_targetIps = value; }
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline void SetTargetIps(Aws::Vector<TargetAddress>&& value) { m_targetIpsHasBeenSet = true; m_targetIps = std::move(value); }
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline ResolverRuleConfig& WithTargetIps(const Aws::Vector<TargetAddress>& value) { SetTargetIps(value); return *this;}
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline ResolverRuleConfig& WithTargetIps(Aws::Vector<TargetAddress>&& value) { SetTargetIps(std::move(value)); return *this;}
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline ResolverRuleConfig& AddTargetIps(const TargetAddress& value) { m_targetIpsHasBeenSet = true; m_targetIps.push_back(value); return *this; }
+
+    /**
+     * <p>For DNS queries that originate in your VPC, the new IP addresses that you
+     * want to route outbound DNS queries to.</p>
+     */
+    inline ResolverRuleConfig& AddTargetIps(TargetAddress&& value) { m_targetIpsHasBeenSet = true; m_targetIps.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline ResolverRuleConfig& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline ResolverRuleConfig& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the new outbound resolver endpoint that you want to use to route
+     * DNS queries to the IP addresses that you specify in <code>TargetIps</code>.</p>
+     */
+    inline ResolverRuleConfig& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+
+    Aws::Vector<TargetAddress> m_targetIps;
+    bool m_targetIpsHasBeenSet;
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResolverRuleStatus.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class ResolverRuleStatus
+  {
+    NOT_SET,
+    COMPLETE,
+    DELETING,
+    UPDATING,
+    FAILED
+  };
+
+namespace ResolverRuleStatusMapper
+{
+AWS_ROUTE53RESOLVER_API ResolverRuleStatus GetResolverRuleStatusForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForResolverRuleStatus(ResolverRuleStatus value);
+} // namespace ResolverRuleStatusMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResourceExistsException.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>The resource that you tried to create already exists.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResourceExistsException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResourceExistsException
+  {
+  public:
+    ResourceExistsException();
+    ResourceExistsException(Aws::Utils::Json::JsonView jsonValue);
+    ResourceExistsException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    
+    inline ResourceExistsException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    
+    inline ResourceExistsException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    
+    inline ResourceExistsException& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline const Aws::String& GetResourceType() const{ return m_resourceType; }
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline ResourceExistsException& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline ResourceExistsException& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>For a <code>ResourceExistsException</code> error, the type of resource that
+     * the error applies to.</p>
+     */
+    inline ResourceExistsException& WithResourceType(const char* value) { SetResourceType(value); return *this;}
+
+  private:
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::String m_resourceType;
+    bool m_resourceTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResourceInUseException.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>The resource that you tried to update or delete is currently in
+   * use.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResourceInUseException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResourceInUseException
+  {
+  public:
+    ResourceInUseException();
+    ResourceInUseException(Aws::Utils::Json::JsonView jsonValue);
+    ResourceInUseException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    
+    inline ResourceInUseException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    
+    inline ResourceInUseException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    
+    inline ResourceInUseException& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline const Aws::String& GetResourceType() const{ return m_resourceType; }
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline ResourceInUseException& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline ResourceInUseException& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>For a <code>ResourceInUseException</code> error, the type of resource that is
+     * currently in use.</p>
+     */
+    inline ResourceInUseException& WithResourceType(const char* value) { SetResourceType(value); return *this;}
+
+  private:
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::String m_resourceType;
+    bool m_resourceTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResourceNotFoundException.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>The specified resource doesn't exist.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResourceNotFoundException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResourceNotFoundException
+  {
+  public:
+    ResourceNotFoundException();
+    ResourceNotFoundException(Aws::Utils::Json::JsonView jsonValue);
+    ResourceNotFoundException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    
+    inline ResourceNotFoundException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    
+    inline ResourceNotFoundException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    
+    inline ResourceNotFoundException& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline const Aws::String& GetResourceType() const{ return m_resourceType; }
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline ResourceNotFoundException& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline ResourceNotFoundException& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>For a <code>ResourceNotFoundException</code> error, the type of resource that
+     * doesn't exist.</p>
+     */
+    inline ResourceNotFoundException& WithResourceType(const char* value) { SetResourceType(value); return *this;}
+
+  private:
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::String m_resourceType;
+    bool m_resourceTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ResourceUnavailableException.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>The specified resource isn't available.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/ResourceUnavailableException">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API ResourceUnavailableException
+  {
+  public:
+    ResourceUnavailableException();
+    ResourceUnavailableException(Aws::Utils::Json::JsonView jsonValue);
+    ResourceUnavailableException& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    
+    inline const Aws::String& GetMessage() const{ return m_message; }
+
+    
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+
+    
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+
+    
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+
+    
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+
+    
+    inline ResourceUnavailableException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+
+    
+    inline ResourceUnavailableException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+
+    
+    inline ResourceUnavailableException& WithMessage(const char* value) { SetMessage(value); return *this;}
+
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline const Aws::String& GetResourceType() const{ return m_resourceType; }
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline void SetResourceType(const Aws::String& value) { m_resourceTypeHasBeenSet = true; m_resourceType = value; }
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline void SetResourceType(Aws::String&& value) { m_resourceTypeHasBeenSet = true; m_resourceType = std::move(value); }
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline void SetResourceType(const char* value) { m_resourceTypeHasBeenSet = true; m_resourceType.assign(value); }
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline ResourceUnavailableException& WithResourceType(const Aws::String& value) { SetResourceType(value); return *this;}
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline ResourceUnavailableException& WithResourceType(Aws::String&& value) { SetResourceType(std::move(value)); return *this;}
+
+    /**
+     * <p>For a <code>ResourceUnavailableException</code> error, the type of resource
+     * that isn't available.</p>
+     */
+    inline ResourceUnavailableException& WithResourceType(const char* value) { SetResourceType(value); return *this;}
+
+  private:
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet;
+
+    Aws::String m_resourceType;
+    bool m_resourceTypeHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/RuleTypeOption.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class RuleTypeOption
+  {
+    NOT_SET,
+    FORWARD,
+    SYSTEM,
+    RECURSIVE
+  };
+
+namespace RuleTypeOptionMapper
+{
+AWS_ROUTE53RESOLVER_API RuleTypeOption GetRuleTypeOptionForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForRuleTypeOption(RuleTypeOption value);
+} // namespace RuleTypeOptionMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/ShareStatus.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+  enum class ShareStatus
+  {
+    NOT_SET,
+    NOT_SHARED,
+    SHARED_WITH_ME,
+    SHARED_BY_ME
+  };
+
+namespace ShareStatusMapper
+{
+AWS_ROUTE53RESOLVER_API ShareStatus GetShareStatusForName(const Aws::String& name);
+
+AWS_ROUTE53RESOLVER_API Aws::String GetNameForShareStatus(ShareStatus value);
+} // namespace ShareStatusMapper
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/Tag.h

@@ -0,0 +1,166 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>One tag that you want to add to the specified resource. A tag consists of a
+   * <code>Key</code> (a name for the tag) and a <code>Value</code>.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/Tag">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API Tag
+  {
+  public:
+    Tag();
+    Tag(Aws::Utils::Json::JsonView jsonValue);
+    Tag& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline Tag& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline Tag& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+
+    /**
+     * <p>The name for the tag. For example, if you want to associate Resolver
+     * resources with the account IDs of your customers for billing purposes, the value
+     * of <code>Key</code> might be <code>account-id</code>.</p>
+     */
+    inline Tag& WithKey(const char* value) { SetKey(value); return *this;}
+
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline Tag& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline Tag& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+
+    /**
+     * <p>The value for the tag. For example, if <code>Key</code> is
+     * <code>account-id</code>, then <code>Value</code> might be the ID of the customer
+     * account that you're creating the resource for.</p>
+     */
+    inline Tag& WithValue(const char* value) { SetValue(value); return *this;}
+
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/TagResourceRequest.h

@@ -0,0 +1,187 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/route53resolver/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API TagResourceRequest : public Route53ResolverRequest
+  {
+  public:
+    TagResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "TagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline TagResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline TagResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to add tags to.
+     * To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline TagResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline TagResourceRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline TagResourceRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline TagResourceRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+
+    /**
+     * <p>The tags that you want to add to the specified resource.</p>
+     */
+    inline TagResourceRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/TagResourceResult.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API TagResourceResult
+  {
+  public:
+    TagResourceResult();
+    TagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    TagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/TargetAddress.h

@@ -0,0 +1,121 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   * <p>In a <a>CreateResolverRule</a> request, an array of the IPs that you want to
+   * forward DNS queries to.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/route53resolver-2018-04-01/TargetAddress">AWS
+   * API Reference</a></p>
+   */
+  class AWS_ROUTE53RESOLVER_API TargetAddress
+  {
+  public:
+    TargetAddress();
+    TargetAddress(Aws::Utils::Json::JsonView jsonValue);
+    TargetAddress& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline const Aws::String& GetIp() const{ return m_ip; }
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline bool IpHasBeenSet() const { return m_ipHasBeenSet; }
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline void SetIp(const Aws::String& value) { m_ipHasBeenSet = true; m_ip = value; }
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline void SetIp(Aws::String&& value) { m_ipHasBeenSet = true; m_ip = std::move(value); }
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline void SetIp(const char* value) { m_ipHasBeenSet = true; m_ip.assign(value); }
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline TargetAddress& WithIp(const Aws::String& value) { SetIp(value); return *this;}
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline TargetAddress& WithIp(Aws::String&& value) { SetIp(std::move(value)); return *this;}
+
+    /**
+     * <p>One IP address that you want to forward DNS queries to. You can specify only
+     * IPv4 addresses.</p>
+     */
+    inline TargetAddress& WithIp(const char* value) { SetIp(value); return *this;}
+
+
+    /**
+     * <p>The port at <code>Ip</code> that you want to forward DNS queries to.</p>
+     */
+    inline int GetPort() const{ return m_port; }
+
+    /**
+     * <p>The port at <code>Ip</code> that you want to forward DNS queries to.</p>
+     */
+    inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
+
+    /**
+     * <p>The port at <code>Ip</code> that you want to forward DNS queries to.</p>
+     */
+    inline void SetPort(int value) { m_portHasBeenSet = true; m_port = value; }
+
+    /**
+     * <p>The port at <code>Ip</code> that you want to forward DNS queries to.</p>
+     */
+    inline TargetAddress& WithPort(int value) { SetPort(value); return *this;}
+
+  private:
+
+    Aws::String m_ip;
+    bool m_ipHasBeenSet;
+
+    int m_port;
+    bool m_portHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/UntagResourceRequest.h

@@ -0,0 +1,191 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API UntagResourceRequest : public Route53ResolverRequest
+  {
+  public:
+    UntagResourceRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "UntagResource"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline void SetResourceArn(const Aws::String& value) { m_resourceArnHasBeenSet = true; m_resourceArn = value; }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline void SetResourceArn(Aws::String&& value) { m_resourceArnHasBeenSet = true; m_resourceArn = std::move(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline void SetResourceArn(const char* value) { m_resourceArnHasBeenSet = true; m_resourceArn.assign(value); }
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline UntagResourceRequest& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline UntagResourceRequest& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
+
+    /**
+     * <p>The Amazon Resource Name (ARN) for the resource that you want to remove tags
+     * from. To get the ARN for a resource, use the applicable <code>Get</code> or
+     * <code>List</code> command: </p> <ul> <li> <p> <a>GetResolverEndpoint</a> </p>
+     * </li> <li> <p> <a>GetResolverRule</a> </p> </li> <li> <p>
+     * <a>GetResolverRuleAssociation</a> </p> </li> <li> <p>
+     * <a>ListResolverEndpoints</a> </p> </li> <li> <p>
+     * <a>ListResolverRuleAssociations</a> </p> </li> <li> <p> <a>ListResolverRules</a>
+     * </p> </li> </ul>
+     */
+    inline UntagResourceRequest& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
+
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTagKeys() const{ return m_tagKeys; }
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline bool TagKeysHasBeenSet() const { return m_tagKeysHasBeenSet; }
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline void SetTagKeys(const Aws::Vector<Aws::String>& value) { m_tagKeysHasBeenSet = true; m_tagKeys = value; }
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline void SetTagKeys(Aws::Vector<Aws::String>&& value) { m_tagKeysHasBeenSet = true; m_tagKeys = std::move(value); }
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(const Aws::Vector<Aws::String>& value) { SetTagKeys(value); return *this;}
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline UntagResourceRequest& WithTagKeys(Aws::Vector<Aws::String>&& value) { SetTagKeys(std::move(value)); return *this;}
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const Aws::String& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(Aws::String&& value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(std::move(value)); return *this; }
+
+    /**
+     * <p>The tags that you want to remove to the specified resource.</p>
+     */
+    inline UntagResourceRequest& AddTagKeys(const char* value) { m_tagKeysHasBeenSet = true; m_tagKeys.push_back(value); return *this; }
+
+  private:
+
+    Aws::String m_resourceArn;
+    bool m_resourceArnHasBeenSet;
+
+    Aws::Vector<Aws::String> m_tagKeys;
+    bool m_tagKeysHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/UntagResourceResult.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API UntagResourceResult
+  {
+  public:
+    UntagResourceResult();
+    UntagResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UntagResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/UpdateResolverEndpointRequest.h

@@ -0,0 +1,129 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API UpdateResolverEndpointRequest : public Route53ResolverRequest
+  {
+  public:
+    UpdateResolverEndpointRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "UpdateResolverEndpoint"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline const Aws::String& GetResolverEndpointId() const{ return m_resolverEndpointId; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline bool ResolverEndpointIdHasBeenSet() const { return m_resolverEndpointIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline void SetResolverEndpointId(const Aws::String& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = value; }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline void SetResolverEndpointId(Aws::String&& value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline void SetResolverEndpointId(const char* value) { m_resolverEndpointIdHasBeenSet = true; m_resolverEndpointId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline UpdateResolverEndpointRequest& WithResolverEndpointId(const Aws::String& value) { SetResolverEndpointId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline UpdateResolverEndpointRequest& WithResolverEndpointId(Aws::String&& value) { SetResolverEndpointId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver endpoint that you want to update.</p>
+     */
+    inline UpdateResolverEndpointRequest& WithResolverEndpointId(const char* value) { SetResolverEndpointId(value); return *this;}
+
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline UpdateResolverEndpointRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline UpdateResolverEndpointRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+
+    /**
+     * <p>The name of the resolver endpoint that you want to update.</p>
+     */
+    inline UpdateResolverEndpointRequest& WithName(const char* value) { SetName(value); return *this;}
+
+  private:
+
+    Aws::String m_resolverEndpointId;
+    bool m_resolverEndpointIdHasBeenSet;
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/UpdateResolverEndpointResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverEndpoint.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API UpdateResolverEndpointResult
+  {
+  public:
+    UpdateResolverEndpointResult();
+    UpdateResolverEndpointResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateResolverEndpointResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The response to an <code>UpdateResolverEndpoint</code> request.</p>
+     */
+    inline const ResolverEndpoint& GetResolverEndpoint() const{ return m_resolverEndpoint; }
+
+    /**
+     * <p>The response to an <code>UpdateResolverEndpoint</code> request.</p>
+     */
+    inline void SetResolverEndpoint(const ResolverEndpoint& value) { m_resolverEndpoint = value; }
+
+    /**
+     * <p>The response to an <code>UpdateResolverEndpoint</code> request.</p>
+     */
+    inline void SetResolverEndpoint(ResolverEndpoint&& value) { m_resolverEndpoint = std::move(value); }
+
+    /**
+     * <p>The response to an <code>UpdateResolverEndpoint</code> request.</p>
+     */
+    inline UpdateResolverEndpointResult& WithResolverEndpoint(const ResolverEndpoint& value) { SetResolverEndpoint(value); return *this;}
+
+    /**
+     * <p>The response to an <code>UpdateResolverEndpoint</code> request.</p>
+     */
+    inline UpdateResolverEndpointResult& WithResolverEndpoint(ResolverEndpoint&& value) { SetResolverEndpoint(std::move(value)); return *this;}
+
+  private:
+
+    ResolverEndpoint m_resolverEndpoint;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/UpdateResolverRuleRequest.h

@@ -0,0 +1,120 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/Route53ResolverRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/route53resolver/model/ResolverRuleConfig.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Route53Resolver
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_ROUTE53RESOLVER_API UpdateResolverRuleRequest : public Route53ResolverRequest
+  {
+  public:
+    UpdateResolverRuleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "UpdateResolverRule"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline const Aws::String& GetResolverRuleId() const{ return m_resolverRuleId; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline bool ResolverRuleIdHasBeenSet() const { return m_resolverRuleIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline void SetResolverRuleId(const Aws::String& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = value; }
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline void SetResolverRuleId(Aws::String&& value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId = std::move(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline void SetResolverRuleId(const char* value) { m_resolverRuleIdHasBeenSet = true; m_resolverRuleId.assign(value); }
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline UpdateResolverRuleRequest& WithResolverRuleId(const Aws::String& value) { SetResolverRuleId(value); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline UpdateResolverRuleRequest& WithResolverRuleId(Aws::String&& value) { SetResolverRuleId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the resolver rule that you want to update.</p>
+     */
+    inline UpdateResolverRuleRequest& WithResolverRuleId(const char* value) { SetResolverRuleId(value); return *this;}
+
+
+    /**
+     * <p>The new settings for the resolver rule.</p>
+     */
+    inline const ResolverRuleConfig& GetConfig() const{ return m_config; }
+
+    /**
+     * <p>The new settings for the resolver rule.</p>
+     */
+    inline bool ConfigHasBeenSet() const { return m_configHasBeenSet; }
+
+    /**
+     * <p>The new settings for the resolver rule.</p>
+     */
+    inline void SetConfig(const ResolverRuleConfig& value) { m_configHasBeenSet = true; m_config = value; }
+
+    /**
+     * <p>The new settings for the resolver rule.</p>
+     */
+    inline void SetConfig(ResolverRuleConfig&& value) { m_configHasBeenSet = true; m_config = std::move(value); }
+
+    /**
+     * <p>The new settings for the resolver rule.</p>
+     */
+    inline UpdateResolverRuleRequest& WithConfig(const ResolverRuleConfig& value) { SetConfig(value); return *this;}
+
+    /**
+     * <p>The new settings for the resolver rule.</p>
+     */
+    inline UpdateResolverRuleRequest& WithConfig(ResolverRuleConfig&& value) { SetConfig(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_resolverRuleId;
+    bool m_resolverRuleIdHasBeenSet;
+
+    ResolverRuleConfig m_config;
+    bool m_configHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-route53resolver/include/aws/route53resolver/model/UpdateResolverRuleResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
+#include <aws/route53resolver/model/ResolverRule.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace Route53Resolver
+{
+namespace Model
+{
+  class AWS_ROUTE53RESOLVER_API UpdateResolverRuleResult
+  {
+  public:
+    UpdateResolverRuleResult();
+    UpdateResolverRuleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    UpdateResolverRuleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The response to an <code>UpdateResolverRule</code> request.</p>
+     */
+    inline const ResolverRule& GetResolverRule() const{ return m_resolverRule; }
+
+    /**
+     * <p>The response to an <code>UpdateResolverRule</code> request.</p>
+     */
+    inline void SetResolverRule(const ResolverRule& value) { m_resolverRule = value; }
+
+    /**
+     * <p>The response to an <code>UpdateResolverRule</code> request.</p>
+     */
+    inline void SetResolverRule(ResolverRule&& value) { m_resolverRule = std::move(value); }
+
+    /**
+     * <p>The response to an <code>UpdateResolverRule</code> request.</p>
+     */
+    inline UpdateResolverRuleResult& WithResolverRule(const ResolverRule& value) { SetResolverRule(value); return *this;}
+
+    /**
+     * <p>The response to an <code>UpdateResolverRule</code> request.</p>
+     */
+    inline UpdateResolverRuleResult& WithResolverRule(ResolverRule&& value) { SetResolverRule(std::move(value)); return *this;}
+
+  private:
+
+    ResolverRule m_resolverRule;
+  };
+
+} // namespace Model
+} // namespace Route53Resolver
+} // namespace Aws