@aws-sdk/client-route53resolver 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListFirewallDomainsRequest, ListFirewallDomainsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListFirewallDomainsCommand}.
  */
 export interface ListFirewallDomainsCommandInput extends ListFirewallDomainsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListFirewallDomainsCommand}.
  */
 export interface ListFirewallDomainsCommandOutput extends ListFirewallDomainsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ListFirewallDomainsCommandOutput extends ListFirewallDomainsRes
  * const response = await client.send(command);
  * ```
  *
+ * @param ListFirewallDomainsCommandInput - {@link ListFirewallDomainsCommandInput}
+ * @returns {@link ListFirewallDomainsCommandOutput}
  * @see {@link ListFirewallDomainsCommandInput} for command's `input` shape.
  * @see {@link ListFirewallDomainsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -51,11 +58,20 @@ export interface ListFirewallDomainsCommandOutput extends ListFirewallDomainsRes
 export declare class ListFirewallDomainsCommand extends $Command<ListFirewallDomainsCommandInput, ListFirewallDomainsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallDomainsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListFirewallDomainsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallDomainsCommandInput, ListFirewallDomainsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListFirewallRuleGroupAssociationsRequest, ListFirewallRuleGroupAssociationsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListFirewallRuleGroupAssociationsCommand}.
  */
 export interface ListFirewallRuleGroupAssociationsCommandInput extends ListFirewallRuleGroupAssociationsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListFirewallRuleGroupAssociationsCommand}.
  */
 export interface ListFirewallRuleGroupAssociationsCommandOutput extends ListFirewallRuleGroupAssociationsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ListFirewallRuleGroupAssociationsCommandOutput extends ListFire
  * const response = await client.send(command);
  * ```
  *
