export interface DataConfig {
    /** The ARN of the dataset group used to train the predictor. */
    DatasetGroupArn: string;
    /** Aggregation and filling options for attributes in your dataset group. */
    AttributeConfigs?: any[];
    /** Additional built-in datasets like Holidays and the Weather Index. */
    AdditionalDatasets?: any[];
}
export interface EncryptionConfig {
    /** The ARN of the IAM role that Amazon Forecast can assume to access the KMS key. Passing a role across Amazon Web Services accounts is not allowed. If you pass a role that isn't in your account, you get */
    RoleArn: string;
    /** The Amazon Resource Name (ARN) of the KMS key. */
    KMSKeyArn: string;
}
export interface Tag {
    /** One part of a key-value pair that makes up a tag. A key is a general label that acts like a category for more specific tag values. */
    Key: string;
    /** The optional part of a key-value pair that makes up a tag. A value acts as a descriptor within a tag category (key). */
    Value: string;
}
export interface MonitorConfig {
    /** The name of the monitor resource. */
    MonitorName: string;
}
export interface TimeAlignmentBoundary {
    /** The month to use for time alignment during aggregation. The month must be in uppercase. */
    Month?: 'JANUARY' | 'FEBRUARY' | 'MARCH' | 'APRIL' | 'MAY' | 'JUNE' | 'JULY' | 'AUGUST' | 'SEPTEMBER' | 'OCTOBER' | 'NOVEMBER' | 'DECEMBER';
    /** The day of the month to use for time alignment during aggregation. */
    DayOfMonth?: number;
    /** The day of week to use for time alignment during aggregation. The day must be in uppercase. */
    DayOfWeek?: 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
    /** The hour of day to use for time alignment during aggregation. */
    Hour?: number;
}
export interface Schema {
    /** An array of attributes specifying the name and type of each field in a dataset. */
    Attributes?: any[];
}
export interface S3Config {
    /** The path to an Amazon Simple Storage Service (Amazon S3) bucket or file(s) in an Amazon S3 bucket. */
    Path: string;
    /** The ARN of the Identity and Access Management (IAM) role that Amazon Forecast can assume to access the Amazon S3 bucket or files. If you provide a value for the KMSKeyArn key, the role must allow acce */
    RoleArn: string;
    /** The Amazon Resource Name (ARN) of an Key Management Service (KMS) key. */
    KMSKeyArn?: string;
}
export interface DataSource {
    /** The path to the data stored in an Amazon Simple Storage Service (Amazon S3) bucket along with the credentials to access the data. */
    S3Config: S3Config;
}
export interface ExplainabilityConfig {
    /** To create an Explainability for all time series in your datasets, use ALL. To create an Explainability for specific time series in your datasets, use SPECIFIC. Specify time series by uploading a CSV o */
    TimeSeriesGranularity: 'ALL' | 'SPECIFIC';
    /** To create an Explainability for all time points in your forecast horizon, use ALL. To create an Explainability for specific time points in your forecast horizon, use SPECIFIC. Specify time points with */
    TimePointGranularity: 'ALL' | 'SPECIFIC';
}
export interface DataDestination {
    /** The path to an Amazon Simple Storage Service (Amazon S3) bucket along with the credentials to access the bucket. */
    S3Config: S3Config;
}
export interface TimeSeriesIdentifiers {
    DataSource?: any;
    Schema?: any;
    /** The format of the data, either CSV or PARQUET. */
    Format?: string;
}
export interface TimeSeriesSelector {
    /** Details about the import file that contains the time series for which you want to create forecasts. */
    TimeSeriesIdentifiers?: TimeSeriesIdentifiers;
}
export interface EvaluationParameters {
    /** The number of times to split the input data. The default is 1. Valid values are 1 through 5. */
    NumberOfBacktestWindows?: number;
    /** The point from the end of the dataset where you want to split the data for model training and testing (evaluation). Specify the value as the number of data points. The default is the value of the fore */
    BackTestWindowOffset?: number;
}
export interface ParameterRanges {
    /** Specifies the tunable range for each categorical hyperparameter. */
    CategoricalParameterRanges?: any[];
    /** Specifies the tunable range for each continuous hyperparameter. */
    ContinuousParameterRanges?: any[];
    /** Specifies the tunable range for each integer hyperparameter. */
    IntegerParameterRanges?: any[];
}
export interface HyperParameterTuningJobConfig {
    /** Specifies the ranges of valid values for the hyperparameters. */
    ParameterRanges?: ParameterRanges;
}
export interface InputDataConfig {
    /** The Amazon Resource Name (ARN) of the dataset group. */
    DatasetGroupArn: string;
    /** An array of supplementary features. The only supported feature is a holiday calendar. */
    SupplementaryFeatures?: any[];
}
export interface FeaturizationConfig {
    /** The frequency of predictions in a forecast. Valid intervals are an integer followed by Y (Year), M (Month), W (Week), D (Day), H (Hour), and min (Minute). For example, "1D" indicates every day and "15 */
    ForecastFrequency: string;
    /** An array of dimension (field) names that specify how to group the generated forecast. For example, suppose that you are generating a forecast for item sales across all of your stores, and your dataset */
    ForecastDimensions?: string[];
    /** An array of featurization (transformation) information for the fields of a dataset. */
    Featurizations?: any[];
}
export interface TimeSeriesTransformation {
    /** An array of actions that define a time series and how it is transformed. These transformations create a new time series that is used for the what-if analysis. */
    Action?: any;
    /** An array of conditions that define which members of the related time series are transformed. */
    TimeSeriesConditions?: any[];
}
export interface TimeSeriesReplacementsDataSource {
    S3Config: S3Config;
    Schema: Schema;
    /** The format of the replacement data, CSV or PARQUET. */
    Format?: string;
    /** The timestamp format of the replacement data. */
    TimestampFormat?: string;
}
export interface Filter {
    /** The name of the parameter to filter on. */
    Key: string;
    /** The value to match. */
    Value: string;
    /** The condition to apply. To include the objects that match the statement, specify IS. To exclude matching objects, specify IS_NOT. */
    Condition: 'IS' | 'IS_NOT';
}
export interface CreateAutoPredictorInput {
    /** A unique name for the predictor */
    PredictorName: string;
    /** The data configuration for your dataset group and any additional datasets. */
    DataConfig?: DataConfig;
    EncryptionConfig?: EncryptionConfig;
    /** Create an Explainability resource for the predictor. */
    ExplainPredictor?: boolean;
    /** An array of dimension (field) names that specify how to group the generated forecast. For example, if you are generating forecasts for item sales across all your stores, and your dataset contains a st */
    ForecastDimensions?: string[];
    /** The frequency of predictions in a forecast. Valid intervals are an integer followed by Y (Year), M (Month), W (Week), D (Day), H (Hour), and min (Minute). For example, "1D" indicates every day and "15 */
    ForecastFrequency?: string;
    /** The number of time-steps that the model predicts. The forecast horizon is also called the prediction length. The maximum forecast horizon is the lesser of 500 time-steps or 1/4 of the TARGET_TIME_SERI */
    ForecastHorizon?: number;
    /** The forecast types used to train a predictor. You can specify up to five forecast types. Forecast types can be quantiles from 0.01 to 0.99, by increments of 0.01 or higher. You can also specify the me */
    ForecastTypes?: string[];
    /** The configuration details for predictor monitoring. Provide a name for the monitor resource to enable predictor monitoring. Predictor monitoring allows you to see how your predictor's performance chan */
    MonitorConfig?: MonitorConfig;
    /** The accuracy metric used to optimize the predictor. */
    OptimizationMetric?: 'WAPE' | 'RMSE' | 'AverageWeightedQuantileLoss' | 'MASE' | 'MAPE';
    /** The ARN of the predictor to retrain or upgrade. This parameter is only used when retraining or upgrading a predictor. When creating a new predictor, do not specify a value for this parameter. When upg */
    ReferencePredictorArn?: string;
    /** Optional metadata to help you categorize and organize your predictors. Each tag consists of a key and an optional value, both of which you define. Tag keys and values are case sensitive. The following */
    Tags?: Tag[];
    /** The time boundary Forecast uses to align and aggregate any data that doesn't align with your forecast frequency. Provide the unit of time and the time boundary as a key value pair. For more informatio */
    TimeAlignmentBoundary?: TimeAlignmentBoundary;
}
export interface CreateDatasetInput {
    /** A name for the dataset. */
    DatasetName: string;
    /** The dataset type. Valid values depend on the chosen Domain. */
    DatasetType: 'TARGET_TIME_SERIES' | 'RELATED_TIME_SERIES' | 'ITEM_METADATA';
    /** The domain associated with the dataset. When you add a dataset to a dataset group, this value and the value specified for the Domain parameter of the CreateDatasetGroup operation must match. The Domai */
    Domain: 'RETAIL' | 'CUSTOM' | 'INVENTORY_PLANNING' | 'EC2_CAPACITY' | 'WORK_FORCE' | 'WEB_TRAFFIC' | 'METRICS';
    /** The schema for the dataset. The schema attributes and their order must match the fields in your data. The dataset Domain and DatasetType that you choose determine the minimum required fields in your t */
    Schema: Schema;
    /** The frequency of data collection. This parameter is required for RELATED_TIME_SERIES datasets. Valid intervals are an integer followed by Y (Year), M (Month), W (Week), D (Day), H (Hour), and min (Min */
    DataFrequency?: string;
    /** An Key Management Service (KMS) key and the Identity and Access Management (IAM) role that Amazon Forecast can assume to access the key. */
    EncryptionConfig?: EncryptionConfig;
    /** The optional metadata that you apply to the dataset to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basic restrictio */
    Tags?: Tag[];
}
export interface CreateDatasetGroupInput {
    /** A name for the dataset group. */
    DatasetGroupName: string;
    /** The domain associated with the dataset group. When you add a dataset to a dataset group, this value and the value specified for the Domain parameter of the CreateDataset operation must match. The Doma */
    Domain: 'RETAIL' | 'CUSTOM' | 'INVENTORY_PLANNING' | 'EC2_CAPACITY' | 'WORK_FORCE' | 'WEB_TRAFFIC' | 'METRICS';
    /** An array of Amazon Resource Names (ARNs) of the datasets that you want to include in the dataset group. */
    DatasetArns?: string[];
    /** The optional metadata that you apply to the dataset group to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basic rest */
    Tags?: Tag[];
}
export interface CreateDatasetImportJobInput {
    /** The Amazon Resource Name (ARN) of the Amazon Forecast dataset that you want to import data to. */
    DatasetArn: string;
    /** The name for the dataset import job. We recommend including the current timestamp in the name, for example, 20190721DatasetImport. This can help you avoid getting a ResourceAlreadyExistsException exce */
    DatasetImportJobName: string;
    /** The location of the training data to import and an Identity and Access Management (IAM) role that Amazon Forecast can assume to access the data. The training data must be stored in an Amazon S3 bucket */
    DataSource: DataSource;
    /** The format of the imported data, CSV or PARQUET. The default value is CSV. */
    Format?: string;
    /** The format of the geolocation attribute. The geolocation attribute can be formatted in one of two ways: LAT_LONG - the latitude and longitude in decimal format (Example: 47.61_-122.33). CC_POSTALCODE  */
    GeolocationFormat?: string;
    /** Specifies whether the dataset import job is a FULL or INCREMENTAL import. A FULL dataset import replaces all of the existing data with the newly imported data. An INCREMENTAL import appends the import */
    ImportMode?: 'FULL' | 'INCREMENTAL';
    /** The optional metadata that you apply to the dataset import job to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basic */
    Tags?: Tag[];
    /** The format of timestamps in the dataset. The format that you specify depends on the DataFrequency specified when the dataset was created. The following formats are supported "yyyy-MM-dd" For the follo */
    TimestampFormat?: string;
    /** A single time zone for every item in your dataset. This option is ideal for datasets with all timestamps within a single time zone, or if all timestamps are normalized to a single time zone. Refer to  */
    TimeZone?: string;
    /** Automatically derive time zone information from the geolocation attribute. This option is ideal for datasets that contain timestamps in multiple time zones and those timestamps are expressed in local  */
    UseGeolocationForTimeZone?: boolean;
}
export interface CreateExplainabilityInput {
    /** The configuration settings that define the granularity of time series and time points for the Explainability. */
    ExplainabilityConfig: ExplainabilityConfig;
    /** A unique name for the Explainability. */
    ExplainabilityName: string;
    /** The Amazon Resource Name (ARN) of the Predictor or Forecast used to create the Explainability. */
    ResourceArn: string;
    DataSource?: DataSource;
    /** Create an Explainability visualization that is viewable within the Amazon Web Services console. */
    EnableVisualization?: boolean;
    /** If TimePointGranularity is set to SPECIFIC, define the last time point for the Explainability. Use the following timestamp format: yyyy-MM-ddTHH:mm:ss (example: 2015-01-01T20:00:00) */
    EndDateTime?: string;
    Schema?: Schema;
    /** If TimePointGranularity is set to SPECIFIC, define the first point for the Explainability. Use the following timestamp format: yyyy-MM-ddTHH:mm:ss (example: 2015-01-01T20:00:00) */
    StartDateTime?: string;
    /** Optional metadata to help you categorize and organize your resources. Each tag consists of a key and an optional value, both of which you define. Tag keys and values are case sensitive. The following  */
    Tags?: Tag[];
}
export interface CreateExplainabilityExportInput {
    Destination: DataDestination;
    /** The Amazon Resource Name (ARN) of the Explainability to export. */
    ExplainabilityArn: string;
    /** A unique name for the Explainability export. */
    ExplainabilityExportName: string;
    /** The format of the exported data, CSV or PARQUET. */
    Format?: string;
    /** Optional metadata to help you categorize and organize your resources. Each tag consists of a key and an optional value, both of which you define. Tag keys and values are case sensitive. The following  */
    Tags?: Tag[];
}
export interface CreateForecastInput {
    /** A name for the forecast. */
    ForecastName: string;
    /** The Amazon Resource Name (ARN) of the predictor to use to generate the forecast. */
    PredictorArn: string;
    /** The quantiles at which probabilistic forecasts are generated. You can currently specify up to 5 quantiles per forecast. Accepted values include 0.01 to 0.99 (increments of .01 only) and mean. The mean */
    ForecastTypes?: string[];
    /** The optional metadata that you apply to the forecast to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basic restricti */
    Tags?: Tag[];
    /** Defines the set of time series that are used to create the forecasts in a TimeSeriesIdentifiers object. The TimeSeriesIdentifiers object needs the following information: DataSource Format Schema */
    TimeSeriesSelector?: TimeSeriesSelector;
}
export interface CreateForecastExportJobInput {
    /** The location where you want to save the forecast and an Identity and Access Management (IAM) role that Amazon Forecast can assume to access the location. The forecast must be exported to an Amazon S3  */
    Destination: DataDestination;
    /** The Amazon Resource Name (ARN) of the forecast that you want to export. */
    ForecastArn: string;
    /** The name for the forecast export job. */
    ForecastExportJobName: string;
    /** The format of the exported data, CSV or PARQUET. The default value is CSV. */
    Format?: string;
    /** The optional metadata that you apply to the forecast export job to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basi */
    Tags?: Tag[];
}
export interface CreateMonitorInput {
    /** The name of the monitor resource. */
    MonitorName: string;
    /** The Amazon Resource Name (ARN) of the predictor to monitor. */
    ResourceArn: string;
    /** A list of tags to apply to the monitor resource. */
    Tags?: Tag[];
}
export interface CreatePredictorInput {
    /** The featurization configuration. */
    FeaturizationConfig: FeaturizationConfig;
    /** Specifies the number of time-steps that the model is trained to predict. The forecast horizon is also called the prediction length. For example, if you configure a dataset for daily data collection (u */
    ForecastHorizon: number;
    /** Describes the dataset group that contains the data to use to train the predictor. */
    InputDataConfig: InputDataConfig;
    /** A name for the predictor. */
    PredictorName: string;
    /** The Amazon Resource Name (ARN) of the algorithm to use for model training. Required if PerformAutoML is not set to true. Supported algorithms: arn:aws:forecast:::algorithm/ARIMA arn:aws:forecast:::alg */
    AlgorithmArn?: string;
    /** The LatencyOptimized AutoML override strategy is only available in private beta. Contact Amazon Web Services Support or your account manager to learn more about access privileges. Used to overide the  */
    AutoMLOverrideStrategy?: 'LatencyOptimized' | 'AccuracyOptimized';
    /** An Key Management Service (KMS) key and the Identity and Access Management (IAM) role that Amazon Forecast can assume to access the key. */
    EncryptionConfig?: EncryptionConfig;
    /** Used to override the default evaluation parameters of the specified algorithm. Amazon Forecast evaluates a predictor by splitting a dataset into training data and testing data. The evaluation paramete */
    EvaluationParameters?: EvaluationParameters;
    /** Specifies the forecast types used to train a predictor. You can specify up to five forecast types. Forecast types can be quantiles from 0.01 to 0.99, by increments of 0.01 or higher. You can also spec */
    ForecastTypes?: string[];
    /** Provides hyperparameter override values for the algorithm. If you don't provide this parameter, Amazon Forecast uses default values. The individual algorithms specify which hyperparameters support hyp */
    HPOConfig?: HyperParameterTuningJobConfig;
    /** The accuracy metric used to optimize the predictor. */
    OptimizationMetric?: 'WAPE' | 'RMSE' | 'AverageWeightedQuantileLoss' | 'MASE' | 'MAPE';
    /** Whether to perform AutoML. When Amazon Forecast performs AutoML, it evaluates the algorithms it provides and chooses the best algorithm and configuration for your training dataset. The default value i */
    PerformAutoML?: boolean;
    /** Whether to perform hyperparameter optimization (HPO). HPO finds optimal hyperparameter values for your training data. The process of performing HPO is known as running a hyperparameter tuning job. The */
    PerformHPO?: boolean;
    /** The optional metadata that you apply to the predictor to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basic restrict */
    Tags?: Tag[];
    /** The hyperparameters to override for model training. The hyperparameters that you can override are listed in the individual algorithms. For the list of supported algorithms, see aws-forecast-choosing-r */
    TrainingParameters?: Record<string, string>;
}
export interface CreatePredictorBacktestExportJobInput {
    Destination: DataDestination;
    /** The Amazon Resource Name (ARN) of the predictor that you want to export. */
    PredictorArn: string;
    /** The name for the backtest export job. */
    PredictorBacktestExportJobName: string;
    /** The format of the exported data, CSV or PARQUET. The default value is CSV. */
    Format?: string;
    /** Optional metadata to help you categorize and organize your backtests. Each tag consists of a key and an optional value, both of which you define. Tag keys and values are case sensitive. The following  */
    Tags?: Tag[];
}
export interface CreateWhatIfAnalysisInput {
    /** The Amazon Resource Name (ARN) of the baseline forecast. */
    ForecastArn: string;
    /** The name of the what-if analysis. Each name must be unique. */
    WhatIfAnalysisName: string;
    /** A list of tags to apply to the what if forecast. */
    Tags?: Tag[];
    /** Defines the set of time series that are used in the what-if analysis with a TimeSeriesIdentifiers object. What-if analyses are performed only for the time series in this object. The TimeSeriesIdentifi */
    TimeSeriesSelector?: TimeSeriesSelector;
}
export interface CreateWhatIfForecastInput {
    /** The Amazon Resource Name (ARN) of the what-if analysis. */
    WhatIfAnalysisArn: string;
    /** The name of the what-if forecast. Names must be unique within each what-if analysis. */
    WhatIfForecastName: string;
    /** A list of tags to apply to the what if forecast. */
    Tags?: Tag[];
    /** The replacement time series dataset, which contains the rows that you want to change in the related time series dataset. A replacement time series does not need to contain all rows that are in the bas */
    TimeSeriesReplacementsDataSource?: TimeSeriesReplacementsDataSource;
    /** The transformations that are applied to the baseline time series. Each transformation contains an action and a set of conditions. An action is applied only when all conditions are met. If no condition */
    TimeSeriesTransformations?: TimeSeriesTransformation[];
}
export interface CreateWhatIfForecastExportInput {
    /** The location where you want to save the forecast and an Identity and Access Management (IAM) role that Amazon Forecast can assume to access the location. The forecast must be exported to an Amazon S3  */
    Destination: DataDestination;
    /** The list of what-if forecast Amazon Resource Names (ARNs) to export. */
    WhatIfForecastArns: string[];
    /** The name of the what-if forecast to export. */
    WhatIfForecastExportName: string;
    /** The format of the exported data, CSV or PARQUET. */
    Format?: string;
    /** A list of tags to apply to the what if forecast. */
    Tags?: Tag[];
}
export interface DeleteDatasetInput {
    /** The Amazon Resource Name (ARN) of the dataset to delete. */
    DatasetArn: string;
}
export interface DeleteDatasetGroupInput {
    /** The Amazon Resource Name (ARN) of the dataset group to delete. */
    DatasetGroupArn: string;
}
export interface DeleteDatasetImportJobInput {
    /** The Amazon Resource Name (ARN) of the dataset import job to delete. */
    DatasetImportJobArn: string;
}
export interface DeleteExplainabilityInput {
    /** The Amazon Resource Name (ARN) of the Explainability resource to delete. */
    ExplainabilityArn: string;
}
export interface DeleteExplainabilityExportInput {
    /** The Amazon Resource Name (ARN) of the Explainability export to delete. */
    ExplainabilityExportArn: string;
}
export interface DeleteForecastInput {
    /** The Amazon Resource Name (ARN) of the forecast to delete. */
    ForecastArn: string;
}
export interface DeleteForecastExportJobInput {
    /** The Amazon Resource Name (ARN) of the forecast export job to delete. */
    ForecastExportJobArn: string;
}
export interface DeleteMonitorInput {
    /** The Amazon Resource Name (ARN) of the monitor resource to delete. */
    MonitorArn: string;
}
export interface DeletePredictorInput {
    /** The Amazon Resource Name (ARN) of the predictor to delete. */
    PredictorArn: string;
}
export interface DeletePredictorBacktestExportJobInput {
    /** The Amazon Resource Name (ARN) of the predictor backtest export job to delete. */
    PredictorBacktestExportJobArn: string;
}
export interface DeleteResourceTreeInput {
    /** The Amazon Resource Name (ARN) of the parent resource to delete. All child resources of the parent resource will also be deleted. */
    ResourceArn: string;
}
export interface DeleteWhatIfAnalysisInput {
    /** The Amazon Resource Name (ARN) of the what-if analysis that you want to delete. */
    WhatIfAnalysisArn: string;
}
export interface DeleteWhatIfForecastInput {
    /** The Amazon Resource Name (ARN) of the what-if forecast that you want to delete. */
    WhatIfForecastArn: string;
}
export interface DeleteWhatIfForecastExportInput {
    /** The Amazon Resource Name (ARN) of the what-if forecast export that you want to delete. */
    WhatIfForecastExportArn: string;
}
export interface DescribeAutoPredictorInput {
    /** The Amazon Resource Name (ARN) of the predictor. */
    PredictorArn: string;
}
export interface DescribeDatasetInput {
    /** The Amazon Resource Name (ARN) of the dataset. */
    DatasetArn: string;
}
export interface DescribeDatasetGroupInput {
    /** The Amazon Resource Name (ARN) of the dataset group. */
    DatasetGroupArn: string;
}
export interface DescribeDatasetImportJobInput {
    /** The Amazon Resource Name (ARN) of the dataset import job. */
    DatasetImportJobArn: string;
}
export interface DescribeExplainabilityInput {
    /** The Amazon Resource Name (ARN) of the Explaianability to describe. */
    ExplainabilityArn: string;
}
export interface DescribeExplainabilityExportInput {
    /** The Amazon Resource Name (ARN) of the Explainability export. */
    ExplainabilityExportArn: string;
}
export interface DescribeForecastInput {
    /** The Amazon Resource Name (ARN) of the forecast. */
    ForecastArn: string;
}
export interface DescribeForecastExportJobInput {
    /** The Amazon Resource Name (ARN) of the forecast export job. */
    ForecastExportJobArn: string;
}
export interface DescribeMonitorInput {
    /** The Amazon Resource Name (ARN) of the monitor resource to describe. */
    MonitorArn: string;
}
export interface DescribePredictorInput {
    /** The Amazon Resource Name (ARN) of the predictor that you want information about. */
    PredictorArn: string;
}
export interface DescribePredictorBacktestExportJobInput {
    /** The Amazon Resource Name (ARN) of the predictor backtest export job. */
    PredictorBacktestExportJobArn: string;
}
export interface DescribeWhatIfAnalysisInput {
    /** The Amazon Resource Name (ARN) of the what-if analysis that you are interested in. */
    WhatIfAnalysisArn: string;
}
export interface DescribeWhatIfForecastInput {
    /** The Amazon Resource Name (ARN) of the what-if forecast that you are interested in. */
    WhatIfForecastArn: string;
}
export interface DescribeWhatIfForecastExportInput {
    /** The Amazon Resource Name (ARN) of the what-if forecast export that you are interested in. */
    WhatIfForecastExportArn: string;
}
export interface GetAccuracyMetricsInput {
    /** The Amazon Resource Name (ARN) of the predictor to get metrics for. */
    PredictorArn: string;
}
export interface ListDatasetGroupsInput {
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListDatasetImportJobsInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the datasets that match the sta */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListDatasetsInput {
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListExplainabilitiesInput {
    /** An array of filters. For each filter, provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the resources that match the statem */
    Filters?: Filter[];
    /** The number of items returned in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListExplainabilityExportsInput {
    /** An array of filters. For each filter, provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude resources that match the statement  */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListForecastExportJobsInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the forecast export jobs that m */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListForecastsInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the forecasts that match the st */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListMonitorEvaluationsInput {
    /** The Amazon Resource Name (ARN) of the monitor resource to get results from. */
    MonitorArn: string;
    /** An array of filters. For each filter, provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the resources that match the statem */
    Filters?: Filter[];
    /** The maximum number of monitoring results to return. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListMonitorsInput {
    /** An array of filters. For each filter, provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the resources that match the statem */
    Filters?: Filter[];
    /** The maximum number of monitors to include in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListPredictorBacktestExportJobsInput {
    /** An array of filters. For each filter, provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the predictor backtest export jobs  */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListPredictorsInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the predictors that match the s */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListTagsForResourceInput {
    /** The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. */
    ResourceArn: string;
}
export interface ListWhatIfAnalysesInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the what-if analysis jobs that  */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListWhatIfForecastExportsInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the what-if forecast export job */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ListWhatIfForecastsInput {
    /** An array of filters. For each filter, you provide a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the what-if forecast export job */
    Filters?: Filter[];
    /** The number of items to return in the response. */
    MaxResults?: number;
    /** If the result of the previous request was truncated, the response includes a NextToken. To retrieve the next set of results, use the token in the next request. Tokens expire after 24 hours. */
    NextToken?: string;
}
export interface ResumeResourceInput {
    /** The Amazon Resource Name (ARN) of the monitor resource to resume. */
    ResourceArn: string;
}
export interface StopResourceInput {
    /** The Amazon Resource Name (ARN) that identifies the resource to stop. The supported ARNs are DatasetImportJobArn, PredictorArn, PredictorBacktestExportJobArn, ForecastArn, ForecastExportJobArn, Explain */
    ResourceArn: string;
}
export interface TagResourceInput {
    /** The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. */
    ResourceArn: string;
    /** The tags to add to the resource. A tag is an array of key-value pairs. The following basic restrictions apply to tags: Maximum number of tags per resource - 50. For each resource, each tag key must be */
    Tags: Tag[];
}
export interface UntagResourceInput {
    /** The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. */
    ResourceArn: string;
    /** The keys of the tags to be removed. */
    TagKeys: string[];
}
export interface UpdateDatasetGroupInput {
    /** An array of the Amazon Resource Names (ARNs) of the datasets to add to the dataset group. */
    DatasetArns: string[];
    /** The ARN of the dataset group. */
    DatasetGroupArn: string;
}
/** forecast service binding for Step Functions SDK integrations. */
export declare class forecast {
    constructor();
    createAutoPredictor<T>(params: CreateAutoPredictorInput): Promise<T>;
    createDataset<T>(params: CreateDatasetInput): Promise<T>;
    createDatasetGroup<T>(params: CreateDatasetGroupInput): Promise<T>;
    createDatasetImportJob<T>(params: CreateDatasetImportJobInput): Promise<T>;
    createExplainability<T>(params: CreateExplainabilityInput): Promise<T>;
    createExplainabilityExport<T>(params: CreateExplainabilityExportInput): Promise<T>;
    createForecast<T>(params: CreateForecastInput): Promise<T>;
    createForecastExportJob<T>(params: CreateForecastExportJobInput): Promise<T>;
    createMonitor<T>(params: CreateMonitorInput): Promise<T>;
    createPredictor<T>(params: CreatePredictorInput): Promise<T>;
    createPredictorBacktestExportJob<T>(params: CreatePredictorBacktestExportJobInput): Promise<T>;
    createWhatIfAnalysis<T>(params: CreateWhatIfAnalysisInput): Promise<T>;
    createWhatIfForecast<T>(params: CreateWhatIfForecastInput): Promise<T>;
    createWhatIfForecastExport<T>(params: CreateWhatIfForecastExportInput): Promise<T>;
    deleteDataset<T>(params: DeleteDatasetInput): Promise<T>;
    deleteDatasetGroup<T>(params: DeleteDatasetGroupInput): Promise<T>;
    deleteDatasetImportJob<T>(params: DeleteDatasetImportJobInput): Promise<T>;
    deleteExplainability<T>(params: DeleteExplainabilityInput): Promise<T>;
    deleteExplainabilityExport<T>(params: DeleteExplainabilityExportInput): Promise<T>;
    deleteForecast<T>(params: DeleteForecastInput): Promise<T>;
    deleteForecastExportJob<T>(params: DeleteForecastExportJobInput): Promise<T>;
    deleteMonitor<T>(params: DeleteMonitorInput): Promise<T>;
    deletePredictor<T>(params: DeletePredictorInput): Promise<T>;
    deletePredictorBacktestExportJob<T>(params: DeletePredictorBacktestExportJobInput): Promise<T>;
    deleteResourceTree<T>(params: DeleteResourceTreeInput): Promise<T>;
    deleteWhatIfAnalysis<T>(params: DeleteWhatIfAnalysisInput): Promise<T>;
    deleteWhatIfForecast<T>(params: DeleteWhatIfForecastInput): Promise<T>;
    deleteWhatIfForecastExport<T>(params: DeleteWhatIfForecastExportInput): Promise<T>;
    describeAutoPredictor<T>(params: DescribeAutoPredictorInput): Promise<T>;
    describeDataset<T>(params: DescribeDatasetInput): Promise<T>;
    describeDatasetGroup<T>(params: DescribeDatasetGroupInput): Promise<T>;
    describeDatasetImportJob<T>(params: DescribeDatasetImportJobInput): Promise<T>;
    describeExplainability<T>(params: DescribeExplainabilityInput): Promise<T>;
    describeExplainabilityExport<T>(params: DescribeExplainabilityExportInput): Promise<T>;
    describeForecast<T>(params: DescribeForecastInput): Promise<T>;
    describeForecastExportJob<T>(params: DescribeForecastExportJobInput): Promise<T>;
    describeMonitor<T>(params: DescribeMonitorInput): Promise<T>;
    describePredictor<T>(params: DescribePredictorInput): Promise<T>;
    describePredictorBacktestExportJob<T>(params: DescribePredictorBacktestExportJobInput): Promise<T>;
    describeWhatIfAnalysis<T>(params: DescribeWhatIfAnalysisInput): Promise<T>;
    describeWhatIfForecast<T>(params: DescribeWhatIfForecastInput): Promise<T>;
    describeWhatIfForecastExport<T>(params: DescribeWhatIfForecastExportInput): Promise<T>;
    getAccuracyMetrics<T>(params: GetAccuracyMetricsInput): Promise<T>;
    listDatasetGroups<T>(params: ListDatasetGroupsInput): Promise<T>;
    listDatasetImportJobs<T>(params: ListDatasetImportJobsInput): Promise<T>;
    listDatasets<T>(params: ListDatasetsInput): Promise<T>;
    listExplainabilities<T>(params: ListExplainabilitiesInput): Promise<T>;
    listExplainabilityExports<T>(params: ListExplainabilityExportsInput): Promise<T>;
    listForecastExportJobs<T>(params: ListForecastExportJobsInput): Promise<T>;
    listForecasts<T>(params: ListForecastsInput): Promise<T>;
    listMonitorEvaluations<T>(params: ListMonitorEvaluationsInput): Promise<T>;
    listMonitors<T>(params: ListMonitorsInput): Promise<T>;
    listPredictorBacktestExportJobs<T>(params: ListPredictorBacktestExportJobsInput): Promise<T>;
    listPredictors<T>(params: ListPredictorsInput): Promise<T>;
    listTagsForResource<T>(params: ListTagsForResourceInput): Promise<T>;
    listWhatIfAnalyses<T>(params: ListWhatIfAnalysesInput): Promise<T>;
    listWhatIfForecastExports<T>(params: ListWhatIfForecastExportsInput): Promise<T>;
    listWhatIfForecasts<T>(params: ListWhatIfForecastsInput): Promise<T>;
    resumeResource<T>(params: ResumeResourceInput): Promise<T>;
    stopResource<T>(params: StopResourceInput): Promise<T>;
    tagResource<T>(params: TagResourceInput): Promise<T>;
    untagResource<T>(params: UntagResourceInput): Promise<T>;
    updateDatasetGroup<T>(params: UpdateDatasetGroupInput): Promise<T>;
}
//# sourceMappingURL=forecast.d.ts.map