@aws-sdk/client-route-53 3.33.0 → 3.36.1

package/dist-es/Route53Client.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var Route53Client = (function (_super) {
+    __extends(Route53Client, _super);
+    function Route53Client(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    Route53Client.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return Route53Client;
+}(__Client));
+export { Route53Client };

package/dist-es/commands/ActivateKeySigningKeyCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ActivateKeySigningKeyRequest, ActivateKeySigningKeyResponse } from "../models/models_0";
+import { deserializeAws_restXmlActivateKeySigningKeyCommand, serializeAws_restXmlActivateKeySigningKeyCommand, } from "../protocols/Aws_restXml";
+var ActivateKeySigningKeyCommand = (function (_super) {
+    __extends(ActivateKeySigningKeyCommand, _super);
+    function ActivateKeySigningKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ActivateKeySigningKeyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "ActivateKeySigningKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ActivateKeySigningKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivateKeySigningKeyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ActivateKeySigningKeyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlActivateKeySigningKeyCommand(input, context);
+    };
+    ActivateKeySigningKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlActivateKeySigningKeyCommand(output, context);
+    };
+    return ActivateKeySigningKeyCommand;
+}($Command));
+export { ActivateKeySigningKeyCommand };

package/dist-es/commands/AssociateVPCWithHostedZoneCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AssociateVPCWithHostedZoneRequest, AssociateVPCWithHostedZoneResponse } from "../models/models_0";
+import { deserializeAws_restXmlAssociateVPCWithHostedZoneCommand, serializeAws_restXmlAssociateVPCWithHostedZoneCommand, } from "../protocols/Aws_restXml";
+var AssociateVPCWithHostedZoneCommand = (function (_super) {
+    __extends(AssociateVPCWithHostedZoneCommand, _super);
+    function AssociateVPCWithHostedZoneCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateVPCWithHostedZoneCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "AssociateVPCWithHostedZoneCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateVPCWithHostedZoneRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssociateVPCWithHostedZoneResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateVPCWithHostedZoneCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlAssociateVPCWithHostedZoneCommand(input, context);
+    };
+    AssociateVPCWithHostedZoneCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlAssociateVPCWithHostedZoneCommand(output, context);
+    };
+    return AssociateVPCWithHostedZoneCommand;
+}($Command));
+export { AssociateVPCWithHostedZoneCommand };

package/dist-es/commands/ChangeResourceRecordSetsCommand.js

@@ -0,0 +1,42 @@
+import { __extends } from "tslib";
+import { getChangeResourceRecordSetsPlugin, getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ChangeResourceRecordSetsRequest, ChangeResourceRecordSetsResponse } from "../models/models_0";
+import { deserializeAws_restXmlChangeResourceRecordSetsCommand, serializeAws_restXmlChangeResourceRecordSetsCommand, } from "../protocols/Aws_restXml";
+var ChangeResourceRecordSetsCommand = (function (_super) {
+    __extends(ChangeResourceRecordSetsCommand, _super);
+    function ChangeResourceRecordSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ChangeResourceRecordSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getChangeResourceRecordSetsPlugin(configuration));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "ChangeResourceRecordSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ChangeResourceRecordSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ChangeResourceRecordSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ChangeResourceRecordSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlChangeResourceRecordSetsCommand(input, context);
+    };
+    ChangeResourceRecordSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlChangeResourceRecordSetsCommand(output, context);
+    };
+    return ChangeResourceRecordSetsCommand;
+}($Command));
+export { ChangeResourceRecordSetsCommand };

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

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

package/dist-es/commands/CreateHostedZoneCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateHostedZoneRequest, CreateHostedZoneResponse } from "../models/models_0";
+import { deserializeAws_restXmlCreateHostedZoneCommand, serializeAws_restXmlCreateHostedZoneCommand, } from "../protocols/Aws_restXml";
+var CreateHostedZoneCommand = (function (_super) {
+    __extends(CreateHostedZoneCommand, _super);
+    function CreateHostedZoneCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateHostedZoneCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateHostedZoneCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateHostedZoneRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateHostedZoneResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateHostedZoneCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateHostedZoneCommand(input, context);
+    };
+    CreateHostedZoneCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateHostedZoneCommand(output, context);
+    };
+    return CreateHostedZoneCommand;
+}($Command));
+export { CreateHostedZoneCommand };

package/dist-es/commands/CreateKeySigningKeyCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateKeySigningKeyRequest, CreateKeySigningKeyResponse } from "../models/models_0";
+import { deserializeAws_restXmlCreateKeySigningKeyCommand, serializeAws_restXmlCreateKeySigningKeyCommand, } from "../protocols/Aws_restXml";
+var CreateKeySigningKeyCommand = (function (_super) {
+    __extends(CreateKeySigningKeyCommand, _super);
+    function CreateKeySigningKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateKeySigningKeyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateKeySigningKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateKeySigningKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateKeySigningKeyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateKeySigningKeyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateKeySigningKeyCommand(input, context);
+    };
+    CreateKeySigningKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateKeySigningKeyCommand(output, context);
+    };
+    return CreateKeySigningKeyCommand;
+}($Command));
+export { CreateKeySigningKeyCommand };

package/dist-es/commands/CreateQueryLoggingConfigCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateQueryLoggingConfigRequest, CreateQueryLoggingConfigResponse } from "../models/models_0";
+import { deserializeAws_restXmlCreateQueryLoggingConfigCommand, serializeAws_restXmlCreateQueryLoggingConfigCommand, } from "../protocols/Aws_restXml";
+var CreateQueryLoggingConfigCommand = (function (_super) {
+    __extends(CreateQueryLoggingConfigCommand, _super);
+    function CreateQueryLoggingConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateQueryLoggingConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateQueryLoggingConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateQueryLoggingConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateQueryLoggingConfigResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateQueryLoggingConfigCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateQueryLoggingConfigCommand(input, context);
+    };
+    CreateQueryLoggingConfigCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateQueryLoggingConfigCommand(output, context);
+    };
+    return CreateQueryLoggingConfigCommand;
+}($Command));
+export { CreateQueryLoggingConfigCommand };