+ * @param ListFirewallRuleGroupAssociationsCommandInput - {@link ListFirewallRuleGroupAssociationsCommandInput}
+ * @returns {@link ListFirewallRuleGroupAssociationsCommandOutput}
  * @see {@link ListFirewallRuleGroupAssociationsCommandInput} for command's `input` shape.
  * @see {@link ListFirewallRuleGroupAssociationsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -48,11 +55,20 @@ export interface ListFirewallRuleGroupAssociationsCommandOutput extends ListFire
 export declare class ListFirewallRuleGroupAssociationsCommand extends $Command<ListFirewallRuleGroupAssociationsCommandInput, ListFirewallRuleGroupAssociationsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallRuleGroupAssociationsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListFirewallRuleGroupAssociationsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallRuleGroupAssociationsCommandInput, ListFirewallRuleGroupAssociationsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListFirewallRuleGroupsRequest, ListFirewallRuleGroupsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListFirewallRuleGroupsCommand}.
  */
 export interface ListFirewallRuleGroupsCommandInput extends ListFirewallRuleGroupsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListFirewallRuleGroupsCommand}.
  */
 export interface ListFirewallRuleGroupsCommandOutput extends ListFirewallRuleGroupsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ListFirewallRuleGroupsCommandOutput extends ListFirewallRuleGro
  * const response = await client.send(command);
  * ```
  *
+ * @param ListFirewallRuleGroupsCommandInput - {@link ListFirewallRuleGroupsCommandInput}
+ * @returns {@link ListFirewallRuleGroupsCommandOutput}
  * @see {@link ListFirewallRuleGroupsCommandInput} for command's `input` shape.
  * @see {@link ListFirewallRuleGroupsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -48,11 +55,20 @@ export interface ListFirewallRuleGroupsCommandOutput extends ListFirewallRuleGro
 export declare class ListFirewallRuleGroupsCommand extends $Command<ListFirewallRuleGroupsCommandInput, ListFirewallRuleGroupsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallRuleGroupsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListFirewallRuleGroupsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallRuleGroupsCommandInput, ListFirewallRuleGroupsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListFirewallRulesRequest, ListFirewallRulesResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListFirewallRulesCommand}.
  */
 export interface ListFirewallRulesCommandInput extends ListFirewallRulesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListFirewallRulesCommand}.
  */
 export interface ListFirewallRulesCommandOutput extends ListFirewallRulesResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ListFirewallRulesCommandOutput extends ListFirewallRulesRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param ListFirewallRulesCommandInput - {@link ListFirewallRulesCommandInput}
+ * @returns {@link ListFirewallRulesCommandOutput}
  * @see {@link ListFirewallRulesCommandInput} for command's `input` shape.
  * @see {@link ListFirewallRulesCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -51,11 +58,20 @@ export interface ListFirewallRulesCommandOutput extends ListFirewallRulesRespons
 export declare class ListFirewallRulesCommand extends $Command<ListFirewallRulesCommandInput, ListFirewallRulesCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListFirewallRulesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListFirewallRulesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFirewallRulesCommandInput, ListFirewallRulesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverConfigsRequest, ListResolverConfigsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverConfigsCommand}.
  */
 export interface ListResolverConfigsCommandInput extends ListResolverConfigsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverConfigsCommand}.
  */
 export interface ListResolverConfigsCommandOutput extends ListResolverConfigsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Retrieves the Resolver configurations that you have defined.
  * 			Route 53 Resolver uses the configurations to manage DNS resolution behavior for your VPCs.</p>
  * @example
@@ -26,6 +31,8 @@ export interface ListResolverConfigsCommandOutput extends ListResolverConfigsRes
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverConfigsCommandInput - {@link ListResolverConfigsCommandInput}
+ * @returns {@link ListResolverConfigsCommandOutput}
  * @see {@link ListResolverConfigsCommandInput} for command's `input` shape.
  * @see {@link ListResolverConfigsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -57,11 +64,20 @@ export interface ListResolverConfigsCommandOutput extends ListResolverConfigsRes
 export declare class ListResolverConfigsCommand extends $Command<ListResolverConfigsCommandInput, ListResolverConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverConfigsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverConfigsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverConfigsCommandInput, ListResolverConfigsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverDnssecConfigsRequest, ListResolverDnssecConfigsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverDnssecConfigsCommand}.
  */
 export interface ListResolverDnssecConfigsCommandInput extends ListResolverDnssecConfigsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverDnssecConfigsCommand}.
  */
 export interface ListResolverDnssecConfigsCommandOutput extends ListResolverDnssecConfigsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ListResolverDnssecConfigsCommandOutput extends ListResolverDnss
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverDnssecConfigsCommandInput - {@link ListResolverDnssecConfigsCommandInput}
+ * @returns {@link ListResolverDnssecConfigsCommandOutput}
  * @see {@link ListResolverDnssecConfigsCommandInput} for command's `input` shape.
  * @see {@link ListResolverDnssecConfigsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -52,11 +59,20 @@ export interface ListResolverDnssecConfigsCommandOutput extends ListResolverDnss
 export declare class ListResolverDnssecConfigsCommand extends $Command<ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverDnssecConfigsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverDnssecConfigsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverEndpointIpAddressesRequest, ListResolverEndpointIpAddressesResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverEndpointIpAddressesCommand}.
  */
 export interface ListResolverEndpointIpAddressesCommandInput extends ListResolverEndpointIpAddressesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverEndpointIpAddressesCommand}.
  */
 export interface ListResolverEndpointIpAddressesCommandOutput extends ListResolverEndpointIpAddressesResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ListResolverEndpointIpAddressesCommandOutput extends ListResolv
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverEndpointIpAddressesCommandInput - {@link ListResolverEndpointIpAddressesCommandInput}
+ * @returns {@link ListResolverEndpointIpAddressesCommandOutput}
  * @see {@link ListResolverEndpointIpAddressesCommandInput} for command's `input` shape.
  * @see {@link ListResolverEndpointIpAddressesCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -49,11 +56,20 @@ export interface ListResolverEndpointIpAddressesCommandOutput extends ListResolv
 export declare class ListResolverEndpointIpAddressesCommand extends $Command<ListResolverEndpointIpAddressesCommandInput, ListResolverEndpointIpAddressesCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverEndpointIpAddressesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverEndpointIpAddressesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverEndpointIpAddressesCommandInput, ListResolverEndpointIpAddressesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverEndpointsRequest, ListResolverEndpointsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverEndpointsCommand}.
  */
 export interface ListResolverEndpointsCommandInput extends ListResolverEndpointsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverEndpointsCommand}.
  */
 export interface ListResolverEndpointsCommandOutput extends ListResolverEndpointsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ListResolverEndpointsCommandOutput extends ListResolverEndpoint
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverEndpointsCommandInput - {@link ListResolverEndpointsCommandInput}
+ * @returns {@link ListResolverEndpointsCommandOutput}
  * @see {@link ListResolverEndpointsCommandInput} for command's `input` shape.
  * @see {@link ListResolverEndpointsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -49,11 +56,20 @@ export interface ListResolverEndpointsCommandOutput extends ListResolverEndpoint
 export declare class ListResolverEndpointsCommand extends $Command<ListResolverEndpointsCommandInput, ListResolverEndpointsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverEndpointsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverEndpointsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverEndpointsCommandInput, ListResolverEndpointsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverQueryLogConfigAssociationsRequest, ListResolverQueryLogConfigAssociationsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverQueryLogConfigAssociationsCommand}.
  */
 export interface ListResolverQueryLogConfigAssociationsCommandInput extends ListResolverQueryLogConfigAssociationsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverQueryLogConfigAssociationsCommand}.
  */
 export interface ListResolverQueryLogConfigAssociationsCommandOutput extends ListResolverQueryLogConfigAssociationsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ListResolverQueryLogConfigAssociationsCommandOutput extends Lis
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverQueryLogConfigAssociationsCommandInput - {@link ListResolverQueryLogConfigAssociationsCommandInput}
+ * @returns {@link ListResolverQueryLogConfigAssociationsCommandOutput}
  * @see {@link ListResolverQueryLogConfigAssociationsCommandInput} for command's `input` shape.
  * @see {@link ListResolverQueryLogConfigAssociationsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -52,11 +59,20 @@ export interface ListResolverQueryLogConfigAssociationsCommandOutput extends Lis
 export declare class ListResolverQueryLogConfigAssociationsCommand extends $Command<ListResolverQueryLogConfigAssociationsCommandInput, ListResolverQueryLogConfigAssociationsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverQueryLogConfigAssociationsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverQueryLogConfigAssociationsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverQueryLogConfigAssociationsCommandInput, ListResolverQueryLogConfigAssociationsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverQueryLogConfigsRequest, ListResolverQueryLogConfigsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverQueryLogConfigsCommand}.
  */
 export interface ListResolverQueryLogConfigsCommandInput extends ListResolverQueryLogConfigsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverQueryLogConfigsCommand}.
  */
 export interface ListResolverQueryLogConfigsCommandOutput extends ListResolverQueryLogConfigsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ListResolverQueryLogConfigsCommandOutput extends ListResolverQu
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverQueryLogConfigsCommandInput - {@link ListResolverQueryLogConfigsCommandInput}
+ * @returns {@link ListResolverQueryLogConfigsCommandOutput}
  * @see {@link ListResolverQueryLogConfigsCommandInput} for command's `input` shape.
  * @see {@link ListResolverQueryLogConfigsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -53,11 +60,20 @@ export interface ListResolverQueryLogConfigsCommandOutput extends ListResolverQu
 export declare class ListResolverQueryLogConfigsCommand extends $Command<ListResolverQueryLogConfigsCommandInput, ListResolverQueryLogConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverQueryLogConfigsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverQueryLogConfigsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverQueryLogConfigsCommandInput, ListResolverQueryLogConfigsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverRuleAssociationsRequest, ListResolverRuleAssociationsResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverRuleAssociationsCommand}.
  */
 export interface ListResolverRuleAssociationsCommandInput extends ListResolverRuleAssociationsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverRuleAssociationsCommand}.
  */
 export interface ListResolverRuleAssociationsCommandOutput extends ListResolverRuleAssociationsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ListResolverRuleAssociationsCommandOutput extends ListResolverR
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverRuleAssociationsCommandInput - {@link ListResolverRuleAssociationsCommandInput}
+ * @returns {@link ListResolverRuleAssociationsCommandOutput}
  * @see {@link ListResolverRuleAssociationsCommandInput} for command's `input` shape.
  * @see {@link ListResolverRuleAssociationsCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -49,11 +56,20 @@ export interface ListResolverRuleAssociationsCommandOutput extends ListResolverR
 export declare class ListResolverRuleAssociationsCommand extends $Command<ListResolverRuleAssociationsCommandInput, ListResolverRuleAssociationsCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverRuleAssociationsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverRuleAssociationsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverRuleAssociationsCommandInput, ListResolverRuleAssociationsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ListResolverRulesRequest, ListResolverRulesResponse } from "../models/models_0";
 import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
 /**
+ * @public
+ *
  * The input for {@link ListResolverRulesCommand}.
  */
 export interface ListResolverRulesCommandInput extends ListResolverRulesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListResolverRulesCommand}.
  */
 export interface ListResolverRulesCommandOutput extends ListResolverRulesResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface ListResolverRulesCommandOutput extends ListResolverRulesRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param ListResolverRulesCommandInput - {@link ListResolverRulesCommandInput}
+ * @returns {@link ListResolverRulesCommandOutput}
  * @see {@link ListResolverRulesCommandInput} for command's `input` shape.
  * @see {@link ListResolverRulesCommandOutput} for command's `response` shape.
  * @see {@link Route53ResolverClientResolvedConfig | config} for Route53ResolverClient's `config` shape.
@@ -49,11 +56,20 @@ export interface ListResolverRulesCommandOutput extends ListResolverRulesRespons
 export declare class ListResolverRulesCommand extends $Command<ListResolverRulesCommandInput, ListResolverRulesCommandOutput, Route53ResolverClientResolvedConfig> {
     readonly input: ListResolverRulesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListResolverRulesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverRulesCommandInput, ListResolverRulesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }