@aws-sdk/client-cloudwatch 3.183.0 → 3.185.0

package/dist-es/CloudWatch.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { CloudWatchClient } from "./CloudWatchClient";
 import { DeleteAlarmsCommand, } from "./commands/DeleteAlarmsCommand";
 import { DeleteAnomalyDetectorCommand, } from "./commands/DeleteAnomalyDetectorCommand";
@@ -37,537 +38,543 @@ import { StartMetricStreamsCommand, } from "./commands/StartMetricStreamsCommand
 import { StopMetricStreamsCommand, } from "./commands/StopMetricStreamsCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
-export class CloudWatch extends CloudWatchClient {
-    deleteAlarms(args, optionsOrCb, cb) {
-        const command = new DeleteAlarmsCommand(args);
+var CloudWatch = (function (_super) {
+    __extends(CloudWatch, _super);
+    function CloudWatch() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CloudWatch.prototype.deleteAlarms = function (args, optionsOrCb, cb) {
+        var command = new DeleteAlarmsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAnomalyDetector(args, optionsOrCb, cb) {
-        const command = new DeleteAnomalyDetectorCommand(args);
+    };
+    CloudWatch.prototype.deleteAnomalyDetector = function (args, optionsOrCb, cb) {
+        var command = new DeleteAnomalyDetectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDashboards(args, optionsOrCb, cb) {
-        const command = new DeleteDashboardsCommand(args);
+    };
+    CloudWatch.prototype.deleteDashboards = function (args, optionsOrCb, cb) {
+        var command = new DeleteDashboardsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteInsightRules(args, optionsOrCb, cb) {
-        const command = new DeleteInsightRulesCommand(args);
+    };
+    CloudWatch.prototype.deleteInsightRules = function (args, optionsOrCb, cb) {
+        var command = new DeleteInsightRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteMetricStream(args, optionsOrCb, cb) {
-        const command = new DeleteMetricStreamCommand(args);
+    };
+    CloudWatch.prototype.deleteMetricStream = function (args, optionsOrCb, cb) {
+        var command = new DeleteMetricStreamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAlarmHistory(args, optionsOrCb, cb) {
-        const command = new DescribeAlarmHistoryCommand(args);
+    };
+    CloudWatch.prototype.describeAlarmHistory = function (args, optionsOrCb, cb) {
+        var command = new DescribeAlarmHistoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAlarms(args, optionsOrCb, cb) {
-        const command = new DescribeAlarmsCommand(args);
+    };
+    CloudWatch.prototype.describeAlarms = function (args, optionsOrCb, cb) {
+        var command = new DescribeAlarmsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAlarmsForMetric(args, optionsOrCb, cb) {
-        const command = new DescribeAlarmsForMetricCommand(args);
+    };
+    CloudWatch.prototype.describeAlarmsForMetric = function (args, optionsOrCb, cb) {
+        var command = new DescribeAlarmsForMetricCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAnomalyDetectors(args, optionsOrCb, cb) {
-        const command = new DescribeAnomalyDetectorsCommand(args);
+    };
+    CloudWatch.prototype.describeAnomalyDetectors = function (args, optionsOrCb, cb) {
+        var command = new DescribeAnomalyDetectorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeInsightRules(args, optionsOrCb, cb) {
-        const command = new DescribeInsightRulesCommand(args);
+    };
+    CloudWatch.prototype.describeInsightRules = function (args, optionsOrCb, cb) {
+        var command = new DescribeInsightRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disableAlarmActions(args, optionsOrCb, cb) {
-        const command = new DisableAlarmActionsCommand(args);
+    };
+    CloudWatch.prototype.disableAlarmActions = function (args, optionsOrCb, cb) {
+        var command = new DisableAlarmActionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disableInsightRules(args, optionsOrCb, cb) {
-        const command = new DisableInsightRulesCommand(args);
+    };
+    CloudWatch.prototype.disableInsightRules = function (args, optionsOrCb, cb) {
+        var command = new DisableInsightRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    enableAlarmActions(args, optionsOrCb, cb) {
-        const command = new EnableAlarmActionsCommand(args);
+    };
+    CloudWatch.prototype.enableAlarmActions = function (args, optionsOrCb, cb) {
+        var command = new EnableAlarmActionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    enableInsightRules(args, optionsOrCb, cb) {
-        const command = new EnableInsightRulesCommand(args);
+    };
+    CloudWatch.prototype.enableInsightRules = function (args, optionsOrCb, cb) {
+        var command = new EnableInsightRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDashboard(args, optionsOrCb, cb) {
-        const command = new GetDashboardCommand(args);
+    };
+    CloudWatch.prototype.getDashboard = function (args, optionsOrCb, cb) {
+        var command = new GetDashboardCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInsightRuleReport(args, optionsOrCb, cb) {
-        const command = new GetInsightRuleReportCommand(args);
+    };
+    CloudWatch.prototype.getInsightRuleReport = function (args, optionsOrCb, cb) {
+        var command = new GetInsightRuleReportCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMetricData(args, optionsOrCb, cb) {
-        const command = new GetMetricDataCommand(args);
+    };
+    CloudWatch.prototype.getMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMetricStatistics(args, optionsOrCb, cb) {
-        const command = new GetMetricStatisticsCommand(args);
+    };
+    CloudWatch.prototype.getMetricStatistics = function (args, optionsOrCb, cb) {
+        var command = new GetMetricStatisticsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMetricStream(args, optionsOrCb, cb) {
-        const command = new GetMetricStreamCommand(args);
+    };
+    CloudWatch.prototype.getMetricStream = function (args, optionsOrCb, cb) {
+        var command = new GetMetricStreamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMetricWidgetImage(args, optionsOrCb, cb) {
-        const command = new GetMetricWidgetImageCommand(args);
+    };
+    CloudWatch.prototype.getMetricWidgetImage = function (args, optionsOrCb, cb) {
+        var command = new GetMetricWidgetImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDashboards(args, optionsOrCb, cb) {
-        const command = new ListDashboardsCommand(args);
+    };
+    CloudWatch.prototype.listDashboards = function (args, optionsOrCb, cb) {
+        var command = new ListDashboardsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listManagedInsightRules(args, optionsOrCb, cb) {
-        const command = new ListManagedInsightRulesCommand(args);
+    };
+    CloudWatch.prototype.listManagedInsightRules = function (args, optionsOrCb, cb) {
+        var command = new ListManagedInsightRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMetrics(args, optionsOrCb, cb) {
-        const command = new ListMetricsCommand(args);
+    };
+    CloudWatch.prototype.listMetrics = function (args, optionsOrCb, cb) {
+        var command = new ListMetricsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMetricStreams(args, optionsOrCb, cb) {
-        const command = new ListMetricStreamsCommand(args);
+    };
+    CloudWatch.prototype.listMetricStreams = function (args, optionsOrCb, cb) {
+        var command = new ListMetricStreamsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    CloudWatch.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putAnomalyDetector(args, optionsOrCb, cb) {
-        const command = new PutAnomalyDetectorCommand(args);
+    };
+    CloudWatch.prototype.putAnomalyDetector = function (args, optionsOrCb, cb) {
+        var command = new PutAnomalyDetectorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putCompositeAlarm(args, optionsOrCb, cb) {
-        const command = new PutCompositeAlarmCommand(args);
+    };
+    CloudWatch.prototype.putCompositeAlarm = function (args, optionsOrCb, cb) {
+        var command = new PutCompositeAlarmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putDashboard(args, optionsOrCb, cb) {
-        const command = new PutDashboardCommand(args);
+    };
+    CloudWatch.prototype.putDashboard = function (args, optionsOrCb, cb) {
+        var command = new PutDashboardCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putInsightRule(args, optionsOrCb, cb) {
-        const command = new PutInsightRuleCommand(args);
+    };
+    CloudWatch.prototype.putInsightRule = function (args, optionsOrCb, cb) {
+        var command = new PutInsightRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putManagedInsightRules(args, optionsOrCb, cb) {
-        const command = new PutManagedInsightRulesCommand(args);
+    };
+    CloudWatch.prototype.putManagedInsightRules = function (args, optionsOrCb, cb) {
+        var command = new PutManagedInsightRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putMetricAlarm(args, optionsOrCb, cb) {
-        const command = new PutMetricAlarmCommand(args);
+    };
+    CloudWatch.prototype.putMetricAlarm = function (args, optionsOrCb, cb) {
+        var command = new PutMetricAlarmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putMetricData(args, optionsOrCb, cb) {
-        const command = new PutMetricDataCommand(args);
+    };
+    CloudWatch.prototype.putMetricData = function (args, optionsOrCb, cb) {
+        var command = new PutMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putMetricStream(args, optionsOrCb, cb) {
-        const command = new PutMetricStreamCommand(args);
+    };
+    CloudWatch.prototype.putMetricStream = function (args, optionsOrCb, cb) {
+        var command = new PutMetricStreamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setAlarmState(args, optionsOrCb, cb) {
-        const command = new SetAlarmStateCommand(args);
+    };
+    CloudWatch.prototype.setAlarmState = function (args, optionsOrCb, cb) {
+        var command = new SetAlarmStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startMetricStreams(args, optionsOrCb, cb) {
-        const command = new StartMetricStreamsCommand(args);
+    };
+    CloudWatch.prototype.startMetricStreams = function (args, optionsOrCb, cb) {
+        var command = new StartMetricStreamsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopMetricStreams(args, optionsOrCb, cb) {
-        const command = new StopMetricStreamsCommand(args);
+    };
+    CloudWatch.prototype.stopMetricStreams = function (args, optionsOrCb, cb) {
+        var command = new StopMetricStreamsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    CloudWatch.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    CloudWatch.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return CloudWatch;
+}(CloudWatchClient));
+export { CloudWatch };