@aws-sdk/client-route53resolver 3.34.0 → 3.37.0

package/dist-es/commands/GetResolverRuleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResolverRuleRequest, GetResolverRuleResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverRuleCommand, serializeAws_json1_1GetResolverRuleCommand, } from "../protocols/Aws_json1_1";
+var GetResolverRuleCommand = (function (_super) {
+    __extends(GetResolverRuleCommand, _super);
+    function GetResolverRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverRuleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "GetResolverRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverRuleResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverRuleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverRuleCommand(input, context);
+    };
+    GetResolverRuleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverRuleCommand(output, context);
+    };
+    return GetResolverRuleCommand;
+}($Command));
+export { GetResolverRuleCommand };

package/dist-es/commands/GetResolverRulePolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResolverRulePolicyRequest, GetResolverRulePolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverRulePolicyCommand, serializeAws_json1_1GetResolverRulePolicyCommand, } from "../protocols/Aws_json1_1";
+var GetResolverRulePolicyCommand = (function (_super) {
+    __extends(GetResolverRulePolicyCommand, _super);
+    function GetResolverRulePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverRulePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "GetResolverRulePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverRulePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverRulePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverRulePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverRulePolicyCommand(input, context);
+    };
+    GetResolverRulePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverRulePolicyCommand(output, context);
+    };
+    return GetResolverRulePolicyCommand;
+}($Command));
+export { GetResolverRulePolicyCommand };

package/dist-es/commands/ImportFirewallDomainsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ImportFirewallDomainsRequest, ImportFirewallDomainsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ImportFirewallDomainsCommand, serializeAws_json1_1ImportFirewallDomainsCommand, } from "../protocols/Aws_json1_1";
+var ImportFirewallDomainsCommand = (function (_super) {
+    __extends(ImportFirewallDomainsCommand, _super);
+    function ImportFirewallDomainsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportFirewallDomainsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ImportFirewallDomainsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportFirewallDomainsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ImportFirewallDomainsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportFirewallDomainsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ImportFirewallDomainsCommand(input, context);
+    };
+    ImportFirewallDomainsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ImportFirewallDomainsCommand(output, context);
+    };
+    return ImportFirewallDomainsCommand;
+}($Command));
+export { ImportFirewallDomainsCommand };

package/dist-es/commands/ListFirewallConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFirewallConfigsRequest, ListFirewallConfigsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListFirewallConfigsCommand, serializeAws_json1_1ListFirewallConfigsCommand, } from "../protocols/Aws_json1_1";
+var ListFirewallConfigsCommand = (function (_super) {
+    __extends(ListFirewallConfigsCommand, _super);
+    function ListFirewallConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFirewallConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListFirewallConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFirewallConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFirewallConfigsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFirewallConfigsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListFirewallConfigsCommand(input, context);
+    };
+    ListFirewallConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListFirewallConfigsCommand(output, context);
+    };
+    return ListFirewallConfigsCommand;
+}($Command));
+export { ListFirewallConfigsCommand };

package/dist-es/commands/ListFirewallDomainListsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFirewallDomainListsRequest, ListFirewallDomainListsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListFirewallDomainListsCommand, serializeAws_json1_1ListFirewallDomainListsCommand, } from "../protocols/Aws_json1_1";
+var ListFirewallDomainListsCommand = (function (_super) {
+    __extends(ListFirewallDomainListsCommand, _super);
+    function ListFirewallDomainListsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFirewallDomainListsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListFirewallDomainListsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFirewallDomainListsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFirewallDomainListsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFirewallDomainListsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListFirewallDomainListsCommand(input, context);
+    };
+    ListFirewallDomainListsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListFirewallDomainListsCommand(output, context);
+    };
+    return ListFirewallDomainListsCommand;
+}($Command));
+export { ListFirewallDomainListsCommand };

package/dist-es/commands/ListFirewallDomainsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFirewallDomainsRequest, ListFirewallDomainsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListFirewallDomainsCommand, serializeAws_json1_1ListFirewallDomainsCommand, } from "../protocols/Aws_json1_1";
+var ListFirewallDomainsCommand = (function (_super) {
+    __extends(ListFirewallDomainsCommand, _super);
+    function ListFirewallDomainsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFirewallDomainsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListFirewallDomainsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFirewallDomainsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFirewallDomainsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFirewallDomainsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListFirewallDomainsCommand(input, context);
+    };
+    ListFirewallDomainsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListFirewallDomainsCommand(output, context);
+    };
+    return ListFirewallDomainsCommand;
+}($Command));
+export { ListFirewallDomainsCommand };

