@aws-sdk/client-route53resolver 3.36.0 → 3.36.1

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

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

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

@@ -6,41 +6,11 @@ export interface DeleteResolverEndpointCommandInput extends DeleteResolverEndpoi
 }
 export interface DeleteResolverEndpointCommandOutput extends DeleteResolverEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a Resolver endpoint. The effect of deleting a Resolver endpoint depends on whether it's an inbound or an outbound
- * 			Resolver endpoint:</p>
- * 		       <ul>
- *             <li>
- *                <p>
- *                   <b>Inbound</b>: DNS queries from your network are no longer routed
- * 				to the DNS service for the specified VPC.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <b>Outbound</b>: DNS queries from a VPC are no longer routed to your network.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, DeleteResolverEndpointCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, DeleteResolverEndpointCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new DeleteResolverEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResolverEndpointCommandInput} for command's `input` shape.
- * @see {@link DeleteResolverEndpointCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteResolverEndpointCommand extends $Command<DeleteResolverEndpointCommandInput, DeleteResolverEndpointCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DeleteResolverEndpointCommandInput;
     constructor(input: DeleteResolverEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResolverEndpointCommandInput, DeleteResolverEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface DeleteResolverQueryLogConfigCommandInput extends DeleteResolver
 }
 export interface DeleteResolverQueryLogConfigCommandOutput extends DeleteResolverQueryLogConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a query logging configuration. When you delete a configuration, Resolver stops logging DNS queries for all of the Amazon VPCs that are
- * 			associated with the configuration. This also applies if the query logging configuration is shared with other Amazon Web Services accounts, and
- * 			the other accounts have associated VPCs with the shared configuration.</p>
- *
- * 		       <p>Before you can delete a query logging configuration, you must first disassociate all VPCs from the configuration. See
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_DisassociateResolverQueryLogConfig.html">DisassociateResolverQueryLogConfig</a>.</p>
- *
- * 		       <p>If you used Resource Access Manager (RAM) to share a query logging configuration with other accounts, you must stop sharing
- * 			the configuration before you can delete a configuration. The accounts that you shared the configuration with can first disassociate VPCs
- * 			that they associated with the configuration, but that's not necessary. If you stop sharing the configuration, those VPCs are automatically
- * 			disassociated from the configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, DeleteResolverQueryLogConfigCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, DeleteResolverQueryLogConfigCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new DeleteResolverQueryLogConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResolverQueryLogConfigCommandInput} for command's `input` shape.
- * @see {@link DeleteResolverQueryLogConfigCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteResolverQueryLogConfigCommand extends $Command<DeleteResolverQueryLogConfigCommandInput, DeleteResolverQueryLogConfigCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DeleteResolverQueryLogConfigCommandInput;
     constructor(input: DeleteResolverQueryLogConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResolverQueryLogConfigCommandInput, DeleteResolverQueryLogConfigCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteResolverRuleCommandInput extends DeleteResolverRuleReques
 }
 export interface DeleteResolverRuleCommandOutput extends DeleteResolverRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a Resolver rule. Before you can delete a Resolver rule, you must disassociate it from all the VPCs that you
- * 			associated the Resolver rule with. For more information, see
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_DisassociateResolverRule.html">DisassociateResolverRule</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, DeleteResolverRuleCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, DeleteResolverRuleCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new DeleteResolverRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResolverRuleCommandInput} for command's `input` shape.
- * @see {@link DeleteResolverRuleCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteResolverRuleCommand extends $Command<DeleteResolverRuleCommandInput, DeleteResolverRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DeleteResolverRuleCommandInput;
     constructor(input: DeleteResolverRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResolverRuleCommandInput, DeleteResolverRuleCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,33 +6,11 @@ export interface DisassociateResolverEndpointIpAddressCommandInput extends Disas
 }
 export interface DisassociateResolverEndpointIpAddressCommandOutput extends DisassociateResolverEndpointIpAddressResponse, __MetadataBearer {
 }
-/**
- * <p>Removes IP addresses from an inbound or an outbound Resolver endpoint. If you want to remove more than one IP address,
- * 			submit one <code>DisassociateResolverEndpointIpAddress</code> request for each IP address.</p>
- * 		       <p>To add an IP address to an endpoint, see
- * 			<a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_AssociateResolverEndpointIpAddress.html">AssociateResolverEndpointIpAddress</a>.
- * 		</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, DisassociateResolverEndpointIpAddressCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, DisassociateResolverEndpointIpAddressCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new DisassociateResolverEndpointIpAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateResolverEndpointIpAddressCommandInput} for command's `input` shape.
- * @see {@link DisassociateResolverEndpointIpAddressCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateResolverEndpointIpAddressCommand extends $Command<DisassociateResolverEndpointIpAddressCommandInput, DisassociateResolverEndpointIpAddressCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DisassociateResolverEndpointIpAddressCommandInput;
     constructor(input: DisassociateResolverEndpointIpAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateResolverEndpointIpAddressCommandInput, DisassociateResolverEndpointIpAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface DisassociateResolverQueryLogConfigCommandInput extends Disassoc
 }
 export interface DisassociateResolverQueryLogConfigCommandOutput extends DisassociateResolverQueryLogConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Disassociates a VPC from a query logging configuration.</p>
- *
- * 		       <note>
- * 			         <p>Before you can delete a query logging configuration, you must first disassociate all VPCs
- * 				from the configuration. If you used Resource Access Manager (RAM) to share a
- * 				query logging configuration with other accounts, VPCs can be disassociated from the
- * 				configuration in the following ways:</p>
- * 			         <ul>
- *                <li>
- *                   <p>The accounts that you shared the configuration with can disassociate VPCs from the configuration.</p>
- *                </li>
- *                <li>
- *                   <p>You can stop sharing the configuration.</p>
- *                </li>
- *             </ul>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, DisassociateResolverQueryLogConfigCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, DisassociateResolverQueryLogConfigCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new DisassociateResolverQueryLogConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateResolverQueryLogConfigCommandInput} for command's `input` shape.
- * @see {@link DisassociateResolverQueryLogConfigCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateResolverQueryLogConfigCommand extends $Command<DisassociateResolverQueryLogConfigCommandInput, DisassociateResolverQueryLogConfigCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DisassociateResolverQueryLogConfigCommandInput;
     constructor(input: DisassociateResolverQueryLogConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateResolverQueryLogConfigCommandInput, DisassociateResolverQueryLogConfigCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DisassociateResolverRuleCommandInput extends DisassociateResolv
 }
 export interface DisassociateResolverRuleCommandOutput extends DisassociateResolverRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Removes the association between a specified Resolver rule and a specified VPC.</p>
- * 		       <important>
- * 			         <p>If you disassociate a Resolver rule from a VPC, Resolver stops forwarding DNS queries for the
- * 				domain name that you specified in the Resolver rule. </p>
- * 		       </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, DisassociateResolverRuleCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, DisassociateResolverRuleCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new DisassociateResolverRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateResolverRuleCommandInput} for command's `input` shape.
- * @see {@link DisassociateResolverRuleCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateResolverRuleCommand extends $Command<DisassociateResolverRuleCommandInput, DisassociateResolverRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DisassociateResolverRuleCommandInput;
     constructor(input: DisassociateResolverRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateResolverRuleCommandInput, DisassociateResolverRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetFirewallConfigCommandInput extends GetFirewallConfigRequest
 }
 export interface GetFirewallConfigCommandOutput extends GetFirewallConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the configuration of the firewall behavior provided by DNS Firewall for a
- * 			single VPC from Amazon Virtual Private Cloud (Amazon VPC). </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetFirewallConfigCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetFirewallConfigCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetFirewallConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFirewallConfigCommandInput} for command's `input` shape.
- * @see {@link GetFirewallConfigCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFirewallConfigCommand extends $Command<GetFirewallConfigCommandInput, GetFirewallConfigCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetFirewallConfigCommandInput;
     constructor(input: GetFirewallConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFirewallConfigCommandInput, GetFirewallConfigCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface GetFirewallRuleGroupAssociationCommandInput extends GetFirewall
 }
 export interface GetFirewallRuleGroupAssociationCommandOutput extends GetFirewallRuleGroupAssociationResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves a firewall rule group association, which enables DNS filtering for a VPC with one rule group. A VPC can have more than one firewall rule group association, and a rule group can be associated with more than one VPC.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetFirewallRuleGroupAssociationCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetFirewallRuleGroupAssociationCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetFirewallRuleGroupAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFirewallRuleGroupAssociationCommandInput} for command's `input` shape.
- * @see {@link GetFirewallRuleGroupAssociationCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFirewallRuleGroupAssociationCommand extends $Command<GetFirewallRuleGroupAssociationCommandInput, GetFirewallRuleGroupAssociationCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetFirewallRuleGroupAssociationCommandInput;
     constructor(input: GetFirewallRuleGroupAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFirewallRuleGroupAssociationCommandInput, GetFirewallRuleGroupAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface GetFirewallRuleGroupPolicyCommandInput extends GetFirewallRuleG
 }
 export interface GetFirewallRuleGroupPolicyCommandOutput extends GetFirewallRuleGroupPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the Identity and Access Management (Amazon Web Services IAM) policy for sharing the
- *        	specified rule group. You can use the policy to share the rule group using Resource Access Manager (RAM). </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetFirewallRuleGroupPolicyCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetFirewallRuleGroupPolicyCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetFirewallRuleGroupPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFirewallRuleGroupPolicyCommandInput} for command's `input` shape.
- * @see {@link GetFirewallRuleGroupPolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFirewallRuleGroupPolicyCommand extends $Command<GetFirewallRuleGroupPolicyCommandInput, GetFirewallRuleGroupPolicyCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetFirewallRuleGroupPolicyCommandInput;
     constructor(input: GetFirewallRuleGroupPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFirewallRuleGroupPolicyCommandInput, GetFirewallRuleGroupPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface GetResolverEndpointCommandInput extends GetResolverEndpointRequ
 }
 export interface GetResolverEndpointCommandOutput extends GetResolverEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a specified Resolver endpoint, such as whether it's an inbound or an outbound Resolver endpoint, and the
- * 			current status of the endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverEndpointCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverEndpointCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverEndpointCommandInput} for command's `input` shape.
- * @see {@link GetResolverEndpointCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverEndpointCommand extends $Command<GetResolverEndpointCommandInput, GetResolverEndpointCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverEndpointCommandInput;
     constructor(input: GetResolverEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverEndpointCommandInput, GetResolverEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetResolverQueryLogConfigAssociationCommandInput extends GetRes
 }
 export interface GetResolverQueryLogConfigAssociationCommandOutput extends GetResolverQueryLogConfigAssociationResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a specified association between a Resolver query logging configuration and an Amazon VPC. When you associate a VPC
- * 			with a query logging configuration, Resolver logs DNS queries that originate in that VPC.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverQueryLogConfigAssociationCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverQueryLogConfigAssociationCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverQueryLogConfigAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverQueryLogConfigAssociationCommandInput} for command's `input` shape.
- * @see {@link GetResolverQueryLogConfigAssociationCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverQueryLogConfigAssociationCommand extends $Command<GetResolverQueryLogConfigAssociationCommandInput, GetResolverQueryLogConfigAssociationCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverQueryLogConfigAssociationCommandInput;
     constructor(input: GetResolverQueryLogConfigAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverQueryLogConfigAssociationCommandInput, GetResolverQueryLogConfigAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetResolverQueryLogConfigCommandInput extends GetResolverQueryL
 }
 export interface GetResolverQueryLogConfigCommandOutput extends GetResolverQueryLogConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a specified Resolver query logging configuration, such as the number of VPCs that the configuration
- * 			is logging queries for and the location that logs are sent to. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, GetResolverQueryLogConfigCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, GetResolverQueryLogConfigCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new GetResolverQueryLogConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverQueryLogConfigCommandInput} for command's `input` shape.
- * @see {@link GetResolverQueryLogConfigCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverQueryLogConfigCommand extends $Command<GetResolverQueryLogConfigCommandInput, GetResolverQueryLogConfigCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: GetResolverQueryLogConfigCommandInput;
     constructor(input: GetResolverQueryLogConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverQueryLogConfigCommandInput, GetResolverQueryLogConfigCommandOutput>;
     private serialize;
     private deserialize;