@aws-sdk/client-route53resolver 3.36.0 → 3.36.1

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

@@ -6,30 +6,11 @@ export interface GetResolverQueryLogConfigPolicyCommandInput extends GetResolver
 }
 export interface GetResolverQueryLogConfigPolicyCommandOutput extends GetResolverQueryLogConfigPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a query logging policy. A query logging policy specifies the Resolver query logging
- * 			operations and resources that you want to allow another Amazon Web Services account to be able to use.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverQueryLogConfigPolicyCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverQueryLogConfigPolicyCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverQueryLogConfigPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverQueryLogConfigPolicyCommandInput} for command's `input` shape.
- * @see {@link GetResolverQueryLogConfigPolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverQueryLogConfigPolicyCommand extends $Command<GetResolverQueryLogConfigPolicyCommandInput, GetResolverQueryLogConfigPolicyCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverQueryLogConfigPolicyCommandInput;
     constructor(input: GetResolverQueryLogConfigPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverQueryLogConfigPolicyCommandInput, GetResolverQueryLogConfigPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetResolverRuleAssociationCommandInput extends GetResolverRuleA
 }
 export interface GetResolverRuleAssociationCommandOutput extends GetResolverRuleAssociationResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about an association between a specified Resolver rule and a VPC. You associate a Resolver rule and a VPC using
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_AssociateResolverRule.html">AssociateResolverRule</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverRuleAssociationCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverRuleAssociationCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverRuleAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverRuleAssociationCommandInput} for command's `input` shape.
- * @see {@link GetResolverRuleAssociationCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverRuleAssociationCommand extends $Command<GetResolverRuleAssociationCommandInput, GetResolverRuleAssociationCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverRuleAssociationCommandInput;
     constructor(input: GetResolverRuleAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverRuleAssociationCommandInput, GetResolverRuleAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetResolverRuleCommandInput extends GetResolverRuleRequest {
 }
 export interface GetResolverRuleCommandOutput extends GetResolverRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a specified Resolver rule, such as the domain name that the rule forwards DNS queries for and the ID of the
- * 			outbound Resolver endpoint that the rule is associated with.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverRuleCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverRuleCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverRuleCommandInput} for command's `input` shape.
- * @see {@link GetResolverRuleCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverRuleCommand extends $Command<GetResolverRuleCommandInput, GetResolverRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverRuleCommandInput;
     constructor(input: GetResolverRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverRuleCommandInput, GetResolverRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetResolverRulePolicyCommandInput extends GetResolverRulePolicy
 }
 export interface GetResolverRulePolicyCommandOutput extends GetResolverRulePolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about the Resolver rule policy for a specified rule. A Resolver rule policy includes the rule that you want to share
- * 			with another account, the account that you want to share the rule with, and the Resolver operations that you want to allow the account to use. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverRulePolicyCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverRulePolicyCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverRulePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverRulePolicyCommandInput} for command's `input` shape.
- * @see {@link GetResolverRulePolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverRulePolicyCommand extends $Command<GetResolverRulePolicyCommandInput, GetResolverRulePolicyCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverRulePolicyCommandInput;
     constructor(input: GetResolverRulePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverRulePolicyCommandInput, GetResolverRulePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface ImportFirewallDomainsCommandInput extends ImportFirewallDomains
 }
 export interface ImportFirewallDomainsCommandOutput extends ImportFirewallDomainsResponse, __MetadataBearer {
 }
-/**
- * <p>Imports domain names from a file into a domain list, for use in a DNS firewall rule group. </p>
- *          <p>Each domain specification in your domain list must satisfy the following
- * 	requirements: </p>
- *          <ul>
- *             <li>
- *       	        <p>It can optionally start with <code>*</code> (asterisk).</p>
- *       	     </li>
- *             <li>
- *       	        <p>With the exception of the optional starting asterisk, it must only contain
- *       	   the following characters: <code>A-Z</code>, <code>a-z</code>,
- *       	   <code>0-9</code>, <code>-</code> (hyphen).</p>
- *       	     </li>
- *             <li>
- *       	        <p>It must be from 1-255 characters in length. </p>
- *       	     </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ImportFirewallDomainsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ImportFirewallDomainsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ImportFirewallDomainsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportFirewallDomainsCommandInput} for command's `input` shape.
- * @see {@link ImportFirewallDomainsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportFirewallDomainsCommand extends $Command<ImportFirewallDomainsCommandInput, ImportFirewallDomainsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ImportFirewallDomainsCommandInput;
     constructor(input: ImportFirewallDomainsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportFirewallDomainsCommandInput, ImportFirewallDomainsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFirewallConfigsCommandInput extends ListFirewallConfigsRequ
 }
 export interface ListFirewallConfigsCommandOutput extends ListFirewallConfigsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the firewall configurations that you have defined. DNS Firewall uses the configurations to manage firewall behavior for your VPCs. </p>
- *          <p>A single call might return only a partial list of the configurations. For information, see <code>MaxResults</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListFirewallConfigsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListFirewallConfigsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListFirewallConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFirewallConfigsCommandInput} for command's `input` shape.
- * @see {@link ListFirewallConfigsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFirewallConfigsCommand extends $Command<ListFirewallConfigsCommandInput, ListFirewallConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallConfigsCommandInput;
     constructor(input: ListFirewallConfigsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallConfigsCommandInput, ListFirewallConfigsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFirewallDomainListsCommandInput extends ListFirewallDomainL
 }
 export interface ListFirewallDomainListsCommandOutput extends ListFirewallDomainListsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the firewall domain lists that you have defined. For each firewall domain list, you can retrieve the domains that are defined for a list by calling <a>ListFirewallDomains</a>. </p>
- *          <p>A single call to this list operation might return only a partial list of the domain lists. For information, see <code>MaxResults</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListFirewallDomainListsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListFirewallDomainListsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListFirewallDomainListsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFirewallDomainListsCommandInput} for command's `input` shape.
- * @see {@link ListFirewallDomainListsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFirewallDomainListsCommand extends $Command<ListFirewallDomainListsCommandInput, ListFirewallDomainListsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallDomainListsCommandInput;
     constructor(input: ListFirewallDomainListsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallDomainListsCommandInput, ListFirewallDomainListsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFirewallDomainsCommandInput extends ListFirewallDomainsRequ
 }
 export interface ListFirewallDomainsCommandOutput extends ListFirewallDomainsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the domains that you have defined for the specified firewall domain list.  </p>
- *          <p>A single call might return only a partial list of the domains. For information, see <code>MaxResults</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListFirewallDomainsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListFirewallDomainsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListFirewallDomainsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFirewallDomainsCommandInput} for command's `input` shape.
- * @see {@link ListFirewallDomainsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFirewallDomainsCommand extends $Command<ListFirewallDomainsCommandInput, ListFirewallDomainsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallDomainsCommandInput;
     constructor(input: ListFirewallDomainsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallDomainsCommandInput, ListFirewallDomainsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFirewallRuleGroupAssociationsCommandInput extends ListFirew
 }
 export interface ListFirewallRuleGroupAssociationsCommandOutput extends ListFirewallRuleGroupAssociationsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the firewall rule group associations that you have defined. Each association enables DNS filtering for a VPC with one rule group. </p>
- *          <p>A single call might return only a partial list of the associations. For information, see <code>MaxResults</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListFirewallRuleGroupAssociationsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListFirewallRuleGroupAssociationsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListFirewallRuleGroupAssociationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFirewallRuleGroupAssociationsCommandInput} for command's `input` shape.
- * @see {@link ListFirewallRuleGroupAssociationsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFirewallRuleGroupAssociationsCommand extends $Command<ListFirewallRuleGroupAssociationsCommandInput, ListFirewallRuleGroupAssociationsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallRuleGroupAssociationsCommandInput;
     constructor(input: ListFirewallRuleGroupAssociationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallRuleGroupAssociationsCommandInput, ListFirewallRuleGroupAssociationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFirewallRuleGroupsCommandInput extends ListFirewallRuleGrou
 }
 export interface ListFirewallRuleGroupsCommandOutput extends ListFirewallRuleGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the minimal high-level information for the rule groups that you have defined.  </p>
- *          <p>A single call might return only a partial list of the rule groups. For information, see <code>MaxResults</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListFirewallRuleGroupsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListFirewallRuleGroupsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListFirewallRuleGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFirewallRuleGroupsCommandInput} for command's `input` shape.
- * @see {@link ListFirewallRuleGroupsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFirewallRuleGroupsCommand extends $Command<ListFirewallRuleGroupsCommandInput, ListFirewallRuleGroupsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallRuleGroupsCommandInput;
     constructor(input: ListFirewallRuleGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallRuleGroupsCommandInput, ListFirewallRuleGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFirewallRulesCommandInput extends ListFirewallRulesRequest
 }
 export interface ListFirewallRulesCommandOutput extends ListFirewallRulesResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the firewall rules that you have defined for the specified firewall rule group. DNS Firewall uses the rules in a rule group to filter DNS network traffic for a VPC. </p>
- *          <p>A single call might return only a partial list of the rules. For information, see <code>MaxResults</code>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListFirewallRulesCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListFirewallRulesCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListFirewallRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFirewallRulesCommandInput} for command's `input` shape.
- * @see {@link ListFirewallRulesCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFirewallRulesCommand extends $Command<ListFirewallRulesCommandInput, ListFirewallRulesCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallRulesCommandInput;
     constructor(input: ListFirewallRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallRulesCommandInput, ListFirewallRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolverDnssecConfigsCommandInput extends ListResolverDnsse
 }
 export interface ListResolverDnssecConfigsCommandOutput extends ListResolverDnssecConfigsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the configurations for DNSSEC validation 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 { Route53ResolverClient, ListResolverDnssecConfigsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverDnssecConfigsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverDnssecConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverDnssecConfigsCommandInput} for command's `input` shape.
- * @see {@link ListResolverDnssecConfigsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverDnssecConfigsCommand extends $Command<ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverDnssecConfigsCommandInput;
     constructor(input: ListResolverDnssecConfigsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolverEndpointIpAddressesCommandInput extends ListResolve
 }
 export interface ListResolverEndpointIpAddressesCommandOutput extends ListResolverEndpointIpAddressesResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the IP addresses for a specified Resolver endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListResolverEndpointIpAddressesCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverEndpointIpAddressesCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverEndpointIpAddressesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverEndpointIpAddressesCommandInput} for command's `input` shape.
- * @see {@link ListResolverEndpointIpAddressesCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverEndpointIpAddressesCommand extends $Command<ListResolverEndpointIpAddressesCommandInput, ListResolverEndpointIpAddressesCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverEndpointIpAddressesCommandInput;
     constructor(input: ListResolverEndpointIpAddressesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverEndpointIpAddressesCommandInput, ListResolverEndpointIpAddressesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolverEndpointsCommandInput extends ListResolverEndpoints
 }
 export interface ListResolverEndpointsCommandOutput extends ListResolverEndpointsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all the Resolver endpoints that were created using 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 { Route53ResolverClient, ListResolverEndpointsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverEndpointsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverEndpointsCommandInput} for command's `input` shape.
- * @see {@link ListResolverEndpointsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverEndpointsCommand extends $Command<ListResolverEndpointsCommandInput, ListResolverEndpointsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverEndpointsCommandInput;
     constructor(input: ListResolverEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverEndpointsCommandInput, ListResolverEndpointsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolverQueryLogConfigAssociationsCommandInput extends List
 }
 export interface ListResolverQueryLogConfigAssociationsCommandOutput extends ListResolverQueryLogConfigAssociationsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists information about associations between Amazon VPCs and query logging configurations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListResolverQueryLogConfigAssociationsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverQueryLogConfigAssociationsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverQueryLogConfigAssociationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverQueryLogConfigAssociationsCommandInput} for command's `input` shape.
- * @see {@link ListResolverQueryLogConfigAssociationsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverQueryLogConfigAssociationsCommand extends $Command<ListResolverQueryLogConfigAssociationsCommandInput, ListResolverQueryLogConfigAssociationsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverQueryLogConfigAssociationsCommandInput;
     constructor(input: ListResolverQueryLogConfigAssociationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverQueryLogConfigAssociationsCommandInput, ListResolverQueryLogConfigAssociationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListResolverQueryLogConfigsCommandInput extends ListResolverQue
 }
 export interface ListResolverQueryLogConfigsCommandOutput extends ListResolverQueryLogConfigsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists information about the specified query logging configurations. Each configuration defines where you want Resolver to save
- * 			DNS query logs and specifies the VPCs that you want to log queries for.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, ListResolverQueryLogConfigsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverQueryLogConfigsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverQueryLogConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverQueryLogConfigsCommandInput} for command's `input` shape.
- * @see {@link ListResolverQueryLogConfigsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverQueryLogConfigsCommand extends $Command<ListResolverQueryLogConfigsCommandInput, ListResolverQueryLogConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverQueryLogConfigsCommandInput;
     constructor(input: ListResolverQueryLogConfigsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverQueryLogConfigsCommandInput, ListResolverQueryLogConfigsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolverRuleAssociationsCommandInput extends ListResolverRu
 }
 export interface ListResolverRuleAssociationsCommandOutput extends ListResolverRuleAssociationsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the associations that were created between Resolver rules and VPCs using 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 { Route53ResolverClient, ListResolverRuleAssociationsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverRuleAssociationsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverRuleAssociationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverRuleAssociationsCommandInput} for command's `input` shape.
- * @see {@link ListResolverRuleAssociationsCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverRuleAssociationsCommand extends $Command<ListResolverRuleAssociationsCommandInput, ListResolverRuleAssociationsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverRuleAssociationsCommandInput;
     constructor(input: ListResolverRuleAssociationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverRuleAssociationsCommandInput, ListResolverRuleAssociationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolverRulesCommandInput extends ListResolverRulesRequest
 }
 export interface ListResolverRulesCommandOutput extends ListResolverRulesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the Resolver rules that were created using 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 { Route53ResolverClient, ListResolverRulesCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, ListResolverRulesCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new ListResolverRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolverRulesCommandInput} for command's `input` shape.
- * @see {@link ListResolverRulesCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolverRulesCommand extends $Command<ListResolverRulesCommandInput, ListResolverRulesCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverRulesCommandInput;
     constructor(input: ListResolverRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverRulesCommandInput, ListResolverRulesCommandOutput>;
     private serialize;
     private deserialize;