@aws-sdk/client-route53resolver 3.34.0 → 3.37.0

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

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

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

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

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

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { GetResolverQueryLogConfigPolicyRequest, GetResolverQueryLogConfigPolicyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/GetResolverRuleAssociationCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { GetResolverRuleAssociationRequest, GetResolverRuleAssociationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/GetResolverRuleCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { GetResolverRuleRequest, GetResolverRuleResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/GetResolverRulePolicyCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { GetResolverRulePolicyRequest, GetResolverRulePolicyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ImportFirewallDomainsCommand.d.ts

@@ -1,50 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ImportFirewallDomainsRequest, ImportFirewallDomainsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListFirewallConfigsCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ListFirewallConfigsRequest, ListFirewallConfigsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListFirewallDomainListsCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ListFirewallDomainListsRequest, ListFirewallDomainListsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListFirewallDomainsCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ListFirewallDomainsRequest, ListFirewallDomainsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListFirewallRuleGroupAssociationsCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ListFirewallRuleGroupAssociationsRequest, ListFirewallRuleGroupAssociationsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListFirewallRuleGroupsCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ListFirewallRuleGroupsRequest, ListFirewallRuleGroupsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListFirewallRulesCommand.d.ts

@@ -1,36 +0,0 @@
-import { Route53ResolverClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53ResolverClient";
-import { ListFirewallRulesRequest, ListFirewallRulesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ListResolverDnssecConfigsCommand.d.ts

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