@aws-sdk/client-route53resolver 3.296.0 → 3.298.0

package/dist-types/commands/AssociateResolverEndpointIpAddressCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AssociateResolverEndpointIpAddressRequest, AssociateResolverEndpointIpAddressResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link AssociateResolverEndpointIpAddressCommand}.
  */
 export interface AssociateResolverEndpointIpAddressCommandInput extends AssociateResolverEndpointIpAddressRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateResolverEndpointIpAddressCommand}.
  */
 export interface AssociateResolverEndpointIpAddressCommandOutput extends AssociateResolverEndpointIpAddressResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds IP addresses to an inbound or an outbound Resolver endpoint. If you want to add more than one IP address,
  * 			submit one <code>AssociateResolverEndpointIpAddress</code> request for each IP address.</p>
  *          <p>To remove an IP address from an endpoint, see
@@ -29,6 +34,8 @@ export interface AssociateResolverEndpointIpAddressCommandOutput extends Associa
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateResolverEndpointIpAddressCommandInput - {@link AssociateResolverEndpointIpAddressCommandInput}
+ * @returns {@link AssociateResolverEndpointIpAddressCommandOutput}
  * @see {@link AssociateResolverEndpointIpAddressCommandInput} for command's `input` shape.
  * @see {@link AssociateResolverEndpointIpAddressCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -59,11 +66,20 @@ export interface AssociateResolverEndpointIpAddressCommandOutput extends Associa
 export declare class AssociateResolverEndpointIpAddressCommand extends $Command<AssociateResolverEndpointIpAddressCommandInput, AssociateResolverEndpointIpAddressCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: AssociateResolverEndpointIpAddressCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateResolverEndpointIpAddressCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateResolverEndpointIpAddressCommandInput, AssociateResolverEndpointIpAddressCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/AssociateResolverQueryLogConfigCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AssociateResolverQueryLogConfigRequest, AssociateResolverQueryLogConfigResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link AssociateResolverQueryLogConfigCommand}.
  */
 export interface AssociateResolverQueryLogConfigCommandInput extends AssociateResolverQueryLogConfigRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateResolverQueryLogConfigCommand}.
  */
 export interface AssociateResolverQueryLogConfigCommandOutput extends AssociateResolverQueryLogConfigResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates an Amazon VPC with a specified query logging configuration. Route 53 Resolver logs DNS queries that originate in all of the Amazon VPCs
  * 			that are associated with a specified query logging configuration. To associate more than one VPC with a configuration, submit one <code>AssociateResolverQueryLogConfig</code>
  * 			request for each VPC.</p>
@@ -33,6 +38,8 @@ export interface AssociateResolverQueryLogConfigCommandOutput extends AssociateR
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateResolverQueryLogConfigCommandInput - {@link AssociateResolverQueryLogConfigCommandInput}
+ * @returns {@link AssociateResolverQueryLogConfigCommandOutput}
  * @see {@link AssociateResolverQueryLogConfigCommandInput} for command's `input` shape.
  * @see {@link AssociateResolverQueryLogConfigCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -66,11 +73,20 @@ export interface AssociateResolverQueryLogConfigCommandOutput extends AssociateR
 export declare class AssociateResolverQueryLogConfigCommand extends $Command<AssociateResolverQueryLogConfigCommandInput, AssociateResolverQueryLogConfigCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: AssociateResolverQueryLogConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateResolverQueryLogConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateResolverQueryLogConfigCommandInput, AssociateResolverQueryLogConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/AssociateResolverRuleCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AssociateResolverRuleRequest, AssociateResolverRuleResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link AssociateResolverRuleCommand}.
  */
 export interface AssociateResolverRuleCommandInput extends AssociateResolverRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateResolverRuleCommand}.
  */
 export interface AssociateResolverRuleCommandOutput extends AssociateResolverRuleResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates a Resolver rule with a VPC. When you associate a rule with a VPC, Resolver forwards all DNS queries
  * 			for the domain name that is specified in the rule and that originate in the VPC. The queries are forwarded to the
  * 			IP addresses for the DNS resolvers that are specified in the rule. For more information about rules, see