package/dist-es/commands/CreateReusableDelegationSetCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateReusableDelegationSetRequest, CreateReusableDelegationSetResponse } from "../models/models_0";
+import { deserializeAws_restXmlCreateReusableDelegationSetCommand, serializeAws_restXmlCreateReusableDelegationSetCommand, } from "../protocols/Aws_restXml";
+var CreateReusableDelegationSetCommand = (function (_super) {
+    __extends(CreateReusableDelegationSetCommand, _super);
+    function CreateReusableDelegationSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateReusableDelegationSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateReusableDelegationSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateReusableDelegationSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateReusableDelegationSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateReusableDelegationSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateReusableDelegationSetCommand(input, context);
+    };
+    CreateReusableDelegationSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateReusableDelegationSetCommand(output, context);
+    };
+    return CreateReusableDelegationSetCommand;
+}($Command));
+export { CreateReusableDelegationSetCommand };

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

package/dist-es/commands/CreateTrafficPolicyInstanceCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateTrafficPolicyInstanceRequest, CreateTrafficPolicyInstanceResponse } from "../models/models_0";
+import { deserializeAws_restXmlCreateTrafficPolicyInstanceCommand, serializeAws_restXmlCreateTrafficPolicyInstanceCommand, } from "../protocols/Aws_restXml";
+var CreateTrafficPolicyInstanceCommand = (function (_super) {
+    __extends(CreateTrafficPolicyInstanceCommand, _super);
+    function CreateTrafficPolicyInstanceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateTrafficPolicyInstanceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateTrafficPolicyInstanceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateTrafficPolicyInstanceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateTrafficPolicyInstanceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTrafficPolicyInstanceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateTrafficPolicyInstanceCommand(input, context);
+    };
+    CreateTrafficPolicyInstanceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateTrafficPolicyInstanceCommand(output, context);
+    };
+    return CreateTrafficPolicyInstanceCommand;
+}($Command));
+export { CreateTrafficPolicyInstanceCommand };

package/dist-es/commands/CreateTrafficPolicyVersionCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateTrafficPolicyVersionRequest, CreateTrafficPolicyVersionResponse } from "../models/models_0";
+import { deserializeAws_restXmlCreateTrafficPolicyVersionCommand, serializeAws_restXmlCreateTrafficPolicyVersionCommand, } from "../protocols/Aws_restXml";
+var CreateTrafficPolicyVersionCommand = (function (_super) {
+    __extends(CreateTrafficPolicyVersionCommand, _super);
+    function CreateTrafficPolicyVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateTrafficPolicyVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateTrafficPolicyVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateTrafficPolicyVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateTrafficPolicyVersionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTrafficPolicyVersionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateTrafficPolicyVersionCommand(input, context);
+    };
+    CreateTrafficPolicyVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateTrafficPolicyVersionCommand(output, context);
+    };
+    return CreateTrafficPolicyVersionCommand;
+}($Command));
+export { CreateTrafficPolicyVersionCommand };

package/dist-es/commands/CreateVPCAssociationAuthorizationCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateVPCAssociationAuthorizationRequest, CreateVPCAssociationAuthorizationResponse, } from "../models/models_0";
+import { deserializeAws_restXmlCreateVPCAssociationAuthorizationCommand, serializeAws_restXmlCreateVPCAssociationAuthorizationCommand, } from "../protocols/Aws_restXml";
+var CreateVPCAssociationAuthorizationCommand = (function (_super) {
+    __extends(CreateVPCAssociationAuthorizationCommand, _super);
+    function CreateVPCAssociationAuthorizationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateVPCAssociationAuthorizationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "CreateVPCAssociationAuthorizationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateVPCAssociationAuthorizationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateVPCAssociationAuthorizationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVPCAssociationAuthorizationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlCreateVPCAssociationAuthorizationCommand(input, context);
+    };
+    CreateVPCAssociationAuthorizationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlCreateVPCAssociationAuthorizationCommand(output, context);
+    };
+    return CreateVPCAssociationAuthorizationCommand;
+}($Command));
+export { CreateVPCAssociationAuthorizationCommand };

package/dist-es/commands/DeactivateKeySigningKeyCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getIdNormalizerPlugin } from "@aws-sdk/middleware-sdk-route53";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeactivateKeySigningKeyRequest, DeactivateKeySigningKeyResponse } from "../models/models_0";
+import { deserializeAws_restXmlDeactivateKeySigningKeyCommand, serializeAws_restXmlDeactivateKeySigningKeyCommand, } from "../protocols/Aws_restXml";
+var DeactivateKeySigningKeyCommand = (function (_super) {
+    __extends(DeactivateKeySigningKeyCommand, _super);
+    function DeactivateKeySigningKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeactivateKeySigningKeyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getIdNormalizerPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53Client";
+        var commandName = "DeactivateKeySigningKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeactivateKeySigningKeyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeactivateKeySigningKeyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeactivateKeySigningKeyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restXmlDeactivateKeySigningKeyCommand(input, context);
+    };
+    DeactivateKeySigningKeyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restXmlDeactivateKeySigningKeyCommand(output, context);
+    };
+    return DeactivateKeySigningKeyCommand;
+}($Command));
+export { DeactivateKeySigningKeyCommand };