@aws-sdk/client-route-53 3.33.0 → 3.36.1

package/dist/types/commands/CreateQueryLoggingConfigCommand.d.ts

@@ -1,151 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { CreateQueryLoggingConfigRequest, CreateQueryLoggingConfigResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateQueryLoggingConfigCommandInput extends CreateQueryLoggingConfigRequest {
-}
-export interface CreateQueryLoggingConfigCommandOutput extends CreateQueryLoggingConfigResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- * 		       <p>DNS query logs contain information about the queries that Route 53 receives for a specified public hosted zone, such as the following:</p>
- * 		       <ul>
- *             <li>
- *                <p>Route 53 edge location that responded to the DNS query</p>
- *             </li>
- *             <li>
- *                <p>Domain or subdomain that was requested</p>
- *             </li>
- *             <li>
- *                <p>DNS record type, such as A or AAAA</p>
- *             </li>
- *             <li>
- *                <p>DNS response code, such as <code>NoError</code> or <code>ServFail</code>
- *                </p>
- *             </li>
- *          </ul>
- *
- * 		       <dl>
- *             <dt>Log Group and Resource Policy</dt>
- *             <dd>
- *                <p>Before you create a query logging configuration, perform the following operations.</p>
- * 					          <note>
- *                   <p>If you create a query logging configuration using the Route 53 console, Route 53 performs these operations automatically.</p>
- *                </note>
- * 					          <ol>
- *                   <li>
- *                      <p>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:</p>
- * 							              <ul>
- *                         <li>
- *                            <p>You must create the log group in the us-east-1 region.</p>
- *                         </li>
- *                         <li>
- *                            <p>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.</p>
- *                         </li>
- *                         <li>
- *                            <p>When you create log groups for query logging, we recommend that you use a consistent prefix, for example:</p>
- * 									                  <p>
- *                               <code>/aws/route53/<i>hosted zone name</i>
- *                               </code>
- *                            </p>
- * 									                  <p>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.</p>
- * 								                </li>
- *                      </ul>
- * 						            </li>
- *                   <li>
- *                      <p>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 <code>Resource</code>, 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 <code>*</code>, for example:</p>
- * 							              <p>
- *                         <code>arn:aws:logs:us-east-1:123412341234:log-group:/aws/route53/*</code>
- *                      </p>
- * 							              <note>
- *                         <p>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.</p>
- *                      </note>
- * 						            </li>
- *                </ol>
- * 				        </dd>
- *             <dt>Log Streams and Edge Locations</dt>
- *             <dd>
- *                <p>When Route 53 finishes creating the configuration for DNS query logging, it does the following:</p>
- * 					          <ul>
- *                   <li>
- *                      <p>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.</p>
- *                   </li>
- *                   <li>
- *                      <p>Begins to send query logs to the applicable log stream.</p>
- *                   </li>
- *                </ul>
- * 					          <p>The name of each log stream is in the following format:</p>
- * 					          <p>
- *                   <code>
- *                      <i>hosted zone ID</i>/<i>edge location code</i>
- *                   </code>
- *                </p>
- * 					          <p>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
- * 						<a href="http://aws.amazon.com/route53/details/">Route 53 Product Details</a> page.</p>
- * 				        </dd>
- *             <dt>Queries That Are Logged</dt>
- *             <dd>
- *                <p>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
- * 					<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/welcome-dns-service.html">Routing Internet Traffic to Your Website or Web Application</a>
- * 					in the <i>Amazon Route 53 Developer Guide</i>.</p>
- * 				        </dd>
- *             <dt>Log File Format</dt>
- *             <dd>
- *                <p>For a list of the values in each query log and the format of each value, see
- * 					<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/query-logs.html">Logging DNS Queries</a> in the
- * 					<i>Amazon Route 53 Developer Guide</i>.</p>
- * 				        </dd>
- *             <dt>Pricing</dt>
- *             <dd>
- *                <p>For information about charges for query logs, see
- * 					<a href="http://aws.amazon.com/cloudwatch/pricing/">Amazon CloudWatch Pricing</a>.</p>
- *             </dd>
- *             <dt>How to Stop Logging</dt>
- *             <dd>
- *                <p>If you want Route 53 to stop sending query logs to CloudWatch Logs, delete the query logging configuration. For more information, see
- * 					<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_DeleteQueryLoggingConfig.html">DeleteQueryLoggingConfig</a>.</p>
- * 				        </dd>
- *          </dl>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, CreateQueryLoggingConfigCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, CreateQueryLoggingConfigCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new CreateQueryLoggingConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateQueryLoggingConfigCommandInput} for command's `input` shape.
- * @see {@link CreateQueryLoggingConfigCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateQueryLoggingConfigCommand extends $Command<CreateQueryLoggingConfigCommandInput, CreateQueryLoggingConfigCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: CreateQueryLoggingConfigCommandInput;
-    constructor(input: CreateQueryLoggingConfigCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateQueryLoggingConfigCommandInput, CreateQueryLoggingConfigCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateReusableDelegationSetCommand.d.ts

@@ -1,85 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { CreateReusableDelegationSetRequest, CreateReusableDelegationSetResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateReusableDelegationSetCommandInput extends CreateReusableDelegationSetRequest {
-}
-export interface CreateReusableDelegationSetCommandOutput extends CreateReusableDelegationSetResponse, __MetadataBearer {
-}
-/**
- * <p>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. </p>
- * 		       <p>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 <code>CreateReusableDelegationSet</code> request.</p>
- * 		       <note>
- * 			         <p>You can't associate a reusable delegation set with a private hosted zone.</p>
- * 		       </note>
- * 		       <p>For information about using a reusable delegation set to configure white label name servers, see
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/white-label-name-servers.html">Configuring White Label Name Servers</a>.</p>
- *
- * 		       <p>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:</p>
- * 		       <ol>
- *             <li>
- *                <p>Create a reusable delegation set.</p>
- *             </li>
- *             <li>
- *                <p>Recreate hosted zones, and reduce the TTL to 60 seconds or less.</p>
- *             </li>
- *             <li>
- *                <p>Recreate resource record sets in the new hosted zones.</p>
- *             </li>
- *             <li>
- *                <p>Change the registrar's name servers to use the name servers for the new hosted zones.</p>
- *             </li>
- *             <li>
- *                <p>Monitor traffic for the website or application.</p>
- *             </li>
- *             <li>
- *                <p>Change TTLs back to their original values.</p>
- *             </li>
- *          </ol>
- *
- * 		       <p>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:</p>
- * 		       <ul>
- *             <li>
- *                <p>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.</p>
- *             </li>
- *             <li>
- *                <p>For larger numbers of hosted zones, the easiest solution is to use more than one reusable delegation set.</p>
- *             </li>
- *             <li>
- *                <p>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.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, CreateReusableDelegationSetCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, CreateReusableDelegationSetCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new CreateReusableDelegationSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateReusableDelegationSetCommandInput} for command's `input` shape.
- * @see {@link CreateReusableDelegationSetCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateReusableDelegationSetCommand extends $Command<CreateReusableDelegationSetCommandInput, CreateReusableDelegationSetCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: CreateReusableDelegationSetCommandInput;
-    constructor(input: CreateReusableDelegationSetCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReusableDelegationSetCommandInput, CreateReusableDelegationSetCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateTrafficPolicyCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { CreateTrafficPolicyRequest, CreateTrafficPolicyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateTrafficPolicyCommandInput extends CreateTrafficPolicyRequest {
-}
-export interface CreateTrafficPolicyCommandOutput extends CreateTrafficPolicyResponse, __MetadataBearer {
-}
-/**
- * <p>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).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, CreateTrafficPolicyCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, CreateTrafficPolicyCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new CreateTrafficPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficPolicyCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficPolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTrafficPolicyCommand extends $Command<CreateTrafficPolicyCommandInput, CreateTrafficPolicyCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: CreateTrafficPolicyCommandInput;
-    constructor(input: CreateTrafficPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficPolicyCommandInput, CreateTrafficPolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateTrafficPolicyInstanceCommand.d.ts

@@ -1,38 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { CreateTrafficPolicyInstanceRequest, CreateTrafficPolicyInstanceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateTrafficPolicyInstanceCommandInput extends CreateTrafficPolicyInstanceRequest {
-}
-export interface CreateTrafficPolicyInstanceCommandOutput extends CreateTrafficPolicyInstanceResponse, __MetadataBearer {
-}
-/**
- * <p>Creates resource record sets in a specified hosted zone based on the settings in a specified traffic policy version.
- * 			In addition, <code>CreateTrafficPolicyInstance</code> 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 <code>CreateTrafficPolicyInstance</code> created.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, CreateTrafficPolicyInstanceCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, CreateTrafficPolicyInstanceCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new CreateTrafficPolicyInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficPolicyInstanceCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficPolicyInstanceCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTrafficPolicyInstanceCommand extends $Command<CreateTrafficPolicyInstanceCommandInput, CreateTrafficPolicyInstanceCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: CreateTrafficPolicyInstanceCommandInput;
-    constructor(input: CreateTrafficPolicyInstanceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficPolicyInstanceCommandInput, CreateTrafficPolicyInstanceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateTrafficPolicyVersionCommand.d.ts

@@ -1,39 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { CreateTrafficPolicyVersionRequest, CreateTrafficPolicyVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateTrafficPolicyVersionCommandInput extends CreateTrafficPolicyVersionRequest {
-}
-export interface CreateTrafficPolicyVersionCommandOutput extends CreateTrafficPolicyVersionResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, CreateTrafficPolicyVersionCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, CreateTrafficPolicyVersionCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new CreateTrafficPolicyVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficPolicyVersionCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficPolicyVersionCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTrafficPolicyVersionCommand extends $Command<CreateTrafficPolicyVersionCommandInput, CreateTrafficPolicyVersionCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: CreateTrafficPolicyVersionCommandInput;
-    constructor(input: CreateTrafficPolicyVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficPolicyVersionCommandInput, CreateTrafficPolicyVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/CreateVPCAssociationAuthorizationCommand.d.ts

@@ -1,43 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { CreateVPCAssociationAuthorizationRequest, CreateVPCAssociationAuthorizationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateVPCAssociationAuthorizationCommandInput extends CreateVPCAssociationAuthorizationRequest {
-}
-export interface CreateVPCAssociationAuthorizationCommandOutput extends CreateVPCAssociationAuthorizationResponse, __MetadataBearer {
-}
-/**
- * <p>Authorizes the Amazon Web Services account that created a specified VPC to submit an <code>AssociateVPCWithHostedZone</code>
- * 			request to associate the VPC with a specified hosted zone that was created by a different account.
- * 			To submit a <code>CreateVPCAssociationAuthorization</code> 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
- * 			<code>AssociateVPCWithHostedZone</code> request.</p>
- * 		       <note>
- *             <p>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.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, CreateVPCAssociationAuthorizationCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, CreateVPCAssociationAuthorizationCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new CreateVPCAssociationAuthorizationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVPCAssociationAuthorizationCommandInput} for command's `input` shape.
- * @see {@link CreateVPCAssociationAuthorizationCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateVPCAssociationAuthorizationCommand extends $Command<CreateVPCAssociationAuthorizationCommandInput, CreateVPCAssociationAuthorizationCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: CreateVPCAssociationAuthorizationCommandInput;
-    constructor(input: CreateVPCAssociationAuthorizationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVPCAssociationAuthorizationCommandInput, CreateVPCAssociationAuthorizationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeactivateKeySigningKeyCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeactivateKeySigningKeyRequest, DeactivateKeySigningKeyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeactivateKeySigningKeyCommandInput extends DeactivateKeySigningKeyRequest {
-}
-export interface DeactivateKeySigningKeyCommandOutput extends DeactivateKeySigningKeyResponse, __MetadataBearer {
-}
-/**
- * <p>Deactivates a key-signing key (KSK) so that it will not be used for signing by DNSSEC. This operation changes the
- * 			KSK status to <code>INACTIVE</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeactivateKeySigningKeyCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeactivateKeySigningKeyCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeactivateKeySigningKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeactivateKeySigningKeyCommandInput} for command's `input` shape.
- * @see {@link DeactivateKeySigningKeyCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeactivateKeySigningKeyCommand extends $Command<DeactivateKeySigningKeyCommandInput, DeactivateKeySigningKeyCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeactivateKeySigningKeyCommandInput;
-    constructor(input: DeactivateKeySigningKeyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeactivateKeySigningKeyCommandInput, DeactivateKeySigningKeyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteHealthCheckCommand.d.ts

@@ -1,48 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteHealthCheckRequest, DeleteHealthCheckResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteHealthCheckCommandInput extends DeleteHealthCheckRequest {
-}
-export interface DeleteHealthCheckCommandOutput extends DeleteHealthCheckResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes a health check.</p>
- * 		       <important>
- * 			         <p>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
- * 				<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/health-checks-creating-deleting.html#health-checks-deleting.html">Replacing and Deleting Health Checks</a>
- * 				in the <i>Amazon Route 53 Developer Guide</i>.</p>
- * 		       </important>
- *
- * 		       <p>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 <code>DeleteHealthCheck</code> 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. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteHealthCheckCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteHealthCheckCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteHealthCheckCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteHealthCheckCommandInput} for command's `input` shape.
- * @see {@link DeleteHealthCheckCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteHealthCheckCommand extends $Command<DeleteHealthCheckCommandInput, DeleteHealthCheckCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteHealthCheckCommandInput;
-    constructor(input: DeleteHealthCheckCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteHealthCheckCommandInput, DeleteHealthCheckCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteHostedZoneCommand.d.ts

@@ -1,73 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteHostedZoneRequest, DeleteHostedZoneResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteHostedZoneCommandInput extends DeleteHostedZoneRequest {
-}
-export interface DeleteHostedZoneCommandOutput extends DeleteHostedZoneResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes a hosted zone.</p>
- *
- * 		       <p>If the hosted zone was created by another service, such as Cloud Map, see
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DeleteHostedZone.html#delete-public-hosted-zone-created-by-another-service">Deleting
- * 			Public Hosted Zones That Were Created by Another Service</a> in the <i>Amazon Route 53 Developer Guide</i> for information about how to delete it.
- * 			(The process is the same for public and private hosted zones that were created by another service.)</p>
- *
- * 		       <p>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.</p>
- *
- * 		       <important>
- * 			         <p>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.</p>
- * 		       </important>
- *
- * 		       <p>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 <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_domains_UpdateDomainNameservers.html">UpdateDomainNameservers</a>
- * 			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."</p>
- *
- * 		       <p>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
- * 			<code>HostedZoneNotEmpty</code> error. For information about deleting records from your hosted zone, see
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_ChangeResourceRecordSets.html">ChangeResourceRecordSets</a>.</p>
- * 		       <p>To verify that the hosted zone has been deleted, do one of the following:</p>
- * 		       <ul>
- *             <li>
- *                <p>Use the <code>GetHostedZone</code> action to request information about the hosted zone.</p>
- *             </li>
- *             <li>
- *                <p>Use the <code>ListHostedZones</code> action to get a list of the hosted zones associated with the current
- * 				Amazon Web Services account.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteHostedZoneCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteHostedZoneCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteHostedZoneCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteHostedZoneCommandInput} for command's `input` shape.
- * @see {@link DeleteHostedZoneCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteHostedZoneCommand extends $Command<DeleteHostedZoneCommandInput, DeleteHostedZoneCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteHostedZoneCommandInput;
-    constructor(input: DeleteHostedZoneCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteHostedZoneCommandInput, DeleteHostedZoneCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteKeySigningKeyCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteKeySigningKeyRequest, DeleteKeySigningKeyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteKeySigningKeyCommandInput extends DeleteKeySigningKeyRequest {
-}
-export interface DeleteKeySigningKeyCommandOutput extends DeleteKeySigningKeyResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteKeySigningKeyCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteKeySigningKeyCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteKeySigningKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteKeySigningKeyCommandInput} for command's `input` shape.
- * @see {@link DeleteKeySigningKeyCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteKeySigningKeyCommand extends $Command<DeleteKeySigningKeyCommandInput, DeleteKeySigningKeyCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteKeySigningKeyCommandInput;
-    constructor(input: DeleteKeySigningKeyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKeySigningKeyCommandInput, DeleteKeySigningKeyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteQueryLoggingConfigCommand.d.ts

@@ -1,39 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteQueryLoggingConfigRequest, DeleteQueryLoggingConfigResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteQueryLoggingConfigCommandInput extends DeleteQueryLoggingConfigRequest {
-}
-export interface DeleteQueryLoggingConfigCommandOutput extends DeleteQueryLoggingConfigResponse, __MetadataBearer {
-}
-/**
- * <p>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.</p>
- *
- * 		       <p>For more information about DNS query logs, see
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_CreateQueryLoggingConfig.html">CreateQueryLoggingConfig</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteQueryLoggingConfigCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteQueryLoggingConfigCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteQueryLoggingConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteQueryLoggingConfigCommandInput} for command's `input` shape.
- * @see {@link DeleteQueryLoggingConfigCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteQueryLoggingConfigCommand extends $Command<DeleteQueryLoggingConfigCommandInput, DeleteQueryLoggingConfigCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteQueryLoggingConfigCommandInput;
-    constructor(input: DeleteQueryLoggingConfigCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteQueryLoggingConfigCommandInput, DeleteQueryLoggingConfigCommandOutput>;
-    private serialize;
-    private deserialize;
-}