aws-sdk-forecastservice 1.49.0 → 1.50.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +5 -0
- data/VERSION +1 -1
- data/lib/aws-sdk-forecastservice/client.rb +1 -1
- data/lib/aws-sdk-forecastservice/plugins/endpoints.rb +1 -0
- data/lib/aws-sdk-forecastservice.rb +1 -1
- data/sig/client.rbs +1274 -0
- data/sig/errors.rbs +34 -0
- data/sig/resource.rbs +80 -0
- data/sig/types.rbs +1351 -0
- data/sig/waiters.rbs +13 -0
- metadata +13 -8
data/sig/client.rbs
ADDED
|
@@ -0,0 +1,1274 @@
|
|
|
1
|
+
# WARNING ABOUT GENERATED CODE
|
|
2
|
+
#
|
|
3
|
+
# This file is generated. See the contributing guide for more information:
|
|
4
|
+
# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
|
|
5
|
+
#
|
|
6
|
+
# WARNING ABOUT GENERATED CODE
|
|
7
|
+
|
|
8
|
+
module Aws
|
|
9
|
+
module ForecastService
|
|
10
|
+
class Client < ::Seahorse::Client::Base
|
|
11
|
+
include ::Aws::ClientStubs
|
|
12
|
+
|
|
13
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#initialize-instance_method
|
|
14
|
+
def self.new: (
|
|
15
|
+
?credentials: untyped,
|
|
16
|
+
?region: String,
|
|
17
|
+
?access_key_id: String,
|
|
18
|
+
?active_endpoint_cache: bool,
|
|
19
|
+
?adaptive_retry_wait_to_fill: bool,
|
|
20
|
+
?client_side_monitoring: bool,
|
|
21
|
+
?client_side_monitoring_client_id: String,
|
|
22
|
+
?client_side_monitoring_host: String,
|
|
23
|
+
?client_side_monitoring_port: Integer,
|
|
24
|
+
?client_side_monitoring_publisher: untyped,
|
|
25
|
+
?convert_params: bool,
|
|
26
|
+
?correct_clock_skew: bool,
|
|
27
|
+
?defaults_mode: String,
|
|
28
|
+
?disable_host_prefix_injection: bool,
|
|
29
|
+
?disable_request_compression: bool,
|
|
30
|
+
?endpoint: String,
|
|
31
|
+
?endpoint_cache_max_entries: Integer,
|
|
32
|
+
?endpoint_cache_max_threads: Integer,
|
|
33
|
+
?endpoint_cache_poll_interval: Integer,
|
|
34
|
+
?endpoint_discovery: bool,
|
|
35
|
+
?ignore_configured_endpoint_urls: bool,
|
|
36
|
+
?log_formatter: untyped,
|
|
37
|
+
?log_level: Symbol,
|
|
38
|
+
?logger: untyped,
|
|
39
|
+
?max_attempts: Integer,
|
|
40
|
+
?profile: String,
|
|
41
|
+
?request_min_compression_size_bytes: Integer,
|
|
42
|
+
?retry_backoff: Proc,
|
|
43
|
+
?retry_base_delay: Float,
|
|
44
|
+
?retry_jitter: (:none | :equal | :full | ^(Integer) -> Integer),
|
|
45
|
+
?retry_limit: Integer,
|
|
46
|
+
?retry_max_delay: Integer,
|
|
47
|
+
?retry_mode: ("legacy" | "standard" | "adaptive"),
|
|
48
|
+
?sdk_ua_app_id: String,
|
|
49
|
+
?secret_access_key: String,
|
|
50
|
+
?session_token: String,
|
|
51
|
+
?simple_json: bool,
|
|
52
|
+
?stub_responses: untyped,
|
|
53
|
+
?token_provider: untyped,
|
|
54
|
+
?use_dualstack_endpoint: bool,
|
|
55
|
+
?use_fips_endpoint: bool,
|
|
56
|
+
?validate_params: bool,
|
|
57
|
+
?endpoint_provider: untyped,
|
|
58
|
+
?http_proxy: String,
|
|
59
|
+
?http_open_timeout: (Float | Integer),
|
|
60
|
+
?http_read_timeout: (Float | Integer),
|
|
61
|
+
?http_idle_timeout: (Float | Integer),
|
|
62
|
+
?http_continue_timeout: (Float | Integer),
|
|
63
|
+
?ssl_timeout: (Float | Integer | nil),
|
|
64
|
+
?http_wire_trace: bool,
|
|
65
|
+
?ssl_verify_peer: bool,
|
|
66
|
+
?ssl_ca_bundle: String,
|
|
67
|
+
?ssl_ca_directory: String,
|
|
68
|
+
?ssl_ca_store: String,
|
|
69
|
+
?on_chunk_received: Proc,
|
|
70
|
+
?on_chunk_sent: Proc,
|
|
71
|
+
?raise_response_errors: bool
|
|
72
|
+
) -> instance
|
|
73
|
+
| (?Hash[Symbol, untyped]) -> instance
|
|
74
|
+
|
|
75
|
+
|
|
76
|
+
interface _CreateAutoPredictorResponseSuccess
|
|
77
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateAutoPredictorResponse]
|
|
78
|
+
def predictor_arn: () -> ::String
|
|
79
|
+
end
|
|
80
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_auto_predictor-instance_method
|
|
81
|
+
def create_auto_predictor: (
|
|
82
|
+
predictor_name: ::String,
|
|
83
|
+
?forecast_horizon: ::Integer,
|
|
84
|
+
?forecast_types: Array[::String],
|
|
85
|
+
?forecast_dimensions: Array[::String],
|
|
86
|
+
?forecast_frequency: ::String,
|
|
87
|
+
?data_config: {
|
|
88
|
+
dataset_group_arn: ::String,
|
|
89
|
+
attribute_configs: Array[
|
|
90
|
+
{
|
|
91
|
+
attribute_name: ::String,
|
|
92
|
+
transformations: Hash[::String, ::String]
|
|
93
|
+
},
|
|
94
|
+
]?,
|
|
95
|
+
additional_datasets: Array[
|
|
96
|
+
{
|
|
97
|
+
name: ::String,
|
|
98
|
+
configuration: Hash[::String, Array[::String]]?
|
|
99
|
+
},
|
|
100
|
+
]?
|
|
101
|
+
},
|
|
102
|
+
?encryption_config: {
|
|
103
|
+
role_arn: ::String,
|
|
104
|
+
kms_key_arn: ::String
|
|
105
|
+
},
|
|
106
|
+
?reference_predictor_arn: ::String,
|
|
107
|
+
?optimization_metric: ("WAPE" | "RMSE" | "AverageWeightedQuantileLoss" | "MASE" | "MAPE"),
|
|
108
|
+
?explain_predictor: bool,
|
|
109
|
+
?tags: Array[
|
|
110
|
+
{
|
|
111
|
+
key: ::String,
|
|
112
|
+
value: ::String
|
|
113
|
+
},
|
|
114
|
+
],
|
|
115
|
+
?monitor_config: {
|
|
116
|
+
monitor_name: ::String
|
|
117
|
+
},
|
|
118
|
+
?time_alignment_boundary: {
|
|
119
|
+
month: ("JANUARY" | "FEBRUARY" | "MARCH" | "APRIL" | "MAY" | "JUNE" | "JULY" | "AUGUST" | "SEPTEMBER" | "OCTOBER" | "NOVEMBER" | "DECEMBER")?,
|
|
120
|
+
day_of_month: ::Integer?,
|
|
121
|
+
day_of_week: ("MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY")?,
|
|
122
|
+
hour: ::Integer?
|
|
123
|
+
}
|
|
124
|
+
) -> _CreateAutoPredictorResponseSuccess
|
|
125
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateAutoPredictorResponseSuccess
|
|
126
|
+
|
|
127
|
+
interface _CreateDatasetResponseSuccess
|
|
128
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateDatasetResponse]
|
|
129
|
+
def dataset_arn: () -> ::String
|
|
130
|
+
end
|
|
131
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_dataset-instance_method
|
|
132
|
+
def create_dataset: (
|
|
133
|
+
dataset_name: ::String,
|
|
134
|
+
domain: ("RETAIL" | "CUSTOM" | "INVENTORY_PLANNING" | "EC2_CAPACITY" | "WORK_FORCE" | "WEB_TRAFFIC" | "METRICS"),
|
|
135
|
+
dataset_type: ("TARGET_TIME_SERIES" | "RELATED_TIME_SERIES" | "ITEM_METADATA"),
|
|
136
|
+
?data_frequency: ::String,
|
|
137
|
+
schema: {
|
|
138
|
+
attributes: Array[
|
|
139
|
+
{
|
|
140
|
+
attribute_name: ::String?,
|
|
141
|
+
attribute_type: ("string" | "integer" | "float" | "timestamp" | "geolocation")?
|
|
142
|
+
},
|
|
143
|
+
]?
|
|
144
|
+
},
|
|
145
|
+
?encryption_config: {
|
|
146
|
+
role_arn: ::String,
|
|
147
|
+
kms_key_arn: ::String
|
|
148
|
+
},
|
|
149
|
+
?tags: Array[
|
|
150
|
+
{
|
|
151
|
+
key: ::String,
|
|
152
|
+
value: ::String
|
|
153
|
+
},
|
|
154
|
+
]
|
|
155
|
+
) -> _CreateDatasetResponseSuccess
|
|
156
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDatasetResponseSuccess
|
|
157
|
+
|
|
158
|
+
interface _CreateDatasetGroupResponseSuccess
|
|
159
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateDatasetGroupResponse]
|
|
160
|
+
def dataset_group_arn: () -> ::String
|
|
161
|
+
end
|
|
162
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_dataset_group-instance_method
|
|
163
|
+
def create_dataset_group: (
|
|
164
|
+
dataset_group_name: ::String,
|
|
165
|
+
domain: ("RETAIL" | "CUSTOM" | "INVENTORY_PLANNING" | "EC2_CAPACITY" | "WORK_FORCE" | "WEB_TRAFFIC" | "METRICS"),
|
|
166
|
+
?dataset_arns: Array[::String],
|
|
167
|
+
?tags: Array[
|
|
168
|
+
{
|
|
169
|
+
key: ::String,
|
|
170
|
+
value: ::String
|
|
171
|
+
},
|
|
172
|
+
]
|
|
173
|
+
) -> _CreateDatasetGroupResponseSuccess
|
|
174
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDatasetGroupResponseSuccess
|
|
175
|
+
|
|
176
|
+
interface _CreateDatasetImportJobResponseSuccess
|
|
177
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateDatasetImportJobResponse]
|
|
178
|
+
def dataset_import_job_arn: () -> ::String
|
|
179
|
+
end
|
|
180
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_dataset_import_job-instance_method
|
|
181
|
+
def create_dataset_import_job: (
|
|
182
|
+
dataset_import_job_name: ::String,
|
|
183
|
+
dataset_arn: ::String,
|
|
184
|
+
data_source: {
|
|
185
|
+
s3_config: {
|
|
186
|
+
path: ::String,
|
|
187
|
+
role_arn: ::String,
|
|
188
|
+
kms_key_arn: ::String?
|
|
189
|
+
}
|
|
190
|
+
},
|
|
191
|
+
?timestamp_format: ::String,
|
|
192
|
+
?time_zone: ::String,
|
|
193
|
+
?use_geolocation_for_time_zone: bool,
|
|
194
|
+
?geolocation_format: ::String,
|
|
195
|
+
?tags: Array[
|
|
196
|
+
{
|
|
197
|
+
key: ::String,
|
|
198
|
+
value: ::String
|
|
199
|
+
},
|
|
200
|
+
],
|
|
201
|
+
?format: ::String,
|
|
202
|
+
?import_mode: ("FULL" | "INCREMENTAL")
|
|
203
|
+
) -> _CreateDatasetImportJobResponseSuccess
|
|
204
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateDatasetImportJobResponseSuccess
|
|
205
|
+
|
|
206
|
+
interface _CreateExplainabilityResponseSuccess
|
|
207
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateExplainabilityResponse]
|
|
208
|
+
def explainability_arn: () -> ::String
|
|
209
|
+
end
|
|
210
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_explainability-instance_method
|
|
211
|
+
def create_explainability: (
|
|
212
|
+
explainability_name: ::String,
|
|
213
|
+
resource_arn: ::String,
|
|
214
|
+
explainability_config: {
|
|
215
|
+
time_series_granularity: ("ALL" | "SPECIFIC"),
|
|
216
|
+
time_point_granularity: ("ALL" | "SPECIFIC")
|
|
217
|
+
},
|
|
218
|
+
?data_source: {
|
|
219
|
+
s3_config: {
|
|
220
|
+
path: ::String,
|
|
221
|
+
role_arn: ::String,
|
|
222
|
+
kms_key_arn: ::String?
|
|
223
|
+
}
|
|
224
|
+
},
|
|
225
|
+
?schema: {
|
|
226
|
+
attributes: Array[
|
|
227
|
+
{
|
|
228
|
+
attribute_name: ::String?,
|
|
229
|
+
attribute_type: ("string" | "integer" | "float" | "timestamp" | "geolocation")?
|
|
230
|
+
},
|
|
231
|
+
]?
|
|
232
|
+
},
|
|
233
|
+
?enable_visualization: bool,
|
|
234
|
+
?start_date_time: ::String,
|
|
235
|
+
?end_date_time: ::String,
|
|
236
|
+
?tags: Array[
|
|
237
|
+
{
|
|
238
|
+
key: ::String,
|
|
239
|
+
value: ::String
|
|
240
|
+
},
|
|
241
|
+
]
|
|
242
|
+
) -> _CreateExplainabilityResponseSuccess
|
|
243
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateExplainabilityResponseSuccess
|
|
244
|
+
|
|
245
|
+
interface _CreateExplainabilityExportResponseSuccess
|
|
246
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateExplainabilityExportResponse]
|
|
247
|
+
def explainability_export_arn: () -> ::String
|
|
248
|
+
end
|
|
249
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_explainability_export-instance_method
|
|
250
|
+
def create_explainability_export: (
|
|
251
|
+
explainability_export_name: ::String,
|
|
252
|
+
explainability_arn: ::String,
|
|
253
|
+
destination: {
|
|
254
|
+
s3_config: {
|
|
255
|
+
path: ::String,
|
|
256
|
+
role_arn: ::String,
|
|
257
|
+
kms_key_arn: ::String?
|
|
258
|
+
}
|
|
259
|
+
},
|
|
260
|
+
?tags: Array[
|
|
261
|
+
{
|
|
262
|
+
key: ::String,
|
|
263
|
+
value: ::String
|
|
264
|
+
},
|
|
265
|
+
],
|
|
266
|
+
?format: ::String
|
|
267
|
+
) -> _CreateExplainabilityExportResponseSuccess
|
|
268
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateExplainabilityExportResponseSuccess
|
|
269
|
+
|
|
270
|
+
interface _CreateForecastResponseSuccess
|
|
271
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateForecastResponse]
|
|
272
|
+
def forecast_arn: () -> ::String
|
|
273
|
+
end
|
|
274
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_forecast-instance_method
|
|
275
|
+
def create_forecast: (
|
|
276
|
+
forecast_name: ::String,
|
|
277
|
+
predictor_arn: ::String,
|
|
278
|
+
?forecast_types: Array[::String],
|
|
279
|
+
?tags: Array[
|
|
280
|
+
{
|
|
281
|
+
key: ::String,
|
|
282
|
+
value: ::String
|
|
283
|
+
},
|
|
284
|
+
],
|
|
285
|
+
?time_series_selector: {
|
|
286
|
+
time_series_identifiers: {
|
|
287
|
+
data_source: {
|
|
288
|
+
s3_config: {
|
|
289
|
+
path: ::String,
|
|
290
|
+
role_arn: ::String,
|
|
291
|
+
kms_key_arn: ::String?
|
|
292
|
+
}
|
|
293
|
+
}?,
|
|
294
|
+
schema: {
|
|
295
|
+
attributes: Array[
|
|
296
|
+
{
|
|
297
|
+
attribute_name: ::String?,
|
|
298
|
+
attribute_type: ("string" | "integer" | "float" | "timestamp" | "geolocation")?
|
|
299
|
+
},
|
|
300
|
+
]?
|
|
301
|
+
}?,
|
|
302
|
+
format: ::String?
|
|
303
|
+
}?
|
|
304
|
+
}
|
|
305
|
+
) -> _CreateForecastResponseSuccess
|
|
306
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateForecastResponseSuccess
|
|
307
|
+
|
|
308
|
+
interface _CreateForecastExportJobResponseSuccess
|
|
309
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateForecastExportJobResponse]
|
|
310
|
+
def forecast_export_job_arn: () -> ::String
|
|
311
|
+
end
|
|
312
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_forecast_export_job-instance_method
|
|
313
|
+
def create_forecast_export_job: (
|
|
314
|
+
forecast_export_job_name: ::String,
|
|
315
|
+
forecast_arn: ::String,
|
|
316
|
+
destination: {
|
|
317
|
+
s3_config: {
|
|
318
|
+
path: ::String,
|
|
319
|
+
role_arn: ::String,
|
|
320
|
+
kms_key_arn: ::String?
|
|
321
|
+
}
|
|
322
|
+
},
|
|
323
|
+
?tags: Array[
|
|
324
|
+
{
|
|
325
|
+
key: ::String,
|
|
326
|
+
value: ::String
|
|
327
|
+
},
|
|
328
|
+
],
|
|
329
|
+
?format: ::String
|
|
330
|
+
) -> _CreateForecastExportJobResponseSuccess
|
|
331
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateForecastExportJobResponseSuccess
|
|
332
|
+
|
|
333
|
+
interface _CreateMonitorResponseSuccess
|
|
334
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateMonitorResponse]
|
|
335
|
+
def monitor_arn: () -> ::String
|
|
336
|
+
end
|
|
337
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_monitor-instance_method
|
|
338
|
+
def create_monitor: (
|
|
339
|
+
monitor_name: ::String,
|
|
340
|
+
resource_arn: ::String,
|
|
341
|
+
?tags: Array[
|
|
342
|
+
{
|
|
343
|
+
key: ::String,
|
|
344
|
+
value: ::String
|
|
345
|
+
},
|
|
346
|
+
]
|
|
347
|
+
) -> _CreateMonitorResponseSuccess
|
|
348
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateMonitorResponseSuccess
|
|
349
|
+
|
|
350
|
+
interface _CreatePredictorResponseSuccess
|
|
351
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreatePredictorResponse]
|
|
352
|
+
def predictor_arn: () -> ::String
|
|
353
|
+
end
|
|
354
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_predictor-instance_method
|
|
355
|
+
def create_predictor: (
|
|
356
|
+
predictor_name: ::String,
|
|
357
|
+
?algorithm_arn: ::String,
|
|
358
|
+
forecast_horizon: ::Integer,
|
|
359
|
+
?forecast_types: Array[::String],
|
|
360
|
+
?perform_auto_ml: bool,
|
|
361
|
+
?auto_ml_override_strategy: ("LatencyOptimized" | "AccuracyOptimized"),
|
|
362
|
+
?perform_hpo: bool,
|
|
363
|
+
?training_parameters: Hash[::String, ::String],
|
|
364
|
+
?evaluation_parameters: {
|
|
365
|
+
number_of_backtest_windows: ::Integer?,
|
|
366
|
+
back_test_window_offset: ::Integer?
|
|
367
|
+
},
|
|
368
|
+
?hpo_config: {
|
|
369
|
+
parameter_ranges: {
|
|
370
|
+
categorical_parameter_ranges: Array[
|
|
371
|
+
{
|
|
372
|
+
name: ::String,
|
|
373
|
+
values: Array[::String]
|
|
374
|
+
},
|
|
375
|
+
]?,
|
|
376
|
+
continuous_parameter_ranges: Array[
|
|
377
|
+
{
|
|
378
|
+
name: ::String,
|
|
379
|
+
max_value: ::Float,
|
|
380
|
+
min_value: ::Float,
|
|
381
|
+
scaling_type: ("Auto" | "Linear" | "Logarithmic" | "ReverseLogarithmic")?
|
|
382
|
+
},
|
|
383
|
+
]?,
|
|
384
|
+
integer_parameter_ranges: Array[
|
|
385
|
+
{
|
|
386
|
+
name: ::String,
|
|
387
|
+
max_value: ::Integer,
|
|
388
|
+
min_value: ::Integer,
|
|
389
|
+
scaling_type: ("Auto" | "Linear" | "Logarithmic" | "ReverseLogarithmic")?
|
|
390
|
+
},
|
|
391
|
+
]?
|
|
392
|
+
}?
|
|
393
|
+
},
|
|
394
|
+
input_data_config: {
|
|
395
|
+
dataset_group_arn: ::String,
|
|
396
|
+
supplementary_features: Array[
|
|
397
|
+
{
|
|
398
|
+
name: ::String,
|
|
399
|
+
value: ::String
|
|
400
|
+
},
|
|
401
|
+
]?
|
|
402
|
+
},
|
|
403
|
+
featurization_config: {
|
|
404
|
+
forecast_frequency: ::String,
|
|
405
|
+
forecast_dimensions: Array[::String]?,
|
|
406
|
+
featurizations: Array[
|
|
407
|
+
{
|
|
408
|
+
attribute_name: ::String,
|
|
409
|
+
featurization_pipeline: Array[
|
|
410
|
+
{
|
|
411
|
+
featurization_method_name: ("filling"),
|
|
412
|
+
featurization_method_parameters: Hash[::String, ::String]?
|
|
413
|
+
},
|
|
414
|
+
]?
|
|
415
|
+
},
|
|
416
|
+
]?
|
|
417
|
+
},
|
|
418
|
+
?encryption_config: {
|
|
419
|
+
role_arn: ::String,
|
|
420
|
+
kms_key_arn: ::String
|
|
421
|
+
},
|
|
422
|
+
?tags: Array[
|
|
423
|
+
{
|
|
424
|
+
key: ::String,
|
|
425
|
+
value: ::String
|
|
426
|
+
},
|
|
427
|
+
],
|
|
428
|
+
?optimization_metric: ("WAPE" | "RMSE" | "AverageWeightedQuantileLoss" | "MASE" | "MAPE")
|
|
429
|
+
) -> _CreatePredictorResponseSuccess
|
|
430
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePredictorResponseSuccess
|
|
431
|
+
|
|
432
|
+
interface _CreatePredictorBacktestExportJobResponseSuccess
|
|
433
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreatePredictorBacktestExportJobResponse]
|
|
434
|
+
def predictor_backtest_export_job_arn: () -> ::String
|
|
435
|
+
end
|
|
436
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_predictor_backtest_export_job-instance_method
|
|
437
|
+
def create_predictor_backtest_export_job: (
|
|
438
|
+
predictor_backtest_export_job_name: ::String,
|
|
439
|
+
predictor_arn: ::String,
|
|
440
|
+
destination: {
|
|
441
|
+
s3_config: {
|
|
442
|
+
path: ::String,
|
|
443
|
+
role_arn: ::String,
|
|
444
|
+
kms_key_arn: ::String?
|
|
445
|
+
}
|
|
446
|
+
},
|
|
447
|
+
?tags: Array[
|
|
448
|
+
{
|
|
449
|
+
key: ::String,
|
|
450
|
+
value: ::String
|
|
451
|
+
},
|
|
452
|
+
],
|
|
453
|
+
?format: ::String
|
|
454
|
+
) -> _CreatePredictorBacktestExportJobResponseSuccess
|
|
455
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreatePredictorBacktestExportJobResponseSuccess
|
|
456
|
+
|
|
457
|
+
interface _CreateWhatIfAnalysisResponseSuccess
|
|
458
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateWhatIfAnalysisResponse]
|
|
459
|
+
def what_if_analysis_arn: () -> ::String
|
|
460
|
+
end
|
|
461
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_what_if_analysis-instance_method
|
|
462
|
+
def create_what_if_analysis: (
|
|
463
|
+
what_if_analysis_name: ::String,
|
|
464
|
+
forecast_arn: ::String,
|
|
465
|
+
?time_series_selector: {
|
|
466
|
+
time_series_identifiers: {
|
|
467
|
+
data_source: {
|
|
468
|
+
s3_config: {
|
|
469
|
+
path: ::String,
|
|
470
|
+
role_arn: ::String,
|
|
471
|
+
kms_key_arn: ::String?
|
|
472
|
+
}
|
|
473
|
+
}?,
|
|
474
|
+
schema: {
|
|
475
|
+
attributes: Array[
|
|
476
|
+
{
|
|
477
|
+
attribute_name: ::String?,
|
|
478
|
+
attribute_type: ("string" | "integer" | "float" | "timestamp" | "geolocation")?
|
|
479
|
+
},
|
|
480
|
+
]?
|
|
481
|
+
}?,
|
|
482
|
+
format: ::String?
|
|
483
|
+
}?
|
|
484
|
+
},
|
|
485
|
+
?tags: Array[
|
|
486
|
+
{
|
|
487
|
+
key: ::String,
|
|
488
|
+
value: ::String
|
|
489
|
+
},
|
|
490
|
+
]
|
|
491
|
+
) -> _CreateWhatIfAnalysisResponseSuccess
|
|
492
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateWhatIfAnalysisResponseSuccess
|
|
493
|
+
|
|
494
|
+
interface _CreateWhatIfForecastResponseSuccess
|
|
495
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateWhatIfForecastResponse]
|
|
496
|
+
def what_if_forecast_arn: () -> ::String
|
|
497
|
+
end
|
|
498
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_what_if_forecast-instance_method
|
|
499
|
+
def create_what_if_forecast: (
|
|
500
|
+
what_if_forecast_name: ::String,
|
|
501
|
+
what_if_analysis_arn: ::String,
|
|
502
|
+
?time_series_transformations: Array[
|
|
503
|
+
{
|
|
504
|
+
action: {
|
|
505
|
+
attribute_name: ::String,
|
|
506
|
+
operation: ("ADD" | "SUBTRACT" | "MULTIPLY" | "DIVIDE"),
|
|
507
|
+
value: ::Float
|
|
508
|
+
}?,
|
|
509
|
+
time_series_conditions: Array[
|
|
510
|
+
{
|
|
511
|
+
attribute_name: ::String,
|
|
512
|
+
attribute_value: ::String,
|
|
513
|
+
condition: ("EQUALS" | "NOT_EQUALS" | "LESS_THAN" | "GREATER_THAN")
|
|
514
|
+
},
|
|
515
|
+
]?
|
|
516
|
+
},
|
|
517
|
+
],
|
|
518
|
+
?time_series_replacements_data_source: {
|
|
519
|
+
s3_config: {
|
|
520
|
+
path: ::String,
|
|
521
|
+
role_arn: ::String,
|
|
522
|
+
kms_key_arn: ::String?
|
|
523
|
+
},
|
|
524
|
+
schema: {
|
|
525
|
+
attributes: Array[
|
|
526
|
+
{
|
|
527
|
+
attribute_name: ::String?,
|
|
528
|
+
attribute_type: ("string" | "integer" | "float" | "timestamp" | "geolocation")?
|
|
529
|
+
},
|
|
530
|
+
]?
|
|
531
|
+
},
|
|
532
|
+
format: ::String?,
|
|
533
|
+
timestamp_format: ::String?
|
|
534
|
+
},
|
|
535
|
+
?tags: Array[
|
|
536
|
+
{
|
|
537
|
+
key: ::String,
|
|
538
|
+
value: ::String
|
|
539
|
+
},
|
|
540
|
+
]
|
|
541
|
+
) -> _CreateWhatIfForecastResponseSuccess
|
|
542
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateWhatIfForecastResponseSuccess
|
|
543
|
+
|
|
544
|
+
interface _CreateWhatIfForecastExportResponseSuccess
|
|
545
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateWhatIfForecastExportResponse]
|
|
546
|
+
def what_if_forecast_export_arn: () -> ::String
|
|
547
|
+
end
|
|
548
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#create_what_if_forecast_export-instance_method
|
|
549
|
+
def create_what_if_forecast_export: (
|
|
550
|
+
what_if_forecast_export_name: ::String,
|
|
551
|
+
what_if_forecast_arns: Array[::String],
|
|
552
|
+
destination: {
|
|
553
|
+
s3_config: {
|
|
554
|
+
path: ::String,
|
|
555
|
+
role_arn: ::String,
|
|
556
|
+
kms_key_arn: ::String?
|
|
557
|
+
}
|
|
558
|
+
},
|
|
559
|
+
?tags: Array[
|
|
560
|
+
{
|
|
561
|
+
key: ::String,
|
|
562
|
+
value: ::String
|
|
563
|
+
},
|
|
564
|
+
],
|
|
565
|
+
?format: ::String
|
|
566
|
+
) -> _CreateWhatIfForecastExportResponseSuccess
|
|
567
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateWhatIfForecastExportResponseSuccess
|
|
568
|
+
|
|
569
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_dataset-instance_method
|
|
570
|
+
def delete_dataset: (
|
|
571
|
+
dataset_arn: ::String
|
|
572
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
573
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
574
|
+
|
|
575
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_dataset_group-instance_method
|
|
576
|
+
def delete_dataset_group: (
|
|
577
|
+
dataset_group_arn: ::String
|
|
578
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
579
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
580
|
+
|
|
581
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_dataset_import_job-instance_method
|
|
582
|
+
def delete_dataset_import_job: (
|
|
583
|
+
dataset_import_job_arn: ::String
|
|
584
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
585
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
586
|
+
|
|
587
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_explainability-instance_method
|
|
588
|
+
def delete_explainability: (
|
|
589
|
+
explainability_arn: ::String
|
|
590
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
591
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
592
|
+
|
|
593
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_explainability_export-instance_method
|
|
594
|
+
def delete_explainability_export: (
|
|
595
|
+
explainability_export_arn: ::String
|
|
596
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
597
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
598
|
+
|
|
599
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_forecast-instance_method
|
|
600
|
+
def delete_forecast: (
|
|
601
|
+
forecast_arn: ::String
|
|
602
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
603
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
604
|
+
|
|
605
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_forecast_export_job-instance_method
|
|
606
|
+
def delete_forecast_export_job: (
|
|
607
|
+
forecast_export_job_arn: ::String
|
|
608
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
609
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
610
|
+
|
|
611
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_monitor-instance_method
|
|
612
|
+
def delete_monitor: (
|
|
613
|
+
monitor_arn: ::String
|
|
614
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
615
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
616
|
+
|
|
617
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_predictor-instance_method
|
|
618
|
+
def delete_predictor: (
|
|
619
|
+
predictor_arn: ::String
|
|
620
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
621
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
622
|
+
|
|
623
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_predictor_backtest_export_job-instance_method
|
|
624
|
+
def delete_predictor_backtest_export_job: (
|
|
625
|
+
predictor_backtest_export_job_arn: ::String
|
|
626
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
627
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
628
|
+
|
|
629
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_resource_tree-instance_method
|
|
630
|
+
def delete_resource_tree: (
|
|
631
|
+
resource_arn: ::String
|
|
632
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
633
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
634
|
+
|
|
635
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_what_if_analysis-instance_method
|
|
636
|
+
def delete_what_if_analysis: (
|
|
637
|
+
what_if_analysis_arn: ::String
|
|
638
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
639
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
640
|
+
|
|
641
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_what_if_forecast-instance_method
|
|
642
|
+
def delete_what_if_forecast: (
|
|
643
|
+
what_if_forecast_arn: ::String
|
|
644
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
645
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
646
|
+
|
|
647
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#delete_what_if_forecast_export-instance_method
|
|
648
|
+
def delete_what_if_forecast_export: (
|
|
649
|
+
what_if_forecast_export_arn: ::String
|
|
650
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
651
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
652
|
+
|
|
653
|
+
interface _DescribeAutoPredictorResponseSuccess
|
|
654
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAutoPredictorResponse]
|
|
655
|
+
def predictor_arn: () -> ::String
|
|
656
|
+
def predictor_name: () -> ::String
|
|
657
|
+
def forecast_horizon: () -> ::Integer
|
|
658
|
+
def forecast_types: () -> ::Array[::String]
|
|
659
|
+
def forecast_frequency: () -> ::String
|
|
660
|
+
def forecast_dimensions: () -> ::Array[::String]
|
|
661
|
+
def dataset_import_job_arns: () -> ::Array[::String]
|
|
662
|
+
def data_config: () -> Types::DataConfig
|
|
663
|
+
def encryption_config: () -> Types::EncryptionConfig
|
|
664
|
+
def reference_predictor_summary: () -> Types::ReferencePredictorSummary
|
|
665
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
666
|
+
def status: () -> ::String
|
|
667
|
+
def message: () -> ::String
|
|
668
|
+
def creation_time: () -> ::Time
|
|
669
|
+
def last_modification_time: () -> ::Time
|
|
670
|
+
def optimization_metric: () -> ("WAPE" | "RMSE" | "AverageWeightedQuantileLoss" | "MASE" | "MAPE")
|
|
671
|
+
def explainability_info: () -> Types::ExplainabilityInfo
|
|
672
|
+
def monitor_info: () -> Types::MonitorInfo
|
|
673
|
+
def time_alignment_boundary: () -> Types::TimeAlignmentBoundary
|
|
674
|
+
end
|
|
675
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_auto_predictor-instance_method
|
|
676
|
+
def describe_auto_predictor: (
|
|
677
|
+
predictor_arn: ::String
|
|
678
|
+
) -> _DescribeAutoPredictorResponseSuccess
|
|
679
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAutoPredictorResponseSuccess
|
|
680
|
+
|
|
681
|
+
interface _DescribeDatasetResponseSuccess
|
|
682
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDatasetResponse]
|
|
683
|
+
def dataset_arn: () -> ::String
|
|
684
|
+
def dataset_name: () -> ::String
|
|
685
|
+
def domain: () -> ("RETAIL" | "CUSTOM" | "INVENTORY_PLANNING" | "EC2_CAPACITY" | "WORK_FORCE" | "WEB_TRAFFIC" | "METRICS")
|
|
686
|
+
def dataset_type: () -> ("TARGET_TIME_SERIES" | "RELATED_TIME_SERIES" | "ITEM_METADATA")
|
|
687
|
+
def data_frequency: () -> ::String
|
|
688
|
+
def schema: () -> Types::Schema
|
|
689
|
+
def encryption_config: () -> Types::EncryptionConfig
|
|
690
|
+
def status: () -> ::String
|
|
691
|
+
def creation_time: () -> ::Time
|
|
692
|
+
def last_modification_time: () -> ::Time
|
|
693
|
+
end
|
|
694
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_dataset-instance_method
|
|
695
|
+
def describe_dataset: (
|
|
696
|
+
dataset_arn: ::String
|
|
697
|
+
) -> _DescribeDatasetResponseSuccess
|
|
698
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDatasetResponseSuccess
|
|
699
|
+
|
|
700
|
+
interface _DescribeDatasetGroupResponseSuccess
|
|
701
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDatasetGroupResponse]
|
|
702
|
+
def dataset_group_name: () -> ::String
|
|
703
|
+
def dataset_group_arn: () -> ::String
|
|
704
|
+
def dataset_arns: () -> ::Array[::String]
|
|
705
|
+
def domain: () -> ("RETAIL" | "CUSTOM" | "INVENTORY_PLANNING" | "EC2_CAPACITY" | "WORK_FORCE" | "WEB_TRAFFIC" | "METRICS")
|
|
706
|
+
def status: () -> ::String
|
|
707
|
+
def creation_time: () -> ::Time
|
|
708
|
+
def last_modification_time: () -> ::Time
|
|
709
|
+
end
|
|
710
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_dataset_group-instance_method
|
|
711
|
+
def describe_dataset_group: (
|
|
712
|
+
dataset_group_arn: ::String
|
|
713
|
+
) -> _DescribeDatasetGroupResponseSuccess
|
|
714
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDatasetGroupResponseSuccess
|
|
715
|
+
|
|
716
|
+
interface _DescribeDatasetImportJobResponseSuccess
|
|
717
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeDatasetImportJobResponse]
|
|
718
|
+
def dataset_import_job_name: () -> ::String
|
|
719
|
+
def dataset_import_job_arn: () -> ::String
|
|
720
|
+
def dataset_arn: () -> ::String
|
|
721
|
+
def timestamp_format: () -> ::String
|
|
722
|
+
def time_zone: () -> ::String
|
|
723
|
+
def use_geolocation_for_time_zone: () -> bool
|
|
724
|
+
def geolocation_format: () -> ::String
|
|
725
|
+
def data_source: () -> Types::DataSource
|
|
726
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
727
|
+
def field_statistics: () -> ::Hash[::String, Types::Statistics]
|
|
728
|
+
def data_size: () -> ::Float
|
|
729
|
+
def status: () -> ::String
|
|
730
|
+
def message: () -> ::String
|
|
731
|
+
def creation_time: () -> ::Time
|
|
732
|
+
def last_modification_time: () -> ::Time
|
|
733
|
+
def format: () -> ::String
|
|
734
|
+
def import_mode: () -> ("FULL" | "INCREMENTAL")
|
|
735
|
+
end
|
|
736
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_dataset_import_job-instance_method
|
|
737
|
+
def describe_dataset_import_job: (
|
|
738
|
+
dataset_import_job_arn: ::String
|
|
739
|
+
) -> _DescribeDatasetImportJobResponseSuccess
|
|
740
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeDatasetImportJobResponseSuccess
|
|
741
|
+
|
|
742
|
+
interface _DescribeExplainabilityResponseSuccess
|
|
743
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeExplainabilityResponse]
|
|
744
|
+
def explainability_arn: () -> ::String
|
|
745
|
+
def explainability_name: () -> ::String
|
|
746
|
+
def resource_arn: () -> ::String
|
|
747
|
+
def explainability_config: () -> Types::ExplainabilityConfig
|
|
748
|
+
def enable_visualization: () -> bool
|
|
749
|
+
def data_source: () -> Types::DataSource
|
|
750
|
+
def schema: () -> Types::Schema
|
|
751
|
+
def start_date_time: () -> ::String
|
|
752
|
+
def end_date_time: () -> ::String
|
|
753
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
754
|
+
def message: () -> ::String
|
|
755
|
+
def status: () -> ::String
|
|
756
|
+
def creation_time: () -> ::Time
|
|
757
|
+
def last_modification_time: () -> ::Time
|
|
758
|
+
end
|
|
759
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_explainability-instance_method
|
|
760
|
+
def describe_explainability: (
|
|
761
|
+
explainability_arn: ::String
|
|
762
|
+
) -> _DescribeExplainabilityResponseSuccess
|
|
763
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeExplainabilityResponseSuccess
|
|
764
|
+
|
|
765
|
+
interface _DescribeExplainabilityExportResponseSuccess
|
|
766
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeExplainabilityExportResponse]
|
|
767
|
+
def explainability_export_arn: () -> ::String
|
|
768
|
+
def explainability_export_name: () -> ::String
|
|
769
|
+
def explainability_arn: () -> ::String
|
|
770
|
+
def destination: () -> Types::DataDestination
|
|
771
|
+
def message: () -> ::String
|
|
772
|
+
def status: () -> ::String
|
|
773
|
+
def creation_time: () -> ::Time
|
|
774
|
+
def last_modification_time: () -> ::Time
|
|
775
|
+
def format: () -> ::String
|
|
776
|
+
end
|
|
777
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_explainability_export-instance_method
|
|
778
|
+
def describe_explainability_export: (
|
|
779
|
+
explainability_export_arn: ::String
|
|
780
|
+
) -> _DescribeExplainabilityExportResponseSuccess
|
|
781
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeExplainabilityExportResponseSuccess
|
|
782
|
+
|
|
783
|
+
interface _DescribeForecastResponseSuccess
|
|
784
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeForecastResponse]
|
|
785
|
+
def forecast_arn: () -> ::String
|
|
786
|
+
def forecast_name: () -> ::String
|
|
787
|
+
def forecast_types: () -> ::Array[::String]
|
|
788
|
+
def predictor_arn: () -> ::String
|
|
789
|
+
def dataset_group_arn: () -> ::String
|
|
790
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
791
|
+
def status: () -> ::String
|
|
792
|
+
def message: () -> ::String
|
|
793
|
+
def creation_time: () -> ::Time
|
|
794
|
+
def last_modification_time: () -> ::Time
|
|
795
|
+
def time_series_selector: () -> Types::TimeSeriesSelector
|
|
796
|
+
end
|
|
797
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_forecast-instance_method
|
|
798
|
+
def describe_forecast: (
|
|
799
|
+
forecast_arn: ::String
|
|
800
|
+
) -> _DescribeForecastResponseSuccess
|
|
801
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeForecastResponseSuccess
|
|
802
|
+
|
|
803
|
+
interface _DescribeForecastExportJobResponseSuccess
|
|
804
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeForecastExportJobResponse]
|
|
805
|
+
def forecast_export_job_arn: () -> ::String
|
|
806
|
+
def forecast_export_job_name: () -> ::String
|
|
807
|
+
def forecast_arn: () -> ::String
|
|
808
|
+
def destination: () -> Types::DataDestination
|
|
809
|
+
def message: () -> ::String
|
|
810
|
+
def status: () -> ::String
|
|
811
|
+
def creation_time: () -> ::Time
|
|
812
|
+
def last_modification_time: () -> ::Time
|
|
813
|
+
def format: () -> ::String
|
|
814
|
+
end
|
|
815
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_forecast_export_job-instance_method
|
|
816
|
+
def describe_forecast_export_job: (
|
|
817
|
+
forecast_export_job_arn: ::String
|
|
818
|
+
) -> _DescribeForecastExportJobResponseSuccess
|
|
819
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeForecastExportJobResponseSuccess
|
|
820
|
+
|
|
821
|
+
interface _DescribeMonitorResponseSuccess
|
|
822
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeMonitorResponse]
|
|
823
|
+
def monitor_name: () -> ::String
|
|
824
|
+
def monitor_arn: () -> ::String
|
|
825
|
+
def resource_arn: () -> ::String
|
|
826
|
+
def status: () -> ::String
|
|
827
|
+
def last_evaluation_time: () -> ::Time
|
|
828
|
+
def last_evaluation_state: () -> ::String
|
|
829
|
+
def baseline: () -> Types::Baseline
|
|
830
|
+
def message: () -> ::String
|
|
831
|
+
def creation_time: () -> ::Time
|
|
832
|
+
def last_modification_time: () -> ::Time
|
|
833
|
+
def estimated_evaluation_time_remaining_in_minutes: () -> ::Integer
|
|
834
|
+
end
|
|
835
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_monitor-instance_method
|
|
836
|
+
def describe_monitor: (
|
|
837
|
+
monitor_arn: ::String
|
|
838
|
+
) -> _DescribeMonitorResponseSuccess
|
|
839
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeMonitorResponseSuccess
|
|
840
|
+
|
|
841
|
+
interface _DescribePredictorResponseSuccess
|
|
842
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribePredictorResponse]
|
|
843
|
+
def predictor_arn: () -> ::String
|
|
844
|
+
def predictor_name: () -> ::String
|
|
845
|
+
def algorithm_arn: () -> ::String
|
|
846
|
+
def auto_ml_algorithm_arns: () -> ::Array[::String]
|
|
847
|
+
def forecast_horizon: () -> ::Integer
|
|
848
|
+
def forecast_types: () -> ::Array[::String]
|
|
849
|
+
def perform_auto_ml: () -> bool
|
|
850
|
+
def auto_ml_override_strategy: () -> ("LatencyOptimized" | "AccuracyOptimized")
|
|
851
|
+
def perform_hpo: () -> bool
|
|
852
|
+
def training_parameters: () -> ::Hash[::String, ::String]
|
|
853
|
+
def evaluation_parameters: () -> Types::EvaluationParameters
|
|
854
|
+
def hpo_config: () -> Types::HyperParameterTuningJobConfig
|
|
855
|
+
def input_data_config: () -> Types::InputDataConfig
|
|
856
|
+
def featurization_config: () -> Types::FeaturizationConfig
|
|
857
|
+
def encryption_config: () -> Types::EncryptionConfig
|
|
858
|
+
def predictor_execution_details: () -> Types::PredictorExecutionDetails
|
|
859
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
860
|
+
def is_auto_predictor: () -> bool
|
|
861
|
+
def dataset_import_job_arns: () -> ::Array[::String]
|
|
862
|
+
def status: () -> ::String
|
|
863
|
+
def message: () -> ::String
|
|
864
|
+
def creation_time: () -> ::Time
|
|
865
|
+
def last_modification_time: () -> ::Time
|
|
866
|
+
def optimization_metric: () -> ("WAPE" | "RMSE" | "AverageWeightedQuantileLoss" | "MASE" | "MAPE")
|
|
867
|
+
end
|
|
868
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_predictor-instance_method
|
|
869
|
+
def describe_predictor: (
|
|
870
|
+
predictor_arn: ::String
|
|
871
|
+
) -> _DescribePredictorResponseSuccess
|
|
872
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribePredictorResponseSuccess
|
|
873
|
+
|
|
874
|
+
interface _DescribePredictorBacktestExportJobResponseSuccess
|
|
875
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribePredictorBacktestExportJobResponse]
|
|
876
|
+
def predictor_backtest_export_job_arn: () -> ::String
|
|
877
|
+
def predictor_backtest_export_job_name: () -> ::String
|
|
878
|
+
def predictor_arn: () -> ::String
|
|
879
|
+
def destination: () -> Types::DataDestination
|
|
880
|
+
def message: () -> ::String
|
|
881
|
+
def status: () -> ::String
|
|
882
|
+
def creation_time: () -> ::Time
|
|
883
|
+
def last_modification_time: () -> ::Time
|
|
884
|
+
def format: () -> ::String
|
|
885
|
+
end
|
|
886
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_predictor_backtest_export_job-instance_method
|
|
887
|
+
def describe_predictor_backtest_export_job: (
|
|
888
|
+
predictor_backtest_export_job_arn: ::String
|
|
889
|
+
) -> _DescribePredictorBacktestExportJobResponseSuccess
|
|
890
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribePredictorBacktestExportJobResponseSuccess
|
|
891
|
+
|
|
892
|
+
interface _DescribeWhatIfAnalysisResponseSuccess
|
|
893
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeWhatIfAnalysisResponse]
|
|
894
|
+
def what_if_analysis_name: () -> ::String
|
|
895
|
+
def what_if_analysis_arn: () -> ::String
|
|
896
|
+
def forecast_arn: () -> ::String
|
|
897
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
898
|
+
def status: () -> ::String
|
|
899
|
+
def message: () -> ::String
|
|
900
|
+
def creation_time: () -> ::Time
|
|
901
|
+
def last_modification_time: () -> ::Time
|
|
902
|
+
def time_series_selector: () -> Types::TimeSeriesSelector
|
|
903
|
+
end
|
|
904
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_what_if_analysis-instance_method
|
|
905
|
+
def describe_what_if_analysis: (
|
|
906
|
+
what_if_analysis_arn: ::String
|
|
907
|
+
) -> _DescribeWhatIfAnalysisResponseSuccess
|
|
908
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeWhatIfAnalysisResponseSuccess
|
|
909
|
+
|
|
910
|
+
interface _DescribeWhatIfForecastResponseSuccess
|
|
911
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeWhatIfForecastResponse]
|
|
912
|
+
def what_if_forecast_name: () -> ::String
|
|
913
|
+
def what_if_forecast_arn: () -> ::String
|
|
914
|
+
def what_if_analysis_arn: () -> ::String
|
|
915
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
916
|
+
def status: () -> ::String
|
|
917
|
+
def message: () -> ::String
|
|
918
|
+
def creation_time: () -> ::Time
|
|
919
|
+
def last_modification_time: () -> ::Time
|
|
920
|
+
def time_series_transformations: () -> ::Array[Types::TimeSeriesTransformation]
|
|
921
|
+
def time_series_replacements_data_source: () -> Types::TimeSeriesReplacementsDataSource
|
|
922
|
+
def forecast_types: () -> ::Array[::String]
|
|
923
|
+
end
|
|
924
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_what_if_forecast-instance_method
|
|
925
|
+
def describe_what_if_forecast: (
|
|
926
|
+
what_if_forecast_arn: ::String
|
|
927
|
+
) -> _DescribeWhatIfForecastResponseSuccess
|
|
928
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeWhatIfForecastResponseSuccess
|
|
929
|
+
|
|
930
|
+
interface _DescribeWhatIfForecastExportResponseSuccess
|
|
931
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeWhatIfForecastExportResponse]
|
|
932
|
+
def what_if_forecast_export_arn: () -> ::String
|
|
933
|
+
def what_if_forecast_export_name: () -> ::String
|
|
934
|
+
def what_if_forecast_arns: () -> ::Array[::String]
|
|
935
|
+
def destination: () -> Types::DataDestination
|
|
936
|
+
def message: () -> ::String
|
|
937
|
+
def status: () -> ::String
|
|
938
|
+
def creation_time: () -> ::Time
|
|
939
|
+
def estimated_time_remaining_in_minutes: () -> ::Integer
|
|
940
|
+
def last_modification_time: () -> ::Time
|
|
941
|
+
def format: () -> ::String
|
|
942
|
+
end
|
|
943
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#describe_what_if_forecast_export-instance_method
|
|
944
|
+
def describe_what_if_forecast_export: (
|
|
945
|
+
what_if_forecast_export_arn: ::String
|
|
946
|
+
) -> _DescribeWhatIfForecastExportResponseSuccess
|
|
947
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeWhatIfForecastExportResponseSuccess
|
|
948
|
+
|
|
949
|
+
interface _GetAccuracyMetricsResponseSuccess
|
|
950
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::GetAccuracyMetricsResponse]
|
|
951
|
+
def predictor_evaluation_results: () -> ::Array[Types::EvaluationResult]
|
|
952
|
+
def is_auto_predictor: () -> bool
|
|
953
|
+
def auto_ml_override_strategy: () -> ("LatencyOptimized" | "AccuracyOptimized")
|
|
954
|
+
def optimization_metric: () -> ("WAPE" | "RMSE" | "AverageWeightedQuantileLoss" | "MASE" | "MAPE")
|
|
955
|
+
end
|
|
956
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#get_accuracy_metrics-instance_method
|
|
957
|
+
def get_accuracy_metrics: (
|
|
958
|
+
predictor_arn: ::String
|
|
959
|
+
) -> _GetAccuracyMetricsResponseSuccess
|
|
960
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _GetAccuracyMetricsResponseSuccess
|
|
961
|
+
|
|
962
|
+
interface _ListDatasetGroupsResponseSuccess
|
|
963
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListDatasetGroupsResponse]
|
|
964
|
+
def dataset_groups: () -> ::Array[Types::DatasetGroupSummary]
|
|
965
|
+
def next_token: () -> ::String
|
|
966
|
+
end
|
|
967
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_dataset_groups-instance_method
|
|
968
|
+
def list_dataset_groups: (
|
|
969
|
+
?next_token: ::String,
|
|
970
|
+
?max_results: ::Integer
|
|
971
|
+
) -> _ListDatasetGroupsResponseSuccess
|
|
972
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDatasetGroupsResponseSuccess
|
|
973
|
+
|
|
974
|
+
interface _ListDatasetImportJobsResponseSuccess
|
|
975
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListDatasetImportJobsResponse]
|
|
976
|
+
def dataset_import_jobs: () -> ::Array[Types::DatasetImportJobSummary]
|
|
977
|
+
def next_token: () -> ::String
|
|
978
|
+
end
|
|
979
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_dataset_import_jobs-instance_method
|
|
980
|
+
def list_dataset_import_jobs: (
|
|
981
|
+
?next_token: ::String,
|
|
982
|
+
?max_results: ::Integer,
|
|
983
|
+
?filters: Array[
|
|
984
|
+
{
|
|
985
|
+
key: ::String,
|
|
986
|
+
value: ::String,
|
|
987
|
+
condition: ("IS" | "IS_NOT")
|
|
988
|
+
},
|
|
989
|
+
]
|
|
990
|
+
) -> _ListDatasetImportJobsResponseSuccess
|
|
991
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDatasetImportJobsResponseSuccess
|
|
992
|
+
|
|
993
|
+
interface _ListDatasetsResponseSuccess
|
|
994
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListDatasetsResponse]
|
|
995
|
+
def datasets: () -> ::Array[Types::DatasetSummary]
|
|
996
|
+
def next_token: () -> ::String
|
|
997
|
+
end
|
|
998
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_datasets-instance_method
|
|
999
|
+
def list_datasets: (
|
|
1000
|
+
?next_token: ::String,
|
|
1001
|
+
?max_results: ::Integer
|
|
1002
|
+
) -> _ListDatasetsResponseSuccess
|
|
1003
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListDatasetsResponseSuccess
|
|
1004
|
+
|
|
1005
|
+
interface _ListExplainabilitiesResponseSuccess
|
|
1006
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListExplainabilitiesResponse]
|
|
1007
|
+
def explainabilities: () -> ::Array[Types::ExplainabilitySummary]
|
|
1008
|
+
def next_token: () -> ::String
|
|
1009
|
+
end
|
|
1010
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_explainabilities-instance_method
|
|
1011
|
+
def list_explainabilities: (
|
|
1012
|
+
?next_token: ::String,
|
|
1013
|
+
?max_results: ::Integer,
|
|
1014
|
+
?filters: Array[
|
|
1015
|
+
{
|
|
1016
|
+
key: ::String,
|
|
1017
|
+
value: ::String,
|
|
1018
|
+
condition: ("IS" | "IS_NOT")
|
|
1019
|
+
},
|
|
1020
|
+
]
|
|
1021
|
+
) -> _ListExplainabilitiesResponseSuccess
|
|
1022
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListExplainabilitiesResponseSuccess
|
|
1023
|
+
|
|
1024
|
+
interface _ListExplainabilityExportsResponseSuccess
|
|
1025
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListExplainabilityExportsResponse]
|
|
1026
|
+
def explainability_exports: () -> ::Array[Types::ExplainabilityExportSummary]
|
|
1027
|
+
def next_token: () -> ::String
|
|
1028
|
+
end
|
|
1029
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_explainability_exports-instance_method
|
|
1030
|
+
def list_explainability_exports: (
|
|
1031
|
+
?next_token: ::String,
|
|
1032
|
+
?max_results: ::Integer,
|
|
1033
|
+
?filters: Array[
|
|
1034
|
+
{
|
|
1035
|
+
key: ::String,
|
|
1036
|
+
value: ::String,
|
|
1037
|
+
condition: ("IS" | "IS_NOT")
|
|
1038
|
+
},
|
|
1039
|
+
]
|
|
1040
|
+
) -> _ListExplainabilityExportsResponseSuccess
|
|
1041
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListExplainabilityExportsResponseSuccess
|
|
1042
|
+
|
|
1043
|
+
interface _ListForecastExportJobsResponseSuccess
|
|
1044
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListForecastExportJobsResponse]
|
|
1045
|
+
def forecast_export_jobs: () -> ::Array[Types::ForecastExportJobSummary]
|
|
1046
|
+
def next_token: () -> ::String
|
|
1047
|
+
end
|
|
1048
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_forecast_export_jobs-instance_method
|
|
1049
|
+
def list_forecast_export_jobs: (
|
|
1050
|
+
?next_token: ::String,
|
|
1051
|
+
?max_results: ::Integer,
|
|
1052
|
+
?filters: Array[
|
|
1053
|
+
{
|
|
1054
|
+
key: ::String,
|
|
1055
|
+
value: ::String,
|
|
1056
|
+
condition: ("IS" | "IS_NOT")
|
|
1057
|
+
},
|
|
1058
|
+
]
|
|
1059
|
+
) -> _ListForecastExportJobsResponseSuccess
|
|
1060
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListForecastExportJobsResponseSuccess
|
|
1061
|
+
|
|
1062
|
+
interface _ListForecastsResponseSuccess
|
|
1063
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListForecastsResponse]
|
|
1064
|
+
def forecasts: () -> ::Array[Types::ForecastSummary]
|
|
1065
|
+
def next_token: () -> ::String
|
|
1066
|
+
end
|
|
1067
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_forecasts-instance_method
|
|
1068
|
+
def list_forecasts: (
|
|
1069
|
+
?next_token: ::String,
|
|
1070
|
+
?max_results: ::Integer,
|
|
1071
|
+
?filters: Array[
|
|
1072
|
+
{
|
|
1073
|
+
key: ::String,
|
|
1074
|
+
value: ::String,
|
|
1075
|
+
condition: ("IS" | "IS_NOT")
|
|
1076
|
+
},
|
|
1077
|
+
]
|
|
1078
|
+
) -> _ListForecastsResponseSuccess
|
|
1079
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListForecastsResponseSuccess
|
|
1080
|
+
|
|
1081
|
+
interface _ListMonitorEvaluationsResponseSuccess
|
|
1082
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListMonitorEvaluationsResponse]
|
|
1083
|
+
def next_token: () -> ::String
|
|
1084
|
+
def predictor_monitor_evaluations: () -> ::Array[Types::PredictorMonitorEvaluation]
|
|
1085
|
+
end
|
|
1086
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_monitor_evaluations-instance_method
|
|
1087
|
+
def list_monitor_evaluations: (
|
|
1088
|
+
?next_token: ::String,
|
|
1089
|
+
?max_results: ::Integer,
|
|
1090
|
+
monitor_arn: ::String,
|
|
1091
|
+
?filters: Array[
|
|
1092
|
+
{
|
|
1093
|
+
key: ::String,
|
|
1094
|
+
value: ::String,
|
|
1095
|
+
condition: ("IS" | "IS_NOT")
|
|
1096
|
+
},
|
|
1097
|
+
]
|
|
1098
|
+
) -> _ListMonitorEvaluationsResponseSuccess
|
|
1099
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListMonitorEvaluationsResponseSuccess
|
|
1100
|
+
|
|
1101
|
+
interface _ListMonitorsResponseSuccess
|
|
1102
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListMonitorsResponse]
|
|
1103
|
+
def monitors: () -> ::Array[Types::MonitorSummary]
|
|
1104
|
+
def next_token: () -> ::String
|
|
1105
|
+
end
|
|
1106
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_monitors-instance_method
|
|
1107
|
+
def list_monitors: (
|
|
1108
|
+
?next_token: ::String,
|
|
1109
|
+
?max_results: ::Integer,
|
|
1110
|
+
?filters: Array[
|
|
1111
|
+
{
|
|
1112
|
+
key: ::String,
|
|
1113
|
+
value: ::String,
|
|
1114
|
+
condition: ("IS" | "IS_NOT")
|
|
1115
|
+
},
|
|
1116
|
+
]
|
|
1117
|
+
) -> _ListMonitorsResponseSuccess
|
|
1118
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListMonitorsResponseSuccess
|
|
1119
|
+
|
|
1120
|
+
interface _ListPredictorBacktestExportJobsResponseSuccess
|
|
1121
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListPredictorBacktestExportJobsResponse]
|
|
1122
|
+
def predictor_backtest_export_jobs: () -> ::Array[Types::PredictorBacktestExportJobSummary]
|
|
1123
|
+
def next_token: () -> ::String
|
|
1124
|
+
end
|
|
1125
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_predictor_backtest_export_jobs-instance_method
|
|
1126
|
+
def list_predictor_backtest_export_jobs: (
|
|
1127
|
+
?next_token: ::String,
|
|
1128
|
+
?max_results: ::Integer,
|
|
1129
|
+
?filters: Array[
|
|
1130
|
+
{
|
|
1131
|
+
key: ::String,
|
|
1132
|
+
value: ::String,
|
|
1133
|
+
condition: ("IS" | "IS_NOT")
|
|
1134
|
+
},
|
|
1135
|
+
]
|
|
1136
|
+
) -> _ListPredictorBacktestExportJobsResponseSuccess
|
|
1137
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPredictorBacktestExportJobsResponseSuccess
|
|
1138
|
+
|
|
1139
|
+
interface _ListPredictorsResponseSuccess
|
|
1140
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListPredictorsResponse]
|
|
1141
|
+
def predictors: () -> ::Array[Types::PredictorSummary]
|
|
1142
|
+
def next_token: () -> ::String
|
|
1143
|
+
end
|
|
1144
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_predictors-instance_method
|
|
1145
|
+
def list_predictors: (
|
|
1146
|
+
?next_token: ::String,
|
|
1147
|
+
?max_results: ::Integer,
|
|
1148
|
+
?filters: Array[
|
|
1149
|
+
{
|
|
1150
|
+
key: ::String,
|
|
1151
|
+
value: ::String,
|
|
1152
|
+
condition: ("IS" | "IS_NOT")
|
|
1153
|
+
},
|
|
1154
|
+
]
|
|
1155
|
+
) -> _ListPredictorsResponseSuccess
|
|
1156
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListPredictorsResponseSuccess
|
|
1157
|
+
|
|
1158
|
+
interface _ListTagsForResourceResponseSuccess
|
|
1159
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListTagsForResourceResponse]
|
|
1160
|
+
def tags: () -> ::Array[Types::Tag]
|
|
1161
|
+
end
|
|
1162
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_tags_for_resource-instance_method
|
|
1163
|
+
def list_tags_for_resource: (
|
|
1164
|
+
resource_arn: ::String
|
|
1165
|
+
) -> _ListTagsForResourceResponseSuccess
|
|
1166
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTagsForResourceResponseSuccess
|
|
1167
|
+
|
|
1168
|
+
interface _ListWhatIfAnalysesResponseSuccess
|
|
1169
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListWhatIfAnalysesResponse]
|
|
1170
|
+
def what_if_analyses: () -> ::Array[Types::WhatIfAnalysisSummary]
|
|
1171
|
+
def next_token: () -> ::String
|
|
1172
|
+
end
|
|
1173
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_what_if_analyses-instance_method
|
|
1174
|
+
def list_what_if_analyses: (
|
|
1175
|
+
?next_token: ::String,
|
|
1176
|
+
?max_results: ::Integer,
|
|
1177
|
+
?filters: Array[
|
|
1178
|
+
{
|
|
1179
|
+
key: ::String,
|
|
1180
|
+
value: ::String,
|
|
1181
|
+
condition: ("IS" | "IS_NOT")
|
|
1182
|
+
},
|
|
1183
|
+
]
|
|
1184
|
+
) -> _ListWhatIfAnalysesResponseSuccess
|
|
1185
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListWhatIfAnalysesResponseSuccess
|
|
1186
|
+
|
|
1187
|
+
interface _ListWhatIfForecastExportsResponseSuccess
|
|
1188
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListWhatIfForecastExportsResponse]
|
|
1189
|
+
def what_if_forecast_exports: () -> ::Array[Types::WhatIfForecastExportSummary]
|
|
1190
|
+
def next_token: () -> ::String
|
|
1191
|
+
end
|
|
1192
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_what_if_forecast_exports-instance_method
|
|
1193
|
+
def list_what_if_forecast_exports: (
|
|
1194
|
+
?next_token: ::String,
|
|
1195
|
+
?max_results: ::Integer,
|
|
1196
|
+
?filters: Array[
|
|
1197
|
+
{
|
|
1198
|
+
key: ::String,
|
|
1199
|
+
value: ::String,
|
|
1200
|
+
condition: ("IS" | "IS_NOT")
|
|
1201
|
+
},
|
|
1202
|
+
]
|
|
1203
|
+
) -> _ListWhatIfForecastExportsResponseSuccess
|
|
1204
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListWhatIfForecastExportsResponseSuccess
|
|
1205
|
+
|
|
1206
|
+
interface _ListWhatIfForecastsResponseSuccess
|
|
1207
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ListWhatIfForecastsResponse]
|
|
1208
|
+
def what_if_forecasts: () -> ::Array[Types::WhatIfForecastSummary]
|
|
1209
|
+
def next_token: () -> ::String
|
|
1210
|
+
end
|
|
1211
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#list_what_if_forecasts-instance_method
|
|
1212
|
+
def list_what_if_forecasts: (
|
|
1213
|
+
?next_token: ::String,
|
|
1214
|
+
?max_results: ::Integer,
|
|
1215
|
+
?filters: Array[
|
|
1216
|
+
{
|
|
1217
|
+
key: ::String,
|
|
1218
|
+
value: ::String,
|
|
1219
|
+
condition: ("IS" | "IS_NOT")
|
|
1220
|
+
},
|
|
1221
|
+
]
|
|
1222
|
+
) -> _ListWhatIfForecastsResponseSuccess
|
|
1223
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListWhatIfForecastsResponseSuccess
|
|
1224
|
+
|
|
1225
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#resume_resource-instance_method
|
|
1226
|
+
def resume_resource: (
|
|
1227
|
+
resource_arn: ::String
|
|
1228
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
1229
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
1230
|
+
|
|
1231
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#stop_resource-instance_method
|
|
1232
|
+
def stop_resource: (
|
|
1233
|
+
resource_arn: ::String
|
|
1234
|
+
) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
1235
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
|
|
1236
|
+
|
|
1237
|
+
interface _TagResourceResponseSuccess
|
|
1238
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::TagResourceResponse]
|
|
1239
|
+
end
|
|
1240
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#tag_resource-instance_method
|
|
1241
|
+
def tag_resource: (
|
|
1242
|
+
resource_arn: ::String,
|
|
1243
|
+
tags: Array[
|
|
1244
|
+
{
|
|
1245
|
+
key: ::String,
|
|
1246
|
+
value: ::String
|
|
1247
|
+
},
|
|
1248
|
+
]
|
|
1249
|
+
) -> _TagResourceResponseSuccess
|
|
1250
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TagResourceResponseSuccess
|
|
1251
|
+
|
|
1252
|
+
interface _UntagResourceResponseSuccess
|
|
1253
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::UntagResourceResponse]
|
|
1254
|
+
end
|
|
1255
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#untag_resource-instance_method
|
|
1256
|
+
def untag_resource: (
|
|
1257
|
+
resource_arn: ::String,
|
|
1258
|
+
tag_keys: Array[::String]
|
|
1259
|
+
) -> _UntagResourceResponseSuccess
|
|
1260
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UntagResourceResponseSuccess
|
|
1261
|
+
|
|
1262
|
+
interface _UpdateDatasetGroupResponseSuccess
|
|
1263
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::UpdateDatasetGroupResponse]
|
|
1264
|
+
end
|
|
1265
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ForecastService/Client.html#update_dataset_group-instance_method
|
|
1266
|
+
def update_dataset_group: (
|
|
1267
|
+
dataset_group_arn: ::String,
|
|
1268
|
+
dataset_arns: Array[::String]
|
|
1269
|
+
) -> _UpdateDatasetGroupResponseSuccess
|
|
1270
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateDatasetGroupResponseSuccess
|
|
1271
|
+
end
|
|
1272
|
+
end
|
|
1273
|
+
end
|
|
1274
|
+
|