@aws-sdk/client-cloudwatch 3.150.0 → 3.153.0

package/dist-es/CloudWatch.js

@@ -21,6 +21,7 @@ import { GetMetricStatisticsCommand, } from "./commands/GetMetricStatisticsComma
 import { GetMetricStreamCommand, } from "./commands/GetMetricStreamCommand";
 import { GetMetricWidgetImageCommand, } from "./commands/GetMetricWidgetImageCommand";
 import { ListDashboardsCommand, } from "./commands/ListDashboardsCommand";
+import { ListManagedInsightRulesCommand, } from "./commands/ListManagedInsightRulesCommand";
 import { ListMetricsCommand } from "./commands/ListMetricsCommand";
 import { ListMetricStreamsCommand, } from "./commands/ListMetricStreamsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
@@ -28,6 +29,7 @@ import { PutAnomalyDetectorCommand, } from "./commands/PutAnomalyDetectorCommand
 import { PutCompositeAlarmCommand, } from "./commands/PutCompositeAlarmCommand";
 import { PutDashboardCommand, } from "./commands/PutDashboardCommand";
 import { PutInsightRuleCommand, } from "./commands/PutInsightRuleCommand";
+import { PutManagedInsightRulesCommand, } from "./commands/PutManagedInsightRulesCommand";
 import { PutMetricAlarmCommand, } from "./commands/PutMetricAlarmCommand";
 import { PutMetricDataCommand, } from "./commands/PutMetricDataCommand";
 import { PutMetricStreamCommand, } from "./commands/PutMetricStreamCommand";
@@ -335,6 +337,20 @@ var CloudWatch = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    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 ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     CloudWatch.prototype.listMetrics = function (args, optionsOrCb, cb) {
         var command = new ListMetricsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -433,6 +449,20 @@ var CloudWatch = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    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 ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     CloudWatch.prototype.putMetricAlarm = function (args, optionsOrCb, cb) {
         var command = new PutMetricAlarmCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/ListManagedInsightRulesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListManagedInsightRulesInputFilterSensitiveLog, ListManagedInsightRulesOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_queryListManagedInsightRulesCommand, serializeAws_queryListManagedInsightRulesCommand, } from "../protocols/Aws_query";
+var ListManagedInsightRulesCommand = (function (_super) {
+    __extends(ListManagedInsightRulesCommand, _super);
+    function ListManagedInsightRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListManagedInsightRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "ListManagedInsightRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListManagedInsightRulesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListManagedInsightRulesOutputFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListManagedInsightRulesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryListManagedInsightRulesCommand(input, context);
+    };
+    ListManagedInsightRulesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryListManagedInsightRulesCommand(output, context);
+    };
+    return ListManagedInsightRulesCommand;
+}($Command));
+export { ListManagedInsightRulesCommand };

package/dist-es/commands/PutManagedInsightRulesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutManagedInsightRulesInputFilterSensitiveLog, PutManagedInsightRulesOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_queryPutManagedInsightRulesCommand, serializeAws_queryPutManagedInsightRulesCommand, } from "../protocols/Aws_query";
+var PutManagedInsightRulesCommand = (function (_super) {
+    __extends(PutManagedInsightRulesCommand, _super);
+    function PutManagedInsightRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutManagedInsightRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CloudWatchClient";
+        var commandName = "PutManagedInsightRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutManagedInsightRulesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: PutManagedInsightRulesOutputFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutManagedInsightRulesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryPutManagedInsightRulesCommand(input, context);
+    };
+    PutManagedInsightRulesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPutManagedInsightRulesCommand(output, context);
+    };
+    return PutManagedInsightRulesCommand;
+}($Command));
+export { PutManagedInsightRulesCommand };

package/dist-es/commands/index.js

@@ -19,6 +19,7 @@ export * from "./GetMetricStatisticsCommand";
 export * from "./GetMetricStreamCommand";
 export * from "./GetMetricWidgetImageCommand";
 export * from "./ListDashboardsCommand";
+export * from "./ListManagedInsightRulesCommand";
 export * from "./ListMetricStreamsCommand";
 export * from "./ListMetricsCommand";
 export * from "./ListTagsForResourceCommand";
@@ -26,6 +27,7 @@ export * from "./PutAnomalyDetectorCommand";
 export * from "./PutCompositeAlarmCommand";
 export * from "./PutDashboardCommand";
 export * from "./PutInsightRuleCommand";
+export * from "./PutManagedInsightRulesCommand";
 export * from "./PutMetricAlarmCommand";
 export * from "./PutMetricDataCommand";
 export * from "./PutMetricStreamCommand";

package/dist-es/models/models_0.js

@@ -260,6 +260,10 @@ export var GetMetricWidgetImageInputFilterSensitiveLog = function (obj) { return
 export var GetMetricWidgetImageOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListDashboardsInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListDashboardsOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ListManagedInsightRulesInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ManagedRuleStateFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ManagedRuleDescriptionFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ListManagedInsightRulesOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListMetricsInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListMetricsOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListMetricStreamsInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -275,6 +279,9 @@ export var PutDashboardInputFilterSensitiveLog = function (obj) { return (__assi
 export var PutDashboardOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var PutInsightRuleInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var PutInsightRuleOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ManagedRuleFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var PutManagedInsightRulesInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var PutManagedInsightRulesOutputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var PutMetricAlarmInputFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var StatisticSetFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var MetricDatumFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/DescribeAnomalyDetectorsPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { CloudWatch } from "../CloudWatch";
+import { CloudWatchClient } from "../CloudWatchClient";
+import { DescribeAnomalyDetectorsCommand, } from "../commands/DescribeAnomalyDetectorsCommand";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new DescribeAnomalyDetectorsCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.describeAnomalyDetectors.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateDescribeAnomalyDetectors(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateDescribeAnomalyDetectors_1() {
+        var token, hasNext, page, prevToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof CloudWatch)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof CloudWatchClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected CloudWatch | CloudWatchClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.NextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/ListManagedInsightRulesPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { CloudWatch } from "../CloudWatch";
+import { CloudWatchClient } from "../CloudWatchClient";
+import { ListManagedInsightRulesCommand, } from "../commands/ListManagedInsightRulesCommand";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListManagedInsightRulesCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listManagedInsightRules.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListManagedInsightRules(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListManagedInsightRules_1() {
+        var token, hasNext, page, prevToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof CloudWatch)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof CloudWatchClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected CloudWatch | CloudWatchClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.NextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -1,8 +1,10 @@
 export * from "./DescribeAlarmHistoryPaginator";
 export * from "./DescribeAlarmsPaginator";
+export * from "./DescribeAnomalyDetectorsPaginator";
 export * from "./DescribeInsightRulesPaginator";
 export * from "./GetMetricDataPaginator";
 export * from "./Interfaces";
 export * from "./ListDashboardsPaginator";
+export * from "./ListManagedInsightRulesPaginator";
 export * from "./ListMetricStreamsPaginator";
 export * from "./ListMetricsPaginator";