@aws-sdk/client-cloudwatch 3.183.0 → 3.185.0

package/dist-es/commands/DescribeInsightRulesCommand.js

@@ -1,32 +1,39 @@
+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";
-export class DescribeInsightRulesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeInsightRulesCommand = (function (_super) {
+    __extends(DescribeInsightRulesCommand, _super);
+    function DescribeInsightRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeInsightRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "DescribeInsightRulesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "DescribeInsightRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeInsightRulesInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeInsightRulesOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeInsightRulesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeInsightRulesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeInsightRulesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeInsightRulesCommand(output, context);
-    }
-}
+    };
+    return DescribeInsightRulesCommand;
+}($Command));
+export { DescribeInsightRulesCommand };

package/dist-es/commands/DisableAlarmActionsCommand.js

@@ -1,32 +1,39 @@
+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";
-export class DisableAlarmActionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisableAlarmActionsCommand = (function (_super) {
+    __extends(DisableAlarmActionsCommand, _super);
+    function DisableAlarmActionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisableAlarmActionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "DisableAlarmActionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "DisableAlarmActionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisableAlarmActionsInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisableAlarmActionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDisableAlarmActionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisableAlarmActionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDisableAlarmActionsCommand(output, context);
-    }
-}
+    };
+    return DisableAlarmActionsCommand;
+}($Command));
+export { DisableAlarmActionsCommand };

package/dist-es/commands/DisableInsightRulesCommand.js

@@ -1,32 +1,39 @@
+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";
-export class DisableInsightRulesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisableInsightRulesCommand = (function (_super) {
+    __extends(DisableInsightRulesCommand, _super);
+    function DisableInsightRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisableInsightRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "DisableInsightRulesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "DisableInsightRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisableInsightRulesInputFilterSensitiveLog,
             outputFilterSensitiveLog: DisableInsightRulesOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisableInsightRulesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDisableInsightRulesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisableInsightRulesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDisableInsightRulesCommand(output, context);
-    }
-}
+    };
+    return DisableInsightRulesCommand;
+}($Command));
+export { DisableInsightRulesCommand };

package/dist-es/commands/EnableAlarmActionsCommand.js

@@ -1,32 +1,39 @@
+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";
-export class EnableAlarmActionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var EnableAlarmActionsCommand = (function (_super) {
+    __extends(EnableAlarmActionsCommand, _super);
+    function EnableAlarmActionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    EnableAlarmActionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "EnableAlarmActionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "EnableAlarmActionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: EnableAlarmActionsInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    EnableAlarmActionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryEnableAlarmActionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    EnableAlarmActionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryEnableAlarmActionsCommand(output, context);
-    }
-}
+    };
+    return EnableAlarmActionsCommand;
+}($Command));
+export { EnableAlarmActionsCommand };

package/dist-es/commands/EnableInsightRulesCommand.js

@@ -1,32 +1,39 @@
+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";
-export class EnableInsightRulesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var EnableInsightRulesCommand = (function (_super) {
+    __extends(EnableInsightRulesCommand, _super);
+    function EnableInsightRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    EnableInsightRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "EnableInsightRulesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "EnableInsightRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: EnableInsightRulesInputFilterSensitiveLog,
             outputFilterSensitiveLog: EnableInsightRulesOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    EnableInsightRulesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryEnableInsightRulesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    EnableInsightRulesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryEnableInsightRulesCommand(output, context);
-    }
-}
+    };
+    return EnableInsightRulesCommand;
+}($Command));
+export { EnableInsightRulesCommand };

package/dist-es/commands/GetDashboardCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetDashboardCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetDashboardCommand = (function (_super) {
+    __extends(GetDashboardCommand, _super);
+    function GetDashboardCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetDashboardCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "GetDashboardCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "GetDashboardCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetDashboardInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetDashboardOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDashboardCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetDashboardCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetDashboardCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetDashboardCommand(output, context);
-    }
-}
+    };
+    return GetDashboardCommand;
+}($Command));
+export { GetDashboardCommand };

package/dist-es/commands/GetInsightRuleReportCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetInsightRuleReportCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetInsightRuleReportCommand = (function (_super) {
+    __extends(GetInsightRuleReportCommand, _super);
+    function GetInsightRuleReportCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetInsightRuleReportCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "GetInsightRuleReportCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "GetInsightRuleReportCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetInsightRuleReportInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetInsightRuleReportOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetInsightRuleReportCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetInsightRuleReportCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetInsightRuleReportCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetInsightRuleReportCommand(output, context);
-    }
-}
+    };
+    return GetInsightRuleReportCommand;
+}($Command));
+export { GetInsightRuleReportCommand };

package/dist-es/commands/GetMetricDataCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetMetricDataCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMetricDataCommand = (function (_super) {
+    __extends(GetMetricDataCommand, _super);
+    function GetMetricDataCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMetricDataCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "GetMetricDataCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "GetMetricDataCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMetricDataInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetMetricDataOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMetricDataCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetMetricDataCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMetricDataCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetMetricDataCommand(output, context);
-    }
-}
+    };
+    return GetMetricDataCommand;
+}($Command));
+export { GetMetricDataCommand };

package/dist-es/commands/GetMetricStatisticsCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetMetricStatisticsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMetricStatisticsCommand = (function (_super) {
+    __extends(GetMetricStatisticsCommand, _super);
+    function GetMetricStatisticsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMetricStatisticsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "GetMetricStatisticsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "GetMetricStatisticsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMetricStatisticsInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetMetricStatisticsOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMetricStatisticsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetMetricStatisticsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMetricStatisticsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetMetricStatisticsCommand(output, context);
-    }
-}
+    };
+    return GetMetricStatisticsCommand;
+}($Command));
+export { GetMetricStatisticsCommand };

package/dist-es/commands/GetMetricStreamCommand.js

@@ -1,32 +1,39 @@
+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";
-export class GetMetricStreamCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMetricStreamCommand = (function (_super) {
+    __extends(GetMetricStreamCommand, _super);
+    function GetMetricStreamCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMetricStreamCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudWatchClient";
-        const commandName = "GetMetricStreamCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "GetMetricStreamCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMetricStreamInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetMetricStreamOutputFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMetricStreamCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetMetricStreamCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMetricStreamCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetMetricStreamCommand(output, context);
-    }
-}
+    };
+    return GetMetricStreamCommand;
+}($Command));
+export { GetMetricStreamCommand };