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

Amazon Route 53 is a highly available and scalable Domain Name System (DNS) * web service.

You can use Route 53 to:

*/ class AWS_ROUTE53_API Route53Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef Route53ClientConfiguration ClientConfigurationType; typedef Route53EndpointProvider 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. */ Route53Client(const Aws::Route53::Route53ClientConfiguration& clientConfiguration = Aws::Route53::Route53ClientConfiguration(), 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. */ Route53Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Route53::Route53ClientConfiguration& clientConfiguration = Aws::Route53::Route53ClientConfiguration()); /** * 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 */ Route53Client(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Route53::Route53ClientConfiguration& clientConfiguration = Aws::Route53::Route53ClientConfiguration()); /* 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. */ Route53Client(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. */ Route53Client(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 */ Route53Client(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~Route53Client(); /** *

Activates a key-signing key (KSK) so that it can be used for signing by * DNSSEC. This operation changes the KSK status to * ACTIVE.

See Also:

AWS * API Reference

*/ virtual Model::ActivateKeySigningKeyOutcome ActivateKeySigningKey(const Model::ActivateKeySigningKeyRequest& request) const; /** * A Callable wrapper for ActivateKeySigningKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ActivateKeySigningKeyOutcomeCallable ActivateKeySigningKeyCallable(const ActivateKeySigningKeyRequestT& request) const { return SubmitCallable(&Route53Client::ActivateKeySigningKey, request); } /** * An Async wrapper for ActivateKeySigningKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ActivateKeySigningKeyAsync(const ActivateKeySigningKeyRequestT& request, const ActivateKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ActivateKeySigningKey, request, handler, context); } /** *

Associates an Amazon VPC with a private hosted zone.

To * perform the association, the VPC and the private hosted zone must already exist. * You can't convert a public hosted zone into a private hosted zone.

*

If you want to associate a VPC that was created by using * one Amazon Web Services account with a private hosted zone that was created by * using a different account, the Amazon Web Services account that created the * private hosted zone must first submit a * CreateVPCAssociationAuthorization request. Then the account that * created the VPC must submit an AssociateVPCWithHostedZone * request.

When granting access, the hosted zone and the * Amazon VPC must belong to the same partition. A partition is a group of Amazon * Web Services Regions. Each Amazon Web Services account is scoped to one * partition.

The following are the supported partitions:

  • * aws - Amazon Web Services Regions

  • * aws-cn - China Regions

  • aws-us-gov - * Amazon Web Services GovCloud (US) Region

For more * information, see Access * Management in the Amazon Web Services General Reference.

*

See Also:

AWS * API Reference

*/ virtual Model::AssociateVPCWithHostedZoneOutcome AssociateVPCWithHostedZone(const Model::AssociateVPCWithHostedZoneRequest& request) const; /** * A Callable wrapper for AssociateVPCWithHostedZone that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateVPCWithHostedZoneOutcomeCallable AssociateVPCWithHostedZoneCallable(const AssociateVPCWithHostedZoneRequestT& request) const { return SubmitCallable(&Route53Client::AssociateVPCWithHostedZone, request); } /** * An Async wrapper for AssociateVPCWithHostedZone that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateVPCWithHostedZoneAsync(const AssociateVPCWithHostedZoneRequestT& request, const AssociateVPCWithHostedZoneResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::AssociateVPCWithHostedZone, request, handler, context); } /** *

Creates, changes, or deletes CIDR blocks within a collection. Contains * authoritative IP information mapping blocks to one or multiple locations.

*

A change request can update multiple locations in a collection at a time, * which is helpful if you want to move one or more CIDR blocks from one location * to another in one transaction, without downtime.

Limits

*

The max number of CIDR blocks included in the request is 1000. As a result, * big updates require multiple API calls.

PUT and DELETE_IF_EXISTS *

Use ChangeCidrCollection to perform the following * actions:

  • PUT: Create a CIDR block within the * specified collection.

  • DELETE_IF_EXISTS: Delete * an existing CIDR block from the collection.

See Also:

* AWS * API Reference

*/ virtual Model::ChangeCidrCollectionOutcome ChangeCidrCollection(const Model::ChangeCidrCollectionRequest& request) const; /** * A Callable wrapper for ChangeCidrCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ChangeCidrCollectionOutcomeCallable ChangeCidrCollectionCallable(const ChangeCidrCollectionRequestT& request) const { return SubmitCallable(&Route53Client::ChangeCidrCollection, request); } /** * An Async wrapper for ChangeCidrCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ChangeCidrCollectionAsync(const ChangeCidrCollectionRequestT& request, const ChangeCidrCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ChangeCidrCollection, request, handler, context); } /** *

Creates, changes, or deletes a resource record set, which contains * authoritative DNS information for a specified domain name or subdomain name. For * example, you can use ChangeResourceRecordSets to create a resource * record set that routes traffic for test.example.com to a web server that has an * IP address of 192.0.2.44.

Deleting Resource Record Sets

*

To delete a resource record set, you must specify all the same values that * you specified when you created it.

Change Batches and Transactional * Changes

The request body must include a document with a * ChangeResourceRecordSetsRequest element. The request body contains * a list of change items, known as a change batch. Change batches are considered * transactional changes. Route 53 validates the changes in the request and then * either makes all or none of the changes in the change batch request. This * ensures that DNS routing isn't adversely affected by partial changes to the * resource record sets in a hosted zone.

For example, suppose a change * batch request contains two changes: it deletes the CNAME resource * record set for www.example.com and creates an alias resource record set for * www.example.com. If validation for both records succeeds, Route 53 deletes the * first resource record set and creates the second resource record set in a single * operation. If validation for either the DELETE or the * CREATE action fails, then the request is canceled, and the original * CNAME record continues to exist.

If you try to delete * the same resource record set more than once in a single change batch, Route 53 * returns an InvalidChangeBatch error.

Traffic * Flow

To create resource record sets for complex routing * configurations, use either the traffic flow visual editor in the Route 53 * console or the API actions for traffic policies and traffic policy instances. * Save the configuration as a traffic policy, then associate the traffic policy * with one or more domain names (such as example.com) or subdomain names (such as * www.example.com), in the same hosted zone or in multiple hosted zones. You can * roll back the updates if the new configuration isn't performing as expected. For * more information, see Using * Traffic Flow to Route DNS Traffic in the Amazon Route 53 Developer * Guide.

Create, Delete, and Upsert

Use * ChangeResourceRecordsSetsRequest to perform the following * actions:

  • CREATE: Creates a resource record set * that has the specified values.

  • DELETE: Deletes * an existing resource record set that has the specified values.

  • *

    UPSERT: If a resource set exists Route 53 updates it with the * values in the request.

Syntaxes for Creating, Updating, * and Deleting Resource Record Sets

The syntax for a request depends * on the type of resource record set that you want to create, delete, or update, * such as weighted, alias, or failover. The XML elements in your request must * appear in the order listed in the syntax.

For an example for each type * of resource record set, see "Examples."

Don't refer to the syntax in the * "Parameter Syntax" section, which includes all of the elements for every kind of * resource record set that you can create, delete, or update by using * ChangeResourceRecordSets.

Change Propagation to Route * 53 DNS Servers

When you submit a * ChangeResourceRecordSets request, Route 53 propagates your changes * to all of the Route 53 authoritative DNS servers managing the hosted zone. While * your changes are propagating, GetChange returns a status of * PENDING. When propagation is complete, GetChange * returns a status of INSYNC. Changes generally propagate to all * Route 53 name servers managing the hosted zone within 60 seconds. For more * information, see GetChange.

*

Limits on ChangeResourceRecordSets Requests

For information * about the limits on a ChangeResourceRecordSets request, see Limits * in the Amazon Route 53 Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::ChangeResourceRecordSetsOutcome ChangeResourceRecordSets(const Model::ChangeResourceRecordSetsRequest& request) const; /** * A Callable wrapper for ChangeResourceRecordSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ChangeResourceRecordSetsOutcomeCallable ChangeResourceRecordSetsCallable(const ChangeResourceRecordSetsRequestT& request) const { return SubmitCallable(&Route53Client::ChangeResourceRecordSets, request); } /** * An Async wrapper for ChangeResourceRecordSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ChangeResourceRecordSetsAsync(const ChangeResourceRecordSetsRequestT& request, const ChangeResourceRecordSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ChangeResourceRecordSets, request, handler, context); } /** *

Adds, edits, or deletes tags for a health check or a hosted zone.

For * information about using tags for cost allocation, see Using * Cost Allocation Tags in the Billing and Cost Management User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ChangeTagsForResourceOutcome ChangeTagsForResource(const Model::ChangeTagsForResourceRequest& request) const; /** * A Callable wrapper for ChangeTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ChangeTagsForResourceOutcomeCallable ChangeTagsForResourceCallable(const ChangeTagsForResourceRequestT& request) const { return SubmitCallable(&Route53Client::ChangeTagsForResource, request); } /** * An Async wrapper for ChangeTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ChangeTagsForResourceAsync(const ChangeTagsForResourceRequestT& request, const ChangeTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ChangeTagsForResource, request, handler, context); } /** *

Creates a CIDR collection in the current Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::CreateCidrCollectionOutcome CreateCidrCollection(const Model::CreateCidrCollectionRequest& request) const; /** * A Callable wrapper for CreateCidrCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCidrCollectionOutcomeCallable CreateCidrCollectionCallable(const CreateCidrCollectionRequestT& request) const { return SubmitCallable(&Route53Client::CreateCidrCollection, request); } /** * An Async wrapper for CreateCidrCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCidrCollectionAsync(const CreateCidrCollectionRequestT& request, const CreateCidrCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateCidrCollection, request, handler, context); } /** *

Creates a new health check.

For information about adding health checks * to resource record sets, see HealthCheckId * in ChangeResourceRecordSets. *

ELB Load Balancers

If you're registering EC2 instances * with an Elastic Load Balancing (ELB) load balancer, do not create Amazon Route * 53 health checks for the EC2 instances. When you register an EC2 instance with a * load balancer, you configure settings for an ELB health check, which performs a * similar function to a Route 53 health check.

Private Hosted Zones *

You can associate health checks with failover resource record sets in a * private hosted zone. Note the following:

  • Route 53 health * checkers are outside the VPC. To check the health of an endpoint within a VPC by * IP address, you must assign a public IP address to the instance in the VPC.

    *

  • You can configure a health checker to check the health of an * external resource that the instance relies on, such as a database server.

    *

  • You can create a CloudWatch metric, associate an alarm with the * metric, and then create a health check that is based on the state of the alarm. * For example, you might create a CloudWatch metric that checks the status of the * Amazon EC2 StatusCheckFailed metric, add an alarm to the metric, * and then create a health check that is based on the state of the alarm. For * information about creating CloudWatch metrics and alarms by using the CloudWatch * console, see the Amazon * CloudWatch User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateHealthCheckOutcome CreateHealthCheck(const Model::CreateHealthCheckRequest& request) const; /** * A Callable wrapper for CreateHealthCheck that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHealthCheckOutcomeCallable CreateHealthCheckCallable(const CreateHealthCheckRequestT& request) const { return SubmitCallable(&Route53Client::CreateHealthCheck, request); } /** * An Async wrapper for CreateHealthCheck that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHealthCheckAsync(const CreateHealthCheckRequestT& request, const CreateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateHealthCheck, request, handler, context); } /** *

Creates a new public or private hosted zone. You create records in a public * hosted zone to define how you want to route traffic on the internet for a * domain, such as example.com, and its subdomains (apex.example.com, * acme.example.com). You create records in a private hosted zone to define how you * want to route traffic for a domain and its subdomains within one or more Amazon * Virtual Private Clouds (Amazon VPCs).

You can't convert a * public hosted zone to a private hosted zone or vice versa. Instead, you must * create a new hosted zone with the same name and create new resource record * sets.

For more information about charges for hosted zones, * see Amazon Route 53 * Pricing.

Note the following:

  • You can't create a * hosted zone for a top-level domain (TLD) such as .com.

  • For * public hosted zones, Route 53 automatically creates a default SOA record and * four NS records for the zone. For more information about SOA and NS records, see * NS * and SOA Records that Route 53 Creates for a Hosted Zone in the Amazon * Route 53 Developer Guide.

    If you want to use the same name servers * for multiple public hosted zones, you can optionally associate a reusable * delegation set with the hosted zone. See the DelegationSetId * element.

  • If your domain is registered with a registrar other * than Route 53, you must update the name servers with your registrar to make * Route 53 the DNS service for the domain. For more information, see Migrating * DNS Service for an Existing Domain to Amazon Route 53 in the Amazon Route * 53 Developer Guide.

When you submit a * CreateHostedZone request, the initial status of the hosted zone is * PENDING. For public hosted zones, this means that the NS and SOA * records are not yet available on all Route 53 DNS servers. When the NS and SOA * records are available, the status of the zone changes to * INSYNC.

The CreateHostedZone request requires * the caller to have an ec2:DescribeVpcs permission.

*

When creating private hosted zones, the Amazon VPC must belong to the same * partition where the hosted zone is created. A partition is a group of Amazon Web * Services Regions. Each Amazon Web Services account is scoped to one * partition.

The following are the supported partitions:

  • * aws - Amazon Web Services Regions

  • * aws-cn - China Regions

  • aws-us-gov - * Amazon Web Services GovCloud (US) Region

For more * information, see Access * Management in the Amazon Web Services General Reference.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateHostedZoneOutcome CreateHostedZone(const Model::CreateHostedZoneRequest& request) const; /** * A Callable wrapper for CreateHostedZone that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHostedZoneOutcomeCallable CreateHostedZoneCallable(const CreateHostedZoneRequestT& request) const { return SubmitCallable(&Route53Client::CreateHostedZone, request); } /** * An Async wrapper for CreateHostedZone that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHostedZoneAsync(const CreateHostedZoneRequestT& request, const CreateHostedZoneResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateHostedZone, request, handler, context); } /** *

Creates a new key-signing key (KSK) associated with a hosted zone. You can * only have two KSKs per hosted zone.

See Also:

AWS * API Reference

*/ virtual Model::CreateKeySigningKeyOutcome CreateKeySigningKey(const Model::CreateKeySigningKeyRequest& request) const; /** * A Callable wrapper for CreateKeySigningKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateKeySigningKeyOutcomeCallable CreateKeySigningKeyCallable(const CreateKeySigningKeyRequestT& request) const { return SubmitCallable(&Route53Client::CreateKeySigningKey, request); } /** * An Async wrapper for CreateKeySigningKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateKeySigningKeyAsync(const CreateKeySigningKeyRequestT& request, const CreateKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateKeySigningKey, request, handler, context); } /** *

Creates a configuration for DNS query logging. After you create a query * logging configuration, Amazon Route 53 begins to publish log data to an Amazon * CloudWatch Logs log group.

DNS query logs contain information about the * queries that Route 53 receives for a specified public hosted zone, such as the * following:

  • Route 53 edge location that responded to the DNS * query

  • Domain or subdomain that was requested

  • *

    DNS record type, such as A or AAAA

  • DNS response code, such * as NoError or ServFail

Log * Group and Resource Policy

Before you create a query logging * configuration, perform the following operations.

If you create a * query logging configuration using the Route 53 console, Route 53 performs these * operations automatically.

  1. Create a CloudWatch Logs log * group, and make note of the ARN, which you specify when you create a query * logging configuration. Note the following:

    • You must create the * log group in the us-east-1 region.

    • You must use the same * Amazon Web Services account to create the log group and the hosted zone that you * want to configure query logging for.

    • When you create log * groups for query logging, we recommend that you use a consistent prefix, for * example:

      /aws/route53/hosted zone name

      In * the next step, you'll create a resource policy, which controls access to one or * more log groups and the associated Amazon Web Services resources, such as Route * 53 hosted zones. There's a limit on the number of resource policies that you can * create, so we recommend that you use a consistent prefix so you can use the same * resource policy for all the log groups that you create for query logging.

      *

  2. Create a CloudWatch Logs resource policy, and give it * the permissions that Route 53 needs to create log streams and to send query logs * to log streams. For the value of Resource, specify the ARN for the * log group that you created in the previous step. To use the same resource policy * for all the CloudWatch Logs log groups that you created for query logging * configurations, replace the hosted zone name with *, for * example:

    * arn:aws:logs:us-east-1:123412341234:log-group:/aws/route53/ *

    *

    To avoid the confused deputy problem, a security issue where an entity * without a permission for an action can coerce a more-privileged entity to * perform it, you can optionally limit the permissions that a service has to a * resource in a resource-based policy by supplying the following values:

      *

    • For aws:SourceArn, supply the hosted zone ARN used in * creating the query logging configuration. For example, aws:SourceArn: * arn:aws:route53:::hostedzone/hosted zone ID.

    • For * aws:SourceAccount, supply the account ID for the account that * creates the query logging configuration. For example, * aws:SourceAccount:111111111111.

    For more * information, see The * confused deputy problem in the Amazon Web Services IAM User * Guide.

    You can't use the CloudWatch console to create or edit * a resource policy. You must use the CloudWatch API, one of the Amazon Web * Services SDKs, or the CLI.

Log Streams and * Edge Locations

When Route 53 finishes creating the configuration * for DNS query logging, it does the following:

  • Creates a log * stream for an edge location the first time that the edge location responds to * DNS queries for the specified hosted zone. That log stream is used to log all * queries that Route 53 responds to for that edge location.

  • *

    Begins to send query logs to the applicable log stream.

*

The name of each log stream is in the following format:

* hosted zone ID/edge location code

The edge * location code is a three-letter code and an arbitrarily assigned number, for * example, DFW3. The three-letter code typically corresponds with the * International Air Transport Association airport code for an airport near the * edge location. (These abbreviations might change in the future.) For a list of * edge locations, see "The Route 53 Global Network" on the Route 53 Product Details * page.

Queries That Are Logged

Query logs contain only * the queries that DNS resolvers forward to Route 53. If a DNS resolver has * already cached the response to a query (such as the IP address for a load * balancer for example.com), the resolver will continue to return the cached * response. It doesn't forward another query to Route 53 until the TTL for the * corresponding resource record set expires. Depending on how many DNS queries are * submitted for a resource record set, and depending on the TTL for that resource * record set, query logs might contain information about only one query out of * every several thousand queries that are submitted to DNS. For more information * about how DNS works, see Routing * Internet Traffic to Your Website or Web Application in the Amazon Route * 53 Developer Guide.

Log File Format

For a list of * the values in each query log and the format of each value, see Logging * DNS Queries in the Amazon Route 53 Developer Guide.

*
Pricing

For information about charges for query logs, see Amazon CloudWatch * Pricing.

How to Stop Logging

If you want Route 53 * to stop sending query logs to CloudWatch Logs, delete the query logging * configuration. For more information, see DeleteQueryLoggingConfig.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateQueryLoggingConfigOutcome CreateQueryLoggingConfig(const Model::CreateQueryLoggingConfigRequest& request) const; /** * A Callable wrapper for CreateQueryLoggingConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateQueryLoggingConfigOutcomeCallable CreateQueryLoggingConfigCallable(const CreateQueryLoggingConfigRequestT& request) const { return SubmitCallable(&Route53Client::CreateQueryLoggingConfig, request); } /** * An Async wrapper for CreateQueryLoggingConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateQueryLoggingConfigAsync(const CreateQueryLoggingConfigRequestT& request, const CreateQueryLoggingConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateQueryLoggingConfig, request, handler, context); } /** *

Creates a delegation set (a group of four name servers) that can be reused by * multiple hosted zones that were created by the same Amazon Web Services account. *

You can also create a reusable delegation set that uses the four name * servers that are associated with an existing hosted zone. Specify the hosted * zone ID in the CreateReusableDelegationSet request.

*

You can't associate a reusable delegation set with a private hosted zone.

*

For information about using a reusable delegation set to configure * white label name servers, see Configuring * White Label Name Servers.

The process for migrating existing hosted * zones to use a reusable delegation set is comparable to the process for * configuring white label name servers. You need to perform the following * steps:

  1. Create a reusable delegation set.

  2. *

    Recreate hosted zones, and reduce the TTL to 60 seconds or less.

    3. *

  3. Recreate resource record sets in the new hosted zones.

  4. *

    Change the registrar's name servers to use the name servers for the new * hosted zones.

  5. Monitor traffic for the website or * application.

  6. Change TTLs back to their original values.

    *

If you want to migrate existing hosted zones to use a reusable * delegation set, the existing hosted zones can't use any of the name servers that * are assigned to the reusable delegation set. If one or more hosted zones do use * one or more name servers that are assigned to the reusable delegation set, you * can do one of the following:

  • For small numbers of hosted * zones—up to a few hundred—it's relatively easy to create reusable delegation * sets until you get one that has four name servers that don't overlap with any of * the name servers in your hosted zones.

  • For larger numbers of * hosted zones, the easiest solution is to use more than one reusable delegation * set.

  • For larger numbers of hosted zones, you can also migrate * hosted zones that have overlapping name servers to hosted zones that don't have * overlapping name servers, then migrate the hosted zones again to use the * reusable delegation set.

See Also:

AWS * API Reference

*/ virtual Model::CreateReusableDelegationSetOutcome CreateReusableDelegationSet(const Model::CreateReusableDelegationSetRequest& request) const; /** * A Callable wrapper for CreateReusableDelegationSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReusableDelegationSetOutcomeCallable CreateReusableDelegationSetCallable(const CreateReusableDelegationSetRequestT& request) const { return SubmitCallable(&Route53Client::CreateReusableDelegationSet, request); } /** * An Async wrapper for CreateReusableDelegationSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReusableDelegationSetAsync(const CreateReusableDelegationSetRequestT& request, const CreateReusableDelegationSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateReusableDelegationSet, request, handler, context); } /** *

Creates a traffic policy, which you use to create multiple DNS resource * record sets for one domain name (such as example.com) or one subdomain name * (such as www.example.com).

See Also:

AWS * API Reference

*/ virtual Model::CreateTrafficPolicyOutcome CreateTrafficPolicy(const Model::CreateTrafficPolicyRequest& request) const; /** * A Callable wrapper for CreateTrafficPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficPolicyOutcomeCallable CreateTrafficPolicyCallable(const CreateTrafficPolicyRequestT& request) const { return SubmitCallable(&Route53Client::CreateTrafficPolicy, request); } /** * An Async wrapper for CreateTrafficPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficPolicyAsync(const CreateTrafficPolicyRequestT& request, const CreateTrafficPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateTrafficPolicy, request, handler, context); } /** *

Creates resource record sets in a specified hosted zone based on the settings * in a specified traffic policy version. In addition, * CreateTrafficPolicyInstance associates the resource record sets * with a specified domain name (such as example.com) or subdomain name (such as * www.example.com). Amazon Route 53 responds to DNS queries for the domain or * subdomain name by using the resource record sets that * CreateTrafficPolicyInstance created.

After you submit * an CreateTrafficPolicyInstance request, there's a brief delay while * Amazon Route 53 creates the resource record sets that are specified in the * traffic policy definition. Use GetTrafficPolicyInstance with the * id of new traffic policy instance to confirm that the * CreateTrafficPolicyInstance request completed successfully. For * more information, see the State response element.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateTrafficPolicyInstanceOutcome CreateTrafficPolicyInstance(const Model::CreateTrafficPolicyInstanceRequest& request) const; /** * A Callable wrapper for CreateTrafficPolicyInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficPolicyInstanceOutcomeCallable CreateTrafficPolicyInstanceCallable(const CreateTrafficPolicyInstanceRequestT& request) const { return SubmitCallable(&Route53Client::CreateTrafficPolicyInstance, request); } /** * An Async wrapper for CreateTrafficPolicyInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficPolicyInstanceAsync(const CreateTrafficPolicyInstanceRequestT& request, const CreateTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateTrafficPolicyInstance, request, handler, context); } /** *

Creates a new version of an existing traffic policy. When you create a new * version of a traffic policy, you specify the ID of the traffic policy that you * want to update and a JSON-formatted document that describes the new version. You * use traffic policies to create multiple DNS resource record sets for one domain * name (such as example.com) or one subdomain name (such as www.example.com). You * can create a maximum of 1000 versions of a traffic policy. If you reach the * limit and need to create another version, you'll need to start a new traffic * policy.

See Also:

AWS * API Reference

*/ virtual Model::CreateTrafficPolicyVersionOutcome CreateTrafficPolicyVersion(const Model::CreateTrafficPolicyVersionRequest& request) const; /** * A Callable wrapper for CreateTrafficPolicyVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficPolicyVersionOutcomeCallable CreateTrafficPolicyVersionCallable(const CreateTrafficPolicyVersionRequestT& request) const { return SubmitCallable(&Route53Client::CreateTrafficPolicyVersion, request); } /** * An Async wrapper for CreateTrafficPolicyVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficPolicyVersionAsync(const CreateTrafficPolicyVersionRequestT& request, const CreateTrafficPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateTrafficPolicyVersion, request, handler, context); } /** *

Authorizes the Amazon Web Services account that created a specified VPC to * submit an AssociateVPCWithHostedZone request to associate the VPC * with a specified hosted zone that was created by a different account. To submit * a CreateVPCAssociationAuthorization request, you must use the * account that created the hosted zone. After you authorize the association, use * the account that created the VPC to submit an * AssociateVPCWithHostedZone request.

If you want to * associate multiple VPCs that you created by using one account with a hosted zone * that you created by using a different account, you must submit one authorization * request for each VPC.

See Also:

AWS * API Reference

*/ virtual Model::CreateVPCAssociationAuthorizationOutcome CreateVPCAssociationAuthorization(const Model::CreateVPCAssociationAuthorizationRequest& request) const; /** * A Callable wrapper for CreateVPCAssociationAuthorization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVPCAssociationAuthorizationOutcomeCallable CreateVPCAssociationAuthorizationCallable(const CreateVPCAssociationAuthorizationRequestT& request) const { return SubmitCallable(&Route53Client::CreateVPCAssociationAuthorization, request); } /** * An Async wrapper for CreateVPCAssociationAuthorization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVPCAssociationAuthorizationAsync(const CreateVPCAssociationAuthorizationRequestT& request, const CreateVPCAssociationAuthorizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::CreateVPCAssociationAuthorization, request, handler, context); } /** *

Deactivates a key-signing key (KSK) so that it will not be used for signing * by DNSSEC. This operation changes the KSK status to * INACTIVE.

See Also:

AWS * API Reference

*/ virtual Model::DeactivateKeySigningKeyOutcome DeactivateKeySigningKey(const Model::DeactivateKeySigningKeyRequest& request) const; /** * A Callable wrapper for DeactivateKeySigningKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeactivateKeySigningKeyOutcomeCallable DeactivateKeySigningKeyCallable(const DeactivateKeySigningKeyRequestT& request) const { return SubmitCallable(&Route53Client::DeactivateKeySigningKey, request); } /** * An Async wrapper for DeactivateKeySigningKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeactivateKeySigningKeyAsync(const DeactivateKeySigningKeyRequestT& request, const DeactivateKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeactivateKeySigningKey, request, handler, context); } /** *

Deletes a CIDR collection in the current Amazon Web Services account. The * collection must be empty before it can be deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCidrCollectionOutcome DeleteCidrCollection(const Model::DeleteCidrCollectionRequest& request) const; /** * A Callable wrapper for DeleteCidrCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCidrCollectionOutcomeCallable DeleteCidrCollectionCallable(const DeleteCidrCollectionRequestT& request) const { return SubmitCallable(&Route53Client::DeleteCidrCollection, request); } /** * An Async wrapper for DeleteCidrCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCidrCollectionAsync(const DeleteCidrCollectionRequestT& request, const DeleteCidrCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteCidrCollection, request, handler, context); } /** *

Deletes a health check.

Amazon Route 53 does not prevent * you from deleting a health check even if the health check is associated with one * or more resource record sets. If you delete a health check and you don't update * the associated resource record sets, the future status of the health check can't * be predicted and may change. This will affect the routing of DNS queries for * your DNS failover configuration. For more information, see Replacing * and Deleting Health Checks in the Amazon Route 53 Developer * Guide.

If you're using Cloud Map and you configured * Cloud Map to create a Route 53 health check when you register an instance, you * can't use the Route 53 DeleteHealthCheck command to delete the * health check. The health check is deleted automatically when you deregister the * instance; there can be a delay of several hours before the health check is * deleted from Route 53.

See Also:

AWS * API Reference

*/ virtual Model::DeleteHealthCheckOutcome DeleteHealthCheck(const Model::DeleteHealthCheckRequest& request) const; /** * A Callable wrapper for DeleteHealthCheck that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHealthCheckOutcomeCallable DeleteHealthCheckCallable(const DeleteHealthCheckRequestT& request) const { return SubmitCallable(&Route53Client::DeleteHealthCheck, request); } /** * An Async wrapper for DeleteHealthCheck that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHealthCheckAsync(const DeleteHealthCheckRequestT& request, const DeleteHealthCheckResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteHealthCheck, request, handler, context); } /** *

Deletes a hosted zone.

If the hosted zone was created by another * service, such as Cloud Map, see Deleting * Public Hosted Zones That Were Created by Another Service in the Amazon * Route 53 Developer Guide for information about how to delete it. (The * process is the same for public and private hosted zones that were created by * another service.)

If you want to keep your domain registration but you * want to stop routing internet traffic to your website or web application, we * recommend that you delete resource record sets in the hosted zone instead of * deleting the hosted zone.

If you delete a hosted zone, you * can't undelete it. You must create a new hosted zone and update the name servers * for your domain registration, which can require up to 48 hours to take effect. * (If you delegated responsibility for a subdomain to a hosted zone and you delete * the child hosted zone, you must update the name servers in the parent hosted * zone.) In addition, if you delete a hosted zone, someone could hijack the domain * and route traffic to their own resources using your domain name.

*

If you want to avoid the monthly charge for the hosted zone, you * can transfer DNS service for the domain to a free DNS service. When you transfer * DNS service, you have to update the name servers for the domain registration. If * the domain is registered with Route 53, see UpdateDomainNameservers * for information about how to replace Route 53 name servers with name servers for * the new DNS service. If the domain is registered with another registrar, use the * method provided by the registrar to update name servers for the domain * registration. For more information, perform an internet search on "free DNS * service."

You can delete a hosted zone only if it contains only the * default SOA record and NS resource record sets. If the hosted zone contains * other resource record sets, you must delete them before you can delete the * hosted zone. If you try to delete a hosted zone that contains other resource * record sets, the request fails, and Route 53 returns a * HostedZoneNotEmpty error. For information about deleting records * from your hosted zone, see ChangeResourceRecordSets.

*

To verify that the hosted zone has been deleted, do one of the following:

*

  • Use the GetHostedZone action to request information * about the hosted zone.

  • Use the ListHostedZones * action to get a list of the hosted zones associated with the current Amazon Web * Services account.

See Also:

AWS * API Reference

*/ virtual Model::DeleteHostedZoneOutcome DeleteHostedZone(const Model::DeleteHostedZoneRequest& request) const; /** * A Callable wrapper for DeleteHostedZone that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHostedZoneOutcomeCallable DeleteHostedZoneCallable(const DeleteHostedZoneRequestT& request) const { return SubmitCallable(&Route53Client::DeleteHostedZone, request); } /** * An Async wrapper for DeleteHostedZone that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHostedZoneAsync(const DeleteHostedZoneRequestT& request, const DeleteHostedZoneResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteHostedZone, request, handler, context); } /** *

Deletes a key-signing key (KSK). Before you can delete a KSK, you must * deactivate it. The KSK must be deactivated before you can delete it regardless * of whether the hosted zone is enabled for DNSSEC signing.

You can use DeactivateKeySigningKey * to deactivate the key before you delete it.

Use GetDNSSEC * to verify that the KSK is in an INACTIVE status.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteKeySigningKeyOutcome DeleteKeySigningKey(const Model::DeleteKeySigningKeyRequest& request) const; /** * A Callable wrapper for DeleteKeySigningKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteKeySigningKeyOutcomeCallable DeleteKeySigningKeyCallable(const DeleteKeySigningKeyRequestT& request) const { return SubmitCallable(&Route53Client::DeleteKeySigningKey, request); } /** * An Async wrapper for DeleteKeySigningKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteKeySigningKeyAsync(const DeleteKeySigningKeyRequestT& request, const DeleteKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteKeySigningKey, request, handler, context); } /** *

Deletes a configuration for DNS query logging. If you delete a configuration, * Amazon Route 53 stops sending query logs to CloudWatch Logs. Route 53 doesn't * delete any logs that are already in CloudWatch Logs.

For more information * about DNS query logs, see CreateQueryLoggingConfig.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteQueryLoggingConfigOutcome DeleteQueryLoggingConfig(const Model::DeleteQueryLoggingConfigRequest& request) const; /** * A Callable wrapper for DeleteQueryLoggingConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteQueryLoggingConfigOutcomeCallable DeleteQueryLoggingConfigCallable(const DeleteQueryLoggingConfigRequestT& request) const { return SubmitCallable(&Route53Client::DeleteQueryLoggingConfig, request); } /** * An Async wrapper for DeleteQueryLoggingConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteQueryLoggingConfigAsync(const DeleteQueryLoggingConfigRequestT& request, const DeleteQueryLoggingConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteQueryLoggingConfig, request, handler, context); } /** *

Deletes a reusable delegation set.

You can delete a * reusable delegation set only if it isn't associated with any hosted zones.

*

To verify that the reusable delegation set is not associated * with any hosted zones, submit a GetReusableDelegationSet * request and specify the ID of the reusable delegation set that you want to * delete.

See Also:

AWS * API Reference

*/ virtual Model::DeleteReusableDelegationSetOutcome DeleteReusableDelegationSet(const Model::DeleteReusableDelegationSetRequest& request) const; /** * A Callable wrapper for DeleteReusableDelegationSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteReusableDelegationSetOutcomeCallable DeleteReusableDelegationSetCallable(const DeleteReusableDelegationSetRequestT& request) const { return SubmitCallable(&Route53Client::DeleteReusableDelegationSet, request); } /** * An Async wrapper for DeleteReusableDelegationSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteReusableDelegationSetAsync(const DeleteReusableDelegationSetRequestT& request, const DeleteReusableDelegationSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteReusableDelegationSet, request, handler, context); } /** *

Deletes a traffic policy.

When you delete a traffic policy, Route 53 * sets a flag on the policy to indicate that it has been deleted. However, Route * 53 never fully deletes the traffic policy. Note the following:

  • *

    Deleted traffic policies aren't listed if you run ListTrafficPolicies.

    *

  • There's no way to get a list of deleted policies.

  • *

    If you retain the ID of the policy, you can get information about the policy, * including the traffic policy document, by running GetTrafficPolicy.

    *

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrafficPolicyOutcome DeleteTrafficPolicy(const Model::DeleteTrafficPolicyRequest& request) const; /** * A Callable wrapper for DeleteTrafficPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrafficPolicyOutcomeCallable DeleteTrafficPolicyCallable(const DeleteTrafficPolicyRequestT& request) const { return SubmitCallable(&Route53Client::DeleteTrafficPolicy, request); } /** * An Async wrapper for DeleteTrafficPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrafficPolicyAsync(const DeleteTrafficPolicyRequestT& request, const DeleteTrafficPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteTrafficPolicy, request, handler, context); } /** *

Deletes a traffic policy instance and all of the resource record sets that * Amazon Route 53 created when you created the instance.

In the * Route 53 console, traffic policy instances are known as policy records.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrafficPolicyInstanceOutcome DeleteTrafficPolicyInstance(const Model::DeleteTrafficPolicyInstanceRequest& request) const; /** * A Callable wrapper for DeleteTrafficPolicyInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrafficPolicyInstanceOutcomeCallable DeleteTrafficPolicyInstanceCallable(const DeleteTrafficPolicyInstanceRequestT& request) const { return SubmitCallable(&Route53Client::DeleteTrafficPolicyInstance, request); } /** * An Async wrapper for DeleteTrafficPolicyInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrafficPolicyInstanceAsync(const DeleteTrafficPolicyInstanceRequestT& request, const DeleteTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteTrafficPolicyInstance, request, handler, context); } /** *

Removes authorization to submit an AssociateVPCWithHostedZone * request to associate a specified VPC with a hosted zone that was created by a * different account. You must use the account that created the hosted zone to * submit a DeleteVPCAssociationAuthorization request.

*

Sending this request only prevents the Amazon Web Services account that * created the VPC from associating the VPC with the Amazon Route 53 hosted zone in * the future. If the VPC is already associated with the hosted zone, * DeleteVPCAssociationAuthorization won't disassociate the VPC from * the hosted zone. If you want to delete an existing association, use * DisassociateVPCFromHostedZone.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteVPCAssociationAuthorizationOutcome DeleteVPCAssociationAuthorization(const Model::DeleteVPCAssociationAuthorizationRequest& request) const; /** * A Callable wrapper for DeleteVPCAssociationAuthorization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVPCAssociationAuthorizationOutcomeCallable DeleteVPCAssociationAuthorizationCallable(const DeleteVPCAssociationAuthorizationRequestT& request) const { return SubmitCallable(&Route53Client::DeleteVPCAssociationAuthorization, request); } /** * An Async wrapper for DeleteVPCAssociationAuthorization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVPCAssociationAuthorizationAsync(const DeleteVPCAssociationAuthorizationRequestT& request, const DeleteVPCAssociationAuthorizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DeleteVPCAssociationAuthorization, request, handler, context); } /** *

Disables DNSSEC signing in a specific hosted zone. This action does not * deactivate any key-signing keys (KSKs) that are active in the hosted * zone.

See Also:

AWS * API Reference

*/ virtual Model::DisableHostedZoneDNSSECOutcome DisableHostedZoneDNSSEC(const Model::DisableHostedZoneDNSSECRequest& request) const; /** * A Callable wrapper for DisableHostedZoneDNSSEC that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableHostedZoneDNSSECOutcomeCallable DisableHostedZoneDNSSECCallable(const DisableHostedZoneDNSSECRequestT& request) const { return SubmitCallable(&Route53Client::DisableHostedZoneDNSSEC, request); } /** * An Async wrapper for DisableHostedZoneDNSSEC that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableHostedZoneDNSSECAsync(const DisableHostedZoneDNSSECRequestT& request, const DisableHostedZoneDNSSECResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DisableHostedZoneDNSSEC, request, handler, context); } /** *

Disassociates an Amazon Virtual Private Cloud (Amazon VPC) from an Amazon * Route 53 private hosted zone. Note the following:

  • You can't * disassociate the last Amazon VPC from a private hosted zone.

  • *

    You can't convert a private hosted zone into a public hosted zone.

    • *

  • You can submit a DisassociateVPCFromHostedZone request * using either the account that created the hosted zone or the account that * created the Amazon VPC.

  • Some services, such as Cloud Map and * Amazon Elastic File System (Amazon EFS) automatically create hosted zones and * associate VPCs with the hosted zones. A service can create a hosted zone using * your account or using its own account. You can disassociate a VPC from a hosted * zone only if the service created the hosted zone using your account.

    When * you run DisassociateVPCFromHostedZone, * if the hosted zone has a value for OwningAccount, you can use * DisassociateVPCFromHostedZone. If the hosted zone has a value for * OwningService, you can't use * DisassociateVPCFromHostedZone.

When * revoking access, the hosted zone and the Amazon VPC must belong to the same * partition. A partition is a group of Amazon Web Services Regions. Each Amazon * Web Services account is scoped to one partition.

The following are the * supported partitions:

  • aws - Amazon Web Services * Regions

  • aws-cn - China Regions

  • *

    aws-us-gov - Amazon Web Services GovCloud (US) Region

    • *

For more information, see Access * Management in the Amazon Web Services General Reference.

*

See Also:

AWS * API Reference

*/ virtual Model::DisassociateVPCFromHostedZoneOutcome DisassociateVPCFromHostedZone(const Model::DisassociateVPCFromHostedZoneRequest& request) const; /** * A Callable wrapper for DisassociateVPCFromHostedZone that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateVPCFromHostedZoneOutcomeCallable DisassociateVPCFromHostedZoneCallable(const DisassociateVPCFromHostedZoneRequestT& request) const { return SubmitCallable(&Route53Client::DisassociateVPCFromHostedZone, request); } /** * An Async wrapper for DisassociateVPCFromHostedZone that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateVPCFromHostedZoneAsync(const DisassociateVPCFromHostedZoneRequestT& request, const DisassociateVPCFromHostedZoneResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::DisassociateVPCFromHostedZone, request, handler, context); } /** *

Enables DNSSEC signing in a specific hosted zone.

See Also:

* AWS * API Reference

*/ virtual Model::EnableHostedZoneDNSSECOutcome EnableHostedZoneDNSSEC(const Model::EnableHostedZoneDNSSECRequest& request) const; /** * A Callable wrapper for EnableHostedZoneDNSSEC that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableHostedZoneDNSSECOutcomeCallable EnableHostedZoneDNSSECCallable(const EnableHostedZoneDNSSECRequestT& request) const { return SubmitCallable(&Route53Client::EnableHostedZoneDNSSEC, request); } /** * An Async wrapper for EnableHostedZoneDNSSEC that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableHostedZoneDNSSECAsync(const EnableHostedZoneDNSSECRequestT& request, const EnableHostedZoneDNSSECResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::EnableHostedZoneDNSSEC, request, handler, context); } /** *

Gets the specified limit for the current account, for example, the maximum * number of health checks that you can create using the account.

For the * default limit, see Limits * in the Amazon Route 53 Developer Guide. To request a higher limit, open * a case.

You can also view account limits in Amazon Web * Services Trusted Advisor. Sign in to the Amazon Web Services Management Console * and open the Trusted Advisor console at https://console.aws.amazon.com/trustedadvisor/. * Then choose Service limits in the navigation pane.

See * Also:

AWS * API Reference

*/ virtual Model::GetAccountLimitOutcome GetAccountLimit(const Model::GetAccountLimitRequest& request) const; /** * A Callable wrapper for GetAccountLimit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountLimitOutcomeCallable GetAccountLimitCallable(const GetAccountLimitRequestT& request) const { return SubmitCallable(&Route53Client::GetAccountLimit, request); } /** * An Async wrapper for GetAccountLimit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountLimitAsync(const GetAccountLimitRequestT& request, const GetAccountLimitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetAccountLimit, request, handler, context); } /** *

Returns the current status of a change batch request. The status is one of * the following values:

  • PENDING indicates that the * changes in this request have not propagated to all Amazon Route 53 DNS servers * managing the hosted zone. This is the initial status of all change batch * requests.

  • INSYNC indicates that the changes have * propagated to all Route 53 DNS servers managing the hosted zone.

    • *

See Also:

AWS * API Reference

*/ virtual Model::GetChangeOutcome GetChange(const Model::GetChangeRequest& request) const; /** * A Callable wrapper for GetChange that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChangeOutcomeCallable GetChangeCallable(const GetChangeRequestT& request) const { return SubmitCallable(&Route53Client::GetChange, request); } /** * An Async wrapper for GetChange that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChangeAsync(const GetChangeRequestT& request, const GetChangeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetChange, request, handler, context); } /** *

Route 53 does not perform authorization for this API because it retrieves * information that is already available to the public.

* GetCheckerIpRanges still works, but we recommend that you download * ip-ranges.json, which includes IP address ranges for all Amazon Web Services * services. For more information, see IP * Address Ranges of Amazon Route 53 Servers in the Amazon Route 53 * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetCheckerIpRangesOutcome GetCheckerIpRanges(const Model::GetCheckerIpRangesRequest& request) const; /** * A Callable wrapper for GetCheckerIpRanges that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCheckerIpRangesOutcomeCallable GetCheckerIpRangesCallable(const GetCheckerIpRangesRequestT& request) const { return SubmitCallable(&Route53Client::GetCheckerIpRanges, request); } /** * An Async wrapper for GetCheckerIpRanges that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCheckerIpRangesAsync(const GetCheckerIpRangesRequestT& request, const GetCheckerIpRangesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetCheckerIpRanges, request, handler, context); } /** *

Returns information about DNSSEC for a specific hosted zone, including the * key-signing keys (KSKs) in the hosted zone.

See Also:

AWS * API Reference

*/ virtual Model::GetDNSSECOutcome GetDNSSEC(const Model::GetDNSSECRequest& request) const; /** * A Callable wrapper for GetDNSSEC that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDNSSECOutcomeCallable GetDNSSECCallable(const GetDNSSECRequestT& request) const { return SubmitCallable(&Route53Client::GetDNSSEC, request); } /** * An Async wrapper for GetDNSSEC that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDNSSECAsync(const GetDNSSECRequestT& request, const GetDNSSECResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetDNSSEC, request, handler, context); } /** *

Gets information about whether a specified geographic location is supported * for Amazon Route 53 geolocation resource record sets.

Route 53 does not * perform authorization for this API because it retrieves information that is * already available to the public.

Use the following syntax to determine * whether a continent is supported for geolocation:

GET * /2013-04-01/geolocation?continentcode=two-letter abbreviation for a * continent

Use the following syntax to determine whether a * country is supported for geolocation:

GET * /2013-04-01/geolocation?countrycode=two-character country code *

Use the following syntax to determine whether a subdivision of a country * is supported for geolocation:

GET * /2013-04-01/geolocation?countrycode=two-character country * code&subdivisioncode=subdivision code

See * Also:

AWS * API Reference

*/ virtual Model::GetGeoLocationOutcome GetGeoLocation(const Model::GetGeoLocationRequest& request) const; /** * A Callable wrapper for GetGeoLocation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetGeoLocationOutcomeCallable GetGeoLocationCallable(const GetGeoLocationRequestT& request) const { return SubmitCallable(&Route53Client::GetGeoLocation, request); } /** * An Async wrapper for GetGeoLocation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetGeoLocationAsync(const GetGeoLocationRequestT& request, const GetGeoLocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetGeoLocation, request, handler, context); } /** *

Gets information about a specified health check.

See Also:

* AWS * API Reference

*/ virtual Model::GetHealthCheckOutcome GetHealthCheck(const Model::GetHealthCheckRequest& request) const; /** * A Callable wrapper for GetHealthCheck that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHealthCheckOutcomeCallable GetHealthCheckCallable(const GetHealthCheckRequestT& request) const { return SubmitCallable(&Route53Client::GetHealthCheck, request); } /** * An Async wrapper for GetHealthCheck that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHealthCheckAsync(const GetHealthCheckRequestT& request, const GetHealthCheckResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHealthCheck, request, handler, context); } /** *

Retrieves the number of health checks that are associated with the current * Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::GetHealthCheckCountOutcome GetHealthCheckCount(const Model::GetHealthCheckCountRequest& request) const; /** * A Callable wrapper for GetHealthCheckCount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHealthCheckCountOutcomeCallable GetHealthCheckCountCallable(const GetHealthCheckCountRequestT& request) const { return SubmitCallable(&Route53Client::GetHealthCheckCount, request); } /** * An Async wrapper for GetHealthCheckCount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHealthCheckCountAsync(const GetHealthCheckCountRequestT& request, const GetHealthCheckCountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHealthCheckCount, request, handler, context); } /** *

Gets the reason that a specified health check failed most * recently.

See Also:

AWS * API Reference

*/ virtual Model::GetHealthCheckLastFailureReasonOutcome GetHealthCheckLastFailureReason(const Model::GetHealthCheckLastFailureReasonRequest& request) const; /** * A Callable wrapper for GetHealthCheckLastFailureReason that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHealthCheckLastFailureReasonOutcomeCallable GetHealthCheckLastFailureReasonCallable(const GetHealthCheckLastFailureReasonRequestT& request) const { return SubmitCallable(&Route53Client::GetHealthCheckLastFailureReason, request); } /** * An Async wrapper for GetHealthCheckLastFailureReason that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHealthCheckLastFailureReasonAsync(const GetHealthCheckLastFailureReasonRequestT& request, const GetHealthCheckLastFailureReasonResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHealthCheckLastFailureReason, request, handler, context); } /** *

Gets status of a specified health check.

This API is * intended for use during development to diagnose behavior. It doesn’t support * production use-cases with high query rates that require immediate and actionable * responses.

See Also:

AWS * API Reference

*/ virtual Model::GetHealthCheckStatusOutcome GetHealthCheckStatus(const Model::GetHealthCheckStatusRequest& request) const; /** * A Callable wrapper for GetHealthCheckStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHealthCheckStatusOutcomeCallable GetHealthCheckStatusCallable(const GetHealthCheckStatusRequestT& request) const { return SubmitCallable(&Route53Client::GetHealthCheckStatus, request); } /** * An Async wrapper for GetHealthCheckStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHealthCheckStatusAsync(const GetHealthCheckStatusRequestT& request, const GetHealthCheckStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHealthCheckStatus, request, handler, context); } /** *

Gets information about a specified hosted zone including the four name * servers assigned to the hosted zone.

See Also:

AWS * API Reference

*/ virtual Model::GetHostedZoneOutcome GetHostedZone(const Model::GetHostedZoneRequest& request) const; /** * A Callable wrapper for GetHostedZone that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHostedZoneOutcomeCallable GetHostedZoneCallable(const GetHostedZoneRequestT& request) const { return SubmitCallable(&Route53Client::GetHostedZone, request); } /** * An Async wrapper for GetHostedZone that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHostedZoneAsync(const GetHostedZoneRequestT& request, const GetHostedZoneResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHostedZone, request, handler, context); } /** *

Retrieves the number of hosted zones that are associated with the current * Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::GetHostedZoneCountOutcome GetHostedZoneCount(const Model::GetHostedZoneCountRequest& request) const; /** * A Callable wrapper for GetHostedZoneCount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHostedZoneCountOutcomeCallable GetHostedZoneCountCallable(const GetHostedZoneCountRequestT& request) const { return SubmitCallable(&Route53Client::GetHostedZoneCount, request); } /** * An Async wrapper for GetHostedZoneCount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHostedZoneCountAsync(const GetHostedZoneCountRequestT& request, const GetHostedZoneCountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHostedZoneCount, request, handler, context); } /** *

Gets the specified limit for a specified hosted zone, for example, the * maximum number of records that you can create in the hosted zone.

For * the default limit, see Limits * in the Amazon Route 53 Developer Guide. To request a higher limit, open * a case.

See Also:

AWS * API Reference

*/ virtual Model::GetHostedZoneLimitOutcome GetHostedZoneLimit(const Model::GetHostedZoneLimitRequest& request) const; /** * A Callable wrapper for GetHostedZoneLimit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHostedZoneLimitOutcomeCallable GetHostedZoneLimitCallable(const GetHostedZoneLimitRequestT& request) const { return SubmitCallable(&Route53Client::GetHostedZoneLimit, request); } /** * An Async wrapper for GetHostedZoneLimit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHostedZoneLimitAsync(const GetHostedZoneLimitRequestT& request, const GetHostedZoneLimitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetHostedZoneLimit, request, handler, context); } /** *

Gets information about a specified configuration for DNS query logging.

*

For more information about DNS query logs, see CreateQueryLoggingConfig * and Logging * DNS Queries.

See Also:

AWS * API Reference

*/ virtual Model::GetQueryLoggingConfigOutcome GetQueryLoggingConfig(const Model::GetQueryLoggingConfigRequest& request) const; /** * A Callable wrapper for GetQueryLoggingConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueryLoggingConfigOutcomeCallable GetQueryLoggingConfigCallable(const GetQueryLoggingConfigRequestT& request) const { return SubmitCallable(&Route53Client::GetQueryLoggingConfig, request); } /** * An Async wrapper for GetQueryLoggingConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueryLoggingConfigAsync(const GetQueryLoggingConfigRequestT& request, const GetQueryLoggingConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetQueryLoggingConfig, request, handler, context); } /** *

Retrieves information about a specified reusable delegation set, including * the four name servers that are assigned to the delegation set.

See * Also:

AWS * API Reference

*/ virtual Model::GetReusableDelegationSetOutcome GetReusableDelegationSet(const Model::GetReusableDelegationSetRequest& request) const; /** * A Callable wrapper for GetReusableDelegationSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetReusableDelegationSetOutcomeCallable GetReusableDelegationSetCallable(const GetReusableDelegationSetRequestT& request) const { return SubmitCallable(&Route53Client::GetReusableDelegationSet, request); } /** * An Async wrapper for GetReusableDelegationSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetReusableDelegationSetAsync(const GetReusableDelegationSetRequestT& request, const GetReusableDelegationSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetReusableDelegationSet, request, handler, context); } /** *

Gets the maximum number of hosted zones that you can associate with the * specified reusable delegation set.

For the default limit, see Limits * in the Amazon Route 53 Developer Guide. To request a higher limit, open * a case.

See Also:

AWS * API Reference

*/ virtual Model::GetReusableDelegationSetLimitOutcome GetReusableDelegationSetLimit(const Model::GetReusableDelegationSetLimitRequest& request) const; /** * A Callable wrapper for GetReusableDelegationSetLimit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetReusableDelegationSetLimitOutcomeCallable GetReusableDelegationSetLimitCallable(const GetReusableDelegationSetLimitRequestT& request) const { return SubmitCallable(&Route53Client::GetReusableDelegationSetLimit, request); } /** * An Async wrapper for GetReusableDelegationSetLimit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetReusableDelegationSetLimitAsync(const GetReusableDelegationSetLimitRequestT& request, const GetReusableDelegationSetLimitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetReusableDelegationSetLimit, request, handler, context); } /** *

Gets information about a specific traffic policy version.

For * information about how of deleting a traffic policy affects the response from * GetTrafficPolicy, see DeleteTrafficPolicy. *

See Also:

AWS * API Reference

*/ virtual Model::GetTrafficPolicyOutcome GetTrafficPolicy(const Model::GetTrafficPolicyRequest& request) const; /** * A Callable wrapper for GetTrafficPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTrafficPolicyOutcomeCallable GetTrafficPolicyCallable(const GetTrafficPolicyRequestT& request) const { return SubmitCallable(&Route53Client::GetTrafficPolicy, request); } /** * An Async wrapper for GetTrafficPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTrafficPolicyAsync(const GetTrafficPolicyRequestT& request, const GetTrafficPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetTrafficPolicy, request, handler, context); } /** *

Gets information about a specified traffic policy instance.

* Use GetTrafficPolicyInstance with the id of new * traffic policy instance to confirm that the * CreateTrafficPolicyInstance or an * UpdateTrafficPolicyInstance request completed successfully. For * more information, see the State response element.

*

In the Route 53 console, traffic policy instances are known as policy * records.

See Also:

AWS * API Reference

*/ virtual Model::GetTrafficPolicyInstanceOutcome GetTrafficPolicyInstance(const Model::GetTrafficPolicyInstanceRequest& request) const; /** * A Callable wrapper for GetTrafficPolicyInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTrafficPolicyInstanceOutcomeCallable GetTrafficPolicyInstanceCallable(const GetTrafficPolicyInstanceRequestT& request) const { return SubmitCallable(&Route53Client::GetTrafficPolicyInstance, request); } /** * An Async wrapper for GetTrafficPolicyInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTrafficPolicyInstanceAsync(const GetTrafficPolicyInstanceRequestT& request, const GetTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetTrafficPolicyInstance, request, handler, context); } /** *

Gets the number of traffic policy instances that are associated with the * current Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::GetTrafficPolicyInstanceCountOutcome GetTrafficPolicyInstanceCount(const Model::GetTrafficPolicyInstanceCountRequest& request) const; /** * A Callable wrapper for GetTrafficPolicyInstanceCount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTrafficPolicyInstanceCountOutcomeCallable GetTrafficPolicyInstanceCountCallable(const GetTrafficPolicyInstanceCountRequestT& request) const { return SubmitCallable(&Route53Client::GetTrafficPolicyInstanceCount, request); } /** * An Async wrapper for GetTrafficPolicyInstanceCount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTrafficPolicyInstanceCountAsync(const GetTrafficPolicyInstanceCountRequestT& request, const GetTrafficPolicyInstanceCountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::GetTrafficPolicyInstanceCount, request, handler, context); } /** *

Returns a paginated list of location objects and their CIDR * blocks.

See Also:

AWS * API Reference

*/ virtual Model::ListCidrBlocksOutcome ListCidrBlocks(const Model::ListCidrBlocksRequest& request) const; /** * A Callable wrapper for ListCidrBlocks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCidrBlocksOutcomeCallable ListCidrBlocksCallable(const ListCidrBlocksRequestT& request) const { return SubmitCallable(&Route53Client::ListCidrBlocks, request); } /** * An Async wrapper for ListCidrBlocks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCidrBlocksAsync(const ListCidrBlocksRequestT& request, const ListCidrBlocksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListCidrBlocks, request, handler, context); } /** *

Returns a paginated list of CIDR collections in the Amazon Web Services * account (metadata only).

See Also:

AWS * API Reference

*/ virtual Model::ListCidrCollectionsOutcome ListCidrCollections(const Model::ListCidrCollectionsRequest& request) const; /** * A Callable wrapper for ListCidrCollections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCidrCollectionsOutcomeCallable ListCidrCollectionsCallable(const ListCidrCollectionsRequestT& request) const { return SubmitCallable(&Route53Client::ListCidrCollections, request); } /** * An Async wrapper for ListCidrCollections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCidrCollectionsAsync(const ListCidrCollectionsRequestT& request, const ListCidrCollectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListCidrCollections, request, handler, context); } /** *

Returns a paginated list of CIDR locations for the given collection (metadata * only, does not include CIDR blocks).

See Also:

AWS * API Reference

*/ virtual Model::ListCidrLocationsOutcome ListCidrLocations(const Model::ListCidrLocationsRequest& request) const; /** * A Callable wrapper for ListCidrLocations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCidrLocationsOutcomeCallable ListCidrLocationsCallable(const ListCidrLocationsRequestT& request) const { return SubmitCallable(&Route53Client::ListCidrLocations, request); } /** * An Async wrapper for ListCidrLocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCidrLocationsAsync(const ListCidrLocationsRequestT& request, const ListCidrLocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListCidrLocations, request, handler, context); } /** *

Retrieves a list of supported geographic locations.

Countries are * listed first, and continents are listed last. If Amazon Route 53 supports * subdivisions for a country (for example, states or provinces), the subdivisions * for that country are listed in alphabetical order immediately after the * corresponding country.

Route 53 does not perform authorization for this * API because it retrieves information that is already available to the * public.

For a list of supported geolocation codes, see the GeoLocation * data type.

See Also:

AWS * API Reference

*/ virtual Model::ListGeoLocationsOutcome ListGeoLocations(const Model::ListGeoLocationsRequest& request) const; /** * A Callable wrapper for ListGeoLocations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGeoLocationsOutcomeCallable ListGeoLocationsCallable(const ListGeoLocationsRequestT& request) const { return SubmitCallable(&Route53Client::ListGeoLocations, request); } /** * An Async wrapper for ListGeoLocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGeoLocationsAsync(const ListGeoLocationsRequestT& request, const ListGeoLocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListGeoLocations, request, handler, context); } /** *

Retrieve a list of the health checks that are associated with the current * Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListHealthChecksOutcome ListHealthChecks(const Model::ListHealthChecksRequest& request) const; /** * A Callable wrapper for ListHealthChecks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHealthChecksOutcomeCallable ListHealthChecksCallable(const ListHealthChecksRequestT& request) const { return SubmitCallable(&Route53Client::ListHealthChecks, request); } /** * An Async wrapper for ListHealthChecks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHealthChecksAsync(const ListHealthChecksRequestT& request, const ListHealthChecksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListHealthChecks, request, handler, context); } /** *

Retrieves a list of the public and private hosted zones that are associated * with the current Amazon Web Services account. The response includes a * HostedZones child element for each hosted zone.

Amazon Route * 53 returns a maximum of 100 items in each response. If you have a lot of hosted * zones, you can use the maxitems parameter to list them in groups of * up to 100.

See Also:

AWS * API Reference

*/ virtual Model::ListHostedZonesOutcome ListHostedZones(const Model::ListHostedZonesRequest& request) const; /** * A Callable wrapper for ListHostedZones that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHostedZonesOutcomeCallable ListHostedZonesCallable(const ListHostedZonesRequestT& request) const { return SubmitCallable(&Route53Client::ListHostedZones, request); } /** * An Async wrapper for ListHostedZones that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHostedZonesAsync(const ListHostedZonesRequestT& request, const ListHostedZonesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListHostedZones, request, handler, context); } /** *

Retrieves a list of your hosted zones in lexicographic order. The response * includes a HostedZones child element for each hosted zone created * by the current Amazon Web Services account.

* ListHostedZonesByName sorts hosted zones by name with the labels * reversed. For example:

com.example.www.

Note the * trailing dot, which can change the sort order in some circumstances.

If * the domain name includes escape characters or Punycode, * ListHostedZonesByName alphabetizes the domain name using the * escaped or Punycoded value, which is the format that Amazon Route 53 saves in * its database. For example, to create a hosted zone for exämple.com, you specify * ex\344mple.com for the domain name. ListHostedZonesByName * alphabetizes it as:

com.ex\344mple.

The labels are * reversed and alphabetized using the escaped value. For more information about * valid domain name formats, including internationalized domain names, see DNS * Domain Name Format in the Amazon Route 53 Developer Guide.

*

Route 53 returns up to 100 items in each response. If you have a lot of * hosted zones, use the MaxItems parameter to list them in groups of * up to 100. The response includes values that help navigate from one group of * MaxItems hosted zones to the next:

  • The * DNSName and HostedZoneId elements in the response * contain the values, if any, specified for the dnsname and * hostedzoneid parameters in the request that produced the current * response.

  • The MaxItems element in the response * contains the value, if any, that you specified for the maxitems * parameter in the request that produced the current response.

  • *

    If the value of IsTruncated in the response is true, there are * more hosted zones associated with the current Amazon Web Services account.

    *

    If IsTruncated is false, this response includes the last hosted * zone that is associated with the current account. The NextDNSName * element and NextHostedZoneId elements are omitted from the * response.

  • The NextDNSName and * NextHostedZoneId elements in the response contain the domain name * and the hosted zone ID of the next hosted zone that is associated with the * current Amazon Web Services account. If you want to list more hosted zones, make * another call to ListHostedZonesByName, and specify the value of * NextDNSName and NextHostedZoneId in the * dnsname and hostedzoneid parameters, respectively.

    *

See Also:

AWS * API Reference

*/ virtual Model::ListHostedZonesByNameOutcome ListHostedZonesByName(const Model::ListHostedZonesByNameRequest& request) const; /** * A Callable wrapper for ListHostedZonesByName that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHostedZonesByNameOutcomeCallable ListHostedZonesByNameCallable(const ListHostedZonesByNameRequestT& request) const { return SubmitCallable(&Route53Client::ListHostedZonesByName, request); } /** * An Async wrapper for ListHostedZonesByName that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHostedZonesByNameAsync(const ListHostedZonesByNameRequestT& request, const ListHostedZonesByNameResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListHostedZonesByName, request, handler, context); } /** *

Lists all the private hosted zones that a specified VPC is associated with, * regardless of which Amazon Web Services account or Amazon Web Services service * owns the hosted zones. The HostedZoneOwner structure in the * response contains one of the following values:

  • An * OwningAccount element, which contains the account number of either * the current Amazon Web Services account or another Amazon Web Services account. * Some services, such as Cloud Map, create hosted zones using the current account. *

  • An OwningService element, which identifies the * Amazon Web Services service that created and owns the hosted zone. For example, * if a hosted zone was created by Amazon Elastic File System (Amazon EFS), the * value of Owner is efs.amazonaws.com.

*

When listing private hosted zones, the hosted zone and the Amazon VPC * must belong to the same partition where the hosted zones were created. A * partition is a group of Amazon Web Services Regions. Each Amazon Web Services * account is scoped to one partition.

The following are the supported * partitions:

  • aws - Amazon Web Services Regions

    *

  • aws-cn - China Regions

  • * aws-us-gov - Amazon Web Services GovCloud (US) Region

    • *

For more information, see Access * Management in the Amazon Web Services General Reference.

*

See Also:

AWS * API Reference

*/ virtual Model::ListHostedZonesByVPCOutcome ListHostedZonesByVPC(const Model::ListHostedZonesByVPCRequest& request) const; /** * A Callable wrapper for ListHostedZonesByVPC that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHostedZonesByVPCOutcomeCallable ListHostedZonesByVPCCallable(const ListHostedZonesByVPCRequestT& request) const { return SubmitCallable(&Route53Client::ListHostedZonesByVPC, request); } /** * An Async wrapper for ListHostedZonesByVPC that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHostedZonesByVPCAsync(const ListHostedZonesByVPCRequestT& request, const ListHostedZonesByVPCResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListHostedZonesByVPC, request, handler, context); } /** *

Lists the configurations for DNS query logging that are associated with the * current Amazon Web Services account or the configuration that is associated with * a specified hosted zone.

For more information about DNS query logs, see * CreateQueryLoggingConfig. * Additional information, including the format of DNS query logs, appears in Logging * DNS Queries in the Amazon Route 53 Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ListQueryLoggingConfigsOutcome ListQueryLoggingConfigs(const Model::ListQueryLoggingConfigsRequest& request) const; /** * A Callable wrapper for ListQueryLoggingConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListQueryLoggingConfigsOutcomeCallable ListQueryLoggingConfigsCallable(const ListQueryLoggingConfigsRequestT& request) const { return SubmitCallable(&Route53Client::ListQueryLoggingConfigs, request); } /** * An Async wrapper for ListQueryLoggingConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListQueryLoggingConfigsAsync(const ListQueryLoggingConfigsRequestT& request, const ListQueryLoggingConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListQueryLoggingConfigs, request, handler, context); } /** *

Lists the resource record sets in a specified hosted zone.

* ListResourceRecordSets returns up to 300 resource record sets at a * time in ASCII order, beginning at a position specified by the name * and type elements.

Sort order

* ListResourceRecordSets sorts results first by DNS name with the * labels reversed, for example:

com.example.www.

Note * the trailing dot, which can change the sort order when the record name contains * characters that appear before . (decimal 46) in the ASCII table. * These characters include the following: ! " # $ % & ' ( ) * + , * -

When multiple records have the same DNS name, * ListResourceRecordSets sorts results by the record type.

* Specifying where to start listing records

You can use the name * and type elements to specify the resource record set that the list begins * with:

If you do not specify Name or Type

The results * begin with the first resource record set that the hosted zone contains.

*
If you specify Name but not Type

The results begin with * the first resource record set in the list whose name is greater than or equal to * Name.

If you specify Type but not Name
*

Amazon Route 53 returns the InvalidInput error.

If * you specify both Name and Type

The results begin with the first * resource record set in the list whose name is greater than or equal to * Name, and whose type is greater than or equal to * Type.

Resource record sets that are * PENDING

This action returns the most current version of the records. * This includes records that are PENDING, and that are not yet * available on all Route 53 DNS servers.

Changing resource record * sets

To ensure that you get an accurate listing of the resource * record sets for a hosted zone at a point in time, do not submit a * ChangeResourceRecordSets request while you're paging through the * results of a ListResourceRecordSets request. If you do, some pages * may display results without the latest changes while other pages display results * with the latest changes.

Displaying the next page of results

*

If a ListResourceRecordSets command returns more than one page * of results, the value of IsTruncated is true. To * display the next page of results, get the values of NextRecordName, * NextRecordType, and NextRecordIdentifier (if any) from * the response. Then submit another ListResourceRecordSets request, * and specify those values for StartRecordName, * StartRecordType, and * StartRecordIdentifier.

See Also:

AWS * API Reference

*/ virtual Model::ListResourceRecordSetsOutcome ListResourceRecordSets(const Model::ListResourceRecordSetsRequest& request) const; /** * A Callable wrapper for ListResourceRecordSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourceRecordSetsOutcomeCallable ListResourceRecordSetsCallable(const ListResourceRecordSetsRequestT& request) const { return SubmitCallable(&Route53Client::ListResourceRecordSets, request); } /** * An Async wrapper for ListResourceRecordSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourceRecordSetsAsync(const ListResourceRecordSetsRequestT& request, const ListResourceRecordSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListResourceRecordSets, request, handler, context); } /** *

Retrieves a list of the reusable delegation sets that are associated with the * current Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListReusableDelegationSetsOutcome ListReusableDelegationSets(const Model::ListReusableDelegationSetsRequest& request) const; /** * A Callable wrapper for ListReusableDelegationSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListReusableDelegationSetsOutcomeCallable ListReusableDelegationSetsCallable(const ListReusableDelegationSetsRequestT& request) const { return SubmitCallable(&Route53Client::ListReusableDelegationSets, request); } /** * An Async wrapper for ListReusableDelegationSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListReusableDelegationSetsAsync(const ListReusableDelegationSetsRequestT& request, const ListReusableDelegationSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListReusableDelegationSets, request, handler, context); } /** *

Lists tags for one health check or hosted zone.

For information about * using tags for cost allocation, see Using * Cost Allocation Tags in the Billing and Cost Management User * Guide.

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(&Route53Client::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(&Route53Client::ListTagsForResource, request, handler, context); } /** *

Lists tags for up to 10 health checks or hosted zones.

For information * about using tags for cost allocation, see Using * Cost Allocation Tags in the Billing and Cost Management User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourcesOutcome ListTagsForResources(const Model::ListTagsForResourcesRequest& request) const; /** * A Callable wrapper for ListTagsForResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourcesOutcomeCallable ListTagsForResourcesCallable(const ListTagsForResourcesRequestT& request) const { return SubmitCallable(&Route53Client::ListTagsForResources, request); } /** * An Async wrapper for ListTagsForResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourcesAsync(const ListTagsForResourcesRequestT& request, const ListTagsForResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListTagsForResources, request, handler, context); } /** *

Gets information about the latest version for every traffic policy that is * associated with the current Amazon Web Services account. Policies are listed in * the order that they were created in.

For information about how of * deleting a traffic policy affects the response from * ListTrafficPolicies, see DeleteTrafficPolicy. *

See Also:

AWS * API Reference

*/ virtual Model::ListTrafficPoliciesOutcome ListTrafficPolicies(const Model::ListTrafficPoliciesRequest& request) const; /** * A Callable wrapper for ListTrafficPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrafficPoliciesOutcomeCallable ListTrafficPoliciesCallable(const ListTrafficPoliciesRequestT& request) const { return SubmitCallable(&Route53Client::ListTrafficPolicies, request); } /** * An Async wrapper for ListTrafficPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrafficPoliciesAsync(const ListTrafficPoliciesRequestT& request, const ListTrafficPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListTrafficPolicies, request, handler, context); } /** *

Gets information about the traffic policy instances that you created by using * the current Amazon Web Services account.

After you submit an * UpdateTrafficPolicyInstance request, there's a brief delay while * Amazon Route 53 creates the resource record sets that are specified in the * traffic policy definition. For more information, see the State * response element.

Route 53 returns a maximum of 100 items in each * response. If you have a lot of traffic policy instances, you can use the * MaxItems parameter to list them in groups of up to * 100.

See Also:

AWS * API Reference

*/ virtual Model::ListTrafficPolicyInstancesOutcome ListTrafficPolicyInstances(const Model::ListTrafficPolicyInstancesRequest& request) const; /** * A Callable wrapper for ListTrafficPolicyInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrafficPolicyInstancesOutcomeCallable ListTrafficPolicyInstancesCallable(const ListTrafficPolicyInstancesRequestT& request) const { return SubmitCallable(&Route53Client::ListTrafficPolicyInstances, request); } /** * An Async wrapper for ListTrafficPolicyInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrafficPolicyInstancesAsync(const ListTrafficPolicyInstancesRequestT& request, const ListTrafficPolicyInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListTrafficPolicyInstances, request, handler, context); } /** *

Gets information about the traffic policy instances that you created in a * specified hosted zone.

After you submit a * CreateTrafficPolicyInstance or an * UpdateTrafficPolicyInstance request, there's a brief delay while * Amazon Route 53 creates the resource record sets that are specified in the * traffic policy definition. For more information, see the State * response element.

Route 53 returns a maximum of 100 items in each * response. If you have a lot of traffic policy instances, you can use the * MaxItems parameter to list them in groups of up to * 100.

See Also:

AWS * API Reference

*/ virtual Model::ListTrafficPolicyInstancesByHostedZoneOutcome ListTrafficPolicyInstancesByHostedZone(const Model::ListTrafficPolicyInstancesByHostedZoneRequest& request) const; /** * A Callable wrapper for ListTrafficPolicyInstancesByHostedZone that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrafficPolicyInstancesByHostedZoneOutcomeCallable ListTrafficPolicyInstancesByHostedZoneCallable(const ListTrafficPolicyInstancesByHostedZoneRequestT& request) const { return SubmitCallable(&Route53Client::ListTrafficPolicyInstancesByHostedZone, request); } /** * An Async wrapper for ListTrafficPolicyInstancesByHostedZone that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrafficPolicyInstancesByHostedZoneAsync(const ListTrafficPolicyInstancesByHostedZoneRequestT& request, const ListTrafficPolicyInstancesByHostedZoneResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListTrafficPolicyInstancesByHostedZone, request, handler, context); } /** *

Gets information about the traffic policy instances that you created by using * a specify traffic policy version.

After you submit a * CreateTrafficPolicyInstance or an * UpdateTrafficPolicyInstance request, there's a brief delay while * Amazon Route 53 creates the resource record sets that are specified in the * traffic policy definition. For more information, see the State * response element.

Route 53 returns a maximum of 100 items in each * response. If you have a lot of traffic policy instances, you can use the * MaxItems parameter to list them in groups of up to * 100.

See Also:

AWS * API Reference

*/ virtual Model::ListTrafficPolicyInstancesByPolicyOutcome ListTrafficPolicyInstancesByPolicy(const Model::ListTrafficPolicyInstancesByPolicyRequest& request) const; /** * A Callable wrapper for ListTrafficPolicyInstancesByPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrafficPolicyInstancesByPolicyOutcomeCallable ListTrafficPolicyInstancesByPolicyCallable(const ListTrafficPolicyInstancesByPolicyRequestT& request) const { return SubmitCallable(&Route53Client::ListTrafficPolicyInstancesByPolicy, request); } /** * An Async wrapper for ListTrafficPolicyInstancesByPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrafficPolicyInstancesByPolicyAsync(const ListTrafficPolicyInstancesByPolicyRequestT& request, const ListTrafficPolicyInstancesByPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListTrafficPolicyInstancesByPolicy, request, handler, context); } /** *

Gets information about all of the versions for a specified traffic * policy.

Traffic policy versions are listed in numerical order by * VersionNumber.

See Also:

AWS * API Reference

*/ virtual Model::ListTrafficPolicyVersionsOutcome ListTrafficPolicyVersions(const Model::ListTrafficPolicyVersionsRequest& request) const; /** * A Callable wrapper for ListTrafficPolicyVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrafficPolicyVersionsOutcomeCallable ListTrafficPolicyVersionsCallable(const ListTrafficPolicyVersionsRequestT& request) const { return SubmitCallable(&Route53Client::ListTrafficPolicyVersions, request); } /** * An Async wrapper for ListTrafficPolicyVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrafficPolicyVersionsAsync(const ListTrafficPolicyVersionsRequestT& request, const ListTrafficPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListTrafficPolicyVersions, request, handler, context); } /** *

Gets a list of the VPCs that were created by other accounts and that can be * associated with a specified hosted zone because you've submitted one or more * CreateVPCAssociationAuthorization requests.

The response * includes a VPCs element with a VPC child element for * each VPC that can be associated with the hosted zone.

See Also:

* AWS * API Reference

*/ virtual Model::ListVPCAssociationAuthorizationsOutcome ListVPCAssociationAuthorizations(const Model::ListVPCAssociationAuthorizationsRequest& request) const; /** * A Callable wrapper for ListVPCAssociationAuthorizations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVPCAssociationAuthorizationsOutcomeCallable ListVPCAssociationAuthorizationsCallable(const ListVPCAssociationAuthorizationsRequestT& request) const { return SubmitCallable(&Route53Client::ListVPCAssociationAuthorizations, request); } /** * An Async wrapper for ListVPCAssociationAuthorizations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVPCAssociationAuthorizationsAsync(const ListVPCAssociationAuthorizationsRequestT& request, const ListVPCAssociationAuthorizationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::ListVPCAssociationAuthorizations, request, handler, context); } /** *

Gets the value that Amazon Route 53 returns in response to a DNS request for * a specified record name and type. You can optionally specify the IP address of a * DNS resolver, an EDNS0 client subnet IP address, and a subnet mask.

This * call only supports querying public hosted zones.

The * TestDnsAnswer returns information similar to what you would expect * from the answer section of the dig command. Therefore, if you query * for the name servers of a subdomain that point to the parent name servers, those * will not be returned.

See Also:

AWS * API Reference

*/ virtual Model::TestDNSAnswerOutcome TestDNSAnswer(const Model::TestDNSAnswerRequest& request) const; /** * A Callable wrapper for TestDNSAnswer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestDNSAnswerOutcomeCallable TestDNSAnswerCallable(const TestDNSAnswerRequestT& request) const { return SubmitCallable(&Route53Client::TestDNSAnswer, request); } /** * An Async wrapper for TestDNSAnswer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestDNSAnswerAsync(const TestDNSAnswerRequestT& request, const TestDNSAnswerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::TestDNSAnswer, request, handler, context); } /** *

Updates an existing health check. Note that some values can't be updated. *

For more information about updating health checks, see Creating, * Updating, and Deleting Health Checks in the Amazon Route 53 Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateHealthCheckOutcome UpdateHealthCheck(const Model::UpdateHealthCheckRequest& request) const; /** * A Callable wrapper for UpdateHealthCheck that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateHealthCheckOutcomeCallable UpdateHealthCheckCallable(const UpdateHealthCheckRequestT& request) const { return SubmitCallable(&Route53Client::UpdateHealthCheck, request); } /** * An Async wrapper for UpdateHealthCheck that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateHealthCheckAsync(const UpdateHealthCheckRequestT& request, const UpdateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::UpdateHealthCheck, request, handler, context); } /** *

Updates the comment for a specified hosted zone.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateHostedZoneCommentOutcome UpdateHostedZoneComment(const Model::UpdateHostedZoneCommentRequest& request) const; /** * A Callable wrapper for UpdateHostedZoneComment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateHostedZoneCommentOutcomeCallable UpdateHostedZoneCommentCallable(const UpdateHostedZoneCommentRequestT& request) const { return SubmitCallable(&Route53Client::UpdateHostedZoneComment, request); } /** * An Async wrapper for UpdateHostedZoneComment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateHostedZoneCommentAsync(const UpdateHostedZoneCommentRequestT& request, const UpdateHostedZoneCommentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::UpdateHostedZoneComment, request, handler, context); } /** *

Updates the comment for a specified traffic policy version.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateTrafficPolicyCommentOutcome UpdateTrafficPolicyComment(const Model::UpdateTrafficPolicyCommentRequest& request) const; /** * A Callable wrapper for UpdateTrafficPolicyComment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTrafficPolicyCommentOutcomeCallable UpdateTrafficPolicyCommentCallable(const UpdateTrafficPolicyCommentRequestT& request) const { return SubmitCallable(&Route53Client::UpdateTrafficPolicyComment, request); } /** * An Async wrapper for UpdateTrafficPolicyComment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTrafficPolicyCommentAsync(const UpdateTrafficPolicyCommentRequestT& request, const UpdateTrafficPolicyCommentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::UpdateTrafficPolicyComment, request, handler, context); } /** *

After you submit a UpdateTrafficPolicyInstance request, * there's a brief delay while Route 53 creates the resource record sets that are * specified in the traffic policy definition. Use * GetTrafficPolicyInstance with the id of updated * traffic policy instance confirm that the * UpdateTrafficPolicyInstance request completed successfully. For * more information, see the State response element.

*

Updates the resource record sets in a specified hosted zone that were created * based on the settings in a specified traffic policy version.

When you * update a traffic policy instance, Amazon Route 53 continues to respond to DNS * queries for the root resource record set name (such as example.com) while it * replaces one group of resource record sets with another. Route 53 performs the * following operations:

  1. Route 53 creates a new group of resource * record sets based on the specified traffic policy. This is true regardless of * how significant the differences are between the existing resource record sets * and the new resource record sets.

  2. When all of the new * resource record sets have been created, Route 53 starts to respond to DNS * queries for the root resource record set name (such as example.com) by using the * new resource record sets.

  3. Route 53 deletes the old group of * resource record sets that are associated with the root resource record set * name.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTrafficPolicyInstanceOutcome UpdateTrafficPolicyInstance(const Model::UpdateTrafficPolicyInstanceRequest& request) const; /** * A Callable wrapper for UpdateTrafficPolicyInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTrafficPolicyInstanceOutcomeCallable UpdateTrafficPolicyInstanceCallable(const UpdateTrafficPolicyInstanceRequestT& request) const { return SubmitCallable(&Route53Client::UpdateTrafficPolicyInstance, request); } /** * An Async wrapper for UpdateTrafficPolicyInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTrafficPolicyInstanceAsync(const UpdateTrafficPolicyInstanceRequestT& request, const UpdateTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&Route53Client::UpdateTrafficPolicyInstance, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const Route53ClientConfiguration& clientConfiguration); Route53ClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Route53 } // namespace Aws