UNPKG

57 kBTypeScriptView Raw
1import {Request} from '../lib/request';
2import {Response} from '../lib/response';
3import {AWSError} from '../lib/error';
4import {Service} from '../lib/service';
5import {ServiceConfigurationOptions} from '../lib/service';
6import {ConfigBase as Config} from '../lib/config';
7interface Blob {}
8declare class StepFunctions extends Service {
9 /**
10 * Constructs a service object. This object has one method for each API operation.
11 */
12 constructor(options?: StepFunctions.Types.ClientConfiguration)
13 config: Config & StepFunctions.Types.ClientConfiguration;
14 /**
15 * Creates an activity. An activity is a task that you write in any programming language and host on any machine that has access to AWS Step Functions. Activities must poll Step Functions using the GetActivityTask API action and respond using SendTask* API actions. This function lets Step Functions know the existence of your activity and returns an identifier for use in a state machine and when polling from the activity. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
16 */
17 createActivity(params: StepFunctions.Types.CreateActivityInput, callback?: (err: AWSError, data: StepFunctions.Types.CreateActivityOutput) => void): Request<StepFunctions.Types.CreateActivityOutput, AWSError>;
18 /**
19 * Creates an activity. An activity is a task that you write in any programming language and host on any machine that has access to AWS Step Functions. Activities must poll Step Functions using the GetActivityTask API action and respond using SendTask* API actions. This function lets Step Functions know the existence of your activity and returns an identifier for use in a state machine and when polling from the activity. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
20 */
21 createActivity(callback?: (err: AWSError, data: StepFunctions.Types.CreateActivityOutput) => void): Request<StepFunctions.Types.CreateActivityOutput, AWSError>;
22 /**
23 * Creates a state machine. A state machine consists of a collection of states that can do work (Task states), determine to which states to transition next (Choice states), stop an execution with an error (Fail states), and so on. State machines are specified using a JSON-based, structured language. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
24 */
25 createStateMachine(params: StepFunctions.Types.CreateStateMachineInput, callback?: (err: AWSError, data: StepFunctions.Types.CreateStateMachineOutput) => void): Request<StepFunctions.Types.CreateStateMachineOutput, AWSError>;
26 /**
27 * Creates a state machine. A state machine consists of a collection of states that can do work (Task states), determine to which states to transition next (Choice states), stop an execution with an error (Fail states), and so on. State machines are specified using a JSON-based, structured language. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
28 */
29 createStateMachine(callback?: (err: AWSError, data: StepFunctions.Types.CreateStateMachineOutput) => void): Request<StepFunctions.Types.CreateStateMachineOutput, AWSError>;
30 /**
31 * Deletes an activity.
32 */
33 deleteActivity(params: StepFunctions.Types.DeleteActivityInput, callback?: (err: AWSError, data: StepFunctions.Types.DeleteActivityOutput) => void): Request<StepFunctions.Types.DeleteActivityOutput, AWSError>;
34 /**
35 * Deletes an activity.
36 */
37 deleteActivity(callback?: (err: AWSError, data: StepFunctions.Types.DeleteActivityOutput) => void): Request<StepFunctions.Types.DeleteActivityOutput, AWSError>;
38 /**
39 * Deletes a state machine. This is an asynchronous operation: It sets the state machine's status to DELETING and begins the deletion process. Each state machine execution is deleted the next time it makes a state transition. The state machine itself is deleted after all executions are completed or deleted.
40 */
41 deleteStateMachine(params: StepFunctions.Types.DeleteStateMachineInput, callback?: (err: AWSError, data: StepFunctions.Types.DeleteStateMachineOutput) => void): Request<StepFunctions.Types.DeleteStateMachineOutput, AWSError>;
42 /**
43 * Deletes a state machine. This is an asynchronous operation: It sets the state machine's status to DELETING and begins the deletion process. Each state machine execution is deleted the next time it makes a state transition. The state machine itself is deleted after all executions are completed or deleted.
44 */
45 deleteStateMachine(callback?: (err: AWSError, data: StepFunctions.Types.DeleteStateMachineOutput) => void): Request<StepFunctions.Types.DeleteStateMachineOutput, AWSError>;
46 /**
47 * Describes an activity. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
48 */
49 describeActivity(params: StepFunctions.Types.DescribeActivityInput, callback?: (err: AWSError, data: StepFunctions.Types.DescribeActivityOutput) => void): Request<StepFunctions.Types.DescribeActivityOutput, AWSError>;
50 /**
51 * Describes an activity. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
52 */
53 describeActivity(callback?: (err: AWSError, data: StepFunctions.Types.DescribeActivityOutput) => void): Request<StepFunctions.Types.DescribeActivityOutput, AWSError>;
54 /**
55 * Describes an execution. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
56 */
57 describeExecution(params: StepFunctions.Types.DescribeExecutionInput, callback?: (err: AWSError, data: StepFunctions.Types.DescribeExecutionOutput) => void): Request<StepFunctions.Types.DescribeExecutionOutput, AWSError>;
58 /**
59 * Describes an execution. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
60 */
61 describeExecution(callback?: (err: AWSError, data: StepFunctions.Types.DescribeExecutionOutput) => void): Request<StepFunctions.Types.DescribeExecutionOutput, AWSError>;
62 /**
63 * Describes a state machine. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
64 */
65 describeStateMachine(params: StepFunctions.Types.DescribeStateMachineInput, callback?: (err: AWSError, data: StepFunctions.Types.DescribeStateMachineOutput) => void): Request<StepFunctions.Types.DescribeStateMachineOutput, AWSError>;
66 /**
67 * Describes a state machine. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
68 */
69 describeStateMachine(callback?: (err: AWSError, data: StepFunctions.Types.DescribeStateMachineOutput) => void): Request<StepFunctions.Types.DescribeStateMachineOutput, AWSError>;
70 /**
71 * Describes the state machine associated with a specific execution. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
72 */
73 describeStateMachineForExecution(params: StepFunctions.Types.DescribeStateMachineForExecutionInput, callback?: (err: AWSError, data: StepFunctions.Types.DescribeStateMachineForExecutionOutput) => void): Request<StepFunctions.Types.DescribeStateMachineForExecutionOutput, AWSError>;
74 /**
75 * Describes the state machine associated with a specific execution. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
76 */
77 describeStateMachineForExecution(callback?: (err: AWSError, data: StepFunctions.Types.DescribeStateMachineForExecutionOutput) => void): Request<StepFunctions.Types.DescribeStateMachineForExecutionOutput, AWSError>;
78 /**
79 * Used by workers to retrieve a task (with the specified activity ARN) which has been scheduled for execution by a running state machine. This initiates a long poll, where the service holds the HTTP connection open and responds as soon as a task becomes available (i.e. an execution of a task of this type is needed.) The maximum time the service holds on to the request before responding is 60 seconds. If no task is available within 60 seconds, the poll returns a taskToken with a null string. Workers should set their client side socket timeout to at least 65 seconds (5 seconds higher than the maximum time the service may hold the poll request). Polling with GetActivityTask can cause latency in some implementations. See Avoid Latency When Polling for Activity Tasks in the Step Functions Developer Guide.
80 */
81 getActivityTask(params: StepFunctions.Types.GetActivityTaskInput, callback?: (err: AWSError, data: StepFunctions.Types.GetActivityTaskOutput) => void): Request<StepFunctions.Types.GetActivityTaskOutput, AWSError>;
82 /**
83 * Used by workers to retrieve a task (with the specified activity ARN) which has been scheduled for execution by a running state machine. This initiates a long poll, where the service holds the HTTP connection open and responds as soon as a task becomes available (i.e. an execution of a task of this type is needed.) The maximum time the service holds on to the request before responding is 60 seconds. If no task is available within 60 seconds, the poll returns a taskToken with a null string. Workers should set their client side socket timeout to at least 65 seconds (5 seconds higher than the maximum time the service may hold the poll request). Polling with GetActivityTask can cause latency in some implementations. See Avoid Latency When Polling for Activity Tasks in the Step Functions Developer Guide.
84 */
85 getActivityTask(callback?: (err: AWSError, data: StepFunctions.Types.GetActivityTaskOutput) => void): Request<StepFunctions.Types.GetActivityTaskOutput, AWSError>;
86 /**
87 * Returns the history of the specified execution as a list of events. By default, the results are returned in ascending order of the timeStamp of the events. Use the reverseOrder parameter to get the latest events first. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
88 */
89 getExecutionHistory(params: StepFunctions.Types.GetExecutionHistoryInput, callback?: (err: AWSError, data: StepFunctions.Types.GetExecutionHistoryOutput) => void): Request<StepFunctions.Types.GetExecutionHistoryOutput, AWSError>;
90 /**
91 * Returns the history of the specified execution as a list of events. By default, the results are returned in ascending order of the timeStamp of the events. Use the reverseOrder parameter to get the latest events first. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
92 */
93 getExecutionHistory(callback?: (err: AWSError, data: StepFunctions.Types.GetExecutionHistoryOutput) => void): Request<StepFunctions.Types.GetExecutionHistoryOutput, AWSError>;
94 /**
95 * Lists the existing activities. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
96 */
97 listActivities(params: StepFunctions.Types.ListActivitiesInput, callback?: (err: AWSError, data: StepFunctions.Types.ListActivitiesOutput) => void): Request<StepFunctions.Types.ListActivitiesOutput, AWSError>;
98 /**
99 * Lists the existing activities. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
100 */
101 listActivities(callback?: (err: AWSError, data: StepFunctions.Types.ListActivitiesOutput) => void): Request<StepFunctions.Types.ListActivitiesOutput, AWSError>;
102 /**
103 * Lists the executions of a state machine that meet the filtering criteria. Results are sorted by time, with the most recent execution first. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
104 */
105 listExecutions(params: StepFunctions.Types.ListExecutionsInput, callback?: (err: AWSError, data: StepFunctions.Types.ListExecutionsOutput) => void): Request<StepFunctions.Types.ListExecutionsOutput, AWSError>;
106 /**
107 * Lists the executions of a state machine that meet the filtering criteria. Results are sorted by time, with the most recent execution first. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
108 */
109 listExecutions(callback?: (err: AWSError, data: StepFunctions.Types.ListExecutionsOutput) => void): Request<StepFunctions.Types.ListExecutionsOutput, AWSError>;
110 /**
111 * Lists the existing state machines. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
112 */
113 listStateMachines(params: StepFunctions.Types.ListStateMachinesInput, callback?: (err: AWSError, data: StepFunctions.Types.ListStateMachinesOutput) => void): Request<StepFunctions.Types.ListStateMachinesOutput, AWSError>;
114 /**
115 * Lists the existing state machines. If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.
116 */
117 listStateMachines(callback?: (err: AWSError, data: StepFunctions.Types.ListStateMachinesOutput) => void): Request<StepFunctions.Types.ListStateMachinesOutput, AWSError>;
118 /**
119 * List tags for a given resource.
120 */
121 listTagsForResource(params: StepFunctions.Types.ListTagsForResourceInput, callback?: (err: AWSError, data: StepFunctions.Types.ListTagsForResourceOutput) => void): Request<StepFunctions.Types.ListTagsForResourceOutput, AWSError>;
122 /**
123 * List tags for a given resource.
124 */
125 listTagsForResource(callback?: (err: AWSError, data: StepFunctions.Types.ListTagsForResourceOutput) => void): Request<StepFunctions.Types.ListTagsForResourceOutput, AWSError>;
126 /**
127 * Used by workers to report that the task identified by the taskToken failed.
128 */
129 sendTaskFailure(params: StepFunctions.Types.SendTaskFailureInput, callback?: (err: AWSError, data: StepFunctions.Types.SendTaskFailureOutput) => void): Request<StepFunctions.Types.SendTaskFailureOutput, AWSError>;
130 /**
131 * Used by workers to report that the task identified by the taskToken failed.
132 */
133 sendTaskFailure(callback?: (err: AWSError, data: StepFunctions.Types.SendTaskFailureOutput) => void): Request<StepFunctions.Types.SendTaskFailureOutput, AWSError>;
134 /**
135 * Used by workers to report to the service that the task represented by the specified taskToken is still making progress. This action resets the Heartbeat clock. The Heartbeat threshold is specified in the state machine's Amazon States Language definition. This action does not in itself create an event in the execution history. However, if the task times out, the execution history contains an ActivityTimedOut event. The Timeout of a task, defined in the state machine's Amazon States Language definition, is its maximum allowed duration, regardless of the number of SendTaskHeartbeat requests received. This operation is only useful for long-lived tasks to report the liveliness of the task.
136 */
137 sendTaskHeartbeat(params: StepFunctions.Types.SendTaskHeartbeatInput, callback?: (err: AWSError, data: StepFunctions.Types.SendTaskHeartbeatOutput) => void): Request<StepFunctions.Types.SendTaskHeartbeatOutput, AWSError>;
138 /**
139 * Used by workers to report to the service that the task represented by the specified taskToken is still making progress. This action resets the Heartbeat clock. The Heartbeat threshold is specified in the state machine's Amazon States Language definition. This action does not in itself create an event in the execution history. However, if the task times out, the execution history contains an ActivityTimedOut event. The Timeout of a task, defined in the state machine's Amazon States Language definition, is its maximum allowed duration, regardless of the number of SendTaskHeartbeat requests received. This operation is only useful for long-lived tasks to report the liveliness of the task.
140 */
141 sendTaskHeartbeat(callback?: (err: AWSError, data: StepFunctions.Types.SendTaskHeartbeatOutput) => void): Request<StepFunctions.Types.SendTaskHeartbeatOutput, AWSError>;
142 /**
143 * Used by workers to report that the task identified by the taskToken completed successfully.
144 */
145 sendTaskSuccess(params: StepFunctions.Types.SendTaskSuccessInput, callback?: (err: AWSError, data: StepFunctions.Types.SendTaskSuccessOutput) => void): Request<StepFunctions.Types.SendTaskSuccessOutput, AWSError>;
146 /**
147 * Used by workers to report that the task identified by the taskToken completed successfully.
148 */
149 sendTaskSuccess(callback?: (err: AWSError, data: StepFunctions.Types.SendTaskSuccessOutput) => void): Request<StepFunctions.Types.SendTaskSuccessOutput, AWSError>;
150 /**
151 * Starts a state machine execution. StartExecution is idempotent. If StartExecution is called with the same name and input as a running execution, the call will succeed and return the same response as the original request. If the execution is closed or if the input is different, it will return a 400 ExecutionAlreadyExists error. Names can be reused after 90 days.
152 */
153 startExecution(params: StepFunctions.Types.StartExecutionInput, callback?: (err: AWSError, data: StepFunctions.Types.StartExecutionOutput) => void): Request<StepFunctions.Types.StartExecutionOutput, AWSError>;
154 /**
155 * Starts a state machine execution. StartExecution is idempotent. If StartExecution is called with the same name and input as a running execution, the call will succeed and return the same response as the original request. If the execution is closed or if the input is different, it will return a 400 ExecutionAlreadyExists error. Names can be reused after 90 days.
156 */
157 startExecution(callback?: (err: AWSError, data: StepFunctions.Types.StartExecutionOutput) => void): Request<StepFunctions.Types.StartExecutionOutput, AWSError>;
158 /**
159 * Stops an execution.
160 */
161 stopExecution(params: StepFunctions.Types.StopExecutionInput, callback?: (err: AWSError, data: StepFunctions.Types.StopExecutionOutput) => void): Request<StepFunctions.Types.StopExecutionOutput, AWSError>;
162 /**
163 * Stops an execution.
164 */
165 stopExecution(callback?: (err: AWSError, data: StepFunctions.Types.StopExecutionOutput) => void): Request<StepFunctions.Types.StopExecutionOutput, AWSError>;
166 /**
167 * Add a tag to a Step Functions resource.
168 */
169 tagResource(params: StepFunctions.Types.TagResourceInput, callback?: (err: AWSError, data: StepFunctions.Types.TagResourceOutput) => void): Request<StepFunctions.Types.TagResourceOutput, AWSError>;
170 /**
171 * Add a tag to a Step Functions resource.
172 */
173 tagResource(callback?: (err: AWSError, data: StepFunctions.Types.TagResourceOutput) => void): Request<StepFunctions.Types.TagResourceOutput, AWSError>;
174 /**
175 * Remove a tag from a Step Functions resource
176 */
177 untagResource(params: StepFunctions.Types.UntagResourceInput, callback?: (err: AWSError, data: StepFunctions.Types.UntagResourceOutput) => void): Request<StepFunctions.Types.UntagResourceOutput, AWSError>;
178 /**
179 * Remove a tag from a Step Functions resource
180 */
181 untagResource(callback?: (err: AWSError, data: StepFunctions.Types.UntagResourceOutput) => void): Request<StepFunctions.Types.UntagResourceOutput, AWSError>;
182 /**
183 * Updates an existing state machine by modifying its definition and/or roleArn. Running executions will continue to use the previous definition and roleArn. You must include at least one of definition or roleArn or you will receive a MissingRequiredParameter error. All StartExecution calls within a few seconds will use the updated definition and roleArn. Executions started immediately after calling UpdateStateMachine may use the previous state machine definition and roleArn.
184 */
185 updateStateMachine(params: StepFunctions.Types.UpdateStateMachineInput, callback?: (err: AWSError, data: StepFunctions.Types.UpdateStateMachineOutput) => void): Request<StepFunctions.Types.UpdateStateMachineOutput, AWSError>;
186 /**
187 * Updates an existing state machine by modifying its definition and/or roleArn. Running executions will continue to use the previous definition and roleArn. You must include at least one of definition or roleArn or you will receive a MissingRequiredParameter error. All StartExecution calls within a few seconds will use the updated definition and roleArn. Executions started immediately after calling UpdateStateMachine may use the previous state machine definition and roleArn.
188 */
189 updateStateMachine(callback?: (err: AWSError, data: StepFunctions.Types.UpdateStateMachineOutput) => void): Request<StepFunctions.Types.UpdateStateMachineOutput, AWSError>;
190}
191declare namespace StepFunctions {
192 export interface ActivityFailedEventDetails {
193 /**
194 * The error code of the failure.
195 */
196 error?: SensitiveError;
197 /**
198 * A more detailed explanation of the cause of the failure.
199 */
200 cause?: SensitiveCause;
201 }
202 export type ActivityList = ActivityListItem[];
203 export interface ActivityListItem {
204 /**
205 * The Amazon Resource Name (ARN) that identifies the activity.
206 */
207 activityArn: Arn;
208 /**
209 * The name of the activity. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
210 */
211 name: Name;
212 /**
213 * The date the activity is created.
214 */
215 creationDate: Timestamp;
216 }
217 export interface ActivityScheduleFailedEventDetails {
218 /**
219 * The error code of the failure.
220 */
221 error?: SensitiveError;
222 /**
223 * A more detailed explanation of the cause of the failure.
224 */
225 cause?: SensitiveCause;
226 }
227 export interface ActivityScheduledEventDetails {
228 /**
229 * The Amazon Resource Name (ARN) of the scheduled activity.
230 */
231 resource: Arn;
232 /**
233 * The JSON data input to the activity task.
234 */
235 input?: SensitiveData;
236 /**
237 * The maximum allowed duration of the activity task.
238 */
239 timeoutInSeconds?: TimeoutInSeconds;
240 /**
241 * The maximum allowed duration between two heartbeats for the activity task.
242 */
243 heartbeatInSeconds?: TimeoutInSeconds;
244 }
245 export interface ActivityStartedEventDetails {
246 /**
247 * The name of the worker that the task is assigned to. These names are provided by the workers when calling GetActivityTask.
248 */
249 workerName?: Identity;
250 }
251 export interface ActivitySucceededEventDetails {
252 /**
253 * The JSON data output by the activity task.
254 */
255 output?: SensitiveData;
256 }
257 export interface ActivityTimedOutEventDetails {
258 /**
259 * The error code of the failure.
260 */
261 error?: SensitiveError;
262 /**
263 * A more detailed explanation of the cause of the timeout.
264 */
265 cause?: SensitiveCause;
266 }
267 export type Arn = string;
268 export type ConnectorParameters = string;
269 export interface CreateActivityInput {
270 /**
271 * The name of the activity to create. This name must be unique for your AWS account and region for 90 days. For more information, see Limits Related to State Machine Executions in the AWS Step Functions Developer Guide. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
272 */
273 name: Name;
274 /**
275 * The list of tags to add to a resource.
276 */
277 tags?: TagList;
278 }
279 export interface CreateActivityOutput {
280 /**
281 * The Amazon Resource Name (ARN) that identifies the created activity.
282 */
283 activityArn: Arn;
284 /**
285 * The date the activity is created.
286 */
287 creationDate: Timestamp;
288 }
289 export interface CreateStateMachineInput {
290 /**
291 * The name of the state machine. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
292 */
293 name: Name;
294 /**
295 * The Amazon States Language definition of the state machine. See Amazon States Language.
296 */
297 definition: Definition;
298 /**
299 * The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
300 */
301 roleArn: Arn;
302 /**
303 * Tags to be added when creating a state machine.
304 */
305 tags?: TagList;
306 }
307 export interface CreateStateMachineOutput {
308 /**
309 * The Amazon Resource Name (ARN) that identifies the created state machine.
310 */
311 stateMachineArn: Arn;
312 /**
313 * The date the state machine is created.
314 */
315 creationDate: Timestamp;
316 }
317 export type Definition = string;
318 export interface DeleteActivityInput {
319 /**
320 * The Amazon Resource Name (ARN) of the activity to delete.
321 */
322 activityArn: Arn;
323 }
324 export interface DeleteActivityOutput {
325 }
326 export interface DeleteStateMachineInput {
327 /**
328 * The Amazon Resource Name (ARN) of the state machine to delete.
329 */
330 stateMachineArn: Arn;
331 }
332 export interface DeleteStateMachineOutput {
333 }
334 export interface DescribeActivityInput {
335 /**
336 * The Amazon Resource Name (ARN) of the activity to describe.
337 */
338 activityArn: Arn;
339 }
340 export interface DescribeActivityOutput {
341 /**
342 * The Amazon Resource Name (ARN) that identifies the activity.
343 */
344 activityArn: Arn;
345 /**
346 * The name of the activity. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
347 */
348 name: Name;
349 /**
350 * The date the activity is created.
351 */
352 creationDate: Timestamp;
353 }
354 export interface DescribeExecutionInput {
355 /**
356 * The Amazon Resource Name (ARN) of the execution to describe.
357 */
358 executionArn: Arn;
359 }
360 export interface DescribeExecutionOutput {
361 /**
362 * The Amazon Resource Name (ARN) that identifies the execution.
363 */
364 executionArn: Arn;
365 /**
366 * The Amazon Resource Name (ARN) of the executed stated machine.
367 */
368 stateMachineArn: Arn;
369 /**
370 * The name of the execution. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
371 */
372 name?: Name;
373 /**
374 * The current status of the execution.
375 */
376 status: ExecutionStatus;
377 /**
378 * The date the execution is started.
379 */
380 startDate: Timestamp;
381 /**
382 * If the execution has already ended, the date the execution stopped.
383 */
384 stopDate?: Timestamp;
385 /**
386 * The string that contains the JSON input data of the execution.
387 */
388 input: SensitiveData;
389 /**
390 * The JSON output data of the execution. This field is set only if the execution succeeds. If the execution fails, this field is null.
391 */
392 output?: SensitiveData;
393 }
394 export interface DescribeStateMachineForExecutionInput {
395 /**
396 * The Amazon Resource Name (ARN) of the execution you want state machine information for.
397 */
398 executionArn: Arn;
399 }
400 export interface DescribeStateMachineForExecutionOutput {
401 /**
402 * The Amazon Resource Name (ARN) of the state machine associated with the execution.
403 */
404 stateMachineArn: Arn;
405 /**
406 * The name of the state machine associated with the execution.
407 */
408 name: Name;
409 /**
410 * The Amazon States Language definition of the state machine. See Amazon States Language.
411 */
412 definition: Definition;
413 /**
414 * The Amazon Resource Name (ARN) of the IAM role of the State Machine for the execution.
415 */
416 roleArn: Arn;
417 /**
418 * The date and time the state machine associated with an execution was updated. For a newly created state machine, this is the creation date.
419 */
420 updateDate: Timestamp;
421 }
422 export interface DescribeStateMachineInput {
423 /**
424 * The Amazon Resource Name (ARN) of the state machine to describe.
425 */
426 stateMachineArn: Arn;
427 }
428 export interface DescribeStateMachineOutput {
429 /**
430 * The Amazon Resource Name (ARN) that identifies the state machine.
431 */
432 stateMachineArn: Arn;
433 /**
434 * The name of the state machine. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
435 */
436 name: Name;
437 /**
438 * The current status of the state machine.
439 */
440 status?: StateMachineStatus;
441 /**
442 * The Amazon States Language definition of the state machine. See Amazon States Language.
443 */
444 definition: Definition;
445 /**
446 * The Amazon Resource Name (ARN) of the IAM role used when creating this state machine. (The IAM role maintains security by granting Step Functions access to AWS resources.)
447 */
448 roleArn: Arn;
449 /**
450 * The date the state machine is created.
451 */
452 creationDate: Timestamp;
453 }
454 export type EventId = number;
455 export interface ExecutionAbortedEventDetails {
456 /**
457 * The error code of the failure.
458 */
459 error?: SensitiveError;
460 /**
461 * A more detailed explanation of the cause of the failure.
462 */
463 cause?: SensitiveCause;
464 }
465 export interface ExecutionFailedEventDetails {
466 /**
467 * The error code of the failure.
468 */
469 error?: SensitiveError;
470 /**
471 * A more detailed explanation of the cause of the failure.
472 */
473 cause?: SensitiveCause;
474 }
475 export type ExecutionList = ExecutionListItem[];
476 export interface ExecutionListItem {
477 /**
478 * The Amazon Resource Name (ARN) that identifies the execution.
479 */
480 executionArn: Arn;
481 /**
482 * The Amazon Resource Name (ARN) of the executed state machine.
483 */
484 stateMachineArn: Arn;
485 /**
486 * The name of the execution. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
487 */
488 name: Name;
489 /**
490 * The current status of the execution.
491 */
492 status: ExecutionStatus;
493 /**
494 * The date the execution started.
495 */
496 startDate: Timestamp;
497 /**
498 * If the execution already ended, the date the execution stopped.
499 */
500 stopDate?: Timestamp;
501 }
502 export interface ExecutionStartedEventDetails {
503 /**
504 * The JSON data input to the execution.
505 */
506 input?: SensitiveData;
507 /**
508 * The Amazon Resource Name (ARN) of the IAM role used for executing AWS Lambda tasks.
509 */
510 roleArn?: Arn;
511 }
512 export type ExecutionStatus = "RUNNING"|"SUCCEEDED"|"FAILED"|"TIMED_OUT"|"ABORTED"|string;
513 export interface ExecutionSucceededEventDetails {
514 /**
515 * The JSON data output by the execution.
516 */
517 output?: SensitiveData;
518 }
519 export interface ExecutionTimedOutEventDetails {
520 /**
521 * The error code of the failure.
522 */
523 error?: SensitiveError;
524 /**
525 * A more detailed explanation of the cause of the timeout.
526 */
527 cause?: SensitiveCause;
528 }
529 export interface GetActivityTaskInput {
530 /**
531 * The Amazon Resource Name (ARN) of the activity to retrieve tasks from (assigned when you create the task using CreateActivity.)
532 */
533 activityArn: Arn;
534 /**
535 * You can provide an arbitrary name in order to identify the worker that the task is assigned to. This name is used when it is logged in the execution history.
536 */
537 workerName?: Name;
538 }
539 export interface GetActivityTaskOutput {
540 /**
541 * A token that identifies the scheduled task. This token must be copied and included in subsequent calls to SendTaskHeartbeat, SendTaskSuccess or SendTaskFailure in order to report the progress or completion of the task.
542 */
543 taskToken?: TaskToken;
544 /**
545 * The string that contains the JSON input data for the task.
546 */
547 input?: SensitiveDataJobInput;
548 }
549 export interface GetExecutionHistoryInput {
550 /**
551 * The Amazon Resource Name (ARN) of the execution.
552 */
553 executionArn: Arn;
554 /**
555 * The maximum number of results that are returned per call. You can use nextToken to obtain further pages of results. The default is 100 and the maximum allowed page size is 1000. A value of 0 uses the default. This is only an upper limit. The actual number of results returned per call might be fewer than the specified maximum.
556 */
557 maxResults?: PageSize;
558 /**
559 * Lists events in descending order of their timeStamp.
560 */
561 reverseOrder?: ReverseOrder;
562 /**
563 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
564 */
565 nextToken?: PageToken;
566 }
567 export interface GetExecutionHistoryOutput {
568 /**
569 * The list of events that occurred in the execution.
570 */
571 events: HistoryEventList;
572 /**
573 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
574 */
575 nextToken?: PageToken;
576 }
577 export interface HistoryEvent {
578 /**
579 * The date and time the event occurred.
580 */
581 timestamp: Timestamp;
582 /**
583 * The type of the event.
584 */
585 type: HistoryEventType;
586 /**
587 * The id of the event. Events are numbered sequentially, starting at one.
588 */
589 id: EventId;
590 /**
591 * The id of the previous event.
592 */
593 previousEventId?: EventId;
594 activityFailedEventDetails?: ActivityFailedEventDetails;
595 /**
596 * Contains details about an activity schedule event that failed during an execution.
597 */
598 activityScheduleFailedEventDetails?: ActivityScheduleFailedEventDetails;
599 activityScheduledEventDetails?: ActivityScheduledEventDetails;
600 activityStartedEventDetails?: ActivityStartedEventDetails;
601 activitySucceededEventDetails?: ActivitySucceededEventDetails;
602 activityTimedOutEventDetails?: ActivityTimedOutEventDetails;
603 /**
604 * Contains details about the failure of a task.
605 */
606 taskFailedEventDetails?: TaskFailedEventDetails;
607 /**
608 * Contains details about a task that was scheduled.
609 */
610 taskScheduledEventDetails?: TaskScheduledEventDetails;
611 /**
612 * Contains details about a task that failed to start.
613 */
614 taskStartFailedEventDetails?: TaskStartFailedEventDetails;
615 /**
616 * Contains details about a task that was started.
617 */
618 taskStartedEventDetails?: TaskStartedEventDetails;
619 /**
620 * Contains details about a task that where the submit failed.
621 */
622 taskSubmitFailedEventDetails?: TaskSubmitFailedEventDetails;
623 /**
624 * Contains details about a submitted task.
625 */
626 taskSubmittedEventDetails?: TaskSubmittedEventDetails;
627 /**
628 * Contains details about a task that succeeded.
629 */
630 taskSucceededEventDetails?: TaskSucceededEventDetails;
631 /**
632 * Contains details about a task that timed out.
633 */
634 taskTimedOutEventDetails?: TaskTimedOutEventDetails;
635 executionFailedEventDetails?: ExecutionFailedEventDetails;
636 executionStartedEventDetails?: ExecutionStartedEventDetails;
637 executionSucceededEventDetails?: ExecutionSucceededEventDetails;
638 executionAbortedEventDetails?: ExecutionAbortedEventDetails;
639 executionTimedOutEventDetails?: ExecutionTimedOutEventDetails;
640 lambdaFunctionFailedEventDetails?: LambdaFunctionFailedEventDetails;
641 lambdaFunctionScheduleFailedEventDetails?: LambdaFunctionScheduleFailedEventDetails;
642 lambdaFunctionScheduledEventDetails?: LambdaFunctionScheduledEventDetails;
643 /**
644 * Contains details about a lambda function that failed to start during an execution.
645 */
646 lambdaFunctionStartFailedEventDetails?: LambdaFunctionStartFailedEventDetails;
647 /**
648 * Contains details about a lambda function that terminated successfully during an execution.
649 */
650 lambdaFunctionSucceededEventDetails?: LambdaFunctionSucceededEventDetails;
651 lambdaFunctionTimedOutEventDetails?: LambdaFunctionTimedOutEventDetails;
652 stateEnteredEventDetails?: StateEnteredEventDetails;
653 stateExitedEventDetails?: StateExitedEventDetails;
654 }
655 export type HistoryEventList = HistoryEvent[];
656 export type HistoryEventType = "ActivityFailed"|"ActivityScheduleFailed"|"ActivityScheduled"|"ActivityStarted"|"ActivitySucceeded"|"ActivityTimedOut"|"ChoiceStateEntered"|"ChoiceStateExited"|"TaskFailed"|"TaskScheduled"|"TaskStartFailed"|"TaskStarted"|"TaskSubmitFailed"|"TaskSubmitted"|"TaskSucceeded"|"TaskTimedOut"|"ExecutionFailed"|"ExecutionStarted"|"ExecutionSucceeded"|"ExecutionAborted"|"ExecutionTimedOut"|"FailStateEntered"|"LambdaFunctionFailed"|"LambdaFunctionScheduleFailed"|"LambdaFunctionScheduled"|"LambdaFunctionStartFailed"|"LambdaFunctionStarted"|"LambdaFunctionSucceeded"|"LambdaFunctionTimedOut"|"SucceedStateEntered"|"SucceedStateExited"|"TaskStateAborted"|"TaskStateEntered"|"TaskStateExited"|"PassStateEntered"|"PassStateExited"|"ParallelStateAborted"|"ParallelStateEntered"|"ParallelStateExited"|"ParallelStateFailed"|"ParallelStateStarted"|"ParallelStateSucceeded"|"WaitStateAborted"|"WaitStateEntered"|"WaitStateExited"|string;
657 export type Identity = string;
658 export interface LambdaFunctionFailedEventDetails {
659 /**
660 * The error code of the failure.
661 */
662 error?: SensitiveError;
663 /**
664 * A more detailed explanation of the cause of the failure.
665 */
666 cause?: SensitiveCause;
667 }
668 export interface LambdaFunctionScheduleFailedEventDetails {
669 /**
670 * The error code of the failure.
671 */
672 error?: SensitiveError;
673 /**
674 * A more detailed explanation of the cause of the failure.
675 */
676 cause?: SensitiveCause;
677 }
678 export interface LambdaFunctionScheduledEventDetails {
679 /**
680 * The Amazon Resource Name (ARN) of the scheduled lambda function.
681 */
682 resource: Arn;
683 /**
684 * The JSON data input to the lambda function.
685 */
686 input?: SensitiveData;
687 /**
688 * The maximum allowed duration of the lambda function.
689 */
690 timeoutInSeconds?: TimeoutInSeconds;
691 }
692 export interface LambdaFunctionStartFailedEventDetails {
693 /**
694 * The error code of the failure.
695 */
696 error?: SensitiveError;
697 /**
698 * A more detailed explanation of the cause of the failure.
699 */
700 cause?: SensitiveCause;
701 }
702 export interface LambdaFunctionSucceededEventDetails {
703 /**
704 * The JSON data output by the lambda function.
705 */
706 output?: SensitiveData;
707 }
708 export interface LambdaFunctionTimedOutEventDetails {
709 /**
710 * The error code of the failure.
711 */
712 error?: SensitiveError;
713 /**
714 * A more detailed explanation of the cause of the timeout.
715 */
716 cause?: SensitiveCause;
717 }
718 export interface ListActivitiesInput {
719 /**
720 * The maximum number of results that are returned per call. You can use nextToken to obtain further pages of results. The default is 100 and the maximum allowed page size is 1000. A value of 0 uses the default. This is only an upper limit. The actual number of results returned per call might be fewer than the specified maximum.
721 */
722 maxResults?: PageSize;
723 /**
724 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
725 */
726 nextToken?: PageToken;
727 }
728 export interface ListActivitiesOutput {
729 /**
730 * The list of activities.
731 */
732 activities: ActivityList;
733 /**
734 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
735 */
736 nextToken?: PageToken;
737 }
738 export interface ListExecutionsInput {
739 /**
740 * The Amazon Resource Name (ARN) of the state machine whose executions is listed.
741 */
742 stateMachineArn: Arn;
743 /**
744 * If specified, only list the executions whose current execution status matches the given filter.
745 */
746 statusFilter?: ExecutionStatus;
747 /**
748 * The maximum number of results that are returned per call. You can use nextToken to obtain further pages of results. The default is 100 and the maximum allowed page size is 1000. A value of 0 uses the default. This is only an upper limit. The actual number of results returned per call might be fewer than the specified maximum.
749 */
750 maxResults?: PageSize;
751 /**
752 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
753 */
754 nextToken?: PageToken;
755 }
756 export interface ListExecutionsOutput {
757 /**
758 * The list of matching executions.
759 */
760 executions: ExecutionList;
761 /**
762 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
763 */
764 nextToken?: PageToken;
765 }
766 export interface ListStateMachinesInput {
767 /**
768 * The maximum number of results that are returned per call. You can use nextToken to obtain further pages of results. The default is 100 and the maximum allowed page size is 1000. A value of 0 uses the default. This is only an upper limit. The actual number of results returned per call might be fewer than the specified maximum.
769 */
770 maxResults?: PageSize;
771 /**
772 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
773 */
774 nextToken?: PageToken;
775 }
776 export interface ListStateMachinesOutput {
777 stateMachines: StateMachineList;
778 /**
779 * If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an HTTP 400 InvalidToken error.
780 */
781 nextToken?: PageToken;
782 }
783 export interface ListTagsForResourceInput {
784 /**
785 * The Amazon Resource Name (ARN) for the Step Functions state machine or activity.
786 */
787 resourceArn: Arn;
788 }
789 export interface ListTagsForResourceOutput {
790 /**
791 * An array of tags associated with the resource.
792 */
793 tags?: TagList;
794 }
795 export type Name = string;
796 export type PageSize = number;
797 export type PageToken = string;
798 export type ReverseOrder = boolean;
799 export interface SendTaskFailureInput {
800 /**
801 * The token that represents this task. Task tokens are generated by the service when the tasks are assigned to a worker (see GetActivityTask::taskToken).
802 */
803 taskToken: TaskToken;
804 /**
805 * The error code of the failure.
806 */
807 error?: SensitiveError;
808 /**
809 * A more detailed explanation of the cause of the failure.
810 */
811 cause?: SensitiveCause;
812 }
813 export interface SendTaskFailureOutput {
814 }
815 export interface SendTaskHeartbeatInput {
816 /**
817 * The token that represents this task. Task tokens are generated by the service when the tasks are assigned to a worker (see GetActivityTaskOutput$taskToken).
818 */
819 taskToken: TaskToken;
820 }
821 export interface SendTaskHeartbeatOutput {
822 }
823 export interface SendTaskSuccessInput {
824 /**
825 * The token that represents this task. Task tokens are generated by the service when the tasks are assigned to a worker (see GetActivityTaskOutput$taskToken).
826 */
827 taskToken: TaskToken;
828 /**
829 * The JSON output of the task.
830 */
831 output: SensitiveData;
832 }
833 export interface SendTaskSuccessOutput {
834 }
835 export type SensitiveCause = string;
836 export type SensitiveData = string;
837 export type SensitiveDataJobInput = string;
838 export type SensitiveError = string;
839 export interface StartExecutionInput {
840 /**
841 * The Amazon Resource Name (ARN) of the state machine to execute.
842 */
843 stateMachineArn: Arn;
844 /**
845 * The name of the execution. This name must be unique for your AWS account, region, and state machine for 90 days. For more information, see Limits Related to State Machine Executions in the AWS Step Functions Developer Guide. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
846 */
847 name?: Name;
848 /**
849 * The string that contains the JSON input data for the execution, for example: "input": "{\"first_name\" : \"test\"}" If you don't include any JSON input data, you still must include the two braces, for example: "input": "{}"
850 */
851 input?: SensitiveData;
852 }
853 export interface StartExecutionOutput {
854 /**
855 * The Amazon Resource Name (ARN) that identifies the execution.
856 */
857 executionArn: Arn;
858 /**
859 * The date the execution is started.
860 */
861 startDate: Timestamp;
862 }
863 export interface StateEnteredEventDetails {
864 /**
865 * The name of the state.
866 */
867 name: Name;
868 /**
869 * The string that contains the JSON input data for the state.
870 */
871 input?: SensitiveData;
872 }
873 export interface StateExitedEventDetails {
874 /**
875 * The name of the state. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
876 */
877 name: Name;
878 /**
879 * The JSON output data of the state.
880 */
881 output?: SensitiveData;
882 }
883 export type StateMachineList = StateMachineListItem[];
884 export interface StateMachineListItem {
885 /**
886 * The Amazon Resource Name (ARN) that identifies the state machine.
887 */
888 stateMachineArn: Arn;
889 /**
890 * The name of the state machine. A name must not contain: whitespace brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F)
891 */
892 name: Name;
893 /**
894 * The date the state machine is created.
895 */
896 creationDate: Timestamp;
897 }
898 export type StateMachineStatus = "ACTIVE"|"DELETING"|string;
899 export interface StopExecutionInput {
900 /**
901 * The Amazon Resource Name (ARN) of the execution to stop.
902 */
903 executionArn: Arn;
904 /**
905 * The error code of the failure.
906 */
907 error?: SensitiveError;
908 /**
909 * A more detailed explanation of the cause of the failure.
910 */
911 cause?: SensitiveCause;
912 }
913 export interface StopExecutionOutput {
914 /**
915 * The date the execution is stopped.
916 */
917 stopDate: Timestamp;
918 }
919 export interface Tag {
920 /**
921 * The key of a tag.
922 */
923 key?: TagKey;
924 /**
925 * The value of a tag.
926 */
927 value?: TagValue;
928 }
929 export type TagKey = string;
930 export type TagKeyList = TagKey[];
931 export type TagList = Tag[];
932 export interface TagResourceInput {
933 /**
934 * The Amazon Resource Name (ARN) for the Step Functions state machine or activity.
935 */
936 resourceArn: Arn;
937 /**
938 * The list of tags to add to a resource. Tags may only contain unicode letters, digits, whitespace, or these symbols: _ . : / = + - @.
939 */
940 tags: TagList;
941 }
942 export interface TagResourceOutput {
943 }
944 export type TagValue = string;
945 export interface TaskFailedEventDetails {
946 /**
947 * The action of the resource called by a task state.
948 */
949 resourceType: Name;
950 /**
951 * The service name of the resource in a task state.
952 */
953 resource: Name;
954 /**
955 * The error code of the failure.
956 */
957 error?: SensitiveError;
958 /**
959 * A more detailed explanation of the cause of the failure.
960 */
961 cause?: SensitiveCause;
962 }
963 export interface TaskScheduledEventDetails {
964 /**
965 * The action of the resource called by a task state.
966 */
967 resourceType: Name;
968 /**
969 * The service name of the resource in a task state.
970 */
971 resource: Name;
972 /**
973 * The region of the scheduled task
974 */
975 region: Name;
976 /**
977 * The JSON data passed to the resource referenced in a task state.
978 */
979 parameters: ConnectorParameters;
980 /**
981 * The maximum allowed duration of the task.
982 */
983 timeoutInSeconds?: TimeoutInSeconds;
984 }
985 export interface TaskStartFailedEventDetails {
986 /**
987 * The action of the resource called by a task state.
988 */
989 resourceType: Name;
990 /**
991 * The service name of the resource in a task state.
992 */
993 resource: Name;
994 /**
995 * The error code of the failure.
996 */
997 error?: SensitiveError;
998 /**
999 * A more detailed explanation of the cause of the failure.
1000 */
1001 cause?: SensitiveCause;
1002 }
1003 export interface TaskStartedEventDetails {
1004 /**
1005 * The action of the resource called by a task state.
1006 */
1007 resourceType: Name;
1008 /**
1009 * The service name of the resource in a task state.
1010 */
1011 resource: Name;
1012 }
1013 export interface TaskSubmitFailedEventDetails {
1014 /**
1015 * The action of the resource called by a task state.
1016 */
1017 resourceType: Name;
1018 /**
1019 * The service name of the resource in a task state.
1020 */
1021 resource: Name;
1022 /**
1023 * The error code of the failure.
1024 */
1025 error?: SensitiveError;
1026 /**
1027 * A more detailed explanation of the cause of the failure.
1028 */
1029 cause?: SensitiveCause;
1030 }
1031 export interface TaskSubmittedEventDetails {
1032 /**
1033 * The action of the resource called by a task state.
1034 */
1035 resourceType: Name;
1036 /**
1037 * The service name of the resource in a task state.
1038 */
1039 resource: Name;
1040 /**
1041 * The response from a resource when a task has started.
1042 */
1043 output?: SensitiveData;
1044 }
1045 export interface TaskSucceededEventDetails {
1046 /**
1047 * The action of the resource called by a task state.
1048 */
1049 resourceType: Name;
1050 /**
1051 * The service name of the resource in a task state.
1052 */
1053 resource: Name;
1054 /**
1055 * The full JSON response from a resource when a task has succeeded. This response becomes the output of the related task.
1056 */
1057 output?: SensitiveData;
1058 }
1059 export interface TaskTimedOutEventDetails {
1060 /**
1061 * The action of the resource called by a task state.
1062 */
1063 resourceType: Name;
1064 /**
1065 * The service name of the resource in a task state.
1066 */
1067 resource: Name;
1068 /**
1069 * The error code of the failure.
1070 */
1071 error?: SensitiveError;
1072 /**
1073 * A more detailed explanation of the cause of the failure.
1074 */
1075 cause?: SensitiveCause;
1076 }
1077 export type TaskToken = string;
1078 export type TimeoutInSeconds = number;
1079 export type Timestamp = Date;
1080 export interface UntagResourceInput {
1081 /**
1082 * The Amazon Resource Name (ARN) for the Step Functions state machine or activity.
1083 */
1084 resourceArn: Arn;
1085 /**
1086 * The list of tags to remove from the resource.
1087 */
1088 tagKeys: TagKeyList;
1089 }
1090 export interface UntagResourceOutput {
1091 }
1092 export interface UpdateStateMachineInput {
1093 /**
1094 * The Amazon Resource Name (ARN) of the state machine.
1095 */
1096 stateMachineArn: Arn;
1097 /**
1098 * The Amazon States Language definition of the state machine. See Amazon States Language.
1099 */
1100 definition?: Definition;
1101 /**
1102 * The Amazon Resource Name (ARN) of the IAM role of the state machine.
1103 */
1104 roleArn?: Arn;
1105 }
1106 export interface UpdateStateMachineOutput {
1107 /**
1108 * The date and time the state machine was updated.
1109 */
1110 updateDate: Timestamp;
1111 }
1112 /**
1113 * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
1114 */
1115 export type apiVersion = "2016-11-23"|"latest"|string;
1116 export interface ClientApiVersions {
1117 /**
1118 * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
1119 */
1120 apiVersion?: apiVersion;
1121 }
1122 export type ClientConfiguration = ServiceConfigurationOptions & ClientApiVersions;
1123 /**
1124 * Contains interfaces for use with the StepFunctions client.
1125 */
1126 export import Types = StepFunctions;
1127}
1128export = StepFunctions;