@aws-sdk/client-forecast 3.40.0 → 3.45.0

package/dist-es/Forecast.js

@@ -1,7 +1,10 @@
 import { __extends } from "tslib";
+import { CreateAutoPredictorCommand, } from "./commands/CreateAutoPredictorCommand";
 import { CreateDatasetCommand, } from "./commands/CreateDatasetCommand";
 import { CreateDatasetGroupCommand, } from "./commands/CreateDatasetGroupCommand";
 import { CreateDatasetImportJobCommand, } from "./commands/CreateDatasetImportJobCommand";
+import { CreateExplainabilityCommand, } from "./commands/CreateExplainabilityCommand";
+import { CreateExplainabilityExportCommand, } from "./commands/CreateExplainabilityExportCommand";
 import { CreateForecastCommand, } from "./commands/CreateForecastCommand";
 import { CreateForecastExportJobCommand, } from "./commands/CreateForecastExportJobCommand";
 import { CreatePredictorBacktestExportJobCommand, } from "./commands/CreatePredictorBacktestExportJobCommand";
@@ -9,14 +12,19 @@ import { CreatePredictorCommand, } from "./commands/CreatePredictorCommand";
 import { DeleteDatasetCommand, } from "./commands/DeleteDatasetCommand";
 import { DeleteDatasetGroupCommand, } from "./commands/DeleteDatasetGroupCommand";
 import { DeleteDatasetImportJobCommand, } from "./commands/DeleteDatasetImportJobCommand";
+import { DeleteExplainabilityCommand, } from "./commands/DeleteExplainabilityCommand";
+import { DeleteExplainabilityExportCommand, } from "./commands/DeleteExplainabilityExportCommand";
 import { DeleteForecastCommand, } from "./commands/DeleteForecastCommand";
 import { DeleteForecastExportJobCommand, } from "./commands/DeleteForecastExportJobCommand";
 import { DeletePredictorBacktestExportJobCommand, } from "./commands/DeletePredictorBacktestExportJobCommand";
 import { DeletePredictorCommand, } from "./commands/DeletePredictorCommand";
 import { DeleteResourceTreeCommand, } from "./commands/DeleteResourceTreeCommand";
+import { DescribeAutoPredictorCommand, } from "./commands/DescribeAutoPredictorCommand";
 import { DescribeDatasetCommand, } from "./commands/DescribeDatasetCommand";
 import { DescribeDatasetGroupCommand, } from "./commands/DescribeDatasetGroupCommand";
 import { DescribeDatasetImportJobCommand, } from "./commands/DescribeDatasetImportJobCommand";
+import { DescribeExplainabilityCommand, } from "./commands/DescribeExplainabilityCommand";
+import { DescribeExplainabilityExportCommand, } from "./commands/DescribeExplainabilityExportCommand";
 import { DescribeForecastCommand, } from "./commands/DescribeForecastCommand";
 import { DescribeForecastExportJobCommand, } from "./commands/DescribeForecastExportJobCommand";
 import { DescribePredictorBacktestExportJobCommand, } from "./commands/DescribePredictorBacktestExportJobCommand";
@@ -25,6 +33,8 @@ import { GetAccuracyMetricsCommand, } from "./commands/GetAccuracyMetricsCommand
 import { ListDatasetGroupsCommand, } from "./commands/ListDatasetGroupsCommand";
 import { ListDatasetImportJobsCommand, } from "./commands/ListDatasetImportJobsCommand";
 import { ListDatasetsCommand, } from "./commands/ListDatasetsCommand";
+import { ListExplainabilitiesCommand, } from "./commands/ListExplainabilitiesCommand";
+import { ListExplainabilityExportsCommand, } from "./commands/ListExplainabilityExportsCommand";
 import { ListForecastExportJobsCommand, } from "./commands/ListForecastExportJobsCommand";
 import { ListForecastsCommand, } from "./commands/ListForecastsCommand";
 import { ListPredictorBacktestExportJobsCommand, } from "./commands/ListPredictorBacktestExportJobsCommand";
