@aws-sdk/client-cloudwatch 3.181.0 → 3.183.0

package/dist-es/commands/DescribeInsightRulesCommand.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 { DescribeInsightRulesInputFilterSensitiveLog, DescribeInsightRulesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeInsightRulesCommand, serializeAws_queryDescribeInsightRulesCommand, } from "../protocols/Aws_query";
-var DescribeInsightRulesCommand = (function (_super) {
-    __extends(DescribeInsightRulesCommand, _super);
-    function DescribeInsightRulesCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DescribeInsightRulesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DescribeInsightRulesCommand.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 = "CloudWatchClient";
-        var commandName = "DescribeInsightRulesCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "DescribeInsightRulesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DescribeInsightRulesInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeInsightRulesOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DescribeInsightRulesCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryDescribeInsightRulesCommand(input, context);
-    };
-    DescribeInsightRulesCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryDescribeInsightRulesCommand(output, context);
-    };
-    return DescribeInsightRulesCommand;
-}($Command));
-export { DescribeInsightRulesCommand };
+    }
+}

package/dist-es/commands/DisableAlarmActionsCommand.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 { DisableAlarmActionsInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryDisableAlarmActionsCommand, serializeAws_queryDisableAlarmActionsCommand, } from "../protocols/Aws_query";
-var DisableAlarmActionsCommand = (function (_super) {
-    __extends(DisableAlarmActionsCommand, _super);
-    function DisableAlarmActionsCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DisableAlarmActionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DisableAlarmActionsCommand.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 = "CloudWatchClient";
-        var commandName = "DisableAlarmActionsCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "DisableAlarmActionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DisableAlarmActionsInputFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DisableAlarmActionsCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryDisableAlarmActionsCommand(input, context);
-    };
-    DisableAlarmActionsCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryDisableAlarmActionsCommand(output, context);
-    };
-    return DisableAlarmActionsCommand;
-}($Command));
-export { DisableAlarmActionsCommand };
+    }
+}

package/dist-es/commands/DisableInsightRulesCommand.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 { DisableInsightRulesInputFilterSensitiveLog, DisableInsightRulesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDisableInsightRulesCommand, serializeAws_queryDisableInsightRulesCommand, } from "../protocols/Aws_query";
-var DisableInsightRulesCommand = (function (_super) {
-    __extends(DisableInsightRulesCommand, _super);
-    function DisableInsightRulesCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DisableInsightRulesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DisableInsightRulesCommand.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 = "CloudWatchClient";
-        var commandName = "DisableInsightRulesCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "DisableInsightRulesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DisableInsightRulesInputFilterSensitiveLog,
             outputFilterSensitiveLog: DisableInsightRulesOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DisableInsightRulesCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryDisableInsightRulesCommand(input, context);
-    };
-    DisableInsightRulesCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryDisableInsightRulesCommand(output, context);
-    };
-    return DisableInsightRulesCommand;
-}($Command));
-export { DisableInsightRulesCommand };
+    }
+}

package/dist-es/commands/EnableAlarmActionsCommand.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 { EnableAlarmActionsInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryEnableAlarmActionsCommand, serializeAws_queryEnableAlarmActionsCommand, } from "../protocols/Aws_query";
-var EnableAlarmActionsCommand = (function (_super) {
-    __extends(EnableAlarmActionsCommand, _super);
-    function EnableAlarmActionsCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class EnableAlarmActionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    EnableAlarmActionsCommand.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 = "CloudWatchClient";
-        var commandName = "EnableAlarmActionsCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "EnableAlarmActionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: EnableAlarmActionsInputFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    EnableAlarmActionsCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryEnableAlarmActionsCommand(input, context);
-    };
-    EnableAlarmActionsCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryEnableAlarmActionsCommand(output, context);
-    };
-    return EnableAlarmActionsCommand;
-}($Command));
-export { EnableAlarmActionsCommand };
+    }
+}

package/dist-es/commands/EnableInsightRulesCommand.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 { EnableInsightRulesInputFilterSensitiveLog, EnableInsightRulesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryEnableInsightRulesCommand, serializeAws_queryEnableInsightRulesCommand, } from "../protocols/Aws_query";
-var EnableInsightRulesCommand = (function (_super) {
-    __extends(EnableInsightRulesCommand, _super);
-    function EnableInsightRulesCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class EnableInsightRulesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    EnableInsightRulesCommand.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 = "CloudWatchClient";
-        var commandName = "EnableInsightRulesCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "EnableInsightRulesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: EnableInsightRulesInputFilterSensitiveLog,
             outputFilterSensitiveLog: EnableInsightRulesOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    EnableInsightRulesCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryEnableInsightRulesCommand(input, context);
-    };
-    EnableInsightRulesCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryEnableInsightRulesCommand(output, context);
-    };
-    return EnableInsightRulesCommand;
-}($Command));
-export { EnableInsightRulesCommand };
+    }
+}

