@aws-sdk/client-route53resolver 3.34.0 → 3.37.0

package/dist-es/commands/DeleteResolverRuleCommand.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 { DeleteResolverRuleRequest, DeleteResolverRuleResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteResolverRuleCommand, serializeAws_json1_1DeleteResolverRuleCommand, } from "../protocols/Aws_json1_1";
+var DeleteResolverRuleCommand = (function (_super) {
+    __extends(DeleteResolverRuleCommand, _super);
+    function DeleteResolverRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteResolverRuleCommand.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 = "DeleteResolverRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteResolverRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteResolverRuleResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteResolverRuleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteResolverRuleCommand(input, context);
+    };
+    DeleteResolverRuleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteResolverRuleCommand(output, context);
+    };
+    return DeleteResolverRuleCommand;
+}($Command));
+export { DeleteResolverRuleCommand };

package/dist-es/commands/DisassociateFirewallRuleGroupCommand.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 { DisassociateFirewallRuleGroupRequest, DisassociateFirewallRuleGroupResponse } from "../models/models_0";
+import { deserializeAws_json1_1DisassociateFirewallRuleGroupCommand, serializeAws_json1_1DisassociateFirewallRuleGroupCommand, } from "../protocols/Aws_json1_1";
+var DisassociateFirewallRuleGroupCommand = (function (_super) {
+    __extends(DisassociateFirewallRuleGroupCommand, _super);
+    function DisassociateFirewallRuleGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateFirewallRuleGroupCommand.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 = "DisassociateFirewallRuleGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateFirewallRuleGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateFirewallRuleGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateFirewallRuleGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DisassociateFirewallRuleGroupCommand(input, context);
+    };
+    DisassociateFirewallRuleGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DisassociateFirewallRuleGroupCommand(output, context);
+    };
+    return DisassociateFirewallRuleGroupCommand;
+}($Command));
+export { DisassociateFirewallRuleGroupCommand };

package/dist-es/commands/DisassociateResolverEndpointIpAddressCommand.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 { DisassociateResolverEndpointIpAddressRequest, DisassociateResolverEndpointIpAddressResponse, } from "../models/models_0";
+import { deserializeAws_json1_1DisassociateResolverEndpointIpAddressCommand, serializeAws_json1_1DisassociateResolverEndpointIpAddressCommand, } from "../protocols/Aws_json1_1";
+var DisassociateResolverEndpointIpAddressCommand = (function (_super) {
+    __extends(DisassociateResolverEndpointIpAddressCommand, _super);
+    function DisassociateResolverEndpointIpAddressCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateResolverEndpointIpAddressCommand.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 = "DisassociateResolverEndpointIpAddressCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateResolverEndpointIpAddressRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateResolverEndpointIpAddressResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateResolverEndpointIpAddressCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DisassociateResolverEndpointIpAddressCommand(input, context);
+    };
+    DisassociateResolverEndpointIpAddressCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DisassociateResolverEndpointIpAddressCommand(output, context);
+    };
+    return DisassociateResolverEndpointIpAddressCommand;
+}($Command));
+export { DisassociateResolverEndpointIpAddressCommand };

package/dist-es/commands/DisassociateResolverQueryLogConfigCommand.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 { DisassociateResolverQueryLogConfigRequest, DisassociateResolverQueryLogConfigResponse, } from "../models/models_0";
+import { deserializeAws_json1_1DisassociateResolverQueryLogConfigCommand, serializeAws_json1_1DisassociateResolverQueryLogConfigCommand, } from "../protocols/Aws_json1_1";
+var DisassociateResolverQueryLogConfigCommand = (function (_super) {
+    __extends(DisassociateResolverQueryLogConfigCommand, _super);
+    function DisassociateResolverQueryLogConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateResolverQueryLogConfigCommand.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 = "DisassociateResolverQueryLogConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateResolverQueryLogConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateResolverQueryLogConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateResolverQueryLogConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DisassociateResolverQueryLogConfigCommand(input, context);
+    };
+    DisassociateResolverQueryLogConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DisassociateResolverQueryLogConfigCommand(output, context);
+    };
+    return DisassociateResolverQueryLogConfigCommand;
+}($Command));
+export { DisassociateResolverQueryLogConfigCommand };

package/dist-es/commands/DisassociateResolverRuleCommand.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 { DisassociateResolverRuleRequest, DisassociateResolverRuleResponse } from "../models/models_0";
+import { deserializeAws_json1_1DisassociateResolverRuleCommand, serializeAws_json1_1DisassociateResolverRuleCommand, } from "../protocols/Aws_json1_1";
+var DisassociateResolverRuleCommand = (function (_super) {
+    __extends(DisassociateResolverRuleCommand, _super);
+    function DisassociateResolverRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateResolverRuleCommand.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 = "DisassociateResolverRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateResolverRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateResolverRuleResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateResolverRuleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DisassociateResolverRuleCommand(input, context);
+    };
+    DisassociateResolverRuleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DisassociateResolverRuleCommand(output, context);
+    };
+    return DisassociateResolverRuleCommand;
+}($Command));
+export { DisassociateResolverRuleCommand };

