/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Route53Resolver { /** *

When you create a VPC using Amazon VPC, you automatically get DNS resolution * within the VPC from Route 53 Resolver. By default, Resolver answers DNS queries * for VPC domain names such as domain names for EC2 instances or Elastic Load * Balancing load balancers. Resolver performs recursive lookups against public * name servers for all other domain names.

You can also configure DNS * resolution between your VPC and your network over a Direct Connect or VPN * connection:

Forward DNS queries from resolvers on your network to * Route 53 Resolver

DNS resolvers on your network can forward DNS * queries to Resolver in a specified VPC. This allows your DNS resolvers to easily * resolve domain names for Amazon Web Services resources such as EC2 instances or * records in a Route 53 private hosted zone. For more information, see How * DNS Resolvers on Your Network Forward DNS Queries to Route 53 Resolver in * the Amazon Route 53 Developer Guide.

Conditionally forward * queries from a VPC to resolvers on your network

You can configure * Resolver to forward queries that it receives from EC2 instances in your VPCs to * DNS resolvers on your network. To forward selected queries, you create Resolver * rules that specify the domain names for the DNS queries that you want to forward * (such as example.com), and the IP addresses of the DNS resolvers on your network * that you want to forward the queries to. If a query matches multiple rules * (example.com, acme.example.com), Resolver chooses the rule with the most * specific match (acme.example.com) and forwards the query to the IP addresses * that you specified in that rule. For more information, see How * Route 53 Resolver Forwards DNS Queries from Your VPCs to Your Network in the * Amazon Route 53 Developer Guide.

Like Amazon VPC, Resolver is * Regional. In each Region where you have VPCs, you can choose whether to forward * queries from your VPCs to your network (outbound queries), from your network to * your VPCs (inbound queries), or both.

*/ class AWS_ROUTE53RESOLVER_API Route53ResolverClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef Route53ResolverClientConfiguration ClientConfigurationType; typedef Route53ResolverEndpointProvider EndpointProviderType; /** * 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::Route53Resolver::Route53ResolverClientConfiguration& clientConfiguration = Aws::Route53Resolver::Route53ResolverClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * 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, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Route53Resolver::Route53ResolverClientConfiguration& clientConfiguration = Aws::Route53Resolver::Route53ResolverClientConfiguration()); /** * 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& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Route53Resolver::Route53ResolverClientConfiguration& clientConfiguration = Aws::Route53Resolver::Route53ResolverClientConfiguration()); /* Legacy constructors due deprecation */ /** * 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); /** * 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); /** * 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& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~Route53ResolverClient(); /** *

Associates a FirewallRuleGroup with a VPC, to provide DNS filtering * for the VPC.

See Also:

AWS * API Reference

*/ virtual Model::AssociateFirewallRuleGroupOutcome AssociateFirewallRuleGroup(const Model::AssociateFirewallRuleGroupRequest& request) const; /** * A Callable wrapper for AssociateFirewallRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateFirewallRuleGroupOutcomeCallable AssociateFirewallRuleGroupCallable(const AssociateFirewallRuleGroupRequestT& request) const { return SubmitCallable(&Route53ResolverClient::AssociateFirewallRuleGroup, request); } /** * An Async wrapper for AssociateFirewallRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateFirewallRuleGroupAsync(const AssociateFirewallRuleGroupRequestT& request, const AssociateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::AssociateFirewallRuleGroup, request, handler, context); } /** *

Adds IP addresses to an inbound or an outbound Resolver endpoint. If you want * to add more than one IP address, submit one * AssociateResolverEndpointIpAddress request for each IP address.

*

To remove an IP address from an endpoint, see DisassociateResolverEndpointIpAddress. *

See Also:

AWS * API Reference

*/ virtual Model::AssociateResolverEndpointIpAddressOutcome AssociateResolverEndpointIpAddress(const Model::AssociateResolverEndpointIpAddressRequest& request) const; /** * A Callable wrapper for AssociateResolverEndpointIpAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateResolverEndpointIpAddressOutcomeCallable AssociateResolverEndpointIpAddressCallable(const AssociateResolverEndpointIpAddressRequestT& request) const { return SubmitCallable(&Route53ResolverClient::AssociateResolverEndpointIpAddress, request); } /** * An Async wrapper for AssociateResolverEndpointIpAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateResolverEndpointIpAddressAsync(const AssociateResolverEndpointIpAddressRequestT& request, const AssociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::AssociateResolverEndpointIpAddress, request, handler, context); } /** *

Associates an Amazon VPC with a specified query logging configuration. Route * 53 Resolver logs DNS queries that originate in all of the Amazon VPCs that are * associated with a specified query logging configuration. To associate more than * one VPC with a configuration, submit one * AssociateResolverQueryLogConfig request for each VPC.

*

The VPCs that you associate with a query logging configuration must be in the * same Region as the configuration.

To remove a VPC from a query * logging configuration, see DisassociateResolverQueryLogConfig. *

See Also:

AWS * API Reference

*/ virtual Model::AssociateResolverQueryLogConfigOutcome AssociateResolverQueryLogConfig(const Model::AssociateResolverQueryLogConfigRequest& request) const; /** * A Callable wrapper for AssociateResolverQueryLogConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateResolverQueryLogConfigOutcomeCallable AssociateResolverQueryLogConfigCallable(const AssociateResolverQueryLogConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::AssociateResolverQueryLogConfig, request); } /** * An Async wrapper for AssociateResolverQueryLogConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateResolverQueryLogConfigAsync(const AssociateResolverQueryLogConfigRequestT& request, const AssociateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::AssociateResolverQueryLogConfig, request, handler, context); } /** *

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 CreateResolverRule. *

See Also:

AWS * API Reference

*/ virtual Model::AssociateResolverRuleOutcome AssociateResolverRule(const Model::AssociateResolverRuleRequest& request) const; /** * A Callable wrapper for AssociateResolverRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateResolverRuleOutcomeCallable AssociateResolverRuleCallable(const AssociateResolverRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::AssociateResolverRule, request); } /** * An Async wrapper for AssociateResolverRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateResolverRuleAsync(const AssociateResolverRuleRequestT& request, const AssociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::AssociateResolverRule, request, handler, context); } /** *

Creates an empty firewall domain list for use in DNS Firewall rules. You can * populate the domains for the new list with a file, using * ImportFirewallDomains, or with domain strings, using * UpdateFirewallDomains.

See Also:

AWS * API Reference

*/ virtual Model::CreateFirewallDomainListOutcome CreateFirewallDomainList(const Model::CreateFirewallDomainListRequest& request) const; /** * A Callable wrapper for CreateFirewallDomainList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFirewallDomainListOutcomeCallable CreateFirewallDomainListCallable(const CreateFirewallDomainListRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateFirewallDomainList, request); } /** * An Async wrapper for CreateFirewallDomainList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFirewallDomainListAsync(const CreateFirewallDomainListRequestT& request, const CreateFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateFirewallDomainList, request, handler, context); } /** *

Creates a single DNS Firewall rule in the specified rule group, using the * specified domain list.

See Also:

AWS * API Reference

*/ virtual Model::CreateFirewallRuleOutcome CreateFirewallRule(const Model::CreateFirewallRuleRequest& request) const; /** * A Callable wrapper for CreateFirewallRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFirewallRuleOutcomeCallable CreateFirewallRuleCallable(const CreateFirewallRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateFirewallRule, request); } /** * An Async wrapper for CreateFirewallRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFirewallRuleAsync(const CreateFirewallRuleRequestT& request, const CreateFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateFirewallRule, request, handler, context); } /** *

Creates an empty DNS Firewall rule group for filtering DNS network traffic in * a VPC. You can add rules to the new rule group by calling * CreateFirewallRule.

See Also:

AWS * API Reference

*/ virtual Model::CreateFirewallRuleGroupOutcome CreateFirewallRuleGroup(const Model::CreateFirewallRuleGroupRequest& request) const; /** * A Callable wrapper for CreateFirewallRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFirewallRuleGroupOutcomeCallable CreateFirewallRuleGroupCallable(const CreateFirewallRuleGroupRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateFirewallRuleGroup, request); } /** * An Async wrapper for CreateFirewallRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFirewallRuleGroupAsync(const CreateFirewallRuleGroupRequestT& request, const CreateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateFirewallRuleGroup, request, handler, context); } /** *

Creates an Route 53 Resolver on an Outpost.

See Also:

AWS * API Reference

*/ virtual Model::CreateOutpostResolverOutcome CreateOutpostResolver(const Model::CreateOutpostResolverRequest& request) const; /** * A Callable wrapper for CreateOutpostResolver that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOutpostResolverOutcomeCallable CreateOutpostResolverCallable(const CreateOutpostResolverRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateOutpostResolver, request); } /** * An Async wrapper for CreateOutpostResolver that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOutpostResolverAsync(const CreateOutpostResolverRequestT& request, const CreateOutpostResolverResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateOutpostResolver, request, handler, context); } /** *

Creates a Resolver endpoint. There are two types of Resolver endpoints, * inbound and outbound:

  • An inbound Resolver endpoint * forwards DNS queries to the DNS service for a VPC from your network.

    • *

  • An outbound Resolver endpoint forwards DNS queries from the DNS * service for a VPC to your network.

See Also:

AWS * API Reference

*/ virtual Model::CreateResolverEndpointOutcome CreateResolverEndpoint(const Model::CreateResolverEndpointRequest& request) const; /** * A Callable wrapper for CreateResolverEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResolverEndpointOutcomeCallable CreateResolverEndpointCallable(const CreateResolverEndpointRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateResolverEndpoint, request); } /** * An Async wrapper for CreateResolverEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResolverEndpointAsync(const CreateResolverEndpointRequestT& request, const CreateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateResolverEndpoint, request, handler, context); } /** *

Creates a Resolver query logging configuration, which defines where you want * Resolver to save DNS query logs that originate in your VPCs. Resolver can log * queries only for VPCs that are in the same Region as the query logging * configuration.

To specify which VPCs you want to log queries for, you use * AssociateResolverQueryLogConfig. For more information, see AssociateResolverQueryLogConfig. *

You can optionally use Resource Access Manager (RAM) to share a query * logging configuration with other Amazon Web Services accounts. The other * accounts can then associate VPCs with the configuration. The query logs that * Resolver creates for a configuration include all DNS queries that originate in * all VPCs that are associated with the configuration.

See Also:

* AWS * API Reference

*/ virtual Model::CreateResolverQueryLogConfigOutcome CreateResolverQueryLogConfig(const Model::CreateResolverQueryLogConfigRequest& request) const; /** * A Callable wrapper for CreateResolverQueryLogConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResolverQueryLogConfigOutcomeCallable CreateResolverQueryLogConfigCallable(const CreateResolverQueryLogConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateResolverQueryLogConfig, request); } /** * An Async wrapper for CreateResolverQueryLogConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResolverQueryLogConfigAsync(const CreateResolverQueryLogConfigRequestT& request, const CreateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateResolverQueryLogConfig, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::CreateResolverRuleOutcome CreateResolverRule(const Model::CreateResolverRuleRequest& request) const; /** * A Callable wrapper for CreateResolverRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResolverRuleOutcomeCallable CreateResolverRuleCallable(const CreateResolverRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::CreateResolverRule, request); } /** * An Async wrapper for CreateResolverRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResolverRuleAsync(const CreateResolverRuleRequestT& request, const CreateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::CreateResolverRule, request, handler, context); } /** *

Deletes the specified domain list.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFirewallDomainListOutcome DeleteFirewallDomainList(const Model::DeleteFirewallDomainListRequest& request) const; /** * A Callable wrapper for DeleteFirewallDomainList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFirewallDomainListOutcomeCallable DeleteFirewallDomainListCallable(const DeleteFirewallDomainListRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteFirewallDomainList, request); } /** * An Async wrapper for DeleteFirewallDomainList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFirewallDomainListAsync(const DeleteFirewallDomainListRequestT& request, const DeleteFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteFirewallDomainList, request, handler, context); } /** *

Deletes the specified firewall rule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFirewallRuleOutcome DeleteFirewallRule(const Model::DeleteFirewallRuleRequest& request) const; /** * A Callable wrapper for DeleteFirewallRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFirewallRuleOutcomeCallable DeleteFirewallRuleCallable(const DeleteFirewallRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteFirewallRule, request); } /** * An Async wrapper for DeleteFirewallRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFirewallRuleAsync(const DeleteFirewallRuleRequestT& request, const DeleteFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteFirewallRule, request, handler, context); } /** *

Deletes the specified firewall rule group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFirewallRuleGroupOutcome DeleteFirewallRuleGroup(const Model::DeleteFirewallRuleGroupRequest& request) const; /** * A Callable wrapper for DeleteFirewallRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFirewallRuleGroupOutcomeCallable DeleteFirewallRuleGroupCallable(const DeleteFirewallRuleGroupRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteFirewallRuleGroup, request); } /** * An Async wrapper for DeleteFirewallRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFirewallRuleGroupAsync(const DeleteFirewallRuleGroupRequestT& request, const DeleteFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteFirewallRuleGroup, request, handler, context); } /** *

Deletes a Resolver on the Outpost.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOutpostResolverOutcome DeleteOutpostResolver(const Model::DeleteOutpostResolverRequest& request) const; /** * A Callable wrapper for DeleteOutpostResolver that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOutpostResolverOutcomeCallable DeleteOutpostResolverCallable(const DeleteOutpostResolverRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteOutpostResolver, request); } /** * An Async wrapper for DeleteOutpostResolver that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOutpostResolverAsync(const DeleteOutpostResolverRequestT& request, const DeleteOutpostResolverResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteOutpostResolver, request, handler, context); } /** *

Deletes a Resolver endpoint. The effect of deleting a Resolver endpoint * depends on whether it's an inbound or an outbound Resolver endpoint:

    *

  • Inbound: DNS queries from your network are no longer routed to * the DNS service for the specified VPC.

  • Outbound: DNS * queries from a VPC are no longer routed to your network.

    • *

See Also:

AWS * API Reference

*/ virtual Model::DeleteResolverEndpointOutcome DeleteResolverEndpoint(const Model::DeleteResolverEndpointRequest& request) const; /** * A Callable wrapper for DeleteResolverEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResolverEndpointOutcomeCallable DeleteResolverEndpointCallable(const DeleteResolverEndpointRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteResolverEndpoint, request); } /** * An Async wrapper for DeleteResolverEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResolverEndpointAsync(const DeleteResolverEndpointRequestT& request, const DeleteResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteResolverEndpoint, request, handler, context); } /** *

Deletes a query logging configuration. When you delete a configuration, * Resolver stops logging DNS queries for all of the Amazon VPCs that are * associated with the configuration. This also applies if the query logging * configuration is shared with other Amazon Web Services accounts, and the other * accounts have associated VPCs with the shared configuration.

Before you * can delete a query logging configuration, you must first disassociate all VPCs * from the configuration. See DisassociateResolverQueryLogConfig.

*

If you used Resource Access Manager (RAM) to share a query logging * configuration with other accounts, you must stop sharing the configuration * before you can delete a configuration. The accounts that you shared the * configuration with can first disassociate VPCs that they associated with the * configuration, but that's not necessary. If you stop sharing the configuration, * those VPCs are automatically disassociated from the configuration.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteResolverQueryLogConfigOutcome DeleteResolverQueryLogConfig(const Model::DeleteResolverQueryLogConfigRequest& request) const; /** * A Callable wrapper for DeleteResolverQueryLogConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResolverQueryLogConfigOutcomeCallable DeleteResolverQueryLogConfigCallable(const DeleteResolverQueryLogConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteResolverQueryLogConfig, request); } /** * An Async wrapper for DeleteResolverQueryLogConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResolverQueryLogConfigAsync(const DeleteResolverQueryLogConfigRequestT& request, const DeleteResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteResolverQueryLogConfig, request, handler, context); } /** *

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 information, see DisassociateResolverRule.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteResolverRuleOutcome DeleteResolverRule(const Model::DeleteResolverRuleRequest& request) const; /** * A Callable wrapper for DeleteResolverRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResolverRuleOutcomeCallable DeleteResolverRuleCallable(const DeleteResolverRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DeleteResolverRule, request); } /** * An Async wrapper for DeleteResolverRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResolverRuleAsync(const DeleteResolverRuleRequestT& request, const DeleteResolverRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DeleteResolverRule, request, handler, context); } /** *

Disassociates a FirewallRuleGroup from a VPC, to remove DNS filtering * from the VPC.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateFirewallRuleGroupOutcome DisassociateFirewallRuleGroup(const Model::DisassociateFirewallRuleGroupRequest& request) const; /** * A Callable wrapper for DisassociateFirewallRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateFirewallRuleGroupOutcomeCallable DisassociateFirewallRuleGroupCallable(const DisassociateFirewallRuleGroupRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DisassociateFirewallRuleGroup, request); } /** * An Async wrapper for DisassociateFirewallRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateFirewallRuleGroupAsync(const DisassociateFirewallRuleGroupRequestT& request, const DisassociateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DisassociateFirewallRuleGroup, request, handler, context); } /** *

Removes IP addresses from an inbound or an outbound Resolver endpoint. If you * want to remove more than one IP address, submit one * DisassociateResolverEndpointIpAddress request for each IP * address.

To add an IP address to an endpoint, see AssociateResolverEndpointIpAddress. *

See Also:

AWS * API Reference

*/ virtual Model::DisassociateResolverEndpointIpAddressOutcome DisassociateResolverEndpointIpAddress(const Model::DisassociateResolverEndpointIpAddressRequest& request) const; /** * A Callable wrapper for DisassociateResolverEndpointIpAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateResolverEndpointIpAddressOutcomeCallable DisassociateResolverEndpointIpAddressCallable(const DisassociateResolverEndpointIpAddressRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DisassociateResolverEndpointIpAddress, request); } /** * An Async wrapper for DisassociateResolverEndpointIpAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateResolverEndpointIpAddressAsync(const DisassociateResolverEndpointIpAddressRequestT& request, const DisassociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DisassociateResolverEndpointIpAddress, request, handler, context); } /** *

Disassociates a VPC from a query logging configuration.

Before * you can delete a query logging configuration, you must first disassociate all * VPCs from the configuration. If you used Resource Access Manager (RAM) to share * a query logging configuration with other accounts, VPCs can be disassociated * from the configuration in the following ways:

  • The accounts that * you shared the configuration with can disassociate VPCs from the * configuration.

  • You can stop sharing the configuration.

    *

See Also:

AWS * API Reference

*/ virtual Model::DisassociateResolverQueryLogConfigOutcome DisassociateResolverQueryLogConfig(const Model::DisassociateResolverQueryLogConfigRequest& request) const; /** * A Callable wrapper for DisassociateResolverQueryLogConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateResolverQueryLogConfigOutcomeCallable DisassociateResolverQueryLogConfigCallable(const DisassociateResolverQueryLogConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DisassociateResolverQueryLogConfig, request); } /** * An Async wrapper for DisassociateResolverQueryLogConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateResolverQueryLogConfigAsync(const DisassociateResolverQueryLogConfigRequestT& request, const DisassociateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DisassociateResolverQueryLogConfig, request, handler, context); } /** *

Removes the association between a specified Resolver rule and a specified * VPC.

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.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateResolverRuleOutcome DisassociateResolverRule(const Model::DisassociateResolverRuleRequest& request) const; /** * A Callable wrapper for DisassociateResolverRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateResolverRuleOutcomeCallable DisassociateResolverRuleCallable(const DisassociateResolverRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::DisassociateResolverRule, request); } /** * An Async wrapper for DisassociateResolverRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateResolverRuleAsync(const DisassociateResolverRuleRequestT& request, const DisassociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::DisassociateResolverRule, request, handler, context); } /** *

Retrieves the configuration of the firewall behavior provided by DNS Firewall * for a single VPC from Amazon Virtual Private Cloud (Amazon VPC).

See * Also:

AWS * API Reference

*/ virtual Model::GetFirewallConfigOutcome GetFirewallConfig(const Model::GetFirewallConfigRequest& request) const; /** * A Callable wrapper for GetFirewallConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFirewallConfigOutcomeCallable GetFirewallConfigCallable(const GetFirewallConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetFirewallConfig, request); } /** * An Async wrapper for GetFirewallConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFirewallConfigAsync(const GetFirewallConfigRequestT& request, const GetFirewallConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetFirewallConfig, request, handler, context); } /** *

Retrieves the specified firewall domain list.

See Also:

AWS * API Reference

*/ virtual Model::GetFirewallDomainListOutcome GetFirewallDomainList(const Model::GetFirewallDomainListRequest& request) const; /** * A Callable wrapper for GetFirewallDomainList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFirewallDomainListOutcomeCallable GetFirewallDomainListCallable(const GetFirewallDomainListRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetFirewallDomainList, request); } /** * An Async wrapper for GetFirewallDomainList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFirewallDomainListAsync(const GetFirewallDomainListRequestT& request, const GetFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetFirewallDomainList, request, handler, context); } /** *

Retrieves the specified firewall rule group.

See Also:

AWS * API Reference

*/ virtual Model::GetFirewallRuleGroupOutcome GetFirewallRuleGroup(const Model::GetFirewallRuleGroupRequest& request) const; /** * A Callable wrapper for GetFirewallRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFirewallRuleGroupOutcomeCallable GetFirewallRuleGroupCallable(const GetFirewallRuleGroupRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetFirewallRuleGroup, request); } /** * An Async wrapper for GetFirewallRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFirewallRuleGroupAsync(const GetFirewallRuleGroupRequestT& request, const GetFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetFirewallRuleGroup, request, handler, context); } /** *

Retrieves a firewall rule group association, which enables DNS filtering for * a VPC with one rule group. A VPC can have more than one firewall rule group * association, and a rule group can be associated with more than one * VPC.

See Also:

AWS * API Reference

*/ virtual Model::GetFirewallRuleGroupAssociationOutcome GetFirewallRuleGroupAssociation(const Model::GetFirewallRuleGroupAssociationRequest& request) const; /** * A Callable wrapper for GetFirewallRuleGroupAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFirewallRuleGroupAssociationOutcomeCallable GetFirewallRuleGroupAssociationCallable(const GetFirewallRuleGroupAssociationRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetFirewallRuleGroupAssociation, request); } /** * An Async wrapper for GetFirewallRuleGroupAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFirewallRuleGroupAssociationAsync(const GetFirewallRuleGroupAssociationRequestT& request, const GetFirewallRuleGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetFirewallRuleGroupAssociation, request, handler, context); } /** *

Returns the Identity and Access Management (Amazon Web Services IAM) policy * for sharing the specified rule group. You can use the policy to share the rule * group using Resource Access Manager (RAM).

See Also:

AWS * API Reference

*/ virtual Model::GetFirewallRuleGroupPolicyOutcome GetFirewallRuleGroupPolicy(const Model::GetFirewallRuleGroupPolicyRequest& request) const; /** * A Callable wrapper for GetFirewallRuleGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFirewallRuleGroupPolicyOutcomeCallable GetFirewallRuleGroupPolicyCallable(const GetFirewallRuleGroupPolicyRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetFirewallRuleGroupPolicy, request); } /** * An Async wrapper for GetFirewallRuleGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFirewallRuleGroupPolicyAsync(const GetFirewallRuleGroupPolicyRequestT& request, const GetFirewallRuleGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetFirewallRuleGroupPolicy, request, handler, context); } /** *

Gets information about a specified Resolver on the Outpost, such as its * instance count and type, name, and the current status of the * Resolver.

See Also:

AWS * API Reference

*/ virtual Model::GetOutpostResolverOutcome GetOutpostResolver(const Model::GetOutpostResolverRequest& request) const; /** * A Callable wrapper for GetOutpostResolver that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOutpostResolverOutcomeCallable GetOutpostResolverCallable(const GetOutpostResolverRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetOutpostResolver, request); } /** * An Async wrapper for GetOutpostResolver that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOutpostResolverAsync(const GetOutpostResolverRequestT& request, const GetOutpostResolverResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetOutpostResolver, request, handler, context); } /** *

Retrieves the behavior configuration of Route 53 Resolver behavior for a * single VPC from Amazon Virtual Private Cloud.

See Also:

AWS * API Reference

*/ virtual Model::GetResolverConfigOutcome GetResolverConfig(const Model::GetResolverConfigRequest& request) const; /** * A Callable wrapper for GetResolverConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverConfigOutcomeCallable GetResolverConfigCallable(const GetResolverConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverConfig, request); } /** * An Async wrapper for GetResolverConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverConfigAsync(const GetResolverConfigRequestT& request, const GetResolverConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverConfig, request, handler, context); } /** *

Gets DNSSEC validation information for a specified resource.

See * Also:

AWS * API Reference

*/ virtual Model::GetResolverDnssecConfigOutcome GetResolverDnssecConfig(const Model::GetResolverDnssecConfigRequest& request) const; /** * A Callable wrapper for GetResolverDnssecConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverDnssecConfigOutcomeCallable GetResolverDnssecConfigCallable(const GetResolverDnssecConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverDnssecConfig, request); } /** * An Async wrapper for GetResolverDnssecConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverDnssecConfigAsync(const GetResolverDnssecConfigRequestT& request, const GetResolverDnssecConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverDnssecConfig, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::GetResolverEndpointOutcome GetResolverEndpoint(const Model::GetResolverEndpointRequest& request) const; /** * A Callable wrapper for GetResolverEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverEndpointOutcomeCallable GetResolverEndpointCallable(const GetResolverEndpointRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverEndpoint, request); } /** * An Async wrapper for GetResolverEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverEndpointAsync(const GetResolverEndpointRequestT& request, const GetResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverEndpoint, request, handler, context); } /** *

Gets information about a specified Resolver query logging configuration, such * as the number of VPCs that the configuration is logging queries for and the * location that logs are sent to.

See Also:

AWS * API Reference

*/ virtual Model::GetResolverQueryLogConfigOutcome GetResolverQueryLogConfig(const Model::GetResolverQueryLogConfigRequest& request) const; /** * A Callable wrapper for GetResolverQueryLogConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverQueryLogConfigOutcomeCallable GetResolverQueryLogConfigCallable(const GetResolverQueryLogConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverQueryLogConfig, request); } /** * An Async wrapper for GetResolverQueryLogConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverQueryLogConfigAsync(const GetResolverQueryLogConfigRequestT& request, const GetResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverQueryLogConfig, request, handler, context); } /** *

Gets information about a specified association between a Resolver query * logging configuration and an Amazon VPC. When you associate a VPC with a query * logging configuration, Resolver logs DNS queries that originate in that * VPC.

See Also:

AWS * API Reference

*/ virtual Model::GetResolverQueryLogConfigAssociationOutcome GetResolverQueryLogConfigAssociation(const Model::GetResolverQueryLogConfigAssociationRequest& request) const; /** * A Callable wrapper for GetResolverQueryLogConfigAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverQueryLogConfigAssociationOutcomeCallable GetResolverQueryLogConfigAssociationCallable(const GetResolverQueryLogConfigAssociationRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverQueryLogConfigAssociation, request); } /** * An Async wrapper for GetResolverQueryLogConfigAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverQueryLogConfigAssociationAsync(const GetResolverQueryLogConfigAssociationRequestT& request, const GetResolverQueryLogConfigAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverQueryLogConfigAssociation, request, handler, context); } /** *

Gets information about a query logging policy. A query logging policy * specifies the Resolver query logging operations and resources that you want to * allow another Amazon Web Services account to be able to use.

See * Also:

AWS * API Reference

*/ virtual Model::GetResolverQueryLogConfigPolicyOutcome GetResolverQueryLogConfigPolicy(const Model::GetResolverQueryLogConfigPolicyRequest& request) const; /** * A Callable wrapper for GetResolverQueryLogConfigPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverQueryLogConfigPolicyOutcomeCallable GetResolverQueryLogConfigPolicyCallable(const GetResolverQueryLogConfigPolicyRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverQueryLogConfigPolicy, request); } /** * An Async wrapper for GetResolverQueryLogConfigPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverQueryLogConfigPolicyAsync(const GetResolverQueryLogConfigPolicyRequestT& request, const GetResolverQueryLogConfigPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverQueryLogConfigPolicy, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::GetResolverRuleOutcome GetResolverRule(const Model::GetResolverRuleRequest& request) const; /** * A Callable wrapper for GetResolverRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverRuleOutcomeCallable GetResolverRuleCallable(const GetResolverRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverRule, request); } /** * An Async wrapper for GetResolverRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverRuleAsync(const GetResolverRuleRequestT& request, const GetResolverRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverRule, request, handler, context); } /** *

Gets information about an association between a specified Resolver rule and a * VPC. You associate a Resolver rule and a VPC using AssociateResolverRule. *

See Also:

AWS * API Reference

*/ virtual Model::GetResolverRuleAssociationOutcome GetResolverRuleAssociation(const Model::GetResolverRuleAssociationRequest& request) const; /** * A Callable wrapper for GetResolverRuleAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverRuleAssociationOutcomeCallable GetResolverRuleAssociationCallable(const GetResolverRuleAssociationRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverRuleAssociation, request); } /** * An Async wrapper for GetResolverRuleAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverRuleAssociationAsync(const GetResolverRuleAssociationRequestT& request, const GetResolverRuleAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverRuleAssociation, request, handler, context); } /** *

Gets information about the Resolver rule policy for a specified rule. A * Resolver rule policy includes the rule that you want to share with another * account, the account that you want to share the rule with, and the Resolver * operations that you want to allow the account to use.

See Also:

* AWS * API Reference

*/ virtual Model::GetResolverRulePolicyOutcome GetResolverRulePolicy(const Model::GetResolverRulePolicyRequest& request) const; /** * A Callable wrapper for GetResolverRulePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResolverRulePolicyOutcomeCallable GetResolverRulePolicyCallable(const GetResolverRulePolicyRequestT& request) const { return SubmitCallable(&Route53ResolverClient::GetResolverRulePolicy, request); } /** * An Async wrapper for GetResolverRulePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResolverRulePolicyAsync(const GetResolverRulePolicyRequestT& request, const GetResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::GetResolverRulePolicy, request, handler, context); } /** *

Imports domain names from a file into a domain list, for use in a DNS * firewall rule group.

Each domain specification in your domain list must * satisfy the following requirements:

  • It can optionally start * with * (asterisk).

  • With the exception of the * optional starting asterisk, it must only contain the following characters: * A-Z, a-z, 0-9, - * (hyphen).

  • It must be from 1-255 characters in length.

    *

See Also:

AWS * API Reference

*/ virtual Model::ImportFirewallDomainsOutcome ImportFirewallDomains(const Model::ImportFirewallDomainsRequest& request) const; /** * A Callable wrapper for ImportFirewallDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportFirewallDomainsOutcomeCallable ImportFirewallDomainsCallable(const ImportFirewallDomainsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ImportFirewallDomains, request); } /** * An Async wrapper for ImportFirewallDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportFirewallDomainsAsync(const ImportFirewallDomainsRequestT& request, const ImportFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ImportFirewallDomains, request, handler, context); } /** *

Retrieves the firewall configurations that you have defined. DNS Firewall * uses the configurations to manage firewall behavior for your VPCs.

A * single call might return only a partial list of the configurations. For * information, see MaxResults.

See Also:

AWS * API Reference

*/ virtual Model::ListFirewallConfigsOutcome ListFirewallConfigs(const Model::ListFirewallConfigsRequest& request) const; /** * A Callable wrapper for ListFirewallConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFirewallConfigsOutcomeCallable ListFirewallConfigsCallable(const ListFirewallConfigsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListFirewallConfigs, request); } /** * An Async wrapper for ListFirewallConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFirewallConfigsAsync(const ListFirewallConfigsRequestT& request, const ListFirewallConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListFirewallConfigs, request, handler, context); } /** *

Retrieves the firewall domain lists that you have defined. For each firewall * domain list, you can retrieve the domains that are defined for a list by calling * ListFirewallDomains.

A single call to this list operation might * return only a partial list of the domain lists. For information, see * MaxResults.

See Also:

AWS * API Reference

*/ virtual Model::ListFirewallDomainListsOutcome ListFirewallDomainLists(const Model::ListFirewallDomainListsRequest& request) const; /** * A Callable wrapper for ListFirewallDomainLists that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFirewallDomainListsOutcomeCallable ListFirewallDomainListsCallable(const ListFirewallDomainListsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListFirewallDomainLists, request); } /** * An Async wrapper for ListFirewallDomainLists that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFirewallDomainListsAsync(const ListFirewallDomainListsRequestT& request, const ListFirewallDomainListsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListFirewallDomainLists, request, handler, context); } /** *

Retrieves the domains that you have defined for the specified firewall domain * list.

A single call might return only a partial list of the domains. For * information, see MaxResults.

See Also:

AWS * API Reference

*/ virtual Model::ListFirewallDomainsOutcome ListFirewallDomains(const Model::ListFirewallDomainsRequest& request) const; /** * A Callable wrapper for ListFirewallDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFirewallDomainsOutcomeCallable ListFirewallDomainsCallable(const ListFirewallDomainsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListFirewallDomains, request); } /** * An Async wrapper for ListFirewallDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFirewallDomainsAsync(const ListFirewallDomainsRequestT& request, const ListFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListFirewallDomains, request, handler, context); } /** *

Retrieves the firewall rule group associations that you have defined. Each * association enables DNS filtering for a VPC with one rule group.

A * single call might return only a partial list of the associations. For * information, see MaxResults.

See Also:

AWS * API Reference

*/ virtual Model::ListFirewallRuleGroupAssociationsOutcome ListFirewallRuleGroupAssociations(const Model::ListFirewallRuleGroupAssociationsRequest& request) const; /** * A Callable wrapper for ListFirewallRuleGroupAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFirewallRuleGroupAssociationsOutcomeCallable ListFirewallRuleGroupAssociationsCallable(const ListFirewallRuleGroupAssociationsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListFirewallRuleGroupAssociations, request); } /** * An Async wrapper for ListFirewallRuleGroupAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFirewallRuleGroupAssociationsAsync(const ListFirewallRuleGroupAssociationsRequestT& request, const ListFirewallRuleGroupAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListFirewallRuleGroupAssociations, request, handler, context); } /** *

Retrieves the minimal high-level information for the rule groups that you * have defined.

A single call might return only a partial list of the rule * groups. For information, see MaxResults.

See Also:

* AWS * API Reference

*/ virtual Model::ListFirewallRuleGroupsOutcome ListFirewallRuleGroups(const Model::ListFirewallRuleGroupsRequest& request) const; /** * A Callable wrapper for ListFirewallRuleGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFirewallRuleGroupsOutcomeCallable ListFirewallRuleGroupsCallable(const ListFirewallRuleGroupsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListFirewallRuleGroups, request); } /** * An Async wrapper for ListFirewallRuleGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFirewallRuleGroupsAsync(const ListFirewallRuleGroupsRequestT& request, const ListFirewallRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListFirewallRuleGroups, request, handler, context); } /** *

Retrieves the firewall rules that you have defined for the specified firewall * rule group. DNS Firewall uses the rules in a rule group to filter DNS network * traffic for a VPC.

A single call might return only a partial list of the * rules. For information, see MaxResults.

See Also:

* AWS * API Reference

*/ virtual Model::ListFirewallRulesOutcome ListFirewallRules(const Model::ListFirewallRulesRequest& request) const; /** * A Callable wrapper for ListFirewallRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFirewallRulesOutcomeCallable ListFirewallRulesCallable(const ListFirewallRulesRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListFirewallRules, request); } /** * An Async wrapper for ListFirewallRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFirewallRulesAsync(const ListFirewallRulesRequestT& request, const ListFirewallRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListFirewallRules, request, handler, context); } /** *

Lists all the Resolvers on Outposts that were created using the current * Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListOutpostResolversOutcome ListOutpostResolvers(const Model::ListOutpostResolversRequest& request) const; /** * A Callable wrapper for ListOutpostResolvers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOutpostResolversOutcomeCallable ListOutpostResolversCallable(const ListOutpostResolversRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListOutpostResolvers, request); } /** * An Async wrapper for ListOutpostResolvers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOutpostResolversAsync(const ListOutpostResolversRequestT& request, const ListOutpostResolversResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListOutpostResolvers, request, handler, context); } /** *

Retrieves the Resolver configurations that you have defined. Route 53 * Resolver uses the configurations to manage DNS resolution behavior for your * VPCs.

See Also:

AWS * API Reference

*/ virtual Model::ListResolverConfigsOutcome ListResolverConfigs(const Model::ListResolverConfigsRequest& request) const; /** * A Callable wrapper for ListResolverConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverConfigsOutcomeCallable ListResolverConfigsCallable(const ListResolverConfigsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverConfigs, request); } /** * An Async wrapper for ListResolverConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverConfigsAsync(const ListResolverConfigsRequestT& request, const ListResolverConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverConfigs, request, handler, context); } /** *

Lists the configurations for DNSSEC validation that are associated with the * current Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListResolverDnssecConfigsOutcome ListResolverDnssecConfigs(const Model::ListResolverDnssecConfigsRequest& request) const; /** * A Callable wrapper for ListResolverDnssecConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverDnssecConfigsOutcomeCallable ListResolverDnssecConfigsCallable(const ListResolverDnssecConfigsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverDnssecConfigs, request); } /** * An Async wrapper for ListResolverDnssecConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverDnssecConfigsAsync(const ListResolverDnssecConfigsRequestT& request, const ListResolverDnssecConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverDnssecConfigs, request, handler, context); } /** *

Gets the IP addresses for a specified Resolver endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::ListResolverEndpointIpAddressesOutcome ListResolverEndpointIpAddresses(const Model::ListResolverEndpointIpAddressesRequest& request) const; /** * A Callable wrapper for ListResolverEndpointIpAddresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverEndpointIpAddressesOutcomeCallable ListResolverEndpointIpAddressesCallable(const ListResolverEndpointIpAddressesRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverEndpointIpAddresses, request); } /** * An Async wrapper for ListResolverEndpointIpAddresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverEndpointIpAddressesAsync(const ListResolverEndpointIpAddressesRequestT& request, const ListResolverEndpointIpAddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverEndpointIpAddresses, request, handler, context); } /** *

Lists all the Resolver endpoints that were created using the current Amazon * Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListResolverEndpointsOutcome ListResolverEndpoints(const Model::ListResolverEndpointsRequest& request) const; /** * A Callable wrapper for ListResolverEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverEndpointsOutcomeCallable ListResolverEndpointsCallable(const ListResolverEndpointsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverEndpoints, request); } /** * An Async wrapper for ListResolverEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverEndpointsAsync(const ListResolverEndpointsRequestT& request, const ListResolverEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverEndpoints, request, handler, context); } /** *

Lists information about associations between Amazon VPCs and query logging * configurations.

See Also:

AWS * API Reference

*/ virtual Model::ListResolverQueryLogConfigAssociationsOutcome ListResolverQueryLogConfigAssociations(const Model::ListResolverQueryLogConfigAssociationsRequest& request) const; /** * A Callable wrapper for ListResolverQueryLogConfigAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverQueryLogConfigAssociationsOutcomeCallable ListResolverQueryLogConfigAssociationsCallable(const ListResolverQueryLogConfigAssociationsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverQueryLogConfigAssociations, request); } /** * An Async wrapper for ListResolverQueryLogConfigAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverQueryLogConfigAssociationsAsync(const ListResolverQueryLogConfigAssociationsRequestT& request, const ListResolverQueryLogConfigAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverQueryLogConfigAssociations, request, handler, context); } /** *

Lists information about the specified query logging configurations. Each * configuration defines where you want Resolver to save DNS query logs and * specifies the VPCs that you want to log queries for.

See Also:

* AWS * API Reference

*/ virtual Model::ListResolverQueryLogConfigsOutcome ListResolverQueryLogConfigs(const Model::ListResolverQueryLogConfigsRequest& request) const; /** * A Callable wrapper for ListResolverQueryLogConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverQueryLogConfigsOutcomeCallable ListResolverQueryLogConfigsCallable(const ListResolverQueryLogConfigsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverQueryLogConfigs, request); } /** * An Async wrapper for ListResolverQueryLogConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverQueryLogConfigsAsync(const ListResolverQueryLogConfigsRequestT& request, const ListResolverQueryLogConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverQueryLogConfigs, request, handler, context); } /** *

Lists the associations that were created between Resolver rules and VPCs * using the current Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListResolverRuleAssociationsOutcome ListResolverRuleAssociations(const Model::ListResolverRuleAssociationsRequest& request) const; /** * A Callable wrapper for ListResolverRuleAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverRuleAssociationsOutcomeCallable ListResolverRuleAssociationsCallable(const ListResolverRuleAssociationsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverRuleAssociations, request); } /** * An Async wrapper for ListResolverRuleAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverRuleAssociationsAsync(const ListResolverRuleAssociationsRequestT& request, const ListResolverRuleAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverRuleAssociations, request, handler, context); } /** *

Lists the Resolver rules that were created using the current Amazon Web * Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListResolverRulesOutcome ListResolverRules(const Model::ListResolverRulesRequest& request) const; /** * A Callable wrapper for ListResolverRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResolverRulesOutcomeCallable ListResolverRulesCallable(const ListResolverRulesRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListResolverRules, request); } /** * An Async wrapper for ListResolverRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResolverRulesAsync(const ListResolverRulesRequestT& request, const ListResolverRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListResolverRules, request, handler, context); } /** *

Lists the tags that you associated with the specified resource.

See * Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&Route53ResolverClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::ListTagsForResource, request, handler, context); } /** *

Attaches an Identity and Access Management (Amazon Web Services IAM) policy * for sharing the rule group. You can use the policy to share the rule group using * Resource Access Manager (RAM).

See Also:

AWS * API Reference

*/ virtual Model::PutFirewallRuleGroupPolicyOutcome PutFirewallRuleGroupPolicy(const Model::PutFirewallRuleGroupPolicyRequest& request) const; /** * A Callable wrapper for PutFirewallRuleGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutFirewallRuleGroupPolicyOutcomeCallable PutFirewallRuleGroupPolicyCallable(const PutFirewallRuleGroupPolicyRequestT& request) const { return SubmitCallable(&Route53ResolverClient::PutFirewallRuleGroupPolicy, request); } /** * An Async wrapper for PutFirewallRuleGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutFirewallRuleGroupPolicyAsync(const PutFirewallRuleGroupPolicyRequestT& request, const PutFirewallRuleGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::PutFirewallRuleGroupPolicy, request, handler, context); } /** *

Specifies an Amazon Web Services account that you want to share a query * logging configuration with, the query logging configuration that you want to * share, and the operations that you want the account to be able to perform on the * configuration.

See Also:

AWS * API Reference

*/ virtual Model::PutResolverQueryLogConfigPolicyOutcome PutResolverQueryLogConfigPolicy(const Model::PutResolverQueryLogConfigPolicyRequest& request) const; /** * A Callable wrapper for PutResolverQueryLogConfigPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutResolverQueryLogConfigPolicyOutcomeCallable PutResolverQueryLogConfigPolicyCallable(const PutResolverQueryLogConfigPolicyRequestT& request) const { return SubmitCallable(&Route53ResolverClient::PutResolverQueryLogConfigPolicy, request); } /** * An Async wrapper for PutResolverQueryLogConfigPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutResolverQueryLogConfigPolicyAsync(const PutResolverQueryLogConfigPolicyRequestT& request, const PutResolverQueryLogConfigPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::PutResolverQueryLogConfigPolicy, request, handler, context); } /** *

Specifies an Amazon Web Services rule that you want to share with another * account, the account that you want to share the rule with, and the operations * that you want the account to be able to perform on the rule.

See * Also:

AWS * API Reference

*/ virtual Model::PutResolverRulePolicyOutcome PutResolverRulePolicy(const Model::PutResolverRulePolicyRequest& request) const; /** * A Callable wrapper for PutResolverRulePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutResolverRulePolicyOutcomeCallable PutResolverRulePolicyCallable(const PutResolverRulePolicyRequestT& request) const { return SubmitCallable(&Route53ResolverClient::PutResolverRulePolicy, request); } /** * An Async wrapper for PutResolverRulePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutResolverRulePolicyAsync(const PutResolverRulePolicyRequestT& request, const PutResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::PutResolverRulePolicy, request, handler, context); } /** *

Adds one or more tags to a specified resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&Route53ResolverClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::TagResource, request, handler, context); } /** *

Removes one or more tags from a specified resource.

See Also:

* AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UntagResource, request, handler, context); } /** *

Updates the configuration of the firewall behavior provided by DNS Firewall * for a single VPC from Amazon Virtual Private Cloud (Amazon VPC).

See * Also:

AWS * API Reference

*/ virtual Model::UpdateFirewallConfigOutcome UpdateFirewallConfig(const Model::UpdateFirewallConfigRequest& request) const; /** * A Callable wrapper for UpdateFirewallConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFirewallConfigOutcomeCallable UpdateFirewallConfigCallable(const UpdateFirewallConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateFirewallConfig, request); } /** * An Async wrapper for UpdateFirewallConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFirewallConfigAsync(const UpdateFirewallConfigRequestT& request, const UpdateFirewallConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateFirewallConfig, request, handler, context); } /** *

Updates the firewall domain list from an array of domain specifications. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateFirewallDomainsOutcome UpdateFirewallDomains(const Model::UpdateFirewallDomainsRequest& request) const; /** * A Callable wrapper for UpdateFirewallDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFirewallDomainsOutcomeCallable UpdateFirewallDomainsCallable(const UpdateFirewallDomainsRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateFirewallDomains, request); } /** * An Async wrapper for UpdateFirewallDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFirewallDomainsAsync(const UpdateFirewallDomainsRequestT& request, const UpdateFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateFirewallDomains, request, handler, context); } /** *

Updates the specified firewall rule.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFirewallRuleOutcome UpdateFirewallRule(const Model::UpdateFirewallRuleRequest& request) const; /** * A Callable wrapper for UpdateFirewallRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFirewallRuleOutcomeCallable UpdateFirewallRuleCallable(const UpdateFirewallRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateFirewallRule, request); } /** * An Async wrapper for UpdateFirewallRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFirewallRuleAsync(const UpdateFirewallRuleRequestT& request, const UpdateFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateFirewallRule, request, handler, context); } /** *

Changes the association of a FirewallRuleGroup with a VPC. The * association enables DNS filtering for the VPC.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFirewallRuleGroupAssociationOutcome UpdateFirewallRuleGroupAssociation(const Model::UpdateFirewallRuleGroupAssociationRequest& request) const; /** * A Callable wrapper for UpdateFirewallRuleGroupAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFirewallRuleGroupAssociationOutcomeCallable UpdateFirewallRuleGroupAssociationCallable(const UpdateFirewallRuleGroupAssociationRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateFirewallRuleGroupAssociation, request); } /** * An Async wrapper for UpdateFirewallRuleGroupAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFirewallRuleGroupAssociationAsync(const UpdateFirewallRuleGroupAssociationRequestT& request, const UpdateFirewallRuleGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateFirewallRuleGroupAssociation, request, handler, context); } /** *

You can use UpdateOutpostResolver to update the instance count, * type, or name of a Resolver on an Outpost.

See Also:

AWS * API Reference

*/ virtual Model::UpdateOutpostResolverOutcome UpdateOutpostResolver(const Model::UpdateOutpostResolverRequest& request) const; /** * A Callable wrapper for UpdateOutpostResolver that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOutpostResolverOutcomeCallable UpdateOutpostResolverCallable(const UpdateOutpostResolverRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateOutpostResolver, request); } /** * An Async wrapper for UpdateOutpostResolver that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOutpostResolverAsync(const UpdateOutpostResolverRequestT& request, const UpdateOutpostResolverResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateOutpostResolver, request, handler, context); } /** *

Updates the behavior configuration of Route 53 Resolver behavior for a single * VPC from Amazon Virtual Private Cloud.

See Also:

AWS * API Reference

*/ virtual Model::UpdateResolverConfigOutcome UpdateResolverConfig(const Model::UpdateResolverConfigRequest& request) const; /** * A Callable wrapper for UpdateResolverConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResolverConfigOutcomeCallable UpdateResolverConfigCallable(const UpdateResolverConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateResolverConfig, request); } /** * An Async wrapper for UpdateResolverConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResolverConfigAsync(const UpdateResolverConfigRequestT& request, const UpdateResolverConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateResolverConfig, request, handler, context); } /** *

Updates an existing DNSSEC validation configuration. If there is no existing * DNSSEC validation configuration, one is created.

See Also:

AWS * API Reference

*/ virtual Model::UpdateResolverDnssecConfigOutcome UpdateResolverDnssecConfig(const Model::UpdateResolverDnssecConfigRequest& request) const; /** * A Callable wrapper for UpdateResolverDnssecConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResolverDnssecConfigOutcomeCallable UpdateResolverDnssecConfigCallable(const UpdateResolverDnssecConfigRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateResolverDnssecConfig, request); } /** * An Async wrapper for UpdateResolverDnssecConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResolverDnssecConfigAsync(const UpdateResolverDnssecConfigRequestT& request, const UpdateResolverDnssecConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateResolverDnssecConfig, request, handler, context); } /** *

Updates the name, or enpoint type for an inbound or an outbound Resolver * endpoint. You can only update between IPV4 and DUALSTACK, IPV6 endpoint type * can't be updated to other type.

See Also:

AWS * API Reference

*/ virtual Model::UpdateResolverEndpointOutcome UpdateResolverEndpoint(const Model::UpdateResolverEndpointRequest& request) const; /** * A Callable wrapper for UpdateResolverEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResolverEndpointOutcomeCallable UpdateResolverEndpointCallable(const UpdateResolverEndpointRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateResolverEndpoint, request); } /** * An Async wrapper for UpdateResolverEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResolverEndpointAsync(const UpdateResolverEndpointRequestT& request, const UpdateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateResolverEndpoint, request, handler, context); } /** *

Updates settings for a specified Resolver rule. ResolverRuleId * is required, and all other parameters are optional. If you don't specify a * parameter, it retains its current value.

See Also:

AWS * API Reference

*/ virtual Model::UpdateResolverRuleOutcome UpdateResolverRule(const Model::UpdateResolverRuleRequest& request) const; /** * A Callable wrapper for UpdateResolverRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResolverRuleOutcomeCallable UpdateResolverRuleCallable(const UpdateResolverRuleRequestT& request) const { return SubmitCallable(&Route53ResolverClient::UpdateResolverRule, request); } /** * An Async wrapper for UpdateResolverRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResolverRuleAsync(const UpdateResolverRuleRequestT& request, const UpdateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53ResolverClient::UpdateResolverRule, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const Route53ResolverClientConfiguration& clientConfiguration); Route53ResolverClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Route53Resolver } // namespace Aws