@aws-sdk/client-forecast 3.95.0 → 3.97.0

package/dist-es/Forecast.js

@@ -7,6 +7,7 @@ import { CreateExplainabilityCommand, } from "./commands/CreateExplainabilityCom
 import { CreateExplainabilityExportCommand, } from "./commands/CreateExplainabilityExportCommand";
 import { CreateForecastCommand, } from "./commands/CreateForecastCommand";
 import { CreateForecastExportJobCommand, } from "./commands/CreateForecastExportJobCommand";
+import { CreateMonitorCommand, } from "./commands/CreateMonitorCommand";
 import { CreatePredictorBacktestExportJobCommand, } from "./commands/CreatePredictorBacktestExportJobCommand";
 import { CreatePredictorCommand, } from "./commands/CreatePredictorCommand";
 import { DeleteDatasetCommand, } from "./commands/DeleteDatasetCommand";
@@ -16,6 +17,7 @@ import { DeleteExplainabilityCommand, } from "./commands/DeleteExplainabilityCom
 import { DeleteExplainabilityExportCommand, } from "./commands/DeleteExplainabilityExportCommand";
 import { DeleteForecastCommand, } from "./commands/DeleteForecastCommand";
 import { DeleteForecastExportJobCommand, } from "./commands/DeleteForecastExportJobCommand";
+import { DeleteMonitorCommand, } from "./commands/DeleteMonitorCommand";
 import { DeletePredictorBacktestExportJobCommand, } from "./commands/DeletePredictorBacktestExportJobCommand";
 import { DeletePredictorCommand, } from "./commands/DeletePredictorCommand";
 import { DeleteResourceTreeCommand, } from "./commands/DeleteResourceTreeCommand";
@@ -27,6 +29,7 @@ import { DescribeExplainabilityCommand, } from "./commands/DescribeExplainabilit
 import { DescribeExplainabilityExportCommand, } from "./commands/DescribeExplainabilityExportCommand";
 import { DescribeForecastCommand, } from "./commands/DescribeForecastCommand";
 import { DescribeForecastExportJobCommand, } from "./commands/DescribeForecastExportJobCommand";
+import { DescribeMonitorCommand, } from "./commands/DescribeMonitorCommand";
 import { DescribePredictorBacktestExportJobCommand, } from "./commands/DescribePredictorBacktestExportJobCommand";
 import { DescribePredictorCommand, } from "./commands/DescribePredictorCommand";
 import { GetAccuracyMetricsCommand, } from "./commands/GetAccuracyMetricsCommand";
@@ -37,9 +40,12 @@ import { ListExplainabilitiesCommand, } from "./commands/ListExplainabilitiesCom
 import { ListExplainabilityExportsCommand, } from "./commands/ListExplainabilityExportsCommand";
 import { ListForecastExportJobsCommand, } from "./commands/ListForecastExportJobsCommand";
 import { ListForecastsCommand, } from "./commands/ListForecastsCommand";
+import { ListMonitorEvaluationsCommand, } from "./commands/ListMonitorEvaluationsCommand";
+import { ListMonitorsCommand, } from "./commands/ListMonitorsCommand";
 import { ListPredictorBacktestExportJobsCommand, } from "./commands/ListPredictorBacktestExportJobsCommand";
 import { ListPredictorsCommand, } from "./commands/ListPredictorsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { ResumeResourceCommand, } from "./commands/ResumeResourceCommand";
 import { StopResourceCommand, } from "./commands/StopResourceCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