package/dist-es/commands/GetFirewallConfigCommand.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 { GetFirewallConfigRequest, GetFirewallConfigResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetFirewallConfigCommand, serializeAws_json1_1GetFirewallConfigCommand, } from "../protocols/Aws_json1_1";
+var GetFirewallConfigCommand = (function (_super) {
+    __extends(GetFirewallConfigCommand, _super);
+    function GetFirewallConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFirewallConfigCommand.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 = "GetFirewallConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFirewallConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFirewallConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFirewallConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetFirewallConfigCommand(input, context);
+    };
+    GetFirewallConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetFirewallConfigCommand(output, context);
+    };
+    return GetFirewallConfigCommand;
+}($Command));
+export { GetFirewallConfigCommand };

package/dist-es/commands/GetFirewallDomainListCommand.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 { GetFirewallDomainListRequest, GetFirewallDomainListResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetFirewallDomainListCommand, serializeAws_json1_1GetFirewallDomainListCommand, } from "../protocols/Aws_json1_1";
+var GetFirewallDomainListCommand = (function (_super) {
+    __extends(GetFirewallDomainListCommand, _super);
+    function GetFirewallDomainListCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFirewallDomainListCommand.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 = "GetFirewallDomainListCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFirewallDomainListRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFirewallDomainListResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFirewallDomainListCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetFirewallDomainListCommand(input, context);
+    };
+    GetFirewallDomainListCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetFirewallDomainListCommand(output, context);
+    };
+    return GetFirewallDomainListCommand;
+}($Command));
+export { GetFirewallDomainListCommand };

package/dist-es/commands/GetFirewallRuleGroupAssociationCommand.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 { GetFirewallRuleGroupAssociationRequest, GetFirewallRuleGroupAssociationResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetFirewallRuleGroupAssociationCommand, serializeAws_json1_1GetFirewallRuleGroupAssociationCommand, } from "../protocols/Aws_json1_1";
+var GetFirewallRuleGroupAssociationCommand = (function (_super) {
+    __extends(GetFirewallRuleGroupAssociationCommand, _super);
+    function GetFirewallRuleGroupAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFirewallRuleGroupAssociationCommand.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 = "GetFirewallRuleGroupAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFirewallRuleGroupAssociationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFirewallRuleGroupAssociationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFirewallRuleGroupAssociationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetFirewallRuleGroupAssociationCommand(input, context);
+    };
+    GetFirewallRuleGroupAssociationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetFirewallRuleGroupAssociationCommand(output, context);
+    };
+    return GetFirewallRuleGroupAssociationCommand;
+}($Command));
+export { GetFirewallRuleGroupAssociationCommand };

package/dist-es/commands/GetFirewallRuleGroupCommand.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 { GetFirewallRuleGroupRequest, GetFirewallRuleGroupResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetFirewallRuleGroupCommand, serializeAws_json1_1GetFirewallRuleGroupCommand, } from "../protocols/Aws_json1_1";
+var GetFirewallRuleGroupCommand = (function (_super) {
+    __extends(GetFirewallRuleGroupCommand, _super);
+    function GetFirewallRuleGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFirewallRuleGroupCommand.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 = "GetFirewallRuleGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFirewallRuleGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFirewallRuleGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFirewallRuleGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetFirewallRuleGroupCommand(input, context);
+    };
+    GetFirewallRuleGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetFirewallRuleGroupCommand(output, context);
+    };
+    return GetFirewallRuleGroupCommand;
+}($Command));
+export { GetFirewallRuleGroupCommand };

package/dist-es/commands/GetFirewallRuleGroupPolicyCommand.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 { GetFirewallRuleGroupPolicyRequest, GetFirewallRuleGroupPolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetFirewallRuleGroupPolicyCommand, serializeAws_json1_1GetFirewallRuleGroupPolicyCommand, } from "../protocols/Aws_json1_1";
+var GetFirewallRuleGroupPolicyCommand = (function (_super) {
+    __extends(GetFirewallRuleGroupPolicyCommand, _super);
+    function GetFirewallRuleGroupPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFirewallRuleGroupPolicyCommand.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 = "GetFirewallRuleGroupPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFirewallRuleGroupPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFirewallRuleGroupPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFirewallRuleGroupPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetFirewallRuleGroupPolicyCommand(input, context);
+    };
+    GetFirewallRuleGroupPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetFirewallRuleGroupPolicyCommand(output, context);
+    };
+    return GetFirewallRuleGroupPolicyCommand;
+}($Command));
+export { GetFirewallRuleGroupPolicyCommand };

