@aws-sdk/client-route-53 3.186.0 → 3.190.0

package/dist-es/commands/GetHostedZoneCommand.js

@@ -1,41 +1,34 @@
-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 { GetHostedZoneRequestFilterSensitiveLog, GetHostedZoneResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetHostedZoneCommand, serializeAws_restXmlGetHostedZoneCommand, } from "../protocols/Aws_restXml";
-var GetHostedZoneCommand = (function (_super) {
-    __extends(GetHostedZoneCommand, _super);
-    function GetHostedZoneCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetHostedZoneCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetHostedZoneCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetHostedZoneCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetHostedZoneCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetHostedZoneRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetHostedZoneResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetHostedZoneCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetHostedZoneCommand(input, context);
-    };
-    GetHostedZoneCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetHostedZoneCommand(output, context);
-    };
-    return GetHostedZoneCommand;
-}($Command));
-export { GetHostedZoneCommand };
+    }
+}

package/dist-es/commands/GetHostedZoneCountCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetHostedZoneCountRequestFilterSensitiveLog, GetHostedZoneCountResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetHostedZoneCountCommand, serializeAws_restXmlGetHostedZoneCountCommand, } from "../protocols/Aws_restXml";
-var GetHostedZoneCountCommand = (function (_super) {
-    __extends(GetHostedZoneCountCommand, _super);
-    function GetHostedZoneCountCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetHostedZoneCountCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetHostedZoneCountCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetHostedZoneCountCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetHostedZoneCountCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetHostedZoneCountRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetHostedZoneCountResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetHostedZoneCountCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetHostedZoneCountCommand(input, context);
-    };
-    GetHostedZoneCountCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetHostedZoneCountCommand(output, context);
-    };
-    return GetHostedZoneCountCommand;
-}($Command));
-export { GetHostedZoneCountCommand };
+    }
+}

package/dist-es/commands/GetHostedZoneLimitCommand.js

@@ -1,41 +1,34 @@
-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 { GetHostedZoneLimitRequestFilterSensitiveLog, GetHostedZoneLimitResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetHostedZoneLimitCommand, serializeAws_restXmlGetHostedZoneLimitCommand, } from "../protocols/Aws_restXml";
-var GetHostedZoneLimitCommand = (function (_super) {
-    __extends(GetHostedZoneLimitCommand, _super);
-    function GetHostedZoneLimitCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetHostedZoneLimitCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetHostedZoneLimitCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetHostedZoneLimitCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetHostedZoneLimitCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetHostedZoneLimitRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetHostedZoneLimitResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetHostedZoneLimitCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetHostedZoneLimitCommand(input, context);
-    };
-    GetHostedZoneLimitCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetHostedZoneLimitCommand(output, context);
-    };
-    return GetHostedZoneLimitCommand;
-}($Command));
-export { GetHostedZoneLimitCommand };
+    }
+}

package/dist-es/commands/GetQueryLoggingConfigCommand.js

@@ -1,41 +1,34 @@
-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 { GetQueryLoggingConfigRequestFilterSensitiveLog, GetQueryLoggingConfigResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetQueryLoggingConfigCommand, serializeAws_restXmlGetQueryLoggingConfigCommand, } from "../protocols/Aws_restXml";
-var GetQueryLoggingConfigCommand = (function (_super) {
-    __extends(GetQueryLoggingConfigCommand, _super);
-    function GetQueryLoggingConfigCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetQueryLoggingConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetQueryLoggingConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetQueryLoggingConfigCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetQueryLoggingConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetQueryLoggingConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetQueryLoggingConfigResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetQueryLoggingConfigCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetQueryLoggingConfigCommand(input, context);
-    };
-    GetQueryLoggingConfigCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetQueryLoggingConfigCommand(output, context);
-    };
-    return GetQueryLoggingConfigCommand;
-}($Command));
-export { GetQueryLoggingConfigCommand };
+    }
+}

package/dist-es/commands/GetReusableDelegationSetCommand.js

@@ -1,41 +1,34 @@
-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 { GetReusableDelegationSetRequestFilterSensitiveLog, GetReusableDelegationSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetReusableDelegationSetCommand, serializeAws_restXmlGetReusableDelegationSetCommand, } from "../protocols/Aws_restXml";
-var GetReusableDelegationSetCommand = (function (_super) {
-    __extends(GetReusableDelegationSetCommand, _super);
-    function GetReusableDelegationSetCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetReusableDelegationSetCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetReusableDelegationSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetReusableDelegationSetCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetReusableDelegationSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetReusableDelegationSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetReusableDelegationSetResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetReusableDelegationSetCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetReusableDelegationSetCommand(input, context);
-    };
-    GetReusableDelegationSetCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetReusableDelegationSetCommand(output, context);
-    };
-    return GetReusableDelegationSetCommand;
-}($Command));
-export { GetReusableDelegationSetCommand };
+    }
+}

package/dist-es/commands/GetReusableDelegationSetLimitCommand.js