@@ -28,6 +33,8 @@ export interface AssociateResolverRuleCommandOutput extends AssociateResolverRul
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateResolverRuleCommandInput - {@link AssociateResolverRuleCommandInput}
+ * @returns {@link AssociateResolverRuleCommandOutput}
  * @see {@link AssociateResolverRuleCommandInput} for command's `input` shape.
  * @see {@link AssociateResolverRuleCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -61,11 +68,20 @@ export interface AssociateResolverRuleCommandOutput extends AssociateResolverRul
 export declare class AssociateResolverRuleCommand extends $Command<AssociateResolverRuleCommandInput, AssociateResolverRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: AssociateResolverRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateResolverRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateResolverRuleCommandInput, AssociateResolverRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateFirewallDomainListCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateFirewallDomainListRequest, CreateFirewallDomainListResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link CreateFirewallDomainListCommand}.
  */
 export interface CreateFirewallDomainListCommandInput extends CreateFirewallDomainListRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFirewallDomainListCommand}.
  */
 export interface CreateFirewallDomainListCommandOutput extends CreateFirewallDomainListResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an empty firewall domain list for use in DNS Firewall rules. You can populate the domains for the new list with a file, using <a>ImportFirewallDomains</a>, or with domain strings, using <a>UpdateFirewallDomains</a>. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateFirewallDomainListCommandOutput extends CreateFirewallDom
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFirewallDomainListCommandInput - {@link CreateFirewallDomainListCommandInput}
+ * @returns {@link CreateFirewallDomainListCommandOutput}
  * @see {@link CreateFirewallDomainListCommandInput} for command's `input` shape.
  * @see {@link CreateFirewallDomainListCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -50,11 +57,20 @@ export interface CreateFirewallDomainListCommandOutput extends CreateFirewallDom
 export declare class CreateFirewallDomainListCommand extends $Command<CreateFirewallDomainListCommandInput, CreateFirewallDomainListCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: CreateFirewallDomainListCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFirewallDomainListCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFirewallDomainListCommandInput, CreateFirewallDomainListCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateFirewallRuleCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateFirewallRuleRequest, CreateFirewallRuleResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link CreateFirewallRuleCommand}.
  */
 export interface CreateFirewallRuleCommandInput extends CreateFirewallRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFirewallRuleCommand}.
  */
 export interface CreateFirewallRuleCommandOutput extends CreateFirewallRuleResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a single DNS Firewall rule in the specified rule group, using the specified domain list.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateFirewallRuleCommandOutput extends CreateFirewallRuleRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFirewallRuleCommandInput - {@link CreateFirewallRuleCommandInput}
+ * @returns {@link CreateFirewallRuleCommandOutput}
  * @see {@link CreateFirewallRuleCommandInput} for command's `input` shape.
  * @see {@link CreateFirewallRuleCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateFirewallRuleCommandOutput extends CreateFirewallRuleRespo
 export declare class CreateFirewallRuleCommand extends $Command<CreateFirewallRuleCommandInput, CreateFirewallRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: CreateFirewallRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFirewallRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFirewallRuleCommandInput, CreateFirewallRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateFirewallRuleGroupCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateFirewallRuleGroupRequest, CreateFirewallRuleGroupResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link CreateFirewallRuleGroupCommand}.
  */
 export interface CreateFirewallRuleGroupCommandInput extends CreateFirewallRuleGroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFirewallRuleGroupCommand}.
  */
 export interface CreateFirewallRuleGroupCommandOutput extends CreateFirewallRuleGroupResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an empty DNS Firewall rule group for filtering DNS network traffic in a VPC. You can add rules to the new rule group
  *            by calling <a>CreateFirewallRule</a>. </p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateFirewallRuleGroupCommandOutput extends CreateFirewallRule
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFirewallRuleGroupCommandInput - {@link CreateFirewallRuleGroupCommandInput}
+ * @returns {@link CreateFirewallRuleGroupCommandOutput}
  * @see {@link CreateFirewallRuleGroupCommandInput} for command's `input` shape.
  * @see {@link CreateFirewallRuleGroupCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -51,11 +58,20 @@ export interface CreateFirewallRuleGroupCommandOutput extends CreateFirewallRule
 export declare class CreateFirewallRuleGroupCommand extends $Command<CreateFirewallRuleGroupCommandInput, CreateFirewallRuleGroupCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: CreateFirewallRuleGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFirewallRuleGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFirewallRuleGroupCommandInput, CreateFirewallRuleGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateResolverEndpointCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateResolverEndpointRequest, CreateResolverEndpointResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link CreateResolverEndpointCommand}.
  */
 export interface CreateResolverEndpointCommandInput extends CreateResolverEndpointRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateResolverEndpointCommand}.
  */
 export interface CreateResolverEndpointCommandOutput extends CreateResolverEndpointResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Resolver endpoint. There are two types of Resolver endpoints, inbound and outbound:</p>
  *          <ul>
  *             <li>
