@aws-sdk/client-route53resolver 3.36.0 → 3.36.1

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

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

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

@@ -6,31 +6,11 @@ export interface PutFirewallRuleGroupPolicyCommandInput extends PutFirewallRuleG
 }
 export interface PutFirewallRuleGroupPolicyCommandOutput extends PutFirewallRuleGroupPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Attaches an Identity and Access Management (Amazon Web Services IAM) policy for sharing the 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, PutFirewallRuleGroupPolicyCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, PutFirewallRuleGroupPolicyCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new PutFirewallRuleGroupPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutFirewallRuleGroupPolicyCommandInput} for command's `input` shape.
- * @see {@link PutFirewallRuleGroupPolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutFirewallRuleGroupPolicyCommand extends $Command<PutFirewallRuleGroupPolicyCommandInput, PutFirewallRuleGroupPolicyCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: PutFirewallRuleGroupPolicyCommandInput;
     constructor(input: PutFirewallRuleGroupPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutFirewallRuleGroupPolicyCommandInput, PutFirewallRuleGroupPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface PutResolverQueryLogConfigPolicyCommandInput extends PutResolver
 }
 export interface PutResolverQueryLogConfigPolicyCommandOutput extends PutResolverQueryLogConfigPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Specifies an Amazon Web Services account that you want to share a query logging configuration with, the query logging configuration that you want to share,
- * 			and the operations that you want the account to be able to perform on the configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, PutResolverQueryLogConfigPolicyCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, PutResolverQueryLogConfigPolicyCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new PutResolverQueryLogConfigPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutResolverQueryLogConfigPolicyCommandInput} for command's `input` shape.
- * @see {@link PutResolverQueryLogConfigPolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutResolverQueryLogConfigPolicyCommand extends $Command<PutResolverQueryLogConfigPolicyCommandInput, PutResolverQueryLogConfigPolicyCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: PutResolverQueryLogConfigPolicyCommandInput;
     constructor(input: PutResolverQueryLogConfigPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResolverQueryLogConfigPolicyCommandInput, PutResolverQueryLogConfigPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface PutResolverRulePolicyCommandInput extends PutResolverRulePolicy
 }
 export interface PutResolverRulePolicyCommandOutput extends PutResolverRulePolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Specifies an Amazon Web Services rule that you want to share with another account, the account that you want to share the rule with,
- * 			and the operations that you want the account to be able to perform on the rule.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, PutResolverRulePolicyCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, PutResolverRulePolicyCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new PutResolverRulePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutResolverRulePolicyCommandInput} for command's `input` shape.
- * @see {@link PutResolverRulePolicyCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutResolverRulePolicyCommand extends $Command<PutResolverRulePolicyCommandInput, PutResolverRulePolicyCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: PutResolverRulePolicyCommandInput;
     constructor(input: PutResolverRulePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResolverRulePolicyCommandInput, PutResolverRulePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface UpdateResolverRuleCommandInput extends UpdateResolverRuleReques
 }
 export interface UpdateResolverRuleCommandOutput extends UpdateResolverRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Updates settings for a specified Resolver rule. <code>ResolverRuleId</code> is required, and all other parameters are optional.
- * 			If you don't specify a parameter, it retains its current value.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { Route53ResolverClient, UpdateResolverRuleCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
- * // const { Route53ResolverClient, UpdateResolverRuleCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
- * const client = new Route53ResolverClient(config);
- * const command = new UpdateResolverRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateResolverRuleCommandInput} for command's `input` shape.
- * @see {@link UpdateResolverRuleCommandOutput} for command's `response` shape.
- * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateResolverRuleCommand extends $Command<UpdateResolverRuleCommandInput, UpdateResolverRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: UpdateResolverRuleCommandInput;
     constructor(input: UpdateResolverRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateResolverRuleCommandInput, UpdateResolverRuleCommandOutput>;
     private serialize;
     private deserialize;