@@ -1,41 +1,34 @@
-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 { GetReusableDelegationSetLimitRequestFilterSensitiveLog, GetReusableDelegationSetLimitResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetReusableDelegationSetLimitCommand, serializeAws_restXmlGetReusableDelegationSetLimitCommand, } from "../protocols/Aws_restXml";
-var GetReusableDelegationSetLimitCommand = (function (_super) {
-    __extends(GetReusableDelegationSetLimitCommand, _super);
-    function GetReusableDelegationSetLimitCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetReusableDelegationSetLimitCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetReusableDelegationSetLimitCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetReusableDelegationSetLimitCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetReusableDelegationSetLimitCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetReusableDelegationSetLimitRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetReusableDelegationSetLimitResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetReusableDelegationSetLimitCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetReusableDelegationSetLimitCommand(input, context);
-    };
-    GetReusableDelegationSetLimitCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetReusableDelegationSetLimitCommand(output, context);
-    };
-    return GetReusableDelegationSetLimitCommand;
-}($Command));
-export { GetReusableDelegationSetLimitCommand };
+    }
+}

package/dist-es/commands/GetTrafficPolicyCommand.js

@@ -1,41 +1,34 @@
-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 { GetTrafficPolicyRequestFilterSensitiveLog, GetTrafficPolicyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetTrafficPolicyCommand, serializeAws_restXmlGetTrafficPolicyCommand, } from "../protocols/Aws_restXml";
-var GetTrafficPolicyCommand = (function (_super) {
-    __extends(GetTrafficPolicyCommand, _super);
-    function GetTrafficPolicyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetTrafficPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetTrafficPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetTrafficPolicyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetTrafficPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetTrafficPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetTrafficPolicyResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetTrafficPolicyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetTrafficPolicyCommand(input, context);
-    };
-    GetTrafficPolicyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetTrafficPolicyCommand(output, context);
-    };
-    return GetTrafficPolicyCommand;
-}($Command));
-export { GetTrafficPolicyCommand };
+    }
+}

package/dist-es/commands/GetTrafficPolicyInstanceCommand.js

@@ -1,41 +1,34 @@
-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 { GetTrafficPolicyInstanceRequestFilterSensitiveLog, GetTrafficPolicyInstanceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetTrafficPolicyInstanceCommand, serializeAws_restXmlGetTrafficPolicyInstanceCommand, } from "../protocols/Aws_restXml";
-var GetTrafficPolicyInstanceCommand = (function (_super) {
-    __extends(GetTrafficPolicyInstanceCommand, _super);
-    function GetTrafficPolicyInstanceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetTrafficPolicyInstanceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetTrafficPolicyInstanceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetTrafficPolicyInstanceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetTrafficPolicyInstanceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetTrafficPolicyInstanceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetTrafficPolicyInstanceResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetTrafficPolicyInstanceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetTrafficPolicyInstanceCommand(input, context);
-    };
-    GetTrafficPolicyInstanceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetTrafficPolicyInstanceCommand(output, context);
-    };
-    return GetTrafficPolicyInstanceCommand;
-}($Command));
-export { GetTrafficPolicyInstanceCommand };
+    }
+}

package/dist-es/commands/GetTrafficPolicyInstanceCountCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetTrafficPolicyInstanceCountRequestFilterSensitiveLog, GetTrafficPolicyInstanceCountResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlGetTrafficPolicyInstanceCountCommand, serializeAws_restXmlGetTrafficPolicyInstanceCountCommand, } from "../protocols/Aws_restXml";
-var GetTrafficPolicyInstanceCountCommand = (function (_super) {
-    __extends(GetTrafficPolicyInstanceCountCommand, _super);
-    function GetTrafficPolicyInstanceCountCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetTrafficPolicyInstanceCountCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetTrafficPolicyInstanceCountCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetTrafficPolicyInstanceCountCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "GetTrafficPolicyInstanceCountCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetTrafficPolicyInstanceCountRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetTrafficPolicyInstanceCountResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetTrafficPolicyInstanceCountCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlGetTrafficPolicyInstanceCountCommand(input, context);
-    };
-    GetTrafficPolicyInstanceCountCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlGetTrafficPolicyInstanceCountCommand(output, context);
-    };
-    return GetTrafficPolicyInstanceCountCommand;
-}($Command));
-export { GetTrafficPolicyInstanceCountCommand };
+    }
+}

package/dist-es/commands/ListCidrBlocksCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListCidrBlocksRequestFilterSensitiveLog, ListCidrBlocksResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlListCidrBlocksCommand, serializeAws_restXmlListCidrBlocksCommand, } from "../protocols/Aws_restXml";
-var ListCidrBlocksCommand = (function (_super) {
-    __extends(ListCidrBlocksCommand, _super);
-    function ListCidrBlocksCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ListCidrBlocksCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ListCidrBlocksCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "ListCidrBlocksCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53Client";
+        const commandName = "ListCidrBlocksCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ListCidrBlocksRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListCidrBlocksResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ListCidrBlocksCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restXmlListCidrBlocksCommand(input, context);
-    };
-    ListCidrBlocksCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restXmlListCidrBlocksCommand(output, context);
-    };
-    return ListCidrBlocksCommand;
-}($Command));
-export { ListCidrBlocksCommand };
+    }
+}