@@ -35,6 +40,8 @@ export interface CreateResolverEndpointCommandOutput extends CreateResolverEndpo
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateResolverEndpointCommandInput - {@link CreateResolverEndpointCommandInput}
+ * @returns {@link CreateResolverEndpointCommandOutput}
  * @see {@link CreateResolverEndpointCommandInput} for command's `input` shape.
  * @see {@link CreateResolverEndpointCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -65,11 +72,20 @@ export interface CreateResolverEndpointCommandOutput extends CreateResolverEndpo
 export declare class CreateResolverEndpointCommand extends $Command<CreateResolverEndpointCommandInput, CreateResolverEndpointCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: CreateResolverEndpointCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateResolverEndpointCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResolverEndpointCommandInput, CreateResolverEndpointCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateResolverQueryLogConfigCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateResolverQueryLogConfigRequest, CreateResolverQueryLogConfigResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link CreateResolverQueryLogConfigCommand}.
  */
 export interface CreateResolverQueryLogConfigCommandInput extends CreateResolverQueryLogConfigRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateResolverQueryLogConfigCommand}.
  */
 export interface CreateResolverQueryLogConfigCommandOutput extends CreateResolverQueryLogConfigResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Resolver query logging configuration, which defines where you want Resolver to save DNS query logs that originate in your VPCs.
  * 			Resolver can log queries only for VPCs that are in the same Region as the query logging configuration.</p>
  *          <p>To specify which VPCs you want to log queries for, you use <code>AssociateResolverQueryLogConfig</code>. For more information, see
@@ -31,6 +36,8 @@ export interface CreateResolverQueryLogConfigCommandOutput extends CreateResolve
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateResolverQueryLogConfigCommandInput - {@link CreateResolverQueryLogConfigCommandInput}
+ * @returns {@link CreateResolverQueryLogConfigCommandOutput}
  * @see {@link CreateResolverQueryLogConfigCommandInput} for command's `input` shape.
  * @see {@link CreateResolverQueryLogConfigCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -64,11 +71,20 @@ export interface CreateResolverQueryLogConfigCommandOutput extends CreateResolve
 export declare class CreateResolverQueryLogConfigCommand extends $Command<CreateResolverQueryLogConfigCommandInput, CreateResolverQueryLogConfigCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: CreateResolverQueryLogConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateResolverQueryLogConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResolverQueryLogConfigCommandInput, CreateResolverQueryLogConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateResolverRuleCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateResolverRuleRequest, CreateResolverRuleResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link CreateResolverRuleCommand}.
  */
 export interface CreateResolverRuleCommandInput extends CreateResolverRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateResolverRuleCommand}.
  */
 export interface CreateResolverRuleCommandOutput extends CreateResolverRuleResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>For DNS queries that originate in your VPCs, specifies which Resolver endpoint the queries pass through,
  * 			one domain name that you want to forward to your network, and the IP addresses of the DNS resolvers in your network.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateResolverRuleCommandOutput extends CreateResolverRuleRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateResolverRuleCommandInput - {@link CreateResolverRuleCommandInput}
