@aws-sdk/client-route-53 3.35.0 → 3.38.0

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

@@ -6,43 +6,11 @@ export interface DeleteTrafficPolicyCommandInput extends DeleteTrafficPolicyRequ
 }
 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

@@ -6,32 +6,11 @@ export interface DeleteTrafficPolicyInstanceCommandInput extends DeleteTrafficPo
 }
 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

@@ -6,37 +6,11 @@ export interface DeleteVPCAssociationAuthorizationCommandInput extends DeleteVPC
 }
 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

@@ -6,30 +6,11 @@ export interface DisableHostedZoneDNSSECCommandInput extends DisableHostedZoneDN
 }
 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

@@ -6,49 +6,11 @@ export interface DisassociateVPCFromHostedZoneCommandInput extends DisassociateV
 }
 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

@@ -6,29 +6,11 @@ export interface EnableHostedZoneDNSSECCommandInput extends EnableHostedZoneDNSS
 }
 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

@@ -6,38 +6,11 @@ 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

@@ -6,41 +6,11 @@ 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

@@ -6,36 +6,11 @@ export interface GetCheckerIpRangesCommandInput extends GetCheckerIpRangesReques
 }
 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

@@ -6,29 +6,11 @@ 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

@@ -6,49 +6,11 @@ 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

@@ -6,29 +6,11 @@ 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

@@ -6,29 +6,11 @@ export interface GetHealthCheckCountCommandInput extends GetHealthCheckCountRequ
 }
 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;

package/dist-types/ts3.4/commands/GetHealthCheckLastFailureReasonCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetHealthCheckLastFailureReasonCommandInput extends GetHealthCh
 }
 export interface GetHealthCheckLastFailureReasonCommandOutput extends GetHealthCheckLastFailureReasonResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the reason that a specified health check failed most recently.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetHealthCheckLastFailureReasonCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetHealthCheckLastFailureReasonCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetHealthCheckLastFailureReasonCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetHealthCheckLastFailureReasonCommandInput} for command's `input` shape.
- * @see {@link GetHealthCheckLastFailureReasonCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetHealthCheckLastFailureReasonCommand extends $Command<GetHealthCheckLastFailureReasonCommandInput, GetHealthCheckLastFailureReasonCommandOutput, Route53ClientResolvedConfig> {
     readonly input: GetHealthCheckLastFailureReasonCommandInput;
     constructor(input: GetHealthCheckLastFailureReasonCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetHealthCheckLastFailureReasonCommandInput, GetHealthCheckLastFailureReasonCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetHealthCheckStatusCommand.d.ts

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

package/dist-types/ts3.4/commands/GetHostedZoneCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetHostedZoneCommandInput extends GetHostedZoneRequest {
 }
 export interface GetHostedZoneCommandOutput extends GetHostedZoneResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a specified hosted zone including the four name servers assigned to the hosted zone.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53Client, GetHostedZoneCommand } from "@aws-sdk/client-route-53"; // ES Modules import
- * // const { Route53Client, GetHostedZoneCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
- * const client = new Route53Client(config);
- * const command = new GetHostedZoneCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetHostedZoneCommandInput} for command's `input` shape.
- * @see {@link GetHostedZoneCommandOutput} for command's `response` shape.
- * @see {@link Route53ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetHostedZoneCommand extends $Command<GetHostedZoneCommandInput, GetHostedZoneCommandOutput, Route53ClientResolvedConfig> {
     readonly input: GetHostedZoneCommandInput;
     constructor(input: GetHostedZoneCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetHostedZoneCommandInput, GetHostedZoneCommandOutput>;
     private serialize;
     private deserialize;