package/dist-es/commands/GetDashboardCommand.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 { GetDashboardInputFilterSensitiveLog, GetDashboardOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetDashboardCommand, serializeAws_queryGetDashboardCommand } from "../protocols/Aws_query";
-var GetDashboardCommand = (function (_super) {
-    __extends(GetDashboardCommand, _super);
-    function GetDashboardCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetDashboardCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetDashboardCommand.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 = "CloudWatchClient";
-        var commandName = "GetDashboardCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "GetDashboardCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetDashboardInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetDashboardOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetDashboardCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetDashboardCommand(input, context);
-    };
-    GetDashboardCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetDashboardCommand(output, context);
-    };
-    return GetDashboardCommand;
-}($Command));
-export { GetDashboardCommand };
+    }
+}

package/dist-es/commands/GetInsightRuleReportCommand.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 { GetInsightRuleReportInputFilterSensitiveLog, GetInsightRuleReportOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetInsightRuleReportCommand, serializeAws_queryGetInsightRuleReportCommand, } from "../protocols/Aws_query";
-var GetInsightRuleReportCommand = (function (_super) {
-    __extends(GetInsightRuleReportCommand, _super);
-    function GetInsightRuleReportCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetInsightRuleReportCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetInsightRuleReportCommand.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 = "CloudWatchClient";
-        var commandName = "GetInsightRuleReportCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "GetInsightRuleReportCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetInsightRuleReportInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetInsightRuleReportOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetInsightRuleReportCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetInsightRuleReportCommand(input, context);
-    };
-    GetInsightRuleReportCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetInsightRuleReportCommand(output, context);
-    };
-    return GetInsightRuleReportCommand;
-}($Command));
-export { GetInsightRuleReportCommand };
+    }
+}

package/dist-es/commands/GetMetricDataCommand.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 { GetMetricDataInputFilterSensitiveLog, GetMetricDataOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetMetricDataCommand, serializeAws_queryGetMetricDataCommand, } from "../protocols/Aws_query";
-var GetMetricDataCommand = (function (_super) {
-    __extends(GetMetricDataCommand, _super);
-    function GetMetricDataCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetMetricDataCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetMetricDataCommand.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 = "CloudWatchClient";
-        var commandName = "GetMetricDataCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "GetMetricDataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetMetricDataInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetMetricDataOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetMetricDataCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetMetricDataCommand(input, context);
-    };
-    GetMetricDataCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetMetricDataCommand(output, context);
-    };
-    return GetMetricDataCommand;
-}($Command));
-export { GetMetricDataCommand };
+    }
+}

package/dist-es/commands/GetMetricStatisticsCommand.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 { GetMetricStatisticsInputFilterSensitiveLog, GetMetricStatisticsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetMetricStatisticsCommand, serializeAws_queryGetMetricStatisticsCommand, } from "../protocols/Aws_query";
-var GetMetricStatisticsCommand = (function (_super) {
-    __extends(GetMetricStatisticsCommand, _super);
-    function GetMetricStatisticsCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetMetricStatisticsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetMetricStatisticsCommand.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 = "CloudWatchClient";
-        var commandName = "GetMetricStatisticsCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "GetMetricStatisticsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetMetricStatisticsInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetMetricStatisticsOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetMetricStatisticsCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetMetricStatisticsCommand(input, context);
-    };
-    GetMetricStatisticsCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetMetricStatisticsCommand(output, context);
-    };
-    return GetMetricStatisticsCommand;
-}($Command));
-export { GetMetricStatisticsCommand };
+    }
+}

package/dist-es/commands/GetMetricStreamCommand.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 { GetMetricStreamInputFilterSensitiveLog, GetMetricStreamOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetMetricStreamCommand, serializeAws_queryGetMetricStreamCommand, } from "../protocols/Aws_query";
-var GetMetricStreamCommand = (function (_super) {
-    __extends(GetMetricStreamCommand, _super);
-    function GetMetricStreamCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetMetricStreamCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetMetricStreamCommand.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 = "CloudWatchClient";
-        var commandName = "GetMetricStreamCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudWatchClient";
+        const commandName = "GetMetricStreamCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetMetricStreamInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetMetricStreamOutputFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetMetricStreamCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetMetricStreamCommand(input, context);
-    };
-    GetMetricStreamCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetMetricStreamCommand(output, context);
-    };
-    return GetMetricStreamCommand;
-}($Command));
-export { GetMetricStreamCommand };
+    }
+}