/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include <aws/forecast/ForecastService_EXPORTS.h> #include <aws/core/client/ClientConfiguration.h> #include <aws/core/client/AWSClient.h> #include <aws/core/client/AWSClientAsyncCRTP.h> #include <aws/core/utils/json/JsonSerializer.h> #include <aws/forecast/ForecastServiceServiceClientModel.h> namespace Aws { namespace ForecastService { /** * <p>Provides APIs for creating and managing Amazon Forecast resources.</p> */ class AWS_FORECASTSERVICE_API ForecastServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ForecastServiceClient> { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ForecastServiceClientConfiguration ClientConfigurationType; typedef ForecastServiceEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ForecastServiceClient(const Aws::ForecastService::ForecastServiceClientConfiguration& clientConfiguration = Aws::ForecastService::ForecastServiceClientConfiguration(), std::shared_ptr<ForecastServiceEndpointProviderBase> endpointProvider = Aws::MakeShared<ForecastServiceEndpointProvider>(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ForecastServiceClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ForecastServiceEndpointProviderBase> endpointProvider = Aws::MakeShared<ForecastServiceEndpointProvider>(ALLOCATION_TAG), const Aws::ForecastService::ForecastServiceClientConfiguration& clientConfiguration = Aws::ForecastService::ForecastServiceClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ForecastServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider, std::shared_ptr<ForecastServiceEndpointProviderBase> endpointProvider = Aws::MakeShared<ForecastServiceEndpointProvider>(ALLOCATION_TAG), const Aws::ForecastService::ForecastServiceClientConfiguration& clientConfiguration = Aws::ForecastService::ForecastServiceClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ForecastServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ForecastServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ForecastServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ForecastServiceClient(); /** * <p>Creates an Amazon Forecast predictor.</p> <p>Amazon Forecast creates * predictors with AutoPredictor, which involves applying the optimal combination * of algorithms to each time series in your datasets. You can use * <a>CreateAutoPredictor</a> to create new predictors or upgrade/retrain existing * predictors.</p> <p> <b>Creating new predictors</b> </p> <p>The following * parameters are required when creating a new predictor:</p> <ul> <li> <p> * <code>PredictorName</code> - A unique name for the predictor.</p> </li> <li> <p> * <code>DatasetGroupArn</code> - The ARN of the dataset group used to train the * predictor.</p> </li> <li> <p> <code>ForecastFrequency</code> - The granularity * of your forecasts (hourly, daily, weekly, etc).</p> </li> <li> <p> * <code>ForecastHorizon</code> - The number of time-steps that the model predicts. * The forecast horizon is also called the prediction length.</p> </li> </ul> * <p>When creating a new predictor, do not specify a value for * <code>ReferencePredictorArn</code>.</p> <p> <b>Upgrading and retraining * predictors</b> </p> <p>The following parameters are required when retraining or * upgrading a predictor:</p> <ul> <li> <p> <code>PredictorName</code> - A unique * name for the predictor.</p> </li> <li> <p> <code>ReferencePredictorArn</code> - * The ARN of the predictor to retrain or upgrade.</p> </li> </ul> <p>When * upgrading or retraining a predictor, only specify values for the * <code>ReferencePredictorArn</code> and <code>PredictorName</code>. * </p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateAutoPredictor">AWS * API Reference</a></p> */ virtual Model::CreateAutoPredictorOutcome CreateAutoPredictor(const Model::CreateAutoPredictorRequest& request) const; /** * A Callable wrapper for CreateAutoPredictor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateAutoPredictorRequestT = Model::CreateAutoPredictorRequest> Model::CreateAutoPredictorOutcomeCallable CreateAutoPredictorCallable(const CreateAutoPredictorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateAutoPredictor, request); } /** * An Async wrapper for CreateAutoPredictor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateAutoPredictorRequestT = Model::CreateAutoPredictorRequest> void CreateAutoPredictorAsync(const CreateAutoPredictorRequestT& request, const CreateAutoPredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateAutoPredictor, request, handler, context); } /** * <p>Creates an Amazon Forecast dataset. The information about the dataset that * you provide helps Forecast understand how to consume the data for model * training. This includes the following:</p> <ul> <li> <p> <i> * <code>DataFrequency</code> </i> - How frequently your historical time-series * data is collected.</p> </li> <li> <p> <i> <code>Domain</code> </i> and <i> * <code>DatasetType</code> </i> - Each dataset has an associated dataset domain * and a type within the domain. Amazon Forecast provides a list of predefined * domains and types within each domain. For each unique dataset domain and type * within the domain, Amazon Forecast requires your data to include a minimum set * of predefined fields.</p> </li> <li> <p> <i> <code>Schema</code> </i> - A schema * specifies the fields in the dataset, including the field name and data type.</p> * </li> </ul> <p>After creating a dataset, you import your training data into it * and add the dataset to a dataset group. You use the dataset group to create a * predictor. For more information, see <a * href="https://docs.aws.amazon.com/forecast/latest/dg/howitworks-datasets-groups.html">Importing * datasets</a>.</p> <p>To get a list of all your datasets, use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_ListDatasets.html">ListDatasets</a> * operation.</p> <p>For example Forecast datasets, see the <a * href="https://github.com/aws-samples/amazon-forecast-samples">Amazon Forecast * Sample GitHub repository</a>.</p> <p>The <code>Status</code> of a dataset * must be <code>ACTIVE</code> before you can import training data. Use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDataset.html">DescribeDataset</a> * operation to get the status.</p> <p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateDataset">AWS * API Reference</a></p> */ virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const; /** * A Callable wrapper for CreateDataset that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateDatasetRequestT = Model::CreateDatasetRequest> Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateDataset, request); } /** * An Async wrapper for CreateDataset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateDatasetRequestT = Model::CreateDatasetRequest> void CreateDatasetAsync(const CreateDatasetRequestT& request, const CreateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateDataset, request, handler, context); } /** * <p>Creates a dataset group, which holds a collection of related datasets. You * can add datasets to the dataset group when you create the dataset group, or * later by using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_UpdateDatasetGroup.html">UpdateDatasetGroup</a> * operation.</p> <p>After creating a dataset group and adding datasets, you use * the dataset group when you create a predictor. For more information, see <a * href="https://docs.aws.amazon.com/forecast/latest/dg/howitworks-datasets-groups.html">Dataset * groups</a>.</p> <p>To get a list of all your datasets groups, use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_ListDatasetGroups.html">ListDatasetGroups</a> * operation.</p> <p>The <code>Status</code> of a dataset group must be * <code>ACTIVE</code> before you can use the dataset group to create a predictor. * To get the status, use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html">DescribeDatasetGroup</a> * operation.</p> <p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateDatasetGroup">AWS * API Reference</a></p> */ virtual Model::CreateDatasetGroupOutcome CreateDatasetGroup(const Model::CreateDatasetGroupRequest& request) const; /** * A Callable wrapper for CreateDatasetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateDatasetGroupRequestT = Model::CreateDatasetGroupRequest> Model::CreateDatasetGroupOutcomeCallable CreateDatasetGroupCallable(const CreateDatasetGroupRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateDatasetGroup, request); } /** * An Async wrapper for CreateDatasetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateDatasetGroupRequestT = Model::CreateDatasetGroupRequest> void CreateDatasetGroupAsync(const CreateDatasetGroupRequestT& request, const CreateDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateDatasetGroup, request, handler, context); } /** * <p>Imports your training data to an Amazon Forecast dataset. You provide the * location of your training data in an Amazon Simple Storage Service (Amazon S3) * bucket and the Amazon Resource Name (ARN) of the dataset that you want to import * the data to.</p> <p>You must specify a <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DataSource.html">DataSource</a> * object that includes an Identity and Access Management (IAM) role that Amazon * Forecast can assume to access the data, as Amazon Forecast makes a copy of your * data and processes it in an internal Amazon Web Services system. For more * information, see <a * href="https://docs.aws.amazon.com/forecast/latest/dg/aws-forecast-iam-roles.html">Set * up permissions</a>.</p> <p>The training data must be in CSV or Parquet format. * The delimiter must be a comma (,).</p> <p>You can specify the path to a specific * file, the S3 bucket, or to a folder in the S3 bucket. For the latter two cases, * Amazon Forecast imports all files up to the limit of 10,000 files.</p> * <p>Because dataset imports are not aggregated, your most recent dataset import * is the one that is used when training a predictor or generating a forecast. Make * sure that your most recent dataset import contains all of the data you want to * model off of, and not just the new data collected since the previous import.</p> * <p>To get a list of all your dataset import jobs, filtered by specified * criteria, use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_ListDatasetImportJobs.html">ListDatasetImportJobs</a> * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateDatasetImportJob">AWS * API Reference</a></p> */ virtual Model::CreateDatasetImportJobOutcome CreateDatasetImportJob(const Model::CreateDatasetImportJobRequest& request) const; /** * A Callable wrapper for CreateDatasetImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateDatasetImportJobRequestT = Model::CreateDatasetImportJobRequest> Model::CreateDatasetImportJobOutcomeCallable CreateDatasetImportJobCallable(const CreateDatasetImportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateDatasetImportJob, request); } /** * An Async wrapper for CreateDatasetImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateDatasetImportJobRequestT = Model::CreateDatasetImportJobRequest> void CreateDatasetImportJobAsync(const CreateDatasetImportJobRequestT& request, const CreateDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateDatasetImportJob, request, handler, context); } /** * <p>Explainability is only available for Forecasts and Predictors * generated from an AutoPredictor (<a>CreateAutoPredictor</a>)</p> * <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> * <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> <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> <p>You can specify a maximum of 50 time * series and 500 time points.</p> <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><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateExplainability">AWS * API Reference</a></p> */ virtual Model::CreateExplainabilityOutcome CreateExplainability(const Model::CreateExplainabilityRequest& request) const; /** * A Callable wrapper for CreateExplainability that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateExplainabilityRequestT = Model::CreateExplainabilityRequest> Model::CreateExplainabilityOutcomeCallable CreateExplainabilityCallable(const CreateExplainabilityRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateExplainability, request); } /** * An Async wrapper for CreateExplainability that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateExplainabilityRequestT = Model::CreateExplainabilityRequest> void CreateExplainabilityAsync(const CreateExplainabilityRequestT& request, const CreateExplainabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateExplainability, request, handler, context); } /** * <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 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> <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> <p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateExplainabilityExport">AWS * API Reference</a></p> */ virtual Model::CreateExplainabilityExportOutcome CreateExplainabilityExport(const Model::CreateExplainabilityExportRequest& request) const; /** * A Callable wrapper for CreateExplainabilityExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateExplainabilityExportRequestT = Model::CreateExplainabilityExportRequest> Model::CreateExplainabilityExportOutcomeCallable CreateExplainabilityExportCallable(const CreateExplainabilityExportRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateExplainabilityExport, request); } /** * An Async wrapper for CreateExplainabilityExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateExplainabilityExportRequestT = Model::CreateExplainabilityExportRequest> void CreateExplainabilityExportAsync(const CreateExplainabilityExportRequestT& request, const CreateExplainabilityExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateExplainabilityExport, request, handler, context); } /** * <p>Creates a forecast for each item in the <code>TARGET_TIME_SERIES</code> * dataset that was used to train the predictor. This is known as inference. To * retrieve the forecast for a single item at low latency, use the operation. To * export the complete forecast into your Amazon Simple Storage Service (Amazon S3) * bucket, use the <a>CreateForecastExportJob</a> operation.</p> <p>The range of * the forecast is determined by the <code>ForecastHorizon</code> value, which you * specify in the <a>CreatePredictor</a> request. When you query a forecast, you * can request a specific date range within the forecast.</p> <p>To get a list of * all your forecasts, use the <a>ListForecasts</a> operation.</p> <p>The * forecasts generated by Amazon Forecast are in the same time zone as the dataset * that was used to create the predictor.</p> <p>For more information, see * <a>howitworks-forecast</a>.</p> <p>The <code>Status</code> of the * forecast must be <code>ACTIVE</code> before you can query or export the * forecast. Use the <a>DescribeForecast</a> operation to get the status.</p> * <p>By default, a forecast includes predictions for every item * (<code>item_id</code>) in the dataset group that was used to train the * predictor. However, you can use the <code>TimeSeriesSelector</code> object to * generate a forecast on a subset of time series. Forecast creation is skipped for * any time series that you specify that are not in the input dataset. The forecast * export file will not contain these time series or their forecasted * values.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateForecast">AWS * API Reference</a></p> */ virtual Model::CreateForecastOutcome CreateForecast(const Model::CreateForecastRequest& request) const; /** * A Callable wrapper for CreateForecast that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateForecastRequestT = Model::CreateForecastRequest> Model::CreateForecastOutcomeCallable CreateForecastCallable(const CreateForecastRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateForecast, request); } /** * An Async wrapper for CreateForecast that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateForecastRequestT = Model::CreateForecastRequest> void CreateForecastAsync(const CreateForecastRequestT& request, const CreateForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateForecast, request, handler, context); } /** * <p>Exports a forecast created by the <a>CreateForecast</a> operation to your * Amazon Simple Storage Service (Amazon S3) bucket. The forecast file name will * match the following conventions:</p> * <p><ForecastExportJobName>_<ExportTimestamp>_<PartNumber></p> * <p>where the <ExportTimestamp> component is in Java SimpleDateFormat * (yyyy-MM-ddTHH-mm-ssZ).</p> <p>You must specify a <a>DataDestination</a> object * that includes an 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> <p>For more information, see * <a>howitworks-forecast</a>.</p> <p>To get a list of all your forecast export * jobs, use the <a>ListForecastExportJobs</a> operation.</p> <p>The * <code>Status</code> of the forecast export job must be <code>ACTIVE</code> * before you can access the forecast in your Amazon S3 bucket. To get the status, * use the <a>DescribeForecastExportJob</a> operation.</p> <p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateForecastExportJob">AWS * API Reference</a></p> */ virtual Model::CreateForecastExportJobOutcome CreateForecastExportJob(const Model::CreateForecastExportJobRequest& request) const; /** * A Callable wrapper for CreateForecastExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateForecastExportJobRequestT = Model::CreateForecastExportJobRequest> Model::CreateForecastExportJobOutcomeCallable CreateForecastExportJobCallable(const CreateForecastExportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateForecastExportJob, request); } /** * An Async wrapper for CreateForecastExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateForecastExportJobRequestT = Model::CreateForecastExportJobRequest> void CreateForecastExportJobAsync(const CreateForecastExportJobRequestT& request, const CreateForecastExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateForecastExportJob, request, handler, context); } /** * <p>Creates a predictor monitor resource for an existing auto predictor. * Predictor monitoring allows you to see how your predictor's performance changes * over time. For more information, see <a * href="https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring.html">Predictor * Monitoring</a>. </p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateMonitor">AWS * API Reference</a></p> */ virtual Model::CreateMonitorOutcome CreateMonitor(const Model::CreateMonitorRequest& request) const; /** * A Callable wrapper for CreateMonitor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateMonitorRequestT = Model::CreateMonitorRequest> Model::CreateMonitorOutcomeCallable CreateMonitorCallable(const CreateMonitorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateMonitor, request); } /** * An Async wrapper for CreateMonitor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateMonitorRequestT = Model::CreateMonitorRequest> void CreateMonitorAsync(const CreateMonitorRequestT& request, const CreateMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateMonitor, request, handler, context); } /** * <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 * <a>CreateAutoPredictor</a>.</p> <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> <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> <p>When AutoML is enabled, the * following properties are disallowed:</p> <ul> <li> <p> <code>AlgorithmArn</code> * </p> </li> <li> <p> <code>HPOConfig</code> </p> </li> <li> <p> * <code>PerformHPO</code> </p> </li> <li> <p> <code>TrainingParameters</code> </p> * </li> </ul> <p>To get a list of all of your predictors, use the * <a>ListPredictors</a> operation.</p> <p>Before you can use the predictor * to create a forecast, the <code>Status</code> of the predictor must be * <code>ACTIVE</code>, signifying that training has completed. To get the status, * use the <a>DescribePredictor</a> operation.</p> <p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreatePredictor">AWS * API Reference</a></p> */ virtual Model::CreatePredictorOutcome CreatePredictor(const Model::CreatePredictorRequest& request) const; /** * A Callable wrapper for CreatePredictor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreatePredictorRequestT = Model::CreatePredictorRequest> Model::CreatePredictorOutcomeCallable CreatePredictorCallable(const CreatePredictorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreatePredictor, request); } /** * An Async wrapper for CreatePredictor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreatePredictorRequestT = Model::CreatePredictorRequest> void CreatePredictorAsync(const CreatePredictorRequestT& request, const CreatePredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreatePredictor, request, handler, context); } /** * <p>Exports backtest forecasts and accuracy metrics generated by the * <a>CreateAutoPredictor</a> or <a>CreatePredictor</a> operations. Two folders * containing CSV or Parquet files are exported to your specified S3 bucket.</p> * <p> The export file names will match the following conventions:</p> <p> * <code><ExportJobName>_<ExportTimestamp>_<PartNumber>.csv</code> * </p> <p>The <ExportTimestamp> component is in Java SimpleDate format * (yyyy-MM-ddTHH-mm-ssZ).</p> <p>You must specify a <a>DataDestination</a> object * that includes an Amazon S3 bucket and an 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> <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>DescribePredictorBacktestExportJob</a> operation.</p> <p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreatePredictorBacktestExportJob">AWS * API Reference</a></p> */ virtual Model::CreatePredictorBacktestExportJobOutcome CreatePredictorBacktestExportJob(const Model::CreatePredictorBacktestExportJobRequest& request) const; /** * A Callable wrapper for CreatePredictorBacktestExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreatePredictorBacktestExportJobRequestT = Model::CreatePredictorBacktestExportJobRequest> Model::CreatePredictorBacktestExportJobOutcomeCallable CreatePredictorBacktestExportJobCallable(const CreatePredictorBacktestExportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreatePredictorBacktestExportJob, request); } /** * An Async wrapper for CreatePredictorBacktestExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreatePredictorBacktestExportJobRequestT = Model::CreatePredictorBacktestExportJobRequest> void CreatePredictorBacktestExportJobAsync(const CreatePredictorBacktestExportJobRequestT& request, const CreatePredictorBacktestExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreatePredictorBacktestExportJob, request, handler, context); } /** * <p>What-if analysis is a scenario modeling technique where you make a * hypothetical change to a time series and compare the forecasts generated by * these changes against the baseline, unchanged time series. It is important to * remember that the purpose of a what-if analysis is to understand how a forecast * can change given different modifications to the baseline time series.</p> <p>For * example, imagine you are a clothing retailer who is considering an end of season * sale to clear space for new styles. After creating a baseline forecast, you can * use a what-if analysis to investigate how different sales tactics might affect * your goals.</p> <p>You could create a scenario where everything is given a 25% * markdown, and another where everything is given a fixed dollar markdown. You * could create a scenario where the sale lasts for one week and another where the * sale lasts for one month. With a what-if analysis, you can compare many * different scenarios against each other.</p> <p>Note that a what-if analysis is * meant to display what the forecasting model has learned and how it will behave * in the scenarios that you are evaluating. Do not blindly use the results of the * what-if analysis to make business decisions. For instance, forecasts might not * be accurate for novel scenarios where there is no reference available to * determine whether a forecast is good.</p> <p>The <a>TimeSeriesSelector</a> * object defines the items that you want in the what-if analysis.</p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateWhatIfAnalysis">AWS * API Reference</a></p> */ virtual Model::CreateWhatIfAnalysisOutcome CreateWhatIfAnalysis(const Model::CreateWhatIfAnalysisRequest& request) const; /** * A Callable wrapper for CreateWhatIfAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateWhatIfAnalysisRequestT = Model::CreateWhatIfAnalysisRequest> Model::CreateWhatIfAnalysisOutcomeCallable CreateWhatIfAnalysisCallable(const CreateWhatIfAnalysisRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateWhatIfAnalysis, request); } /** * An Async wrapper for CreateWhatIfAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateWhatIfAnalysisRequestT = Model::CreateWhatIfAnalysisRequest> void CreateWhatIfAnalysisAsync(const CreateWhatIfAnalysisRequestT& request, const CreateWhatIfAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateWhatIfAnalysis, request, handler, context); } /** * <p>A what-if forecast is a forecast that is created from a modified version of * the baseline forecast. Each what-if forecast incorporates either a replacement * dataset or a set of transformations to the original dataset. </p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateWhatIfForecast">AWS * API Reference</a></p> */ virtual Model::CreateWhatIfForecastOutcome CreateWhatIfForecast(const Model::CreateWhatIfForecastRequest& request) const; /** * A Callable wrapper for CreateWhatIfForecast that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateWhatIfForecastRequestT = Model::CreateWhatIfForecastRequest> Model::CreateWhatIfForecastOutcomeCallable CreateWhatIfForecastCallable(const CreateWhatIfForecastRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateWhatIfForecast, request); } /** * An Async wrapper for CreateWhatIfForecast that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateWhatIfForecastRequestT = Model::CreateWhatIfForecastRequest> void CreateWhatIfForecastAsync(const CreateWhatIfForecastRequestT& request, const CreateWhatIfForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateWhatIfForecast, request, handler, context); } /** * <p>Exports a forecast created by the <a>CreateWhatIfForecast</a> operation to * your Amazon Simple Storage Service (Amazon S3) bucket. The forecast file name * will match the following conventions:</p> <p> * <code>≈<ForecastExportJobName>_<ExportTimestamp>_<PartNumber></code> * </p> <p>The <ExportTimestamp> component is in Java SimpleDateFormat * (yyyy-MM-ddTHH-mm-ssZ).</p> <p>You must specify a <a>DataDestination</a> object * that includes an 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> <p>For more information, see * <a>howitworks-forecast</a>.</p> <p>To get a list of all your what-if forecast * export jobs, use the <a>ListWhatIfForecastExports</a> operation.</p> * <p>The <code>Status</code> of the forecast export job must be * <code>ACTIVE</code> before you can access the forecast in your Amazon S3 bucket. * To get the status, use the <a>DescribeWhatIfForecastExport</a> operation.</p> * <p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateWhatIfForecastExport">AWS * API Reference</a></p> */ virtual Model::CreateWhatIfForecastExportOutcome CreateWhatIfForecastExport(const Model::CreateWhatIfForecastExportRequest& request) const; /** * A Callable wrapper for CreateWhatIfForecastExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename CreateWhatIfForecastExportRequestT = Model::CreateWhatIfForecastExportRequest> Model::CreateWhatIfForecastExportOutcomeCallable CreateWhatIfForecastExportCallable(const CreateWhatIfForecastExportRequestT& request) const { return SubmitCallable(&ForecastServiceClient::CreateWhatIfForecastExport, request); } /** * An Async wrapper for CreateWhatIfForecastExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename CreateWhatIfForecastExportRequestT = Model::CreateWhatIfForecastExportRequest> void CreateWhatIfForecastExportAsync(const CreateWhatIfForecastExportRequestT& request, const CreateWhatIfForecastExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::CreateWhatIfForecastExport, request, handler, context); } /** * <p>Deletes an Amazon Forecast dataset that was created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html">CreateDataset</a> * operation. You can only delete datasets that have a status of * <code>ACTIVE</code> or <code>CREATE_FAILED</code>. To get the status use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDataset.html">DescribeDataset</a> * operation.</p> <p>Forecast does not automatically update any dataset * groups that contain the deleted dataset. In order to update the dataset group, * use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_UpdateDatasetGroup.html">UpdateDatasetGroup</a> * operation, omitting the deleted dataset's ARN.</p> <p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteDataset">AWS * API Reference</a></p> */ virtual Model::DeleteDatasetOutcome DeleteDataset(const Model::DeleteDatasetRequest& request) const; /** * A Callable wrapper for DeleteDataset that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest> Model::DeleteDatasetOutcomeCallable DeleteDatasetCallable(const DeleteDatasetRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteDataset, request); } /** * An Async wrapper for DeleteDataset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest> void DeleteDatasetAsync(const DeleteDatasetRequestT& request, const DeleteDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteDataset, request, handler, context); } /** * <p>Deletes a dataset group created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html">CreateDatasetGroup</a> * operation. You can only delete dataset groups that have a status of * <code>ACTIVE</code>, <code>CREATE_FAILED</code>, or <code>UPDATE_FAILED</code>. * To get the status, use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html">DescribeDatasetGroup</a> * operation.</p> <p>This operation deletes only the dataset group, not the * datasets in the group.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteDatasetGroup">AWS * API Reference</a></p> */ virtual Model::DeleteDatasetGroupOutcome DeleteDatasetGroup(const Model::DeleteDatasetGroupRequest& request) const; /** * A Callable wrapper for DeleteDatasetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteDatasetGroupRequestT = Model::DeleteDatasetGroupRequest> Model::DeleteDatasetGroupOutcomeCallable DeleteDatasetGroupCallable(const DeleteDatasetGroupRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteDatasetGroup, request); } /** * An Async wrapper for DeleteDatasetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteDatasetGroupRequestT = Model::DeleteDatasetGroupRequest> void DeleteDatasetGroupAsync(const DeleteDatasetGroupRequestT& request, const DeleteDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteDatasetGroup, request, handler, context); } /** * <p>Deletes a dataset import job created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html">CreateDatasetImportJob</a> * operation. You can delete only dataset import jobs that have a status of * <code>ACTIVE</code> or <code>CREATE_FAILED</code>. To get the status, use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetImportJob.html">DescribeDatasetImportJob</a> * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteDatasetImportJob">AWS * API Reference</a></p> */ virtual Model::DeleteDatasetImportJobOutcome DeleteDatasetImportJob(const Model::DeleteDatasetImportJobRequest& request) const; /** * A Callable wrapper for DeleteDatasetImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteDatasetImportJobRequestT = Model::DeleteDatasetImportJobRequest> Model::DeleteDatasetImportJobOutcomeCallable DeleteDatasetImportJobCallable(const DeleteDatasetImportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteDatasetImportJob, request); } /** * An Async wrapper for DeleteDatasetImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteDatasetImportJobRequestT = Model::DeleteDatasetImportJobRequest> void DeleteDatasetImportJobAsync(const DeleteDatasetImportJobRequestT& request, const DeleteDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteDatasetImportJob, request, handler, context); } /** * <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><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteExplainability">AWS * API Reference</a></p> */ virtual Model::DeleteExplainabilityOutcome DeleteExplainability(const Model::DeleteExplainabilityRequest& request) const; /** * A Callable wrapper for DeleteExplainability that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteExplainabilityRequestT = Model::DeleteExplainabilityRequest> Model::DeleteExplainabilityOutcomeCallable DeleteExplainabilityCallable(const DeleteExplainabilityRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteExplainability, request); } /** * An Async wrapper for DeleteExplainability that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteExplainabilityRequestT = Model::DeleteExplainabilityRequest> void DeleteExplainabilityAsync(const DeleteExplainabilityRequestT& request, const DeleteExplainabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteExplainability, request, handler, context); } /** * <p>Deletes an Explainability export.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteExplainabilityExport">AWS * API Reference</a></p> */ virtual Model::DeleteExplainabilityExportOutcome DeleteExplainabilityExport(const Model::DeleteExplainabilityExportRequest& request) const; /** * A Callable wrapper for DeleteExplainabilityExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteExplainabilityExportRequestT = Model::DeleteExplainabilityExportRequest> Model::DeleteExplainabilityExportOutcomeCallable DeleteExplainabilityExportCallable(const DeleteExplainabilityExportRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteExplainabilityExport, request); } /** * An Async wrapper for DeleteExplainabilityExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteExplainabilityExportRequestT = Model::DeleteExplainabilityExportRequest> void DeleteExplainabilityExportAsync(const DeleteExplainabilityExportRequestT& request, const DeleteExplainabilityExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteExplainabilityExport, request, handler, context); } /** * <p>Deletes a forecast created using the <a>CreateForecast</a> operation. You can * delete only forecasts that have a status of <code>ACTIVE</code> or * <code>CREATE_FAILED</code>. To get the status, use the <a>DescribeForecast</a> * operation.</p> <p>You can't delete a forecast while it is being exported. After * a forecast is deleted, you can no longer query the forecast.</p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteForecast">AWS * API Reference</a></p> */ virtual Model::DeleteForecastOutcome DeleteForecast(const Model::DeleteForecastRequest& request) const; /** * A Callable wrapper for DeleteForecast that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteForecastRequestT = Model::DeleteForecastRequest> Model::DeleteForecastOutcomeCallable DeleteForecastCallable(const DeleteForecastRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteForecast, request); } /** * An Async wrapper for DeleteForecast that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteForecastRequestT = Model::DeleteForecastRequest> void DeleteForecastAsync(const DeleteForecastRequestT& request, const DeleteForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteForecast, request, handler, context); } /** * <p>Deletes a forecast export job created using the * <a>CreateForecastExportJob</a> operation. You can delete only export jobs that * have a status of <code>ACTIVE</code> or <code>CREATE_FAILED</code>. To get the * status, use the <a>DescribeForecastExportJob</a> operation.</p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteForecastExportJob">AWS * API Reference</a></p> */ virtual Model::DeleteForecastExportJobOutcome DeleteForecastExportJob(const Model::DeleteForecastExportJobRequest& request) const; /** * A Callable wrapper for DeleteForecastExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteForecastExportJobRequestT = Model::DeleteForecastExportJobRequest> Model::DeleteForecastExportJobOutcomeCallable DeleteForecastExportJobCallable(const DeleteForecastExportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteForecastExportJob, request); } /** * An Async wrapper for DeleteForecastExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteForecastExportJobRequestT = Model::DeleteForecastExportJobRequest> void DeleteForecastExportJobAsync(const DeleteForecastExportJobRequestT& request, const DeleteForecastExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteForecastExportJob, request, handler, context); } /** * <p>Deletes a monitor resource. You can only delete a monitor resource with a * status of <code>ACTIVE</code>, <code>ACTIVE_STOPPED</code>, * <code>CREATE_FAILED</code>, or <code>CREATE_STOPPED</code>.</p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteMonitor">AWS * API Reference</a></p> */ virtual Model::DeleteMonitorOutcome DeleteMonitor(const Model::DeleteMonitorRequest& request) const; /** * A Callable wrapper for DeleteMonitor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteMonitorRequestT = Model::DeleteMonitorRequest> Model::DeleteMonitorOutcomeCallable DeleteMonitorCallable(const DeleteMonitorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteMonitor, request); } /** * An Async wrapper for DeleteMonitor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteMonitorRequestT = Model::DeleteMonitorRequest> void DeleteMonitorAsync(const DeleteMonitorRequestT& request, const DeleteMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteMonitor, request, handler, context); } /** * <p>Deletes a predictor created using the <a>DescribePredictor</a> or * <a>CreatePredictor</a> operations. 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>DescribePredictor</a> operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeletePredictor">AWS * API Reference</a></p> */ virtual Model::DeletePredictorOutcome DeletePredictor(const Model::DeletePredictorRequest& request) const; /** * A Callable wrapper for DeletePredictor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeletePredictorRequestT = Model::DeletePredictorRequest> Model::DeletePredictorOutcomeCallable DeletePredictorCallable(const DeletePredictorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeletePredictor, request); } /** * An Async wrapper for DeletePredictor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeletePredictorRequestT = Model::DeletePredictorRequest> void DeletePredictorAsync(const DeletePredictorRequestT& request, const DeletePredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeletePredictor, request, handler, context); } /** * <p>Deletes a predictor backtest export job.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeletePredictorBacktestExportJob">AWS * API Reference</a></p> */ virtual Model::DeletePredictorBacktestExportJobOutcome DeletePredictorBacktestExportJob(const Model::DeletePredictorBacktestExportJobRequest& request) const; /** * A Callable wrapper for DeletePredictorBacktestExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeletePredictorBacktestExportJobRequestT = Model::DeletePredictorBacktestExportJobRequest> Model::DeletePredictorBacktestExportJobOutcomeCallable DeletePredictorBacktestExportJobCallable(const DeletePredictorBacktestExportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeletePredictorBacktestExportJob, request); } /** * An Async wrapper for DeletePredictorBacktestExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeletePredictorBacktestExportJobRequestT = Model::DeletePredictorBacktestExportJobRequest> void DeletePredictorBacktestExportJobAsync(const DeletePredictorBacktestExportJobRequestT& request, const DeletePredictorBacktestExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeletePredictorBacktestExportJob, request, handler, context); } /** * <p>Deletes an entire resource tree. This operation will delete the parent * resource and its child resources.</p> <p>Child resources are resources that were * created from another resource. For example, when a forecast is generated from a * predictor, the forecast is the child resource and the predictor is the parent * resource.</p> <p>Amazon Forecast resources possess the following parent-child * resource hierarchies:</p> <ul> <li> <p> <b>Dataset</b>: dataset import jobs</p> * </li> <li> <p> <b>Dataset Group</b>: predictors, predictor backtest export jobs, * forecasts, forecast export jobs</p> </li> <li> <p> <b>Predictor</b>: predictor * backtest export jobs, forecasts, forecast export jobs</p> </li> <li> <p> * <b>Forecast</b>: forecast export jobs</p> </li> </ul> <p> * <code>DeleteResourceTree</code> will only delete Amazon Forecast resources, and * will not delete datasets or exported files stored in Amazon S3. </p> * <p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteResourceTree">AWS * API Reference</a></p> */ virtual Model::DeleteResourceTreeOutcome DeleteResourceTree(const Model::DeleteResourceTreeRequest& request) const; /** * A Callable wrapper for DeleteResourceTree that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteResourceTreeRequestT = Model::DeleteResourceTreeRequest> Model::DeleteResourceTreeOutcomeCallable DeleteResourceTreeCallable(const DeleteResourceTreeRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteResourceTree, request); } /** * An Async wrapper for DeleteResourceTree that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteResourceTreeRequestT = Model::DeleteResourceTreeRequest> void DeleteResourceTreeAsync(const DeleteResourceTreeRequestT& request, const DeleteResourceTreeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteResourceTree, request, handler, context); } /** * <p>Deletes a what-if analysis created using the <a>CreateWhatIfAnalysis</a> * operation. You can delete only what-if analyses that have a status of * <code>ACTIVE</code> or <code>CREATE_FAILED</code>. To get the status, use the * <a>DescribeWhatIfAnalysis</a> operation. </p> <p>You can't delete a what-if * analysis while any of its forecasts are being exported.</p><p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteWhatIfAnalysis">AWS * API Reference</a></p> */ virtual Model::DeleteWhatIfAnalysisOutcome DeleteWhatIfAnalysis(const Model::DeleteWhatIfAnalysisRequest& request) const; /** * A Callable wrapper for DeleteWhatIfAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteWhatIfAnalysisRequestT = Model::DeleteWhatIfAnalysisRequest> Model::DeleteWhatIfAnalysisOutcomeCallable DeleteWhatIfAnalysisCallable(const DeleteWhatIfAnalysisRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteWhatIfAnalysis, request); } /** * An Async wrapper for DeleteWhatIfAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteWhatIfAnalysisRequestT = Model::DeleteWhatIfAnalysisRequest> void DeleteWhatIfAnalysisAsync(const DeleteWhatIfAnalysisRequestT& request, const DeleteWhatIfAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteWhatIfAnalysis, request, handler, context); } /** * <p>Deletes a what-if forecast created using the <a>CreateWhatIfForecast</a> * operation. You can delete only what-if forecasts that have a status of * <code>ACTIVE</code> or <code>CREATE_FAILED</code>. To get the status, use the * <a>DescribeWhatIfForecast</a> operation. </p> <p>You can't delete a what-if * forecast while it is being exported. After a what-if forecast is deleted, you * can no longer query the what-if analysis.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteWhatIfForecast">AWS * API Reference</a></p> */ virtual Model::DeleteWhatIfForecastOutcome DeleteWhatIfForecast(const Model::DeleteWhatIfForecastRequest& request) const; /** * A Callable wrapper for DeleteWhatIfForecast that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteWhatIfForecastRequestT = Model::DeleteWhatIfForecastRequest> Model::DeleteWhatIfForecastOutcomeCallable DeleteWhatIfForecastCallable(const DeleteWhatIfForecastRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteWhatIfForecast, request); } /** * An Async wrapper for DeleteWhatIfForecast that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteWhatIfForecastRequestT = Model::DeleteWhatIfForecastRequest> void DeleteWhatIfForecastAsync(const DeleteWhatIfForecastRequestT& request, const DeleteWhatIfForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteWhatIfForecast, request, handler, context); } /** * <p>Deletes a what-if forecast export created using the * <a>CreateWhatIfForecastExport</a> operation. You can delete only what-if * forecast exports that have a status of <code>ACTIVE</code> or * <code>CREATE_FAILED</code>. To get the status, use the * <a>DescribeWhatIfForecastExport</a> operation. </p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteWhatIfForecastExport">AWS * API Reference</a></p> */ virtual Model::DeleteWhatIfForecastExportOutcome DeleteWhatIfForecastExport(const Model::DeleteWhatIfForecastExportRequest& request) const; /** * A Callable wrapper for DeleteWhatIfForecastExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DeleteWhatIfForecastExportRequestT = Model::DeleteWhatIfForecastExportRequest> Model::DeleteWhatIfForecastExportOutcomeCallable DeleteWhatIfForecastExportCallable(const DeleteWhatIfForecastExportRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DeleteWhatIfForecastExport, request); } /** * An Async wrapper for DeleteWhatIfForecastExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DeleteWhatIfForecastExportRequestT = Model::DeleteWhatIfForecastExportRequest> void DeleteWhatIfForecastExportAsync(const DeleteWhatIfForecastExportRequestT& request, const DeleteWhatIfForecastExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DeleteWhatIfForecastExport, request, handler, context); } /** * <p>Describes a predictor created using the CreateAutoPredictor * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeAutoPredictor">AWS * API Reference</a></p> */ virtual Model::DescribeAutoPredictorOutcome DescribeAutoPredictor(const Model::DescribeAutoPredictorRequest& request) const; /** * A Callable wrapper for DescribeAutoPredictor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeAutoPredictorRequestT = Model::DescribeAutoPredictorRequest> Model::DescribeAutoPredictorOutcomeCallable DescribeAutoPredictorCallable(const DescribeAutoPredictorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeAutoPredictor, request); } /** * An Async wrapper for DescribeAutoPredictor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeAutoPredictorRequestT = Model::DescribeAutoPredictorRequest> void DescribeAutoPredictorAsync(const DescribeAutoPredictorRequestT& request, const DescribeAutoPredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeAutoPredictor, request, handler, context); } /** * <p>Describes an Amazon Forecast dataset created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html">CreateDataset</a> * operation.</p> <p>In addition to listing the parameters specified in the * <code>CreateDataset</code> request, this operation includes the following * dataset properties:</p> <ul> <li> <p> <code>CreationTime</code> </p> </li> <li> * <p> <code>LastModificationTime</code> </p> </li> <li> <p> <code>Status</code> * </p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeDataset">AWS * API Reference</a></p> */ virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const; /** * A Callable wrapper for DescribeDataset that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest> Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeDataset, request); } /** * An Async wrapper for DescribeDataset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest> void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeDataset, request, handler, context); } /** * <p>Describes a dataset group created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html">CreateDatasetGroup</a> * operation.</p> <p>In addition to listing the parameters provided in the * <code>CreateDatasetGroup</code> request, this operation includes the following * properties:</p> <ul> <li> <p> <code>DatasetArns</code> - The datasets belonging * to the group.</p> </li> <li> <p> <code>CreationTime</code> </p> </li> <li> <p> * <code>LastModificationTime</code> </p> </li> <li> <p> <code>Status</code> </p> * </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeDatasetGroup">AWS * API Reference</a></p> */ virtual Model::DescribeDatasetGroupOutcome DescribeDatasetGroup(const Model::DescribeDatasetGroupRequest& request) const; /** * A Callable wrapper for DescribeDatasetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeDatasetGroupRequestT = Model::DescribeDatasetGroupRequest> Model::DescribeDatasetGroupOutcomeCallable DescribeDatasetGroupCallable(const DescribeDatasetGroupRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeDatasetGroup, request); } /** * An Async wrapper for DescribeDatasetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeDatasetGroupRequestT = Model::DescribeDatasetGroupRequest> void DescribeDatasetGroupAsync(const DescribeDatasetGroupRequestT& request, const DescribeDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeDatasetGroup, request, handler, context); } /** * <p>Describes a dataset import job created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html">CreateDatasetImportJob</a> * operation.</p> <p>In addition to listing the parameters provided in the * <code>CreateDatasetImportJob</code> request, this operation includes the * following properties:</p> <ul> <li> <p> <code>CreationTime</code> </p> </li> * <li> <p> <code>LastModificationTime</code> </p> </li> <li> <p> * <code>DataSize</code> </p> </li> <li> <p> <code>FieldStatistics</code> </p> * </li> <li> <p> <code>Status</code> </p> </li> <li> <p> <code>Message</code> - If * an error occurred, information about the error.</p> </li> </ul><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeDatasetImportJob">AWS * API Reference</a></p> */ virtual Model::DescribeDatasetImportJobOutcome DescribeDatasetImportJob(const Model::DescribeDatasetImportJobRequest& request) const; /** * A Callable wrapper for DescribeDatasetImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeDatasetImportJobRequestT = Model::DescribeDatasetImportJobRequest> Model::DescribeDatasetImportJobOutcomeCallable DescribeDatasetImportJobCallable(const DescribeDatasetImportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeDatasetImportJob, request); } /** * An Async wrapper for DescribeDatasetImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeDatasetImportJobRequestT = Model::DescribeDatasetImportJobRequest> void DescribeDatasetImportJobAsync(const DescribeDatasetImportJobRequestT& request, const DescribeDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeDatasetImportJob, request, handler, context); } /** * <p>Describes an Explainability resource created using the * <a>CreateExplainability</a> operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeExplainability">AWS * API Reference</a></p> */ virtual Model::DescribeExplainabilityOutcome DescribeExplainability(const Model::DescribeExplainabilityRequest& request) const; /** * A Callable wrapper for DescribeExplainability that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeExplainabilityRequestT = Model::DescribeExplainabilityRequest> Model::DescribeExplainabilityOutcomeCallable DescribeExplainabilityCallable(const DescribeExplainabilityRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeExplainability, request); } /** * An Async wrapper for DescribeExplainability that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeExplainabilityRequestT = Model::DescribeExplainabilityRequest> void DescribeExplainabilityAsync(const DescribeExplainabilityRequestT& request, const DescribeExplainabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeExplainability, request, handler, context); } /** * <p>Describes an Explainability export created using the * <a>CreateExplainabilityExport</a> operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeExplainabilityExport">AWS * API Reference</a></p> */ virtual Model::DescribeExplainabilityExportOutcome DescribeExplainabilityExport(const Model::DescribeExplainabilityExportRequest& request) const; /** * A Callable wrapper for DescribeExplainabilityExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeExplainabilityExportRequestT = Model::DescribeExplainabilityExportRequest> Model::DescribeExplainabilityExportOutcomeCallable DescribeExplainabilityExportCallable(const DescribeExplainabilityExportRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeExplainabilityExport, request); } /** * An Async wrapper for DescribeExplainabilityExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeExplainabilityExportRequestT = Model::DescribeExplainabilityExportRequest> void DescribeExplainabilityExportAsync(const DescribeExplainabilityExportRequestT& request, const DescribeExplainabilityExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeExplainabilityExport, request, handler, context); } /** * <p>Describes a forecast created using the <a>CreateForecast</a> operation.</p> * <p>In addition to listing the properties provided in the * <code>CreateForecast</code> request, this operation lists the following * properties:</p> <ul> <li> <p> <code>DatasetGroupArn</code> - The dataset group * that provided the training data.</p> </li> <li> <p> <code>CreationTime</code> * </p> </li> <li> <p> <code>LastModificationTime</code> </p> </li> <li> <p> * <code>Status</code> </p> </li> <li> <p> <code>Message</code> - If an error * occurred, information about the error.</p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeForecast">AWS * API Reference</a></p> */ virtual Model::DescribeForecastOutcome DescribeForecast(const Model::DescribeForecastRequest& request) const; /** * A Callable wrapper for DescribeForecast that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeForecastRequestT = Model::DescribeForecastRequest> Model::DescribeForecastOutcomeCallable DescribeForecastCallable(const DescribeForecastRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeForecast, request); } /** * An Async wrapper for DescribeForecast that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeForecastRequestT = Model::DescribeForecastRequest> void DescribeForecastAsync(const DescribeForecastRequestT& request, const DescribeForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeForecast, request, handler, context); } /** * <p>Describes a forecast export job created using the * <a>CreateForecastExportJob</a> operation.</p> <p>In addition to listing the * properties provided by the user in the <code>CreateForecastExportJob</code> * request, this operation lists the following properties:</p> <ul> <li> <p> * <code>CreationTime</code> </p> </li> <li> <p> <code>LastModificationTime</code> * </p> </li> <li> <p> <code>Status</code> </p> </li> <li> <p> <code>Message</code> * - If an error occurred, information about the error.</p> </li> </ul><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeForecastExportJob">AWS * API Reference</a></p> */ virtual Model::DescribeForecastExportJobOutcome DescribeForecastExportJob(const Model::DescribeForecastExportJobRequest& request) const; /** * A Callable wrapper for DescribeForecastExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeForecastExportJobRequestT = Model::DescribeForecastExportJobRequest> Model::DescribeForecastExportJobOutcomeCallable DescribeForecastExportJobCallable(const DescribeForecastExportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeForecastExportJob, request); } /** * An Async wrapper for DescribeForecastExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeForecastExportJobRequestT = Model::DescribeForecastExportJobRequest> void DescribeForecastExportJobAsync(const DescribeForecastExportJobRequestT& request, const DescribeForecastExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeForecastExportJob, request, handler, context); } /** * <p>Describes a monitor resource. In addition to listing the properties provided * in the <a>CreateMonitor</a> request, this operation lists the following * properties:</p> <ul> <li> <p> <code>Baseline</code> </p> </li> <li> <p> * <code>CreationTime</code> </p> </li> <li> <p> <code>LastEvaluationTime</code> * </p> </li> <li> <p> <code>LastEvaluationState</code> </p> </li> <li> <p> * <code>LastModificationTime</code> </p> </li> <li> <p> <code>Message</code> </p> * </li> <li> <p> <code>Status</code> </p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeMonitor">AWS * API Reference</a></p> */ virtual Model::DescribeMonitorOutcome DescribeMonitor(const Model::DescribeMonitorRequest& request) const; /** * A Callable wrapper for DescribeMonitor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeMonitorRequestT = Model::DescribeMonitorRequest> Model::DescribeMonitorOutcomeCallable DescribeMonitorCallable(const DescribeMonitorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeMonitor, request); } /** * An Async wrapper for DescribeMonitor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeMonitorRequestT = Model::DescribeMonitorRequest> void DescribeMonitorAsync(const DescribeMonitorRequestT& request, const DescribeMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeMonitor, request, handler, context); } /** * <p> This operation is only valid for legacy predictors created with * CreatePredictor. If you are not using a legacy predictor, use * <a>DescribeAutoPredictor</a>.</p> <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> <ul> <li> <p> * <code>DatasetImportJobArns</code> - The dataset import jobs used to import * training data.</p> </li> <li> <p> <code>AutoMLAlgorithmArns</code> - If AutoML * is performed, the algorithms that were evaluated.</p> </li> <li> <p> * <code>CreationTime</code> </p> </li> <li> <p> <code>LastModificationTime</code> * </p> </li> <li> <p> <code>Status</code> </p> </li> <li> <p> <code>Message</code> * - If an error occurred, information about the error.</p> </li> </ul><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribePredictor">AWS * API Reference</a></p> */ virtual Model::DescribePredictorOutcome DescribePredictor(const Model::DescribePredictorRequest& request) const; /** * A Callable wrapper for DescribePredictor that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribePredictorRequestT = Model::DescribePredictorRequest> Model::DescribePredictorOutcomeCallable DescribePredictorCallable(const DescribePredictorRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribePredictor, request); } /** * An Async wrapper for DescribePredictor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribePredictorRequestT = Model::DescribePredictorRequest> void DescribePredictorAsync(const DescribePredictorRequestT& request, const DescribePredictorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribePredictor, request, handler, context); } /** * <p>Describes a predictor backtest export job created using the * <a>CreatePredictorBacktestExportJob</a> operation.</p> <p>In addition to listing * the properties provided by the user in the * <code>CreatePredictorBacktestExportJob</code> request, this operation lists the * following properties:</p> <ul> <li> <p> <code>CreationTime</code> </p> </li> * <li> <p> <code>LastModificationTime</code> </p> </li> <li> <p> * <code>Status</code> </p> </li> <li> <p> <code>Message</code> (if an error * occurred)</p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribePredictorBacktestExportJob">AWS * API Reference</a></p> */ virtual Model::DescribePredictorBacktestExportJobOutcome DescribePredictorBacktestExportJob(const Model::DescribePredictorBacktestExportJobRequest& request) const; /** * A Callable wrapper for DescribePredictorBacktestExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribePredictorBacktestExportJobRequestT = Model::DescribePredictorBacktestExportJobRequest> Model::DescribePredictorBacktestExportJobOutcomeCallable DescribePredictorBacktestExportJobCallable(const DescribePredictorBacktestExportJobRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribePredictorBacktestExportJob, request); } /** * An Async wrapper for DescribePredictorBacktestExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribePredictorBacktestExportJobRequestT = Model::DescribePredictorBacktestExportJobRequest> void DescribePredictorBacktestExportJobAsync(const DescribePredictorBacktestExportJobRequestT& request, const DescribePredictorBacktestExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribePredictorBacktestExportJob, request, handler, context); } /** * <p>Describes the what-if analysis created using the <a>CreateWhatIfAnalysis</a> * operation.</p> <p>In addition to listing the properties provided in the * <code>CreateWhatIfAnalysis</code> request, this operation lists the following * properties:</p> <ul> <li> <p> <code>CreationTime</code> </p> </li> <li> <p> * <code>LastModificationTime</code> </p> </li> <li> <p> <code>Message</code> - If * an error occurred, information about the error.</p> </li> <li> <p> * <code>Status</code> </p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeWhatIfAnalysis">AWS * API Reference</a></p> */ virtual Model::DescribeWhatIfAnalysisOutcome DescribeWhatIfAnalysis(const Model::DescribeWhatIfAnalysisRequest& request) const; /** * A Callable wrapper for DescribeWhatIfAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeWhatIfAnalysisRequestT = Model::DescribeWhatIfAnalysisRequest> Model::DescribeWhatIfAnalysisOutcomeCallable DescribeWhatIfAnalysisCallable(const DescribeWhatIfAnalysisRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeWhatIfAnalysis, request); } /** * An Async wrapper for DescribeWhatIfAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeWhatIfAnalysisRequestT = Model::DescribeWhatIfAnalysisRequest> void DescribeWhatIfAnalysisAsync(const DescribeWhatIfAnalysisRequestT& request, const DescribeWhatIfAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeWhatIfAnalysis, request, handler, context); } /** * <p>Describes the what-if forecast created using the <a>CreateWhatIfForecast</a> * operation.</p> <p>In addition to listing the properties provided in the * <code>CreateWhatIfForecast</code> request, this operation lists the following * properties:</p> <ul> <li> <p> <code>CreationTime</code> </p> </li> <li> <p> * <code>LastModificationTime</code> </p> </li> <li> <p> <code>Message</code> - If * an error occurred, information about the error.</p> </li> <li> <p> * <code>Status</code> </p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeWhatIfForecast">AWS * API Reference</a></p> */ virtual Model::DescribeWhatIfForecastOutcome DescribeWhatIfForecast(const Model::DescribeWhatIfForecastRequest& request) const; /** * A Callable wrapper for DescribeWhatIfForecast that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeWhatIfForecastRequestT = Model::DescribeWhatIfForecastRequest> Model::DescribeWhatIfForecastOutcomeCallable DescribeWhatIfForecastCallable(const DescribeWhatIfForecastRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeWhatIfForecast, request); } /** * An Async wrapper for DescribeWhatIfForecast that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeWhatIfForecastRequestT = Model::DescribeWhatIfForecastRequest> void DescribeWhatIfForecastAsync(const DescribeWhatIfForecastRequestT& request, const DescribeWhatIfForecastResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeWhatIfForecast, request, handler, context); } /** * <p>Describes the what-if forecast export created using the * <a>CreateWhatIfForecastExport</a> operation.</p> <p>In addition to listing the * properties provided in the <code>CreateWhatIfForecastExport</code> request, this * operation lists the following properties:</p> <ul> <li> <p> * <code>CreationTime</code> </p> </li> <li> <p> <code>LastModificationTime</code> * </p> </li> <li> <p> <code>Message</code> - If an error occurred, information * about the error.</p> </li> <li> <p> <code>Status</code> </p> </li> * </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeWhatIfForecastExport">AWS * API Reference</a></p> */ virtual Model::DescribeWhatIfForecastExportOutcome DescribeWhatIfForecastExport(const Model::DescribeWhatIfForecastExportRequest& request) const; /** * A Callable wrapper for DescribeWhatIfForecastExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename DescribeWhatIfForecastExportRequestT = Model::DescribeWhatIfForecastExportRequest> Model::DescribeWhatIfForecastExportOutcomeCallable DescribeWhatIfForecastExportCallable(const DescribeWhatIfForecastExportRequestT& request) const { return SubmitCallable(&ForecastServiceClient::DescribeWhatIfForecastExport, request); } /** * An Async wrapper for DescribeWhatIfForecastExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename DescribeWhatIfForecastExportRequestT = Model::DescribeWhatIfForecastExportRequest> void DescribeWhatIfForecastExportAsync(const DescribeWhatIfForecastExportRequestT& request, const DescribeWhatIfForecastExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::DescribeWhatIfForecastExport, request, handler, context); } /** * <p>Provides metrics on the accuracy of the models that were trained by the * <a>CreatePredictor</a> operation. Use metrics to see how well the model * performed and to decide whether to use the predictor to generate a forecast. For * more information, see <a * href="https://docs.aws.amazon.com/forecast/latest/dg/metrics.html">Predictor * Metrics</a>.</p> <p>This operation generates metrics for each backtest window * that was evaluated. The number of backtest windows * (<code>NumberOfBacktestWindows</code>) is specified using the * <a>EvaluationParameters</a> object, which is optionally included in the * <code>CreatePredictor</code> request. If <code>NumberOfBacktestWindows</code> * isn't specified, the number defaults to one.</p> <p>The parameters of the * <code>filling</code> method determine which items contribute to the metrics. If * you want all items to contribute, specify <code>zero</code>. If you want only * those items that have complete data in the range being evaluated to contribute, * specify <code>nan</code>. For more information, see * <a>FeaturizationMethod</a>.</p> <p>Before you can get accuracy metrics, * the <code>Status</code> of the predictor must be <code>ACTIVE</code>, signifying * that training has completed. To get the status, use the <a>DescribePredictor</a> * operation.</p> <p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/GetAccuracyMetrics">AWS * API Reference</a></p> */ virtual Model::GetAccuracyMetricsOutcome GetAccuracyMetrics(const Model::GetAccuracyMetricsRequest& request) const; /** * A Callable wrapper for GetAccuracyMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename GetAccuracyMetricsRequestT = Model::GetAccuracyMetricsRequest> Model::GetAccuracyMetricsOutcomeCallable GetAccuracyMetricsCallable(const GetAccuracyMetricsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::GetAccuracyMetrics, request); } /** * An Async wrapper for GetAccuracyMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename GetAccuracyMetricsRequestT = Model::GetAccuracyMetricsRequest> void GetAccuracyMetricsAsync(const GetAccuracyMetricsRequestT& request, const GetAccuracyMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::GetAccuracyMetrics, request, handler, context); } /** * <p>Returns a list of dataset groups created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html">CreateDatasetGroup</a> * operation. For each dataset group, this operation returns a summary of its * properties, including its Amazon Resource Name (ARN). You can retrieve the * complete set of properties by using the dataset group ARN with the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html">DescribeDatasetGroup</a> * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListDatasetGroups">AWS * API Reference</a></p> */ virtual Model::ListDatasetGroupsOutcome ListDatasetGroups(const Model::ListDatasetGroupsRequest& request) const; /** * A Callable wrapper for ListDatasetGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListDatasetGroupsRequestT = Model::ListDatasetGroupsRequest> Model::ListDatasetGroupsOutcomeCallable ListDatasetGroupsCallable(const ListDatasetGroupsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListDatasetGroups, request); } /** * An Async wrapper for ListDatasetGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListDatasetGroupsRequestT = Model::ListDatasetGroupsRequest> void ListDatasetGroupsAsync(const ListDatasetGroupsRequestT& request, const ListDatasetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListDatasetGroups, request, handler, context); } /** * <p>Returns a list of dataset import jobs created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html">CreateDatasetImportJob</a> * operation. For each import job, this operation returns a summary of its * properties, including its Amazon Resource Name (ARN). You can retrieve the * complete set of properties by using the ARN with the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetImportJob.html">DescribeDatasetImportJob</a> * operation. You can filter the list by providing an array of <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_Filter.html">Filter</a> * objects.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListDatasetImportJobs">AWS * API Reference</a></p> */ virtual Model::ListDatasetImportJobsOutcome ListDatasetImportJobs(const Model::ListDatasetImportJobsRequest& request) const; /** * A Callable wrapper for ListDatasetImportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListDatasetImportJobsRequestT = Model::ListDatasetImportJobsRequest> Model::ListDatasetImportJobsOutcomeCallable ListDatasetImportJobsCallable(const ListDatasetImportJobsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListDatasetImportJobs, request); } /** * An Async wrapper for ListDatasetImportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListDatasetImportJobsRequestT = Model::ListDatasetImportJobsRequest> void ListDatasetImportJobsAsync(const ListDatasetImportJobsRequestT& request, const ListDatasetImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListDatasetImportJobs, request, handler, context); } /** * <p>Returns a list of datasets created using the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html">CreateDataset</a> * operation. For each dataset, a summary of its properties, including its Amazon * Resource Name (ARN), is returned. To retrieve the complete set of properties, * use the ARN with the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDataset.html">DescribeDataset</a> * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListDatasets">AWS * API Reference</a></p> */ virtual Model::ListDatasetsOutcome ListDatasets(const Model::ListDatasetsRequest& request) const; /** * A Callable wrapper for ListDatasets that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListDatasetsRequestT = Model::ListDatasetsRequest> Model::ListDatasetsOutcomeCallable ListDatasetsCallable(const ListDatasetsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListDatasets, request); } /** * An Async wrapper for ListDatasets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListDatasetsRequestT = Model::ListDatasetsRequest> void ListDatasetsAsync(const ListDatasetsRequestT& request, const ListDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListDatasets, request, handler, context); } /** * <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><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListExplainabilities">AWS * API Reference</a></p> */ virtual Model::ListExplainabilitiesOutcome ListExplainabilities(const Model::ListExplainabilitiesRequest& request) const; /** * A Callable wrapper for ListExplainabilities that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListExplainabilitiesRequestT = Model::ListExplainabilitiesRequest> Model::ListExplainabilitiesOutcomeCallable ListExplainabilitiesCallable(const ListExplainabilitiesRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListExplainabilities, request); } /** * An Async wrapper for ListExplainabilities that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListExplainabilitiesRequestT = Model::ListExplainabilitiesRequest> void ListExplainabilitiesAsync(const ListExplainabilitiesRequestT& request, const ListExplainabilitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListExplainabilities, request, handler, context); } /** * <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><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListExplainabilityExports">AWS * API Reference</a></p> */ virtual Model::ListExplainabilityExportsOutcome ListExplainabilityExports(const Model::ListExplainabilityExportsRequest& request) const; /** * A Callable wrapper for ListExplainabilityExports that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListExplainabilityExportsRequestT = Model::ListExplainabilityExportsRequest> Model::ListExplainabilityExportsOutcomeCallable ListExplainabilityExportsCallable(const ListExplainabilityExportsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListExplainabilityExports, request); } /** * An Async wrapper for ListExplainabilityExports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListExplainabilityExportsRequestT = Model::ListExplainabilityExportsRequest> void ListExplainabilityExportsAsync(const ListExplainabilityExportsRequestT& request, const ListExplainabilityExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListExplainabilityExports, request, handler, context); } /** * <p>Returns a list of forecast export jobs created using the * <a>CreateForecastExportJob</a> operation. For each forecast export job, this * operation returns a summary of its properties, including its Amazon Resource * Name (ARN). To retrieve the complete set of properties, use the ARN with the * <a>DescribeForecastExportJob</a> operation. You can filter the list using an * array of <a>Filter</a> objects.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListForecastExportJobs">AWS * API Reference</a></p> */ virtual Model::ListForecastExportJobsOutcome ListForecastExportJobs(const Model::ListForecastExportJobsRequest& request) const; /** * A Callable wrapper for ListForecastExportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListForecastExportJobsRequestT = Model::ListForecastExportJobsRequest> Model::ListForecastExportJobsOutcomeCallable ListForecastExportJobsCallable(const ListForecastExportJobsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListForecastExportJobs, request); } /** * An Async wrapper for ListForecastExportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListForecastExportJobsRequestT = Model::ListForecastExportJobsRequest> void ListForecastExportJobsAsync(const ListForecastExportJobsRequestT& request, const ListForecastExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListForecastExportJobs, request, handler, context); } /** * <p>Returns a list of forecasts created using the <a>CreateForecast</a> * operation. For each forecast, this operation returns a summary of its * properties, including its Amazon Resource Name (ARN). To retrieve the complete * set of properties, specify the ARN with the <a>DescribeForecast</a> operation. * You can filter the list using an array of <a>Filter</a> objects.</p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListForecasts">AWS * API Reference</a></p> */ virtual Model::ListForecastsOutcome ListForecasts(const Model::ListForecastsRequest& request) const; /** * A Callable wrapper for ListForecasts that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListForecastsRequestT = Model::ListForecastsRequest> Model::ListForecastsOutcomeCallable ListForecastsCallable(const ListForecastsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListForecasts, request); } /** * An Async wrapper for ListForecasts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListForecastsRequestT = Model::ListForecastsRequest> void ListForecastsAsync(const ListForecastsRequestT& request, const ListForecastsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListForecasts, request, handler, context); } /** * <p>Returns a list of the monitoring evaluation results and predictor events * collected by the monitor resource during different windows of time.</p> <p>For * information about monitoring see <a>predictor-monitoring</a>. For more * information about retrieving monitoring results see <a * href="https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring-results.html">Viewing * Monitoring Results</a>.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListMonitorEvaluations">AWS * API Reference</a></p> */ virtual Model::ListMonitorEvaluationsOutcome ListMonitorEvaluations(const Model::ListMonitorEvaluationsRequest& request) const; /** * A Callable wrapper for ListMonitorEvaluations that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListMonitorEvaluationsRequestT = Model::ListMonitorEvaluationsRequest> Model::ListMonitorEvaluationsOutcomeCallable ListMonitorEvaluationsCallable(const ListMonitorEvaluationsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListMonitorEvaluations, request); } /** * An Async wrapper for ListMonitorEvaluations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListMonitorEvaluationsRequestT = Model::ListMonitorEvaluationsRequest> void ListMonitorEvaluationsAsync(const ListMonitorEvaluationsRequestT& request, const ListMonitorEvaluationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListMonitorEvaluations, request, handler, context); } /** * <p>Returns a list of monitors created with the <a>CreateMonitor</a> operation * and <a>CreateAutoPredictor</a> operation. For each monitor resource, this * operation returns of a summary of its properties, including its Amazon Resource * Name (ARN). You can retrieve a complete set of properties of a monitor resource * by specify the monitor's ARN in the <a>DescribeMonitor</a> * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListMonitors">AWS * API Reference</a></p> */ virtual Model::ListMonitorsOutcome ListMonitors(const Model::ListMonitorsRequest& request) const; /** * A Callable wrapper for ListMonitors that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListMonitorsRequestT = Model::ListMonitorsRequest> Model::ListMonitorsOutcomeCallable ListMonitorsCallable(const ListMonitorsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListMonitors, request); } /** * An Async wrapper for ListMonitors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListMonitorsRequestT = Model::ListMonitorsRequest> void ListMonitorsAsync(const ListMonitorsRequestT& request, const ListMonitorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListMonitors, request, handler, context); } /** * <p>Returns a list of predictor backtest export jobs created using the * <a>CreatePredictorBacktestExportJob</a> operation. This operation returns a * summary for each backtest export job. 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 backtest export job, use the ARN with the * <a>DescribePredictorBacktestExportJob</a> operation.</p><p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListPredictorBacktestExportJobs">AWS * API Reference</a></p> */ virtual Model::ListPredictorBacktestExportJobsOutcome ListPredictorBacktestExportJobs(const Model::ListPredictorBacktestExportJobsRequest& request) const; /** * A Callable wrapper for ListPredictorBacktestExportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListPredictorBacktestExportJobsRequestT = Model::ListPredictorBacktestExportJobsRequest> Model::ListPredictorBacktestExportJobsOutcomeCallable ListPredictorBacktestExportJobsCallable(const ListPredictorBacktestExportJobsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListPredictorBacktestExportJobs, request); } /** * An Async wrapper for ListPredictorBacktestExportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListPredictorBacktestExportJobsRequestT = Model::ListPredictorBacktestExportJobsRequest> void ListPredictorBacktestExportJobsAsync(const ListPredictorBacktestExportJobsRequestT& request, const ListPredictorBacktestExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListPredictorBacktestExportJobs, request, handler, context); } /** * <p>Returns a list of predictors created using the <a>CreateAutoPredictor</a> or * <a>CreatePredictor</a> operations. For each predictor, this operation returns a * summary of its properties, including its Amazon Resource Name (ARN). </p> <p>You * can retrieve the complete set of properties by using the ARN with the * <a>DescribeAutoPredictor</a> and <a>DescribePredictor</a> operations. You can * filter the list using an array of <a>Filter</a> objects.</p><p><h3>See * Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListPredictors">AWS * API Reference</a></p> */ virtual Model::ListPredictorsOutcome ListPredictors(const Model::ListPredictorsRequest& request) const; /** * A Callable wrapper for ListPredictors that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListPredictorsRequestT = Model::ListPredictorsRequest> Model::ListPredictorsOutcomeCallable ListPredictorsCallable(const ListPredictorsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListPredictors, request); } /** * An Async wrapper for ListPredictors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListPredictorsRequestT = Model::ListPredictorsRequest> void ListPredictorsAsync(const ListPredictorsRequestT& request, const ListPredictorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListPredictors, request, handler, context); } /** * <p>Lists the tags for an Amazon Forecast resource.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListTagsForResource">AWS * API Reference</a></p> */ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest> Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest> void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListTagsForResource, request, handler, context); } /** * <p>Returns a list of what-if analyses created using the * <a>CreateWhatIfAnalysis</a> operation. For each what-if analysis, this operation * returns a summary of its properties, including its Amazon Resource Name (ARN). * You can retrieve the complete set of properties by using the what-if analysis * ARN with the <a>DescribeWhatIfAnalysis</a> operation.</p><p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListWhatIfAnalyses">AWS * API Reference</a></p> */ virtual Model::ListWhatIfAnalysesOutcome ListWhatIfAnalyses(const Model::ListWhatIfAnalysesRequest& request) const; /** * A Callable wrapper for ListWhatIfAnalyses that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListWhatIfAnalysesRequestT = Model::ListWhatIfAnalysesRequest> Model::ListWhatIfAnalysesOutcomeCallable ListWhatIfAnalysesCallable(const ListWhatIfAnalysesRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListWhatIfAnalyses, request); } /** * An Async wrapper for ListWhatIfAnalyses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListWhatIfAnalysesRequestT = Model::ListWhatIfAnalysesRequest> void ListWhatIfAnalysesAsync(const ListWhatIfAnalysesRequestT& request, const ListWhatIfAnalysesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListWhatIfAnalyses, request, handler, context); } /** * <p>Returns a list of what-if forecast exports created using the * <a>CreateWhatIfForecastExport</a> operation. For each what-if forecast export, * this operation returns a summary of its properties, including its Amazon * Resource Name (ARN). You can retrieve the complete set of properties by using * the what-if forecast export ARN with the <a>DescribeWhatIfForecastExport</a> * operation.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListWhatIfForecastExports">AWS * API Reference</a></p> */ virtual Model::ListWhatIfForecastExportsOutcome ListWhatIfForecastExports(const Model::ListWhatIfForecastExportsRequest& request) const; /** * A Callable wrapper for ListWhatIfForecastExports that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListWhatIfForecastExportsRequestT = Model::ListWhatIfForecastExportsRequest> Model::ListWhatIfForecastExportsOutcomeCallable ListWhatIfForecastExportsCallable(const ListWhatIfForecastExportsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListWhatIfForecastExports, request); } /** * An Async wrapper for ListWhatIfForecastExports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListWhatIfForecastExportsRequestT = Model::ListWhatIfForecastExportsRequest> void ListWhatIfForecastExportsAsync(const ListWhatIfForecastExportsRequestT& request, const ListWhatIfForecastExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListWhatIfForecastExports, request, handler, context); } /** * <p>Returns a list of what-if forecasts created using the * <a>CreateWhatIfForecast</a> operation. For each what-if forecast, this operation * returns a summary of its properties, including its Amazon Resource Name (ARN). * You can retrieve the complete set of properties by using the what-if forecast * ARN with the <a>DescribeWhatIfForecast</a> operation.</p><p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListWhatIfForecasts">AWS * API Reference</a></p> */ virtual Model::ListWhatIfForecastsOutcome ListWhatIfForecasts(const Model::ListWhatIfForecastsRequest& request) const; /** * A Callable wrapper for ListWhatIfForecasts that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ListWhatIfForecastsRequestT = Model::ListWhatIfForecastsRequest> Model::ListWhatIfForecastsOutcomeCallable ListWhatIfForecastsCallable(const ListWhatIfForecastsRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ListWhatIfForecasts, request); } /** * An Async wrapper for ListWhatIfForecasts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ListWhatIfForecastsRequestT = Model::ListWhatIfForecastsRequest> void ListWhatIfForecastsAsync(const ListWhatIfForecastsRequestT& request, const ListWhatIfForecastsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ListWhatIfForecasts, request, handler, context); } /** * <p>Resumes a stopped monitor resource.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ResumeResource">AWS * API Reference</a></p> */ virtual Model::ResumeResourceOutcome ResumeResource(const Model::ResumeResourceRequest& request) const; /** * A Callable wrapper for ResumeResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename ResumeResourceRequestT = Model::ResumeResourceRequest> Model::ResumeResourceOutcomeCallable ResumeResourceCallable(const ResumeResourceRequestT& request) const { return SubmitCallable(&ForecastServiceClient::ResumeResource, request); } /** * An Async wrapper for ResumeResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename ResumeResourceRequestT = Model::ResumeResourceRequest> void ResumeResourceAsync(const ResumeResourceRequestT& request, const ResumeResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::ResumeResource, request, handler, context); } /** * <p>Stops a resource.</p> <p>The resource undergoes the following states: * <code>CREATE_STOPPING</code> and <code>CREATE_STOPPED</code>. You cannot resume * a resource once it has been stopped.</p> <p>This operation can be applied to the * following resources (and their corresponding child resources):</p> <ul> <li> * <p>Dataset Import Job</p> </li> <li> <p>Predictor Job</p> </li> <li> <p>Forecast * Job</p> </li> <li> <p>Forecast Export Job</p> </li> <li> <p>Predictor Backtest * Export Job</p> </li> <li> <p>Explainability Job</p> </li> <li> <p>Explainability * Export Job</p> </li> </ul><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/StopResource">AWS * API Reference</a></p> */ virtual Model::StopResourceOutcome StopResource(const Model::StopResourceRequest& request) const; /** * A Callable wrapper for StopResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename StopResourceRequestT = Model::StopResourceRequest> Model::StopResourceOutcomeCallable StopResourceCallable(const StopResourceRequestT& request) const { return SubmitCallable(&ForecastServiceClient::StopResource, request); } /** * An Async wrapper for StopResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename StopResourceRequestT = Model::StopResourceRequest> void StopResourceAsync(const StopResourceRequestT& request, const StopResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::StopResource, request, handler, context); } /** * <p>Associates the specified tags to a resource with the specified * <code>resourceArn</code>. If existing tags on a resource are not specified in * the request parameters, they are not changed. When a resource is deleted, the * tags associated with that resource are also deleted.</p><p><h3>See Also:</h3> * <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/TagResource">AWS * API Reference</a></p> */ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename TagResourceRequestT = Model::TagResourceRequest> Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&ForecastServiceClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename TagResourceRequestT = Model::TagResourceRequest> void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::TagResource, request, handler, context); } /** * <p>Deletes the specified tags from a resource.</p><p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/UntagResource">AWS * API Reference</a></p> */ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename UntagResourceRequestT = Model::UntagResourceRequest> Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&ForecastServiceClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename UntagResourceRequestT = Model::UntagResourceRequest> void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::UntagResource, request, handler, context); } /** * <p>Replaces the datasets in a dataset group with the specified datasets.</p> * <p>The <code>Status</code> of the dataset group must be * <code>ACTIVE</code> before you can use the dataset group to create a predictor. * Use the <a * href="https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html">DescribeDatasetGroup</a> * operation to get the status.</p> <p><h3>See Also:</h3> <a * href="http://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/UpdateDatasetGroup">AWS * API Reference</a></p> */ virtual Model::UpdateDatasetGroupOutcome UpdateDatasetGroup(const Model::UpdateDatasetGroupRequest& request) const; /** * A Callable wrapper for UpdateDatasetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template<typename UpdateDatasetGroupRequestT = Model::UpdateDatasetGroupRequest> Model::UpdateDatasetGroupOutcomeCallable UpdateDatasetGroupCallable(const UpdateDatasetGroupRequestT& request) const { return SubmitCallable(&ForecastServiceClient::UpdateDatasetGroup, request); } /** * An Async wrapper for UpdateDatasetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename UpdateDatasetGroupRequestT = Model::UpdateDatasetGroupRequest> void UpdateDatasetGroupAsync(const UpdateDatasetGroupRequestT& request, const UpdateDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&ForecastServiceClient::UpdateDatasetGroup, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr<ForecastServiceEndpointProviderBase>& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods<ForecastServiceClient>; void init(const ForecastServiceClientConfiguration& clientConfiguration); ForecastServiceClientConfiguration m_clientConfiguration; std::shared_ptr<Aws::Utils::Threading::Executor> m_executor; std::shared_ptr<ForecastServiceEndpointProviderBase> m_endpointProvider; }; } // namespace ForecastService } // namespace Aws