package/dist-es/commands/ListFirewallRuleGroupAssociationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFirewallRuleGroupAssociationsRequest, ListFirewallRuleGroupAssociationsResponse, } from "../models/models_0";
+import { deserializeAws_json1_1ListFirewallRuleGroupAssociationsCommand, serializeAws_json1_1ListFirewallRuleGroupAssociationsCommand, } from "../protocols/Aws_json1_1";
+var ListFirewallRuleGroupAssociationsCommand = (function (_super) {
+    __extends(ListFirewallRuleGroupAssociationsCommand, _super);
+    function ListFirewallRuleGroupAssociationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFirewallRuleGroupAssociationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListFirewallRuleGroupAssociationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFirewallRuleGroupAssociationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFirewallRuleGroupAssociationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFirewallRuleGroupAssociationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListFirewallRuleGroupAssociationsCommand(input, context);
+    };
+    ListFirewallRuleGroupAssociationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListFirewallRuleGroupAssociationsCommand(output, context);
+    };
+    return ListFirewallRuleGroupAssociationsCommand;
+}($Command));
+export { ListFirewallRuleGroupAssociationsCommand };

package/dist-es/commands/ListFirewallRuleGroupsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFirewallRuleGroupsRequest, ListFirewallRuleGroupsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListFirewallRuleGroupsCommand, serializeAws_json1_1ListFirewallRuleGroupsCommand, } from "../protocols/Aws_json1_1";
+var ListFirewallRuleGroupsCommand = (function (_super) {
+    __extends(ListFirewallRuleGroupsCommand, _super);
+    function ListFirewallRuleGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFirewallRuleGroupsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListFirewallRuleGroupsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFirewallRuleGroupsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFirewallRuleGroupsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFirewallRuleGroupsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListFirewallRuleGroupsCommand(input, context);
+    };
+    ListFirewallRuleGroupsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListFirewallRuleGroupsCommand(output, context);
+    };
+    return ListFirewallRuleGroupsCommand;
+}($Command));
+export { ListFirewallRuleGroupsCommand };

package/dist-es/commands/ListFirewallRulesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFirewallRulesRequest, ListFirewallRulesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListFirewallRulesCommand, serializeAws_json1_1ListFirewallRulesCommand, } from "../protocols/Aws_json1_1";
+var ListFirewallRulesCommand = (function (_super) {
+    __extends(ListFirewallRulesCommand, _super);
+    function ListFirewallRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFirewallRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListFirewallRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFirewallRulesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFirewallRulesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListFirewallRulesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListFirewallRulesCommand(input, context);
+    };
+    ListFirewallRulesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListFirewallRulesCommand(output, context);
+    };
+    return ListFirewallRulesCommand;
+}($Command));
+export { ListFirewallRulesCommand };

package/dist-es/commands/ListResolverDnssecConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverDnssecConfigsRequest, ListResolverDnssecConfigsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverDnssecConfigsCommand, serializeAws_json1_1ListResolverDnssecConfigsCommand, } from "../protocols/Aws_json1_1";
+var ListResolverDnssecConfigsCommand = (function (_super) {
+    __extends(ListResolverDnssecConfigsCommand, _super);
+    function ListResolverDnssecConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverDnssecConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverDnssecConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverDnssecConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverDnssecConfigsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverDnssecConfigsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverDnssecConfigsCommand(input, context);
+    };
+    ListResolverDnssecConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverDnssecConfigsCommand(output, context);
+    };
+    return ListResolverDnssecConfigsCommand;
+}($Command));
+export { ListResolverDnssecConfigsCommand };

package/dist-es/commands/ListResolverEndpointIpAddressesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverEndpointIpAddressesRequest, ListResolverEndpointIpAddressesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverEndpointIpAddressesCommand, serializeAws_json1_1ListResolverEndpointIpAddressesCommand, } from "../protocols/Aws_json1_1";
+var ListResolverEndpointIpAddressesCommand = (function (_super) {
+    __extends(ListResolverEndpointIpAddressesCommand, _super);
+    function ListResolverEndpointIpAddressesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverEndpointIpAddressesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverEndpointIpAddressesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverEndpointIpAddressesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverEndpointIpAddressesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverEndpointIpAddressesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverEndpointIpAddressesCommand(input, context);
+    };
+    ListResolverEndpointIpAddressesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverEndpointIpAddressesCommand(output, context);
+    };
+    return ListResolverEndpointIpAddressesCommand;
+}($Command));
+export { ListResolverEndpointIpAddressesCommand };