package/dist-es/commands/GetResolverDnssecConfigCommand.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 { GetResolverDnssecConfigRequest, GetResolverDnssecConfigResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverDnssecConfigCommand, serializeAws_json1_1GetResolverDnssecConfigCommand, } from "../protocols/Aws_json1_1";
+var GetResolverDnssecConfigCommand = (function (_super) {
+    __extends(GetResolverDnssecConfigCommand, _super);
+    function GetResolverDnssecConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverDnssecConfigCommand.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 = "GetResolverDnssecConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverDnssecConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverDnssecConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverDnssecConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverDnssecConfigCommand(input, context);
+    };
+    GetResolverDnssecConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverDnssecConfigCommand(output, context);
+    };
+    return GetResolverDnssecConfigCommand;
+}($Command));
+export { GetResolverDnssecConfigCommand };

package/dist-es/commands/GetResolverEndpointCommand.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 { GetResolverEndpointRequest, GetResolverEndpointResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverEndpointCommand, serializeAws_json1_1GetResolverEndpointCommand, } from "../protocols/Aws_json1_1";
+var GetResolverEndpointCommand = (function (_super) {
+    __extends(GetResolverEndpointCommand, _super);
+    function GetResolverEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverEndpointCommand.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 = "GetResolverEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverEndpointRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverEndpointResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverEndpointCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverEndpointCommand(input, context);
+    };
+    GetResolverEndpointCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverEndpointCommand(output, context);
+    };
+    return GetResolverEndpointCommand;
+}($Command));
+export { GetResolverEndpointCommand };

package/dist-es/commands/GetResolverQueryLogConfigAssociationCommand.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 { GetResolverQueryLogConfigAssociationRequest, GetResolverQueryLogConfigAssociationResponse, } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverQueryLogConfigAssociationCommand, serializeAws_json1_1GetResolverQueryLogConfigAssociationCommand, } from "../protocols/Aws_json1_1";
+var GetResolverQueryLogConfigAssociationCommand = (function (_super) {
+    __extends(GetResolverQueryLogConfigAssociationCommand, _super);
+    function GetResolverQueryLogConfigAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverQueryLogConfigAssociationCommand.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 = "GetResolverQueryLogConfigAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverQueryLogConfigAssociationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverQueryLogConfigAssociationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverQueryLogConfigAssociationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverQueryLogConfigAssociationCommand(input, context);
+    };
+    GetResolverQueryLogConfigAssociationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverQueryLogConfigAssociationCommand(output, context);
+    };
+    return GetResolverQueryLogConfigAssociationCommand;
+}($Command));
+export { GetResolverQueryLogConfigAssociationCommand };

package/dist-es/commands/GetResolverQueryLogConfigCommand.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 { GetResolverQueryLogConfigRequest, GetResolverQueryLogConfigResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverQueryLogConfigCommand, serializeAws_json1_1GetResolverQueryLogConfigCommand, } from "../protocols/Aws_json1_1";
+var GetResolverQueryLogConfigCommand = (function (_super) {
+    __extends(GetResolverQueryLogConfigCommand, _super);
+    function GetResolverQueryLogConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverQueryLogConfigCommand.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 = "GetResolverQueryLogConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverQueryLogConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverQueryLogConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverQueryLogConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverQueryLogConfigCommand(input, context);
+    };
+    GetResolverQueryLogConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverQueryLogConfigCommand(output, context);
+    };
+    return GetResolverQueryLogConfigCommand;
+}($Command));
+export { GetResolverQueryLogConfigCommand };

package/dist-es/commands/GetResolverQueryLogConfigPolicyCommand.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 { GetResolverQueryLogConfigPolicyRequest, GetResolverQueryLogConfigPolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverQueryLogConfigPolicyCommand, serializeAws_json1_1GetResolverQueryLogConfigPolicyCommand, } from "../protocols/Aws_json1_1";
+var GetResolverQueryLogConfigPolicyCommand = (function (_super) {
+    __extends(GetResolverQueryLogConfigPolicyCommand, _super);
+    function GetResolverQueryLogConfigPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverQueryLogConfigPolicyCommand.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 = "GetResolverQueryLogConfigPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverQueryLogConfigPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverQueryLogConfigPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverQueryLogConfigPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverQueryLogConfigPolicyCommand(input, context);
+    };
+    GetResolverQueryLogConfigPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverQueryLogConfigPolicyCommand(output, context);
+    };
+    return GetResolverQueryLogConfigPolicyCommand;
+}($Command));
+export { GetResolverQueryLogConfigPolicyCommand };

package/dist-es/commands/GetResolverRuleAssociationCommand.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 { GetResolverRuleAssociationRequest, GetResolverRuleAssociationResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResolverRuleAssociationCommand, serializeAws_json1_1GetResolverRuleAssociationCommand, } from "../protocols/Aws_json1_1";
+var GetResolverRuleAssociationCommand = (function (_super) {
+    __extends(GetResolverRuleAssociationCommand, _super);
+    function GetResolverRuleAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResolverRuleAssociationCommand.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 = "GetResolverRuleAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResolverRuleAssociationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResolverRuleAssociationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResolverRuleAssociationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResolverRuleAssociationCommand(input, context);
+    };
+    GetResolverRuleAssociationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResolverRuleAssociationCommand(output, context);
+    };
+    return GetResolverRuleAssociationCommand;
+}($Command));
+export { GetResolverRuleAssociationCommand };