@@ -162,6 +168,20 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.createMonitor = function (args, optionsOrCb, cb) {
+        var command = new CreateMonitorCommand(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);
+        }
+    };
     Forecast.prototype.createPredictor = function (args, optionsOrCb, cb) {
         var command = new CreatePredictorCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -288,6 +308,20 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.deleteMonitor = function (args, optionsOrCb, cb) {
+        var command = new DeleteMonitorCommand(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);
+        }
+    };
     Forecast.prototype.deletePredictor = function (args, optionsOrCb, cb) {
         var command = new DeletePredictorCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -442,6 +476,20 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.describeMonitor = function (args, optionsOrCb, cb) {
+        var command = new DescribeMonitorCommand(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);
+        }
+    };
     Forecast.prototype.describePredictor = function (args, optionsOrCb, cb) {
         var command = new DescribePredictorCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -582,6 +630,34 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.listMonitorEvaluations = function (args, optionsOrCb, cb) {
+        var command = new ListMonitorEvaluationsCommand(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);
+        }
+    };
+    Forecast.prototype.listMonitors = function (args, optionsOrCb, cb) {
+        var command = new ListMonitorsCommand(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);
+        }
+    };
     Forecast.prototype.listPredictorBacktestExportJobs = function (args, optionsOrCb, cb) {
         var command = new ListPredictorBacktestExportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -624,6 +700,20 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.resumeResource = function (args, optionsOrCb, cb) {
+        var command = new ResumeResourceCommand(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);
+        }
+    };
     Forecast.prototype.stopResource = function (args, optionsOrCb, cb) {
         var command = new StopResourceCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateMonitorCommand.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 { CreateMonitorRequest, CreateMonitorResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateMonitorCommand, serializeAws_json1_1CreateMonitorCommand, } from "../protocols/Aws_json1_1";
+var CreateMonitorCommand = (function (_super) {
+    __extends(CreateMonitorCommand, _super);
+    function CreateMonitorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateMonitorCommand.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 = "ForecastClient";
+        var commandName = "CreateMonitorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateMonitorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateMonitorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateMonitorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateMonitorCommand(input, context);
+    };
+    CreateMonitorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateMonitorCommand(output, context);
+    };
+    return CreateMonitorCommand;
+}($Command));
+export { CreateMonitorCommand };

package/dist-es/commands/DeleteMonitorCommand.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 { DeleteMonitorRequest } from "../models/models_0";
+import { deserializeAws_json1_1DeleteMonitorCommand, serializeAws_json1_1DeleteMonitorCommand, } from "../protocols/Aws_json1_1";
+var DeleteMonitorCommand = (function (_super) {
+    __extends(DeleteMonitorCommand, _super);
+    function DeleteMonitorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteMonitorCommand.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 = "ForecastClient";
+        var commandName = "DeleteMonitorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteMonitorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteMonitorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteMonitorCommand(input, context);
+    };
+    DeleteMonitorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteMonitorCommand(output, context);
+    };
+    return DeleteMonitorCommand;
+}($Command));
+export { DeleteMonitorCommand };

package/dist-es/commands/DescribeMonitorCommand.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 { DescribeMonitorRequest, DescribeMonitorResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeMonitorCommand, serializeAws_json1_1DescribeMonitorCommand, } from "../protocols/Aws_json1_1";
+var DescribeMonitorCommand = (function (_super) {
+    __extends(DescribeMonitorCommand, _super);
+    function DescribeMonitorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeMonitorCommand.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 = "ForecastClient";
+        var commandName = "DescribeMonitorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeMonitorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeMonitorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeMonitorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeMonitorCommand(input, context);
+    };
+    DescribeMonitorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeMonitorCommand(output, context);
+    };
+    return DescribeMonitorCommand;
+}($Command));
+export { DescribeMonitorCommand };

package/dist-es/commands/ListMonitorEvaluationsCommand.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 { ListMonitorEvaluationsRequest, ListMonitorEvaluationsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListMonitorEvaluationsCommand, serializeAws_json1_1ListMonitorEvaluationsCommand, } from "../protocols/Aws_json1_1";
+var ListMonitorEvaluationsCommand = (function (_super) {
+    __extends(ListMonitorEvaluationsCommand, _super);
+    function ListMonitorEvaluationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListMonitorEvaluationsCommand.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 = "ForecastClient";
+        var commandName = "ListMonitorEvaluationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListMonitorEvaluationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListMonitorEvaluationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListMonitorEvaluationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListMonitorEvaluationsCommand(input, context);
+    };
+    ListMonitorEvaluationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListMonitorEvaluationsCommand(output, context);
+    };
+    return ListMonitorEvaluationsCommand;
+}($Command));
+export { ListMonitorEvaluationsCommand };

package/dist-es/commands/ListMonitorsCommand.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 { ListMonitorsRequest, ListMonitorsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListMonitorsCommand, serializeAws_json1_1ListMonitorsCommand, } from "../protocols/Aws_json1_1";
+var ListMonitorsCommand = (function (_super) {
+    __extends(ListMonitorsCommand, _super);
+    function ListMonitorsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListMonitorsCommand.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 = "ForecastClient";
+        var commandName = "ListMonitorsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListMonitorsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListMonitorsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListMonitorsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListMonitorsCommand(input, context);
+    };
+    ListMonitorsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListMonitorsCommand(output, context);
+    };
+    return ListMonitorsCommand;
+}($Command));
+export { ListMonitorsCommand };

package/dist-es/commands/ResumeResourceCommand.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 { ResumeResourceRequest } from "../models/models_0";
+import { deserializeAws_json1_1ResumeResourceCommand, serializeAws_json1_1ResumeResourceCommand, } from "../protocols/Aws_json1_1";
+var ResumeResourceCommand = (function (_super) {
+    __extends(ResumeResourceCommand, _super);
+    function ResumeResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ResumeResourceCommand.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 = "ForecastClient";
+        var commandName = "ResumeResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ResumeResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ResumeResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ResumeResourceCommand(input, context);
+    };
+    ResumeResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ResumeResourceCommand(output, context);
+    };
+    return ResumeResourceCommand;
+}($Command));
+export { ResumeResourceCommand };

package/dist-es/commands/index.js

@@ -6,6 +6,7 @@ export * from "./CreateExplainabilityCommand";
 export * from "./CreateExplainabilityExportCommand";
 export * from "./CreateForecastCommand";
 export * from "./CreateForecastExportJobCommand";
+export * from "./CreateMonitorCommand";
 export * from "./CreatePredictorBacktestExportJobCommand";
 export * from "./CreatePredictorCommand";
 export * from "./DeleteDatasetCommand";
@@ -15,6 +16,7 @@ export * from "./DeleteExplainabilityCommand";
 export * from "./DeleteExplainabilityExportCommand";
 export * from "./DeleteForecastCommand";
 export * from "./DeleteForecastExportJobCommand";
+export * from "./DeleteMonitorCommand";
 export * from "./DeletePredictorBacktestExportJobCommand";
 export * from "./DeletePredictorCommand";
 export * from "./DeleteResourceTreeCommand";
@@ -26,6 +28,7 @@ export * from "./DescribeExplainabilityCommand";
 export * from "./DescribeExplainabilityExportCommand";
 export * from "./DescribeForecastCommand";
 export * from "./DescribeForecastExportJobCommand";
+export * from "./DescribeMonitorCommand";
 export * from "./DescribePredictorBacktestExportJobCommand";
 export * from "./DescribePredictorCommand";
 export * from "./GetAccuracyMetricsCommand";
@@ -36,9 +39,12 @@ export * from "./ListExplainabilitiesCommand";
 export * from "./ListExplainabilityExportsCommand";
 export * from "./ListForecastExportJobsCommand";
 export * from "./ListForecastsCommand";
+export * from "./ListMonitorEvaluationsCommand";
+export * from "./ListMonitorsCommand";
 export * from "./ListPredictorBacktestExportJobsCommand";
 export * from "./ListPredictorsCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./ResumeResourceCommand";
 export * from "./StopResourceCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";

package/dist-es/models/models_0.js