package/dist-es/commands/ListResolverEndpointsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverEndpointsRequest, ListResolverEndpointsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverEndpointsCommand, serializeAws_json1_1ListResolverEndpointsCommand, } from "../protocols/Aws_json1_1";
+var ListResolverEndpointsCommand = (function (_super) {
+    __extends(ListResolverEndpointsCommand, _super);
+    function ListResolverEndpointsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverEndpointsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverEndpointsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverEndpointsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverEndpointsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverEndpointsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverEndpointsCommand(input, context);
+    };
+    ListResolverEndpointsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverEndpointsCommand(output, context);
+    };
+    return ListResolverEndpointsCommand;
+}($Command));
+export { ListResolverEndpointsCommand };

package/dist-es/commands/ListResolverQueryLogConfigAssociationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverQueryLogConfigAssociationsRequest, ListResolverQueryLogConfigAssociationsResponse, } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverQueryLogConfigAssociationsCommand, serializeAws_json1_1ListResolverQueryLogConfigAssociationsCommand, } from "../protocols/Aws_json1_1";
+var ListResolverQueryLogConfigAssociationsCommand = (function (_super) {
+    __extends(ListResolverQueryLogConfigAssociationsCommand, _super);
+    function ListResolverQueryLogConfigAssociationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverQueryLogConfigAssociationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverQueryLogConfigAssociationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverQueryLogConfigAssociationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverQueryLogConfigAssociationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverQueryLogConfigAssociationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverQueryLogConfigAssociationsCommand(input, context);
+    };
+    ListResolverQueryLogConfigAssociationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverQueryLogConfigAssociationsCommand(output, context);
+    };
+    return ListResolverQueryLogConfigAssociationsCommand;
+}($Command));
+export { ListResolverQueryLogConfigAssociationsCommand };

package/dist-es/commands/ListResolverQueryLogConfigsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverQueryLogConfigsRequest, ListResolverQueryLogConfigsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverQueryLogConfigsCommand, serializeAws_json1_1ListResolverQueryLogConfigsCommand, } from "../protocols/Aws_json1_1";
+var ListResolverQueryLogConfigsCommand = (function (_super) {
+    __extends(ListResolverQueryLogConfigsCommand, _super);
+    function ListResolverQueryLogConfigsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverQueryLogConfigsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverQueryLogConfigsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverQueryLogConfigsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverQueryLogConfigsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverQueryLogConfigsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverQueryLogConfigsCommand(input, context);
+    };
+    ListResolverQueryLogConfigsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverQueryLogConfigsCommand(output, context);
+    };
+    return ListResolverQueryLogConfigsCommand;
+}($Command));
+export { ListResolverQueryLogConfigsCommand };

package/dist-es/commands/ListResolverRuleAssociationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverRuleAssociationsRequest, ListResolverRuleAssociationsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverRuleAssociationsCommand, serializeAws_json1_1ListResolverRuleAssociationsCommand, } from "../protocols/Aws_json1_1";
+var ListResolverRuleAssociationsCommand = (function (_super) {
+    __extends(ListResolverRuleAssociationsCommand, _super);
+    function ListResolverRuleAssociationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverRuleAssociationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverRuleAssociationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverRuleAssociationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverRuleAssociationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverRuleAssociationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverRuleAssociationsCommand(input, context);
+    };
+    ListResolverRuleAssociationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverRuleAssociationsCommand(output, context);
+    };
+    return ListResolverRuleAssociationsCommand;
+}($Command));
+export { ListResolverRuleAssociationsCommand };

package/dist-es/commands/ListResolverRulesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListResolverRulesRequest, ListResolverRulesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListResolverRulesCommand, serializeAws_json1_1ListResolverRulesCommand, } from "../protocols/Aws_json1_1";
+var ListResolverRulesCommand = (function (_super) {
+    __extends(ListResolverRulesCommand, _super);
+    function ListResolverRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListResolverRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53ResolverClient";
+        var commandName = "ListResolverRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListResolverRulesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListResolverRulesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListResolverRulesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListResolverRulesCommand(input, context);
+    };
+    ListResolverRulesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListResolverRulesCommand(output, context);
+    };
+    return ListResolverRulesCommand;
+}($Command));
+export { ListResolverRulesCommand };