@aws-sdk/client-forecast 3.42.0 → 3.43.0

package/dist-types/commands/CreateExplainabilityCommand.d.ts

@@ -0,0 +1,153 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { CreateExplainabilityRequest, CreateExplainabilityResponse } from "../models/models_0";
+export interface CreateExplainabilityCommandInput extends CreateExplainabilityRequest {
+}
+export interface CreateExplainabilityCommandOutput extends CreateExplainabilityResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>Explainability is only available for Forecasts and Predictors generated from an
+ *                 AutoPredictor (<a>CreateAutoPredictor</a>)</p>
+ *         </note>
+ *         <p>Creates an Amazon Forecast Explainability.</p>
+ *         <p>Explainability helps you better understand how the attributes in your datasets impact
+ *             forecast. Amazon Forecast uses a metric called Impact scores to quantify the relative
+ *             impact of each attribute and determine whether they increase or decrease forecast
+ *             values.</p>
+ *         <p>To enable Forecast Explainability, your predictor must include at least one of the
+ *             following: related time series, item metadata, or additional datasets like Holidays and
+ *             the Weather Index.</p>
+ *         <p>CreateExplainability accepts either a Predictor ARN or Forecast ARN. To receive
+ *             aggregated Impact scores for all time series and time points in your datasets, provide a
+ *             Predictor ARN. To receive Impact scores for specific time series and time points,
+ *             provide a Forecast ARN.</p>
+ *         <p>
+ *             <b>CreateExplainability with a Predictor ARN</b>
+ *          </p>
+ *         <note>
+ *             <p>You can only have one Explainability resource per predictor. If you already
+ *                 enabled <code>ExplainPredictor</code> in <a>CreateAutoPredictor</a>, that
+ *                 predictor already has an Explainability resource.</p>
+ *         </note>
+ *         <p>The following parameters are required when providing a Predictor ARN:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <code>ExplainabilityName</code> - A unique name for the Explainability.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>ResourceArn</code> - The Arn of the predictor.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>TimePointGranularity</code> - Must be set to “ALL”.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>TimeSeriesGranularity</code> - Must be set to “ALL”.</p>
+ *             </li>
+ *          </ul>
+ *         <p>Do not specify a value for the following parameters:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <code>DataSource</code> - Only valid when TimeSeriesGranularity is
+ *                     “SPECIFIC”.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>Schema</code> - Only valid when TimeSeriesGranularity is
+ *                     “SPECIFIC”.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>StartDateTime</code> - Only valid when TimePointGranularity is
+ *                     “SPECIFIC”.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>EndDateTime</code> - Only valid when TimePointGranularity is
+ *                     “SPECIFIC”.</p>
+ *             </li>
+ *          </ul>
+ *         <p>
+ *             <b>CreateExplainability with a Forecast ARN</b>
+ *          </p>
+ *         <note>
+ *             <p>You can specify a maximum of 50 time series and 1500 time points.</p>
+ *         </note>
+ *         <p>The following parameters are required when providing a Predictor ARN:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <code>ExplainabilityName</code> - A unique name for the Explainability.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>ResourceArn</code> - The Arn of the forecast.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>TimePointGranularity</code> - Either “ALL” or “SPECIFIC”.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>TimeSeriesGranularity</code> - Either “ALL” or “SPECIFIC”.</p>
+ *             </li>
+ *          </ul>
+ *         <p>If you set TimeSeriesGranularity to “SPECIFIC”, you must also provide the
+ *             following:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <code>DataSource</code> - The S3 location of the CSV file specifying your time
+ *                     series.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>Schema</code> - The Schema defines the attributes and attribute types
+ *                     listed in the Data Source.</p>
+ *             </li>
+ *          </ul>
+ *         <p>If you set TimePointGranularity to “SPECIFIC”, you must also provide the
+ *             following:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <code>StartDateTime</code> - The first timestamp in the range of time
+ *                     points.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>EndDateTime</code> - The last timestamp in the range of time
+ *                     points.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, CreateExplainabilityCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, CreateExplainabilityCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new CreateExplainabilityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateExplainabilityCommandInput} for command's `input` shape.
+ * @see {@link CreateExplainabilityCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class CreateExplainabilityCommand extends $Command<CreateExplainabilityCommandInput, CreateExplainabilityCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: CreateExplainabilityCommandInput;
+    constructor(input: CreateExplainabilityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateExplainabilityCommandInput, CreateExplainabilityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateExplainabilityExportCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { CreateExplainabilityExportRequest, CreateExplainabilityExportResponse } from "../models/models_0";
+export interface CreateExplainabilityExportCommandInput extends CreateExplainabilityExportRequest {
+}
+export interface CreateExplainabilityExportCommandOutput extends CreateExplainabilityExportResponse, __MetadataBearer {
+}
+/**
+ * <p>Exports an Explainability resource created by the <a>CreateExplainability</a> operation. Exported files are exported to an Amazon Simple Storage Service (Amazon
+ *             S3) bucket.</p>
+ *         <p>You must specify a <a>DataDestination</a> object that includes an Amazon S3
+ *             bucket and an AWS Identity and Access Management (IAM) role that Amazon Forecast can assume to access the Amazon S3
+ *             bucket. For more information, see <a>aws-forecast-iam-roles</a>.</p>
+ *         <note>
+ *             <p>The <code>Status</code> of the export job must be <code>ACTIVE</code> before you
+ *                 can access the export in your Amazon S3 bucket. To get the status, use the <a>DescribeExplainabilityExport</a> operation.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, CreateExplainabilityExportCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, CreateExplainabilityExportCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new CreateExplainabilityExportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateExplainabilityExportCommandInput} for command's `input` shape.
+ * @see {@link CreateExplainabilityExportCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class CreateExplainabilityExportCommand extends $Command<CreateExplainabilityExportCommandInput, CreateExplainabilityExportCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: CreateExplainabilityExportCommandInput;
+    constructor(input: CreateExplainabilityExportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateExplainabilityExportCommandInput, CreateExplainabilityExportCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreatePredictorCommand.d.ts

@@ -7,35 +7,36 @@ export interface CreatePredictorCommandInput extends CreatePredictorRequest {
 export interface CreatePredictorCommandOutput extends CreatePredictorResponse, __MetadataBearer {
 }
 /**
- * <p>Creates an Amazon Forecast predictor.</p>
- *          <p>In the request, provide a dataset group and either specify an algorithm or let
- *       Amazon Forecast choose an algorithm for you using AutoML. If you specify an algorithm, you also can
- *       override algorithm-specific hyperparameters.</p>
- *          <p>Amazon Forecast uses the algorithm to train a predictor using the latest version of the
- *       datasets in the specified dataset group. You can then generate a
- *       forecast using the <a>CreateForecast</a> operation.</p>
- *          <p>
- *       To see the evaluation metrics, use the <a>GetAccuracyMetrics</a> operation.
- *     </p>
- *          <p>You can specify a featurization configuration to fill and aggregate the data
- *       fields in the <code>TARGET_TIME_SERIES</code> dataset to improve model training. For more
- *       information, see <a>FeaturizationConfig</a>.</p>
+ * <note>
+ *             <p> This operation creates a legacy predictor that does not include all the predictor
+ *         functionalities provided by Amazon Forecast. To create a predictor that is compatible with all
+ *         aspects of Forecast, use CreateAutoPredictor.</p>
+ *          </note>
+ *          <p>Creates an Amazon Forecast predictor.</p>
+ *          <p>In the request, provide a dataset group and either specify an algorithm or let Amazon Forecast
+ *       choose an algorithm for you using AutoML. If you specify an algorithm, you also can override
+ *       algorithm-specific hyperparameters.</p>
+ *          <p>Amazon Forecast uses the algorithm to train a predictor using the latest version of the datasets
+ *       in the specified dataset group. You can then generate a forecast using the <a>CreateForecast</a> operation.</p>
+ *          <p> To see the evaluation metrics, use the <a>GetAccuracyMetrics</a> operation. </p>
+ *          <p>You can specify a featurization configuration to fill and aggregate the data fields in the
+ *         <code>TARGET_TIME_SERIES</code> dataset to improve model training. For more information, see
+ *         <a>FeaturizationConfig</a>.</p>
  *          <p>For RELATED_TIME_SERIES datasets, <code>CreatePredictor</code> verifies that the
  *         <code>DataFrequency</code> specified when the dataset was created matches the
  *         <code>ForecastFrequency</code>. TARGET_TIME_SERIES datasets don't have this restriction.
  *       Amazon Forecast also verifies the delimiter and timestamp format. For more information, see <a>howitworks-datasets-groups</a>.</p>
  *          <p>By default, predictors are trained and evaluated at the 0.1 (P10), 0.5 (P50), and 0.9
- *       (P90) quantiles. You can choose custom forecast types to train and evaluate your predictor
- *       by setting the <code>ForecastTypes</code>.
- *     </p>
+ *       (P90) quantiles. You can choose custom forecast types to train and evaluate your predictor by
+ *       setting the <code>ForecastTypes</code>. </p>
  *          <p>
  *             <b>AutoML</b>
  *          </p>
  *          <p>If you want Amazon Forecast to evaluate each algorithm and choose the one that minimizes the
  *         <code>objective function</code>, set <code>PerformAutoML</code> to <code>true</code>. The
  *         <code>objective function</code> is defined as the mean of the weighted losses over the
- *       forecast types. By default, these are the p10, p50, and p90
- *       quantile losses. For more information, see <a>EvaluationResult</a>.</p>
+ *       forecast types. By default, these are the p10, p50, and p90 quantile losses. For more
+ *       information, see <a>EvaluationResult</a>.</p>
  *          <p>When AutoML is enabled, the following properties are disallowed:</p>
  *          <ul>
  *             <li>

package/dist-types/commands/DeleteExplainabilityCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { DeleteExplainabilityRequest } from "../models/models_0";
+export interface DeleteExplainabilityCommandInput extends DeleteExplainabilityRequest {
+}
+export interface DeleteExplainabilityCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes an Explainability resource.</p>
+ *         <p>You can delete only predictor that have a status of <code>ACTIVE</code> or
+ *                 <code>CREATE_FAILED</code>. To get the status, use the <a>DescribeExplainability</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, DeleteExplainabilityCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, DeleteExplainabilityCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new DeleteExplainabilityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteExplainabilityCommandInput} for command's `input` shape.
+ * @see {@link DeleteExplainabilityCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class DeleteExplainabilityCommand extends $Command<DeleteExplainabilityCommandInput, DeleteExplainabilityCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: DeleteExplainabilityCommandInput;
+    constructor(input: DeleteExplainabilityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteExplainabilityCommandInput, DeleteExplainabilityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteExplainabilityExportCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { DeleteExplainabilityExportRequest } from "../models/models_0";
+export interface DeleteExplainabilityExportCommandInput extends DeleteExplainabilityExportRequest {
+}
+export interface DeleteExplainabilityExportCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes an Explainability export job.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, DeleteExplainabilityExportCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, DeleteExplainabilityExportCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new DeleteExplainabilityExportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteExplainabilityExportCommandInput} for command's `input` shape.
+ * @see {@link DeleteExplainabilityExportCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class DeleteExplainabilityExportCommand extends $Command<DeleteExplainabilityExportCommandInput, DeleteExplainabilityExportCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: DeleteExplainabilityExportCommandInput;
+    constructor(input: DeleteExplainabilityExportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteExplainabilityExportCommandInput, DeleteExplainabilityExportCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeAutoPredictorCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { DescribeAutoPredictorRequest, DescribeAutoPredictorResponse } from "../models/models_0";
+export interface DescribeAutoPredictorCommandInput extends DescribeAutoPredictorRequest {
+}
+export interface DescribeAutoPredictorCommandOutput extends DescribeAutoPredictorResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes a predictor created using the CreateAutoPredictor operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, DescribeAutoPredictorCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, DescribeAutoPredictorCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new DescribeAutoPredictorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeAutoPredictorCommandInput} for command's `input` shape.
+ * @see {@link DescribeAutoPredictorCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class DescribeAutoPredictorCommand extends $Command<DescribeAutoPredictorCommandInput, DescribeAutoPredictorCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: DescribeAutoPredictorCommandInput;
+    constructor(input: DescribeAutoPredictorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAutoPredictorCommandInput, DescribeAutoPredictorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeExplainabilityCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { DescribeExplainabilityRequest, DescribeExplainabilityResponse } from "../models/models_0";
+export interface DescribeExplainabilityCommandInput extends DescribeExplainabilityRequest {
+}
+export interface DescribeExplainabilityCommandOutput extends DescribeExplainabilityResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes an Explainability resource created using the <a>CreateExplainability</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, DescribeExplainabilityCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, DescribeExplainabilityCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new DescribeExplainabilityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeExplainabilityCommandInput} for command's `input` shape.
+ * @see {@link DescribeExplainabilityCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class DescribeExplainabilityCommand extends $Command<DescribeExplainabilityCommandInput, DescribeExplainabilityCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: DescribeExplainabilityCommandInput;
+    constructor(input: DescribeExplainabilityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExplainabilityCommandInput, DescribeExplainabilityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeExplainabilityExportCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { DescribeExplainabilityExportRequest, DescribeExplainabilityExportResponse } from "../models/models_0";
+export interface DescribeExplainabilityExportCommandInput extends DescribeExplainabilityExportRequest {
+}
+export interface DescribeExplainabilityExportCommandOutput extends DescribeExplainabilityExportResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes an Explainability export created using the <a>CreateExplainabilityExport</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, DescribeExplainabilityExportCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, DescribeExplainabilityExportCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new DescribeExplainabilityExportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeExplainabilityExportCommandInput} for command's `input` shape.
+ * @see {@link DescribeExplainabilityExportCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class DescribeExplainabilityExportCommand extends $Command<DescribeExplainabilityExportCommandInput, DescribeExplainabilityExportCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: DescribeExplainabilityExportCommandInput;
+    constructor(input: DescribeExplainabilityExportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExplainabilityExportCommandInput, DescribeExplainabilityExportCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribePredictorCommand.d.ts

@@ -7,7 +7,12 @@ export interface DescribePredictorCommandInput extends DescribePredictorRequest
 export interface DescribePredictorCommandOutput extends DescribePredictorResponse, __MetadataBearer {
 }
 /**
- * <p>Describes a predictor created using the <a>CreatePredictor</a>
+ * <note>
+ *             <p> This operation is only valid for legacy predictors created with CreatePredictor. If you
+ *         are not using a legacy predictor, use DescribeAutoPredictor.</p>
+ *             <p>To upgrade a legacy predictor to AutoPredictor, see Upgrading to AutoPredictor.</p>
+ *          </note>
+ *          <p>Describes a predictor created using the <a>CreatePredictor</a>
  *       operation.</p>
  *          <p>In addition to listing the properties provided in the <code>CreatePredictor</code>
  *       request, this operation lists the following properties:</p>

package/dist-types/commands/ListExplainabilitiesCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { ListExplainabilitiesRequest, ListExplainabilitiesResponse } from "../models/models_0";
+export interface ListExplainabilitiesCommandInput extends ListExplainabilitiesRequest {
+}
+export interface ListExplainabilitiesCommandOutput extends ListExplainabilitiesResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of Explainability resources created using the <a>CreateExplainability</a> operation. This operation returns a summary for
+ *             each Explainability. You can filter the list using an array of <a>Filter</a>
+ *             objects.</p>
+ *         <p>To retrieve the complete set of properties for a particular Explainability resource,
+ *             use the ARN with the <a>DescribeExplainability</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, ListExplainabilitiesCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, ListExplainabilitiesCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new ListExplainabilitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListExplainabilitiesCommandInput} for command's `input` shape.
+ * @see {@link ListExplainabilitiesCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class ListExplainabilitiesCommand extends $Command<ListExplainabilitiesCommandInput, ListExplainabilitiesCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: ListExplainabilitiesCommandInput;
+    constructor(input: ListExplainabilitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListExplainabilitiesCommandInput, ListExplainabilitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListExplainabilityExportsCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ForecastClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ForecastClient";
+import { ListExplainabilityExportsRequest, ListExplainabilityExportsResponse } from "../models/models_0";
+export interface ListExplainabilityExportsCommandInput extends ListExplainabilityExportsRequest {
+}
+export interface ListExplainabilityExportsCommandOutput extends ListExplainabilityExportsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of Explainability exports created using the <a>CreateExplainabilityExport</a> operation. This operation returns a summary
+ *             for each Explainability export. You can filter the list using an array of <a>Filter</a> objects.</p>
+ *         <p>To retrieve the complete set of properties for a particular Explainability export, use
+ *             the ARN with the <a>DescribeExplainability</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ForecastClient, ListExplainabilityExportsCommand } from "@aws-sdk/client-forecast"; // ES Modules import
+ * // const { ForecastClient, ListExplainabilityExportsCommand } = require("@aws-sdk/client-forecast"); // CommonJS import
+ * const client = new ForecastClient(config);
+ * const command = new ListExplainabilityExportsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListExplainabilityExportsCommandInput} for command's `input` shape.
+ * @see {@link ListExplainabilityExportsCommandOutput} for command's `response` shape.
+ * @see {@link ForecastClientResolvedConfig | config} for ForecastClient's `config` shape.
+ *
+ */
+export declare class ListExplainabilityExportsCommand extends $Command<ListExplainabilityExportsCommandInput, ListExplainabilityExportsCommandOutput, ForecastClientResolvedConfig> {
+    readonly input: ListExplainabilityExportsCommandInput;
+    constructor(input: ListExplainabilityExportsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ForecastClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListExplainabilityExportsCommandInput, ListExplainabilityExportsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -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";