+ * @returns {@link CreateResolverRuleCommandOutput}
  * @see {@link CreateResolverRuleCommandInput} for command's `input` shape.
  * @see {@link CreateResolverRuleCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -59,11 +66,20 @@ export interface CreateResolverRuleCommandOutput extends CreateResolverRuleRespo
 export declare class CreateResolverRuleCommand extends $Command<CreateResolverRuleCommandInput, CreateResolverRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: CreateResolverRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateResolverRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResolverRuleCommandInput, CreateResolverRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteFirewallDomainListCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteFirewallDomainListRequest, DeleteFirewallDomainListResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteFirewallDomainListCommand}.
  */
 export interface DeleteFirewallDomainListCommandInput extends DeleteFirewallDomainListRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteFirewallDomainListCommand}.
  */
 export interface DeleteFirewallDomainListCommandOutput extends DeleteFirewallDomainListResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified domain list. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteFirewallDomainListCommandOutput extends DeleteFirewallDom
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteFirewallDomainListCommandInput - {@link DeleteFirewallDomainListCommandInput}
+ * @returns {@link DeleteFirewallDomainListCommandOutput}
  * @see {@link DeleteFirewallDomainListCommandInput} for command's `input` shape.
  * @see {@link DeleteFirewallDomainListCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -51,11 +58,20 @@ export interface DeleteFirewallDomainListCommandOutput extends DeleteFirewallDom
 export declare class DeleteFirewallDomainListCommand extends $Command<DeleteFirewallDomainListCommandInput, DeleteFirewallDomainListCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DeleteFirewallDomainListCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteFirewallDomainListCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFirewallDomainListCommandInput, DeleteFirewallDomainListCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteFirewallRuleCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteFirewallRuleRequest, DeleteFirewallRuleResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteFirewallRuleCommand}.
  */
 export interface DeleteFirewallRuleCommandInput extends DeleteFirewallRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteFirewallRuleCommand}.
  */
 export interface DeleteFirewallRuleCommandOutput extends DeleteFirewallRuleResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified firewall rule.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteFirewallRuleCommandOutput extends DeleteFirewallRuleRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteFirewallRuleCommandInput - {@link DeleteFirewallRuleCommandInput}
+ * @returns {@link DeleteFirewallRuleCommandOutput}
  * @see {@link DeleteFirewallRuleCommandInput} for command's `input` shape.
  * @see {@link DeleteFirewallRuleCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteFirewallRuleCommandOutput extends DeleteFirewallRuleRespo
 export declare class DeleteFirewallRuleCommand extends $Command<DeleteFirewallRuleCommandInput, DeleteFirewallRuleCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DeleteFirewallRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteFirewallRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFirewallRuleCommandInput, DeleteFirewallRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteFirewallRuleGroupRequest, DeleteFirewallRuleGroupResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteFirewallRuleGroupCommand}.
  */
 export interface DeleteFirewallRuleGroupCommandInput extends DeleteFirewallRuleGroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteFirewallRuleGroupCommand}.
  */
 export interface DeleteFirewallRuleGroupCommandOutput extends DeleteFirewallRuleGroupResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified firewall rule group. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteFirewallRuleGroupCommandOutput extends DeleteFirewallRule
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteFirewallRuleGroupCommandInput - {@link DeleteFirewallRuleGroupCommandInput}
+ * @returns {@link DeleteFirewallRuleGroupCommandOutput}
  * @see {@link DeleteFirewallRuleGroupCommandInput} for command's `input` shape.
  * @see {@link DeleteFirewallRuleGroupCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -55,11 +62,20 @@ export interface DeleteFirewallRuleGroupCommandOutput extends DeleteFirewallRule
 export declare class DeleteFirewallRuleGroupCommand extends $Command<DeleteFirewallRuleGroupCommandInput, DeleteFirewallRuleGroupCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: DeleteFirewallRuleGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteFirewallRuleGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFirewallRuleGroupCommandInput, DeleteFirewallRuleGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }