@aws-sdk/client-forecast 3.154.0 → 3.155.0

package/dist-es/Forecast.js

@@ -10,6 +10,9 @@ import { CreateForecastExportJobCommand, } from "./commands/CreateForecastExport
 import { CreateMonitorCommand, } from "./commands/CreateMonitorCommand";
 import { CreatePredictorBacktestExportJobCommand, } from "./commands/CreatePredictorBacktestExportJobCommand";
 import { CreatePredictorCommand, } from "./commands/CreatePredictorCommand";
+import { CreateWhatIfAnalysisCommand, } from "./commands/CreateWhatIfAnalysisCommand";
+import { CreateWhatIfForecastCommand, } from "./commands/CreateWhatIfForecastCommand";
+import { CreateWhatIfForecastExportCommand, } from "./commands/CreateWhatIfForecastExportCommand";
 import { DeleteDatasetCommand, } from "./commands/DeleteDatasetCommand";
 import { DeleteDatasetGroupCommand, } from "./commands/DeleteDatasetGroupCommand";
 import { DeleteDatasetImportJobCommand, } from "./commands/DeleteDatasetImportJobCommand";
@@ -21,6 +24,9 @@ import { DeleteMonitorCommand, } from "./commands/DeleteMonitorCommand";
 import { DeletePredictorBacktestExportJobCommand, } from "./commands/DeletePredictorBacktestExportJobCommand";
 import { DeletePredictorCommand, } from "./commands/DeletePredictorCommand";
 import { DeleteResourceTreeCommand, } from "./commands/DeleteResourceTreeCommand";
+import { DeleteWhatIfAnalysisCommand, } from "./commands/DeleteWhatIfAnalysisCommand";
+import { DeleteWhatIfForecastCommand, } from "./commands/DeleteWhatIfForecastCommand";
+import { DeleteWhatIfForecastExportCommand, } from "./commands/DeleteWhatIfForecastExportCommand";
 import { DescribeAutoPredictorCommand, } from "./commands/DescribeAutoPredictorCommand";
 import { DescribeDatasetCommand, } from "./commands/DescribeDatasetCommand";
 import { DescribeDatasetGroupCommand, } from "./commands/DescribeDatasetGroupCommand";
@@ -32,6 +38,9 @@ import { DescribeForecastExportJobCommand, } from "./commands/DescribeForecastEx
 import { DescribeMonitorCommand, } from "./commands/DescribeMonitorCommand";
 import { DescribePredictorBacktestExportJobCommand, } from "./commands/DescribePredictorBacktestExportJobCommand";
 import { DescribePredictorCommand, } from "./commands/DescribePredictorCommand";
+import { DescribeWhatIfAnalysisCommand, } from "./commands/DescribeWhatIfAnalysisCommand";
+import { DescribeWhatIfForecastCommand, } from "./commands/DescribeWhatIfForecastCommand";
+import { DescribeWhatIfForecastExportCommand, } from "./commands/DescribeWhatIfForecastExportCommand";
 import { GetAccuracyMetricsCommand, } from "./commands/GetAccuracyMetricsCommand";
 import { ListDatasetGroupsCommand, } from "./commands/ListDatasetGroupsCommand";
 import { ListDatasetImportJobsCommand, } from "./commands/ListDatasetImportJobsCommand";
@@ -45,6 +54,9 @@ import { ListMonitorsCommand, } from "./commands/ListMonitorsCommand";
 import { ListPredictorBacktestExportJobsCommand, } from "./commands/ListPredictorBacktestExportJobsCommand";
 import { ListPredictorsCommand, } from "./commands/ListPredictorsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { ListWhatIfAnalysesCommand, } from "./commands/ListWhatIfAnalysesCommand";
+import { ListWhatIfForecastExportsCommand, } from "./commands/ListWhatIfForecastExportsCommand";
+import { ListWhatIfForecastsCommand, } from "./commands/ListWhatIfForecastsCommand";
 import { ResumeResourceCommand, } from "./commands/ResumeResourceCommand";
 import { StopResourceCommand, } from "./commands/StopResourceCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
@@ -210,6 +222,48 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.createWhatIfAnalysis = function (args, optionsOrCb, cb) {
+        var command = new CreateWhatIfAnalysisCommand(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.createWhatIfForecast = function (args, optionsOrCb, cb) {
+        var command = new CreateWhatIfForecastCommand(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.createWhatIfForecastExport = function (args, optionsOrCb, cb) {
+        var command = new CreateWhatIfForecastExportCommand(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.deleteDataset = function (args, optionsOrCb, cb) {
         var command = new DeleteDatasetCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -364,6 +418,48 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.deleteWhatIfAnalysis = function (args, optionsOrCb, cb) {
+        var command = new DeleteWhatIfAnalysisCommand(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.deleteWhatIfForecast = function (args, optionsOrCb, cb) {
+        var command = new DeleteWhatIfForecastCommand(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.deleteWhatIfForecastExport = function (args, optionsOrCb, cb) {
+        var command = new DeleteWhatIfForecastExportCommand(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.describeAutoPredictor = function (args, optionsOrCb, cb) {
         var command = new DescribeAutoPredictorCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -518,6 +614,48 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.describeWhatIfAnalysis = function (args, optionsOrCb, cb) {
+        var command = new DescribeWhatIfAnalysisCommand(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.describeWhatIfForecast = function (args, optionsOrCb, cb) {
+        var command = new DescribeWhatIfForecastCommand(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.describeWhatIfForecastExport = function (args, optionsOrCb, cb) {
+        var command = new DescribeWhatIfForecastExportCommand(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.getAccuracyMetrics = function (args, optionsOrCb, cb) {
         var command = new GetAccuracyMetricsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -700,6 +838,48 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.listWhatIfAnalyses = function (args, optionsOrCb, cb) {
+        var command = new ListWhatIfAnalysesCommand(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.listWhatIfForecastExports = function (args, optionsOrCb, cb) {
+        var command = new ListWhatIfForecastExportsCommand(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.listWhatIfForecasts = function (args, optionsOrCb, cb) {
+        var command = new ListWhatIfForecastsCommand(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.resumeResource = function (args, optionsOrCb, cb) {
         var command = new ResumeResourceCommand(args);
         if (typeof optionsOrCb === "function") {

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

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

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

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

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

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

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

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

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

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