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

package/dist/types/ts3.4/commands/DeleteReusableDelegationSetCommand.d.ts

@@ -1,41 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteReusableDelegationSetRequest, DeleteReusableDelegationSetResponse } 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 DeleteReusableDelegationSetCommandInput extends DeleteReusableDelegationSetRequest {
-}
-export interface DeleteReusableDelegationSetCommandOutput extends DeleteReusableDelegationSetResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes a reusable delegation set.</p>
- * 		       <important>
- * 			         <p>You can delete a reusable delegation set only if it isn't associated with any hosted zones.</p>
- * 		       </important>
- * 		       <p>To verify that the reusable delegation set is not associated with any hosted zones, submit a
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_GetReusableDelegationSet.html">GetReusableDelegationSet</a>
- * 			request and specify the ID of the reusable delegation set that you want to delete.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteReusableDelegationSetCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteReusableDelegationSetCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteReusableDelegationSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteReusableDelegationSetCommandInput} for command's `input` shape.
- * @see {@link DeleteReusableDelegationSetCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteReusableDelegationSetCommand extends $Command<DeleteReusableDelegationSetCommandInput, DeleteReusableDelegationSetCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteReusableDelegationSetCommandInput;
-    constructor(input: DeleteReusableDelegationSetCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteReusableDelegationSetCommandInput, DeleteReusableDelegationSetCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteTrafficPolicyCommand.d.ts

@@ -1,49 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteTrafficPolicyRequest, DeleteTrafficPolicyResponse } 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 DeleteTrafficPolicyCommandInput extends DeleteTrafficPolicyRequest {
-}
-export interface DeleteTrafficPolicyCommandOutput extends DeleteTrafficPolicyResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes a traffic policy.</p>
- * 		       <p>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:</p>
- * 		       <ul>
- *             <li>
- *                <p>Deleted traffic policies aren't listed if you run <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_ListTrafficPolicies.html">ListTrafficPolicies</a>.</p>
- *             </li>
- *             <li>
- *                <p>	There's no way to get a list of deleted policies.</p>
- *             </li>
- *             <li>
- *                <p>If you retain the ID of the policy, you can get information about the policy, including the traffic policy document, by running
- * 				<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_GetTrafficPolicy.html">GetTrafficPolicy</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteTrafficPolicyCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteTrafficPolicyCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteTrafficPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTrafficPolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteTrafficPolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteTrafficPolicyCommand extends $Command<DeleteTrafficPolicyCommandInput, DeleteTrafficPolicyCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteTrafficPolicyCommandInput;
-    constructor(input: DeleteTrafficPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTrafficPolicyCommandInput, DeleteTrafficPolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteTrafficPolicyInstanceCommand.d.ts

@@ -1,38 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteTrafficPolicyInstanceRequest, DeleteTrafficPolicyInstanceResponse } 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 DeleteTrafficPolicyInstanceCommandInput extends DeleteTrafficPolicyInstanceRequest {
-}
-export interface DeleteTrafficPolicyInstanceCommandOutput extends DeleteTrafficPolicyInstanceResponse, __MetadataBearer {
-}
-/**
- * <p>Deletes a traffic policy instance and all of the resource record sets that Amazon Route 53 created when you created the instance.</p>
- * 		       <note>
- * 			         <p>In the Route 53 console, traffic policy instances are known as policy records.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteTrafficPolicyInstanceCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteTrafficPolicyInstanceCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteTrafficPolicyInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTrafficPolicyInstanceCommandInput} for command's `input` shape.
- * @see {@link DeleteTrafficPolicyInstanceCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteTrafficPolicyInstanceCommand extends $Command<DeleteTrafficPolicyInstanceCommandInput, DeleteTrafficPolicyInstanceCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteTrafficPolicyInstanceCommandInput;
-    constructor(input: DeleteTrafficPolicyInstanceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTrafficPolicyInstanceCommandInput, DeleteTrafficPolicyInstanceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteVPCAssociationAuthorizationCommand.d.ts

@@ -1,43 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DeleteVPCAssociationAuthorizationRequest, DeleteVPCAssociationAuthorizationResponse } 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 DeleteVPCAssociationAuthorizationCommandInput extends DeleteVPCAssociationAuthorizationRequest {
-}
-export interface DeleteVPCAssociationAuthorizationCommandOutput extends DeleteVPCAssociationAuthorizationResponse, __MetadataBearer {
-}
-/**
- * <p>Removes authorization to submit an <code>AssociateVPCWithHostedZone</code> 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 <code>DeleteVPCAssociationAuthorization</code> request.</p>
- * 		       <important>
- * 			         <p>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,
- * 				<code>DeleteVPCAssociationAuthorization</code> won't disassociate the VPC from the hosted zone.
- * 				If you want to delete an existing association, use <code>DisassociateVPCFromHostedZone</code>.</p>
- * 		       </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DeleteVPCAssociationAuthorizationCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DeleteVPCAssociationAuthorizationCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DeleteVPCAssociationAuthorizationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVPCAssociationAuthorizationCommandInput} for command's `input` shape.
- * @see {@link DeleteVPCAssociationAuthorizationCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteVPCAssociationAuthorizationCommand extends $Command<DeleteVPCAssociationAuthorizationCommandInput, DeleteVPCAssociationAuthorizationCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DeleteVPCAssociationAuthorizationCommandInput;
-    constructor(input: DeleteVPCAssociationAuthorizationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVPCAssociationAuthorizationCommandInput, DeleteVPCAssociationAuthorizationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DisableHostedZoneDNSSECCommand.d.ts

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

package/dist/types/ts3.4/commands/DisassociateVPCFromHostedZoneCommand.d.ts

@@ -1,55 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { DisassociateVPCFromHostedZoneRequest, DisassociateVPCFromHostedZoneResponse } 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 DisassociateVPCFromHostedZoneCommandInput extends DisassociateVPCFromHostedZoneRequest {
-}
-export interface DisassociateVPCFromHostedZoneCommandOutput extends DisassociateVPCFromHostedZoneResponse, __MetadataBearer {
-}
-/**
- * <p>Disassociates an Amazon Virtual Private Cloud (Amazon VPC) from an Amazon Route 53 private hosted zone. Note the following:</p>
- * 		       <ul>
- *             <li>
- *                <p>You can't disassociate the last Amazon VPC from a private hosted zone.</p>
- *             </li>
- *             <li>
- *                <p>You can't convert a private hosted zone into a public hosted zone.</p>
- *             </li>
- *             <li>
- *                <p>You can submit a <code>DisassociateVPCFromHostedZone</code> request using either the account
- * 				that created the hosted zone or the account that created the Amazon VPC.</p>
- *             </li>
- *             <li>
- *                <p>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.</p>
- * 				           <p>When you run <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_ListHostedZonesByVPC.html">DisassociateVPCFromHostedZone</a>,
- * 					if the hosted zone has a value for <code>OwningAccount</code>, you can use <code>DisassociateVPCFromHostedZone</code>.
- * 					If the hosted zone has a value for <code>OwningService</code>, you can't use <code>DisassociateVPCFromHostedZone</code>.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, DisassociateVPCFromHostedZoneCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, DisassociateVPCFromHostedZoneCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new DisassociateVPCFromHostedZoneCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateVPCFromHostedZoneCommandInput} for command's `input` shape.
- * @see {@link DisassociateVPCFromHostedZoneCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DisassociateVPCFromHostedZoneCommand extends $Command<DisassociateVPCFromHostedZoneCommandInput, DisassociateVPCFromHostedZoneCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: DisassociateVPCFromHostedZoneCommandInput;
-    constructor(input: DisassociateVPCFromHostedZoneCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateVPCFromHostedZoneCommandInput, DisassociateVPCFromHostedZoneCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/EnableHostedZoneDNSSECCommand.d.ts

@@ -1,35 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { EnableHostedZoneDNSSECRequest, EnableHostedZoneDNSSECResponse } 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 EnableHostedZoneDNSSECCommandInput extends EnableHostedZoneDNSSECRequest {
-}
-export interface EnableHostedZoneDNSSECCommandOutput extends EnableHostedZoneDNSSECResponse, __MetadataBearer {
-}
-/**
- * <p>Enables DNSSEC signing in a specific hosted zone.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, EnableHostedZoneDNSSECCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, EnableHostedZoneDNSSECCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new EnableHostedZoneDNSSECCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableHostedZoneDNSSECCommandInput} for command's `input` shape.
- * @see {@link EnableHostedZoneDNSSECCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class EnableHostedZoneDNSSECCommand extends $Command<EnableHostedZoneDNSSECCommandInput, EnableHostedZoneDNSSECCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: EnableHostedZoneDNSSECCommandInput;
-    constructor(input: EnableHostedZoneDNSSECCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableHostedZoneDNSSECCommandInput, EnableHostedZoneDNSSECCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetAccountLimitCommand.d.ts

@@ -1,44 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetAccountLimitRequest, GetAccountLimitResponse } 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 GetAccountLimitCommandInput extends GetAccountLimitRequest {
-}
-export interface GetAccountLimitCommandOutput extends GetAccountLimitResponse, __MetadataBearer {
-}
-/**
- * <p>Gets the specified limit for the current account, for example, the maximum number of health checks that you
- * 			can create using the account.</p>
- * 		       <p>For the default limit, see <a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DNSLimitations.html">Limits</a>
- * 			in the <i>Amazon Route 53 Developer Guide</i>. To request a higher limit,
- * 			<a href="https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-route53">open a case</a>.</p>
- * 		       <note>
- *             <p>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
- * 			<a href="https://console.aws.amazon.com/trustedadvisor">https://console.aws.amazon.com/trustedadvisor/</a>. Then choose
- * 			<b>Service limits</b> in the navigation pane.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetAccountLimitCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetAccountLimitCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetAccountLimitCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccountLimitCommandInput} for command's `input` shape.
- * @see {@link GetAccountLimitCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetAccountLimitCommand extends $Command<GetAccountLimitCommandInput, GetAccountLimitCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetAccountLimitCommandInput;
-    constructor(input: GetAccountLimitCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountLimitCommandInput, GetAccountLimitCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetChangeCommand.d.ts

@@ -1,47 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetChangeRequest, GetChangeResponse } 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 GetChangeCommandInput extends GetChangeRequest {
-}
-export interface GetChangeCommandOutput extends GetChangeResponse, __MetadataBearer {
-}
-/**
- * <p>Returns the current status of a change batch request. The status is one of the
- * 			following values:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>
- *                   <code>PENDING</code> indicates that the changes in this request have not propagated to all Amazon Route 53 DNS servers.
- * 					This is the initial status of all change batch requests.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>INSYNC</code> indicates that the changes have propagated to all Route 53 DNS servers. </p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetChangeCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetChangeCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetChangeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetChangeCommandInput} for command's `input` shape.
- * @see {@link GetChangeCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetChangeCommand extends $Command<GetChangeCommandInput, GetChangeCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetChangeCommandInput;
-    constructor(input: GetChangeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChangeCommandInput, GetChangeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetCheckerIpRangesCommand.d.ts

@@ -1,42 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetCheckerIpRangesRequest, GetCheckerIpRangesResponse } 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 GetCheckerIpRangesCommandInput extends GetCheckerIpRangesRequest {
-}
-export interface GetCheckerIpRangesCommandOutput extends GetCheckerIpRangesResponse, __MetadataBearer {
-}
-/**
- * <p>Route 53 does not perform authorization for this API because it retrieves information that is already available to the public.</p>
- * 	        <important>
- * 			         <p>
- *                <code>GetCheckerIpRanges</code> 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
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/route-53-ip-addresses.html">IP Address Ranges of Amazon Route 53 Servers</a>
- * 			in the <i>Amazon Route 53 Developer Guide</i>.</p>
- * 		       </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetCheckerIpRangesCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetCheckerIpRangesCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetCheckerIpRangesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCheckerIpRangesCommandInput} for command's `input` shape.
- * @see {@link GetCheckerIpRangesCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetCheckerIpRangesCommand extends $Command<GetCheckerIpRangesCommandInput, GetCheckerIpRangesCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetCheckerIpRangesCommandInput;
-    constructor(input: GetCheckerIpRangesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCheckerIpRangesCommandInput, GetCheckerIpRangesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetDNSSECCommand.d.ts

@@ -1,35 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetDNSSECRequest, GetDNSSECResponse } 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 GetDNSSECCommandInput extends GetDNSSECRequest {
-}
-export interface GetDNSSECCommandOutput extends GetDNSSECResponse, __MetadataBearer {
-}
-/**
- * <p>Returns information about DNSSEC for a specific hosted zone, including the key-signing keys (KSKs) in the hosted zone.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetDNSSECCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetDNSSECCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetDNSSECCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDNSSECCommandInput} for command's `input` shape.
- * @see {@link GetDNSSECCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetDNSSECCommand extends $Command<GetDNSSECCommandInput, GetDNSSECCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetDNSSECCommandInput;
-    constructor(input: GetDNSSECCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDNSSECCommandInput, GetDNSSECCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetGeoLocationCommand.d.ts

@@ -1,55 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetGeoLocationRequest, GetGeoLocationResponse } 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 GetGeoLocationCommandInput extends GetGeoLocationRequest {
-}
-export interface GetGeoLocationCommandOutput extends GetGeoLocationResponse, __MetadataBearer {
-}
-/**
- * <p>Gets information about whether a specified geographic location is supported for Amazon Route 53 geolocation
- * 			resource record sets.</p>
- * 	        <p>Route 53 does not perform authorization for this API because it retrieves information that is already available to the public.</p>
- *
- * 		       <p>Use the following syntax to determine whether a continent is supported for geolocation:</p>
- * 		       <p>
- *             <code>GET /2013-04-01/geolocation?continentcode=<i>two-letter abbreviation for a continent</i>
- *             </code>
- *          </p>
- *
- * 		       <p>Use the following syntax to determine whether a country is supported for geolocation:</p>
- * 		       <p>
- *             <code>GET /2013-04-01/geolocation?countrycode=<i>two-character country code</i>
- *             </code>
- *          </p>
- *
- * 		       <p>Use the following syntax to determine whether a subdivision of a country is supported for geolocation:</p>
- * 		       <p>
- *             <code>GET /2013-04-01/geolocation?countrycode=<i>two-character country code</i>&subdivisioncode=<i>subdivision code</i>
- *             </code>
- *          </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetGeoLocationCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetGeoLocationCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetGeoLocationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGeoLocationCommandInput} for command's `input` shape.
- * @see {@link GetGeoLocationCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetGeoLocationCommand extends $Command<GetGeoLocationCommandInput, GetGeoLocationCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetGeoLocationCommandInput;
-    constructor(input: GetGeoLocationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGeoLocationCommandInput, GetGeoLocationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetHealthCheckCommand.d.ts

@@ -1,35 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetHealthCheckRequest, GetHealthCheckResponse } 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 GetHealthCheckCommandInput extends GetHealthCheckRequest {
-}
-export interface GetHealthCheckCommandOutput extends GetHealthCheckResponse, __MetadataBearer {
-}
-/**
- * <p>Gets information about a specified health check.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetHealthCheckCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetHealthCheckCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetHealthCheckCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetHealthCheckCommandInput} for command's `input` shape.
- * @see {@link GetHealthCheckCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetHealthCheckCommand extends $Command<GetHealthCheckCommandInput, GetHealthCheckCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetHealthCheckCommandInput;
-    constructor(input: GetHealthCheckCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetHealthCheckCommandInput, GetHealthCheckCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetHealthCheckCountCommand.d.ts

@@ -1,35 +0,0 @@
-import { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
-import { GetHealthCheckCountRequest, GetHealthCheckCountResponse } 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 GetHealthCheckCountCommandInput extends GetHealthCheckCountRequest {
-}
-export interface GetHealthCheckCountCommandOutput extends GetHealthCheckCountResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves the number of health checks that are associated with the current Amazon Web Services account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetHealthCheckCountCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetHealthCheckCountCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetHealthCheckCountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetHealthCheckCountCommandInput} for command's `input` shape.
- * @see {@link GetHealthCheckCountCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetHealthCheckCountCommand extends $Command<GetHealthCheckCountCommandInput, GetHealthCheckCountCommandOutput, Route53ClientResolvedConfig> {
-    readonly input: GetHealthCheckCountCommandInput;
-    constructor(input: GetHealthCheckCountCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetHealthCheckCountCommandInput, GetHealthCheckCountCommandOutput>;
-    private serialize;
-    private deserialize;
-}