@@ -17,6 +17,10 @@ export var EncryptionConfig;
 (function (EncryptionConfig) {
     EncryptionConfig.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(EncryptionConfig || (EncryptionConfig = {}));
+export var MonitorConfig;
+(function (MonitorConfig) {
+    MonitorConfig.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(MonitorConfig || (MonitorConfig = {}));
 export var OptimizationMetric;
 (function (OptimizationMetric) {
     OptimizationMetric["AverageWeightedQuantileLoss"] = "AverageWeightedQuantileLoss";
@@ -216,6 +220,14 @@ export var CreateForecastExportJobResponse;
 (function (CreateForecastExportJobResponse) {
     CreateForecastExportJobResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(CreateForecastExportJobResponse || (CreateForecastExportJobResponse = {}));
+export var CreateMonitorRequest;
+(function (CreateMonitorRequest) {
+    CreateMonitorRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Tags && { Tags: obj.Tags.map(function (item) { return Tag.filterSensitiveLog(item); }) }))); };
+})(CreateMonitorRequest || (CreateMonitorRequest = {}));
+export var CreateMonitorResponse;
+(function (CreateMonitorResponse) {
+    CreateMonitorResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateMonitorResponse || (CreateMonitorResponse = {}));
 export var AutoMLOverrideStrategy;
 (function (AutoMLOverrideStrategy) {
     AutoMLOverrideStrategy["AccuracyOptimized"] = "AccuracyOptimized";
@@ -320,6 +332,10 @@ export var DeleteForecastExportJobRequest;
 (function (DeleteForecastExportJobRequest) {
     DeleteForecastExportJobRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DeleteForecastExportJobRequest || (DeleteForecastExportJobRequest = {}));
+export var DeleteMonitorRequest;
+(function (DeleteMonitorRequest) {
+    DeleteMonitorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteMonitorRequest || (DeleteMonitorRequest = {}));
 export var DeletePredictorRequest;
 (function (DeletePredictorRequest) {
     DeletePredictorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -340,6 +356,10 @@ export var ExplainabilityInfo;
 (function (ExplainabilityInfo) {
     ExplainabilityInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ExplainabilityInfo || (ExplainabilityInfo = {}));
+export var MonitorInfo;
+(function (MonitorInfo) {
+    MonitorInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(MonitorInfo || (MonitorInfo = {}));
 export var State;
 (function (State) {
     State["Active"] = "Active";
@@ -413,6 +433,26 @@ export var DescribeForecastExportJobResponse;
 (function (DescribeForecastExportJobResponse) {
     DescribeForecastExportJobResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DescribeForecastExportJobResponse || (DescribeForecastExportJobResponse = {}));
+export var DescribeMonitorRequest;
+(function (DescribeMonitorRequest) {
+    DescribeMonitorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeMonitorRequest || (DescribeMonitorRequest = {}));
+export var BaselineMetric;
+(function (BaselineMetric) {
+    BaselineMetric.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BaselineMetric || (BaselineMetric = {}));
+export var PredictorBaseline;
+(function (PredictorBaseline) {
+    PredictorBaseline.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PredictorBaseline || (PredictorBaseline = {}));
+export var Baseline;
+(function (Baseline) {
+    Baseline.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Baseline || (Baseline = {}));
+export var DescribeMonitorResponse;
+(function (DescribeMonitorResponse) {
+    DescribeMonitorResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeMonitorResponse || (DescribeMonitorResponse = {}));
 export var DescribePredictorRequest;
 (function (DescribePredictorRequest) {
     DescribePredictorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -580,6 +620,42 @@ export var ListForecastsResponse;
 (function (ListForecastsResponse) {
     ListForecastsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ListForecastsResponse || (ListForecastsResponse = {}));
+export var ListMonitorEvaluationsRequest;
+(function (ListMonitorEvaluationsRequest) {
+    ListMonitorEvaluationsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListMonitorEvaluationsRequest || (ListMonitorEvaluationsRequest = {}));
+export var MetricResult;
+(function (MetricResult) {
+    MetricResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(MetricResult || (MetricResult = {}));
+export var MonitorDataSource;
+(function (MonitorDataSource) {
+    MonitorDataSource.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(MonitorDataSource || (MonitorDataSource = {}));
+export var PredictorEvent;
+(function (PredictorEvent) {
+    PredictorEvent.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PredictorEvent || (PredictorEvent = {}));
+export var PredictorMonitorEvaluation;
+(function (PredictorMonitorEvaluation) {
+    PredictorMonitorEvaluation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PredictorMonitorEvaluation || (PredictorMonitorEvaluation = {}));
+export var ListMonitorEvaluationsResponse;
+(function (ListMonitorEvaluationsResponse) {
+    ListMonitorEvaluationsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListMonitorEvaluationsResponse || (ListMonitorEvaluationsResponse = {}));
+export var ListMonitorsRequest;
+(function (ListMonitorsRequest) {
+    ListMonitorsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListMonitorsRequest || (ListMonitorsRequest = {}));
+export var MonitorSummary;
+(function (MonitorSummary) {
+    MonitorSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(MonitorSummary || (MonitorSummary = {}));
+export var ListMonitorsResponse;
+(function (ListMonitorsResponse) {
+    ListMonitorsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListMonitorsResponse || (ListMonitorsResponse = {}));
 export var ListPredictorBacktestExportJobsRequest;
 (function (ListPredictorBacktestExportJobsRequest) {
     ListPredictorBacktestExportJobsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -612,6 +688,10 @@ export var ListTagsForResourceResponse;
 (function (ListTagsForResourceResponse) {
     ListTagsForResourceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Tags && { Tags: obj.Tags.map(function (item) { return Tag.filterSensitiveLog(item); }) }))); };
 })(ListTagsForResourceResponse || (ListTagsForResourceResponse = {}));
+export var ResumeResourceRequest;
+(function (ResumeResourceRequest) {
+    ResumeResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResumeResourceRequest || (ResumeResourceRequest = {}));
 export var StopResourceRequest;
 (function (StopResourceRequest) {
     StopResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListExplainabilitiesPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListExplainabilitiesCommand, } from "../commands/ListExplainabilitiesCommand";
+import { Forecast } from "../Forecast";
+import { ForecastClient } from "../ForecastClient";
+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 ListExplainabilitiesCommand(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.listExplainabilities.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListExplainabilities(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListExplainabilities_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 Forecast)) 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 ForecastClient)) 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 Forecast | ForecastClient");
+                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()];
+            }
+        });
+    });
+}