@@ -40,6 +50,20 @@ var Forecast = (function (_super) {
     function Forecast() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    Forecast.prototype.createAutoPredictor = function (args, optionsOrCb, cb) {
+        var command = new CreateAutoPredictorCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Forecast.prototype.createDataset = function (args, optionsOrCb, cb) {
         var command = new CreateDatasetCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -82,6 +106,34 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.createExplainability = function (args, optionsOrCb, cb) {
+        var command = new CreateExplainabilityCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Forecast.prototype.createExplainabilityExport = function (args, optionsOrCb, cb) {
+        var command = new CreateExplainabilityExportCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Forecast.prototype.createForecast = function (args, optionsOrCb, cb) {
         var command = new CreateForecastCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -180,6 +232,34 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.deleteExplainability = function (args, optionsOrCb, cb) {
+        var command = new DeleteExplainabilityCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Forecast.prototype.deleteExplainabilityExport = function (args, optionsOrCb, cb) {
+        var command = new DeleteExplainabilityExportCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Forecast.prototype.deleteForecast = function (args, optionsOrCb, cb) {
         var command = new DeleteForecastCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -250,6 +330,20 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.describeAutoPredictor = function (args, optionsOrCb, cb) {
+        var command = new DescribeAutoPredictorCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Forecast.prototype.describeDataset = function (args, optionsOrCb, cb) {
         var command = new DescribeDatasetCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -292,6 +386,34 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.describeExplainability = function (args, optionsOrCb, cb) {
+        var command = new DescribeExplainabilityCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Forecast.prototype.describeExplainabilityExport = function (args, optionsOrCb, cb) {
+        var command = new DescribeExplainabilityExportCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Forecast.prototype.describeForecast = function (args, optionsOrCb, cb) {
         var command = new DescribeForecastCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -404,6 +526,34 @@ var Forecast = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Forecast.prototype.listExplainabilities = function (args, optionsOrCb, cb) {
+        var command = new ListExplainabilitiesCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Forecast.prototype.listExplainabilityExports = function (args, optionsOrCb, cb) {
+        var command = new ListExplainabilityExportsCommand(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);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Forecast.prototype.listForecastExportJobs = function (args, optionsOrCb, cb) {
         var command = new ListForecastExportJobsCommand(args);
         if (typeof optionsOrCb === "function") {

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

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

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

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

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

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

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

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

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

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

package/dist-es/commands/index.js

@@ -1,6 +1,9 @@
+export * from "./CreateAutoPredictorCommand";
 export * from "./CreateDatasetCommand";
 export * from "./CreateDatasetGroupCommand";
 export * from "./CreateDatasetImportJobCommand";
+export * from "./CreateExplainabilityCommand";
+export * from "./CreateExplainabilityExportCommand";
 export * from "./CreateForecastCommand";
 export * from "./CreateForecastExportJobCommand";
 export * from "./CreatePredictorBacktestExportJobCommand";
@@ -8,14 +11,19 @@ export * from "./CreatePredictorCommand";
 export * from "./DeleteDatasetCommand";
 export * from "./DeleteDatasetGroupCommand";
 export * from "./DeleteDatasetImportJobCommand";
+export * from "./DeleteExplainabilityCommand";
+export * from "./DeleteExplainabilityExportCommand";
 export * from "./DeleteForecastCommand";
 export * from "./DeleteForecastExportJobCommand";
 export * from "./DeletePredictorBacktestExportJobCommand";
 export * from "./DeletePredictorCommand";
 export * from "./DeleteResourceTreeCommand";
+export * from "./DescribeAutoPredictorCommand";
 export * from "./DescribeDatasetCommand";
 export * from "./DescribeDatasetGroupCommand";
 export * from "./DescribeDatasetImportJobCommand";
+export * from "./DescribeExplainabilityCommand";
+export * from "./DescribeExplainabilityExportCommand";
 export * from "./DescribeForecastCommand";
 export * from "./DescribeForecastExportJobCommand";
 export * from "./DescribePredictorBacktestExportJobCommand";
@@ -24,6 +32,8 @@ export * from "./GetAccuracyMetricsCommand";
 export * from "./ListDatasetGroupsCommand";
 export * from "./ListDatasetImportJobsCommand";
 export * from "./ListDatasetsCommand";
+export * from "./ListExplainabilitiesCommand";
+export * from "./ListExplainabilityExportsCommand";
 export * from "./ListForecastExportJobsCommand";
 export * from "./ListForecastsCommand";
 export * from "./ListPredictorBacktestExportJobsCommand";