@aws-sdk/client-route53resolver 3.34.0 → 3.37.0

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetResolverDnssecConfigRequest, GetResolverDnssecConfigResponse } from "../models/models_0";
+import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
+export interface GetResolverDnssecConfigCommandInput extends GetResolverDnssecConfigRequest {
+}
+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/commands/GetResolverEndpointCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetResolverEndpointRequest, GetResolverEndpointResponse } from "../models/models_0";
+import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
+export interface GetResolverEndpointCommandInput extends GetResolverEndpointRequest {
+}
+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/commands/GetResolverQueryLogConfigAssociationCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetResolverQueryLogConfigAssociationRequest, GetResolverQueryLogConfigAssociationResponse } from "../models/models_0";
+import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
+export interface GetResolverQueryLogConfigAssociationCommandInput extends GetResolverQueryLogConfigAssociationRequest {
+}
+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/commands/GetResolverQueryLogConfigCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetResolverQueryLogConfigRequest, GetResolverQueryLogConfigResponse } from "../models/models_0";
+import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
+export interface GetResolverQueryLogConfigCommandInput extends GetResolverQueryLogConfigRequest {
+}
+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;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListResolverDnssecConfigsRequest, ListResolverDnssecConfigsResponse } from "../models/models_0";
+import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
+export interface ListResolverDnssecConfigsCommandInput extends ListResolverDnssecConfigsRequest {
+}
+export interface ListResolverDnssecConfigsCommandOutput extends ListResolverDnssecConfigsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the configurations for DNSSEC validation that are associated with the current Amazon Web Services account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53ResolverClient, ListResolverDnssecConfigsCommand } from "@aws-sdk/client-route53resolver"; // ES Modules import
+ * // const { Route53ResolverClient, ListResolverDnssecConfigsCommand } = require("@aws-sdk/client-route53resolver"); // CommonJS import
+ * const client = new Route53ResolverClient(config);
+ * const command = new ListResolverDnssecConfigsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListResolverDnssecConfigsCommandInput} for command's `input` shape.
+ * @see {@link ListResolverDnssecConfigsCommandOutput} for command's `response` shape.
+ * @see {@link Route53ResolverClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListResolverDnssecConfigsCommand extends $Command<ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput, Route53ResolverClientResolvedConfig> {
+    readonly input: ListResolverDnssecConfigsCommandInput;
+    constructor(input: ListResolverDnssecConfigsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: Route53ResolverClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput>;
+    private serialize;
+    private deserialize;
+}