UNPKG

66 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. CreateActivity is an idempotent API. Subsequent requests won’t create a duplicate resource if it was already created. CreateActivity's idempotency check is based on the activity name. If a following request has different tags values, Step Functions will ignore these differences and treat it as an idempotent request of the previous. In this case, tags will not be updated, even if they are different.
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. CreateActivity is an idempotent API. Subsequent requests won’t create a duplicate resource if it was already created. CreateActivity's idempotency check is based on the activity name. If a following request has different tags values, Step Functions will ignore these differences and treat it as an idempotent request of the previous. In this case, tags will not be updated, even if they are different.
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. For more information, see Amazon States Language in the AWS Step Functions User Guide. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes. CreateStateMachine is an idempotent API. Subsequent requests won’t create a duplicate resource if it was already created. CreateStateMachine's idempotency check is based on the state machine name, definition, type, and LoggingConfiguration. If a following request has a different roleArn or tags, Step Functions will ignore these differences and treat it as an idempotent request of the previous. In this case, roleArn and tags will not be updated, even if they are different.
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. For more information, see Amazon States Language in the AWS Step Functions User Guide. This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes. CreateStateMachine is an idempotent API. Subsequent requests won’t create a duplicate resource if it was already created. CreateStateMachine's idempotency check is based on the state machine name, definition, type, and LoggingConfiguration. If a following request has a different roleArn or tags, Step Functions will ignore these differences and treat it as an idempotent request of the previous. In this case, roleArn and tags will not be updated, even if they are different.
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. For EXPRESSstate machines, the deletion will happen eventually (usually less than a minute). Running executions may emit logs after DeleteStateMachine API is called.
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. For EXPRESSstate machines, the deletion will happen eventually (usually less than a minute). Running executions may emit logs after DeleteStateMachine API is called.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
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. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
124 */
125 listTagsForResource(callback?: (err: AWSError, data: StepFunctions.Types.ListTagsForResourceOutput) => void): Request<StepFunctions.Types.ListTagsForResourceOutput, AWSError>;
126 /**
127 * Used by activity workers and task states using the callback pattern 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 activity workers and task states using the callback pattern 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 activity workers and task states using the callback pattern to report to Step Functions 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 (HeartbeatSeconds). 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 entry for activities, or a TaskTimedOut entry for for tasks using the job run or callback pattern. 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. Use HeartbeatSeconds to configure the timeout interval for heartbeats.
136 */
137 sendTaskHeartbeat(params: StepFunctions.Types.SendTaskHeartbeatInput, callback?: (err: AWSError, data: StepFunctions.Types.SendTaskHeartbeatOutput) => void): Request<StepFunctions.Types.SendTaskHeartbeatOutput, AWSError>;
138 /**
139 * Used by activity workers and task states using the callback pattern to report to Step Functions 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 (HeartbeatSeconds). 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 entry for activities, or a TaskTimedOut entry for for tasks using the job run or callback pattern. 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. Use HeartbeatSeconds to configure the timeout interval for heartbeats.
140 */
141 sendTaskHeartbeat(callback?: (err: AWSError, data: StepFunctions.Types.SendTaskHeartbeatOutput) => void): Request<StepFunctions.Types.SendTaskHeartbeatOutput, AWSError>;
142 /**
143 * Used by activity workers and task states using the callback pattern 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 activity workers and task states using the callback pattern 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. This API action is not supported by EXPRESS state machines.
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. This API action is not supported by EXPRESS state machines.
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. An array of key-value pairs. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide, and Controlling Access Using IAM Tags. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
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. An array of key-value pairs. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide, and Controlling Access Using IAM Tags. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
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, roleArn, or loggingConfiguration. 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, roleArn, or loggingConfiguration. 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: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
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 interface CloudWatchLogsLogGroup {
269 /**
270 * The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*
271 */
272 logGroupArn?: Arn;
273 }
274 export type ConnectorParameters = string;
275 export interface CreateActivityInput {
276 /**
277 * 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: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
278 */
279 name: Name;
280 /**
281 * The list of tags to add to a resource. An array of key-value pairs. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide, and Controlling Access Using IAM Tags. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
282 */
283 tags?: TagList;
284 }
285 export interface CreateActivityOutput {
286 /**
287 * The Amazon Resource Name (ARN) that identifies the created activity.
288 */
289 activityArn: Arn;
290 /**
291 * The date the activity is created.
292 */
293 creationDate: Timestamp;
294 }
295 export interface CreateStateMachineInput {
296 /**
297 * The name of the state machine. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
298 */
299 name: Name;
300 /**
301 * The Amazon States Language definition of the state machine. See Amazon States Language.
302 */
303 definition: Definition;
304 /**
305 * The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
306 */
307 roleArn: Arn;
308 /**
309 * Determines whether a Standard or Express state machine is created. The default is STANDARD. You cannot update the type of a state machine once it has been created.
310 */
311 type?: StateMachineType;
312 /**
313 * Defines what execution history events are logged and where they are logged. By default, the level is set to OFF. For more information see Log Levels in the AWS Step Functions User Guide.
314 */
315 loggingConfiguration?: LoggingConfiguration;
316 /**
317 * Tags to be added when creating a state machine. An array of key-value pairs. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide, and Controlling Access Using IAM Tags. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
318 */
319 tags?: TagList;
320 }
321 export interface CreateStateMachineOutput {
322 /**
323 * The Amazon Resource Name (ARN) that identifies the created state machine.
324 */
325 stateMachineArn: Arn;
326 /**
327 * The date the state machine is created.
328 */
329 creationDate: Timestamp;
330 }
331 export type Definition = string;
332 export interface DeleteActivityInput {
333 /**
334 * The Amazon Resource Name (ARN) of the activity to delete.
335 */
336 activityArn: Arn;
337 }
338 export interface DeleteActivityOutput {
339 }
340 export interface DeleteStateMachineInput {
341 /**
342 * The Amazon Resource Name (ARN) of the state machine to delete.
343 */
344 stateMachineArn: Arn;
345 }
346 export interface DeleteStateMachineOutput {
347 }
348 export interface DescribeActivityInput {
349 /**
350 * The Amazon Resource Name (ARN) of the activity to describe.
351 */
352 activityArn: Arn;
353 }
354 export interface DescribeActivityOutput {
355 /**
356 * The Amazon Resource Name (ARN) that identifies the activity.
357 */
358 activityArn: Arn;
359 /**
360 * The name of the activity. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
361 */
362 name: Name;
363 /**
364 * The date the activity is created.
365 */
366 creationDate: Timestamp;
367 }
368 export interface DescribeExecutionInput {
369 /**
370 * The Amazon Resource Name (ARN) of the execution to describe.
371 */
372 executionArn: Arn;
373 }
374 export interface DescribeExecutionOutput {
375 /**
376 * The Amazon Resource Name (ARN) that id entifies the execution.
377 */
378 executionArn: Arn;
379 /**
380 * The Amazon Resource Name (ARN) of the executed stated machine.
381 */
382 stateMachineArn: Arn;
383 /**
384 * The name of the execution. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
385 */
386 name?: Name;
387 /**
388 * The current status of the execution.
389 */
390 status: ExecutionStatus;
391 /**
392 * The date the execution is started.
393 */
394 startDate: Timestamp;
395 /**
396 * If the execution has already ended, the date the execution stopped.
397 */
398 stopDate?: Timestamp;
399 /**
400 * The string that contains the JSON input data of the execution.
401 */
402 input: SensitiveData;
403 /**
404 * The JSON output data of the execution. This field is set only if the execution succeeds. If the execution fails, this field is null.
405 */
406 output?: SensitiveData;
407 }
408 export interface DescribeStateMachineForExecutionInput {
409 /**
410 * The Amazon Resource Name (ARN) of the execution you want state machine information for.
411 */
412 executionArn: Arn;
413 }
414 export interface DescribeStateMachineForExecutionOutput {
415 /**
416 * The Amazon Resource Name (ARN) of the state machine associated with the execution.
417 */
418 stateMachineArn: Arn;
419 /**
420 * The name of the state machine associated with the execution.
421 */
422 name: Name;
423 /**
424 * The Amazon States Language definition of the state machine. See Amazon States Language.
425 */
426 definition: Definition;
427 /**
428 * The Amazon Resource Name (ARN) of the IAM role of the State Machine for the execution.
429 */
430 roleArn: Arn;
431 /**
432 * The date and time the state machine associated with an execution was updated. For a newly created state machine, this is the creation date.
433 */
434 updateDate: Timestamp;
435 loggingConfiguration?: LoggingConfiguration;
436 }
437 export interface DescribeStateMachineInput {
438 /**
439 * The Amazon Resource Name (ARN) of the state machine to describe.
440 */
441 stateMachineArn: Arn;
442 }
443 export interface DescribeStateMachineOutput {
444 /**
445 * The Amazon Resource Name (ARN) that identifies the state machine.
446 */
447 stateMachineArn: Arn;
448 /**
449 * The name of the state machine. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
450 */
451 name: Name;
452 /**
453 * The current status of the state machine.
454 */
455 status?: StateMachineStatus;
456 /**
457 * The Amazon States Language definition of the state machine. See Amazon States Language.
458 */
459 definition: Definition;
460 /**
461 * 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.)
462 */
463 roleArn: Arn;
464 /**
465 * The type of the state machine (STANDARD or EXPRESS).
466 */
467 type: StateMachineType;
468 /**
469 * The date the state machine is created.
470 */
471 creationDate: Timestamp;
472 loggingConfiguration?: LoggingConfiguration;
473 }
474 export type EventId = number;
475 export interface ExecutionAbortedEventDetails {
476 /**
477 * The error code of the failure.
478 */
479 error?: SensitiveError;
480 /**
481 * A more detailed explanation of the cause of the failure.
482 */
483 cause?: SensitiveCause;
484 }
485 export interface ExecutionFailedEventDetails {
486 /**
487 * The error code of the failure.
488 */
489 error?: SensitiveError;
490 /**
491 * A more detailed explanation of the cause of the failure.
492 */
493 cause?: SensitiveCause;
494 }
495 export type ExecutionList = ExecutionListItem[];
496 export interface ExecutionListItem {
497 /**
498 * The Amazon Resource Name (ARN) that id entifies the execution.
499 */
500 executionArn: Arn;
501 /**
502 * The Amazon Resource Name (ARN) of the executed state machine.
503 */
504 stateMachineArn: Arn;
505 /**
506 * The name of the execution. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
507 */
508 name: Name;
509 /**
510 * The current status of the execution.
511 */
512 status: ExecutionStatus;
513 /**
514 * The date the execution started.
515 */
516 startDate: Timestamp;
517 /**
518 * If the execution already ended, the date the execution stopped.
519 */
520 stopDate?: Timestamp;
521 }
522 export interface ExecutionStartedEventDetails {
523 /**
524 * The JSON data input to the execution.
525 */
526 input?: SensitiveData;
527 /**
528 * The Amazon Resource Name (ARN) of the IAM role used for executing AWS Lambda tasks.
529 */
530 roleArn?: Arn;
531 }
532 export type ExecutionStatus = "RUNNING"|"SUCCEEDED"|"FAILED"|"TIMED_OUT"|"ABORTED"|string;
533 export interface ExecutionSucceededEventDetails {
534 /**
535 * The JSON data output by the execution.
536 */
537 output?: SensitiveData;
538 }
539 export interface ExecutionTimedOutEventDetails {
540 /**
541 * The error code of the failure.
542 */
543 error?: SensitiveError;
544 /**
545 * A more detailed explanation of the cause of the timeout.
546 */
547 cause?: SensitiveCause;
548 }
549 export interface GetActivityTaskInput {
550 /**
551 * The Amazon Resource Name (ARN) of the activity to retrieve tasks from (assigned when you create the task using CreateActivity.)
552 */
553 activityArn: Arn;
554 /**
555 * 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.
556 */
557 workerName?: Name;
558 }
559 export interface GetActivityTaskOutput {
560 /**
561 * 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.
562 */
563 taskToken?: TaskToken;
564 /**
565 * The string that contains the JSON input data for the task.
566 */
567 input?: SensitiveDataJobInput;
568 }
569 export interface GetExecutionHistoryInput {
570 /**
571 * The Amazon Resource Name (ARN) of the execution.
572 */
573 executionArn: Arn;
574 /**
575 * 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.
576 */
577 maxResults?: PageSize;
578 /**
579 * Lists events in descending order of their timeStamp.
580 */
581 reverseOrder?: ReverseOrder;
582 /**
583 * 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.
584 */
585 nextToken?: PageToken;
586 }
587 export interface GetExecutionHistoryOutput {
588 /**
589 * The list of events that occurred in the execution.
590 */
591 events: HistoryEventList;
592 /**
593 * 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.
594 */
595 nextToken?: PageToken;
596 }
597 export interface HistoryEvent {
598 /**
599 * The date and time the event occurred.
600 */
601 timestamp: Timestamp;
602 /**
603 * The type of the event.
604 */
605 type: HistoryEventType;
606 /**
607 * The id of the event. Events are numbered sequentially, starting at one.
608 */
609 id: EventId;
610 /**
611 * The id of the previous event.
612 */
613 previousEventId?: EventId;
614 activityFailedEventDetails?: ActivityFailedEventDetails;
615 /**
616 * Contains details about an activity schedule event that failed during an execution.
617 */
618 activityScheduleFailedEventDetails?: ActivityScheduleFailedEventDetails;
619 activityScheduledEventDetails?: ActivityScheduledEventDetails;
620 activityStartedEventDetails?: ActivityStartedEventDetails;
621 activitySucceededEventDetails?: ActivitySucceededEventDetails;
622 activityTimedOutEventDetails?: ActivityTimedOutEventDetails;
623 /**
624 * Contains details about the failure of a task.
625 */
626 taskFailedEventDetails?: TaskFailedEventDetails;
627 /**
628 * Contains details about a task that was scheduled.
629 */
630 taskScheduledEventDetails?: TaskScheduledEventDetails;
631 /**
632 * Contains details about a task that failed to start.
633 */
634 taskStartFailedEventDetails?: TaskStartFailedEventDetails;
635 /**
636 * Contains details about a task that was started.
637 */
638 taskStartedEventDetails?: TaskStartedEventDetails;
639 /**
640 * Contains details about a task that where the submit failed.
641 */
642 taskSubmitFailedEventDetails?: TaskSubmitFailedEventDetails;
643 /**
644 * Contains details about a submitted task.
645 */
646 taskSubmittedEventDetails?: TaskSubmittedEventDetails;
647 /**
648 * Contains details about a task that succeeded.
649 */
650 taskSucceededEventDetails?: TaskSucceededEventDetails;
651 /**
652 * Contains details about a task that timed out.
653 */
654 taskTimedOutEventDetails?: TaskTimedOutEventDetails;
655 executionFailedEventDetails?: ExecutionFailedEventDetails;
656 executionStartedEventDetails?: ExecutionStartedEventDetails;
657 executionSucceededEventDetails?: ExecutionSucceededEventDetails;
658 executionAbortedEventDetails?: ExecutionAbortedEventDetails;
659 executionTimedOutEventDetails?: ExecutionTimedOutEventDetails;
660 /**
661 * Contains details about Map state that was started.
662 */
663 mapStateStartedEventDetails?: MapStateStartedEventDetails;
664 /**
665 * Contains details about an iteration of a Map state that was started.
666 */
667 mapIterationStartedEventDetails?: MapIterationEventDetails;
668 /**
669 * Contains details about an iteration of a Map state that succeeded.
670 */
671 mapIterationSucceededEventDetails?: MapIterationEventDetails;
672 /**
673 * Contains details about an iteration of a Map state that failed.
674 */
675 mapIterationFailedEventDetails?: MapIterationEventDetails;
676 /**
677 * Contains details about an iteration of a Map state that was aborted.
678 */
679 mapIterationAbortedEventDetails?: MapIterationEventDetails;
680 lambdaFunctionFailedEventDetails?: LambdaFunctionFailedEventDetails;
681 lambdaFunctionScheduleFailedEventDetails?: LambdaFunctionScheduleFailedEventDetails;
682 lambdaFunctionScheduledEventDetails?: LambdaFunctionScheduledEventDetails;
683 /**
684 * Contains details about a lambda function that failed to start during an execution.
685 */
686 lambdaFunctionStartFailedEventDetails?: LambdaFunctionStartFailedEventDetails;
687 /**
688 * Contains details about a lambda function that terminated successfully during an execution.
689 */
690 lambdaFunctionSucceededEventDetails?: LambdaFunctionSucceededEventDetails;
691 lambdaFunctionTimedOutEventDetails?: LambdaFunctionTimedOutEventDetails;
692 stateEnteredEventDetails?: StateEnteredEventDetails;
693 stateExitedEventDetails?: StateExitedEventDetails;
694 }
695 export type HistoryEventList = HistoryEvent[];
696 export type HistoryEventType = "ActivityFailed"|"ActivityScheduled"|"ActivityScheduleFailed"|"ActivityStarted"|"ActivitySucceeded"|"ActivityTimedOut"|"ChoiceStateEntered"|"ChoiceStateExited"|"ExecutionAborted"|"ExecutionFailed"|"ExecutionStarted"|"ExecutionSucceeded"|"ExecutionTimedOut"|"FailStateEntered"|"LambdaFunctionFailed"|"LambdaFunctionScheduled"|"LambdaFunctionScheduleFailed"|"LambdaFunctionStarted"|"LambdaFunctionStartFailed"|"LambdaFunctionSucceeded"|"LambdaFunctionTimedOut"|"MapIterationAborted"|"MapIterationFailed"|"MapIterationStarted"|"MapIterationSucceeded"|"MapStateAborted"|"MapStateEntered"|"MapStateExited"|"MapStateFailed"|"MapStateStarted"|"MapStateSucceeded"|"ParallelStateAborted"|"ParallelStateEntered"|"ParallelStateExited"|"ParallelStateFailed"|"ParallelStateStarted"|"ParallelStateSucceeded"|"PassStateEntered"|"PassStateExited"|"SucceedStateEntered"|"SucceedStateExited"|"TaskFailed"|"TaskScheduled"|"TaskStarted"|"TaskStartFailed"|"TaskStateAborted"|"TaskStateEntered"|"TaskStateExited"|"TaskSubmitFailed"|"TaskSubmitted"|"TaskSucceeded"|"TaskTimedOut"|"WaitStateAborted"|"WaitStateEntered"|"WaitStateExited"|string;
697 export type Identity = string;
698 export type IncludeExecutionData = boolean;
699 export interface LambdaFunctionFailedEventDetails {
700 /**
701 * The error code of the failure.
702 */
703 error?: SensitiveError;
704 /**
705 * A more detailed explanation of the cause of the failure.
706 */
707 cause?: SensitiveCause;
708 }
709 export interface LambdaFunctionScheduleFailedEventDetails {
710 /**
711 * The error code of the failure.
712 */
713 error?: SensitiveError;
714 /**
715 * A more detailed explanation of the cause of the failure.
716 */
717 cause?: SensitiveCause;
718 }
719 export interface LambdaFunctionScheduledEventDetails {
720 /**
721 * The Amazon Resource Name (ARN) of the scheduled lambda function.
722 */
723 resource: Arn;
724 /**
725 * The JSON data input to the lambda function.
726 */
727 input?: SensitiveData;
728 /**
729 * The maximum allowed duration of the lambda function.
730 */
731 timeoutInSeconds?: TimeoutInSeconds;
732 }
733 export interface LambdaFunctionStartFailedEventDetails {
734 /**
735 * The error code of the failure.
736 */
737 error?: SensitiveError;
738 /**
739 * A more detailed explanation of the cause of the failure.
740 */
741 cause?: SensitiveCause;
742 }
743 export interface LambdaFunctionSucceededEventDetails {
744 /**
745 * The JSON data output by the lambda function.
746 */
747 output?: SensitiveData;
748 }
749 export interface LambdaFunctionTimedOutEventDetails {
750 /**
751 * The error code of the failure.
752 */
753 error?: SensitiveError;
754 /**
755 * A more detailed explanation of the cause of the timeout.
756 */
757 cause?: SensitiveCause;
758 }
759 export interface ListActivitiesInput {
760 /**
761 * 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.
762 */
763 maxResults?: PageSize;
764 /**
765 * 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.
766 */
767 nextToken?: PageToken;
768 }
769 export interface ListActivitiesOutput {
770 /**
771 * The list of activities.
772 */
773 activities: ActivityList;
774 /**
775 * 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.
776 */
777 nextToken?: PageToken;
778 }
779 export interface ListExecutionsInput {
780 /**
781 * The Amazon Resource Name (ARN) of the state machine whose executions is listed.
782 */
783 stateMachineArn: Arn;
784 /**
785 * If specified, only list the executions whose current execution status matches the given filter.
786 */
787 statusFilter?: ExecutionStatus;
788 /**
789 * 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.
790 */
791 maxResults?: PageSize;
792 /**
793 * 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.
794 */
795 nextToken?: ListExecutionsPageToken;
796 }
797 export interface ListExecutionsOutput {
798 /**
799 * The list of matching executions.
800 */
801 executions: ExecutionList;
802 /**
803 * 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.
804 */
805 nextToken?: ListExecutionsPageToken;
806 }
807 export type ListExecutionsPageToken = string;
808 export interface ListStateMachinesInput {
809 /**
810 * 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.
811 */
812 maxResults?: PageSize;
813 /**
814 * 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.
815 */
816 nextToken?: PageToken;
817 }
818 export interface ListStateMachinesOutput {
819 stateMachines: StateMachineList;
820 /**
821 * 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.
822 */
823 nextToken?: PageToken;
824 }
825 export interface ListTagsForResourceInput {
826 /**
827 * The Amazon Resource Name (ARN) for the Step Functions state machine or activity.
828 */
829 resourceArn: Arn;
830 }
831 export interface ListTagsForResourceOutput {
832 /**
833 * An array of tags associated with the resource.
834 */
835 tags?: TagList;
836 }
837 export interface LogDestination {
838 /**
839 * An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.
840 */
841 cloudWatchLogsLogGroup?: CloudWatchLogsLogGroup;
842 }
843 export type LogDestinationList = LogDestination[];
844 export type LogLevel = "ALL"|"ERROR"|"FATAL"|"OFF"|string;
845 export interface LoggingConfiguration {
846 /**
847 * Defines which category of execution history events are logged.
848 */
849 level?: LogLevel;
850 /**
851 * Determines whether execution data is included in your log. When set to FALSE, data is excluded.
852 */
853 includeExecutionData?: IncludeExecutionData;
854 /**
855 * An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF.
856 */
857 destinations?: LogDestinationList;
858 }
859 export interface MapIterationEventDetails {
860 /**
861 * The name of the iteration’s parent Map state.
862 */
863 name?: Name;
864 /**
865 * The index of the array belonging to the Map state iteration.
866 */
867 index?: UnsignedInteger;
868 }
869 export interface MapStateStartedEventDetails {
870 /**
871 * The size of the array for Map state iterations.
872 */
873 length?: UnsignedInteger;
874 }
875 export type Name = string;
876 export type PageSize = number;
877 export type PageToken = string;
878 export type ReverseOrder = boolean;
879 export interface SendTaskFailureInput {
880 /**
881 * The token that represents this task. Task tokens are generated by Step Functions when tasks are assigned to a worker, or in the context object when a workflow enters a task state. See GetActivityTaskOutput$taskToken.
882 */
883 taskToken: TaskToken;
884 /**
885 * The error code of the failure.
886 */
887 error?: SensitiveError;
888 /**
889 * A more detailed explanation of the cause of the failure.
890 */
891 cause?: SensitiveCause;
892 }
893 export interface SendTaskFailureOutput {
894 }
895 export interface SendTaskHeartbeatInput {
896 /**
897 * The token that represents this task. Task tokens are generated by Step Functions when tasks are assigned to a worker, or in the context object when a workflow enters a task state. See GetActivityTaskOutput$taskToken.
898 */
899 taskToken: TaskToken;
900 }
901 export interface SendTaskHeartbeatOutput {
902 }
903 export interface SendTaskSuccessInput {
904 /**
905 * The token that represents this task. Task tokens are generated by Step Functions when tasks are assigned to a worker, or in the context object when a workflow enters a task state. See GetActivityTaskOutput$taskToken.
906 */
907 taskToken: TaskToken;
908 /**
909 * The JSON output of the task.
910 */
911 output: SensitiveData;
912 }
913 export interface SendTaskSuccessOutput {
914 }
915 export type SensitiveCause = string;
916 export type SensitiveData = string;
917 export type SensitiveDataJobInput = string;
918 export type SensitiveError = string;
919 export interface StartExecutionInput {
920 /**
921 * The Amazon Resource Name (ARN) of the state machine to execute.
922 */
923 stateMachineArn: Arn;
924 /**
925 * 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: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
926 */
927 name?: Name;
928 /**
929 * 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": "{}"
930 */
931 input?: SensitiveData;
932 }
933 export interface StartExecutionOutput {
934 /**
935 * The Amazon Resource Name (ARN) that id entifies the execution.
936 */
937 executionArn: Arn;
938 /**
939 * The date the execution is started.
940 */
941 startDate: Timestamp;
942 }
943 export interface StateEnteredEventDetails {
944 /**
945 * The name of the state.
946 */
947 name: Name;
948 /**
949 * The string that contains the JSON input data for the state.
950 */
951 input?: SensitiveData;
952 }
953 export interface StateExitedEventDetails {
954 /**
955 * The name of the state. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
956 */
957 name: Name;
958 /**
959 * The JSON output data of the state.
960 */
961 output?: SensitiveData;
962 }
963 export type StateMachineList = StateMachineListItem[];
964 export interface StateMachineListItem {
965 /**
966 * The Amazon Resource Name (ARN) that identifies the state machine.
967 */
968 stateMachineArn: Arn;
969 /**
970 * The name of the state machine. A name must not contain: white space brackets &lt; &gt; { } [ ] wildcard characters ? * special characters " # % \ ^ | ~ ` $ &amp; , ; : / control characters (U+0000-001F, U+007F-009F) To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.
971 */
972 name: Name;
973 /**
974 *
975 */
976 type: StateMachineType;
977 /**
978 * The date the state machine is created.
979 */
980 creationDate: Timestamp;
981 }
982 export type StateMachineStatus = "ACTIVE"|"DELETING"|string;
983 export type StateMachineType = "STANDARD"|"EXPRESS"|string;
984 export interface StopExecutionInput {
985 /**
986 * The Amazon Resource Name (ARN) of the execution to stop.
987 */
988 executionArn: Arn;
989 /**
990 * The error code of the failure.
991 */
992 error?: SensitiveError;
993 /**
994 * A more detailed explanation of the cause of the failure.
995 */
996 cause?: SensitiveCause;
997 }
998 export interface StopExecutionOutput {
999 /**
1000 * The date the execution is stopped.
1001 */
1002 stopDate: Timestamp;
1003 }
1004 export interface Tag {
1005 /**
1006 * The key of a tag.
1007 */
1008 key?: TagKey;
1009 /**
1010 * The value of a tag.
1011 */
1012 value?: TagValue;
1013 }
1014 export type TagKey = string;
1015 export type TagKeyList = TagKey[];
1016 export type TagList = Tag[];
1017 export interface TagResourceInput {
1018 /**
1019 * The Amazon Resource Name (ARN) for the Step Functions state machine or activity.
1020 */
1021 resourceArn: Arn;
1022 /**
1023 * The list of tags to add to a resource. Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @.
1024 */
1025 tags: TagList;
1026 }
1027 export interface TagResourceOutput {
1028 }
1029 export type TagValue = string;
1030 export interface TaskFailedEventDetails {
1031 /**
1032 * The action of the resource called by a task state.
1033 */
1034 resourceType: Name;
1035 /**
1036 * The service name of the resource in a task state.
1037 */
1038 resource: Name;
1039 /**
1040 * The error code of the failure.
1041 */
1042 error?: SensitiveError;
1043 /**
1044 * A more detailed explanation of the cause of the failure.
1045 */
1046 cause?: SensitiveCause;
1047 }
1048 export interface TaskScheduledEventDetails {
1049 /**
1050 * The action of the resource called by a task state.
1051 */
1052 resourceType: Name;
1053 /**
1054 * The service name of the resource in a task state.
1055 */
1056 resource: Name;
1057 /**
1058 * The region of the scheduled task
1059 */
1060 region: Name;
1061 /**
1062 * The JSON data passed to the resource referenced in a task state.
1063 */
1064 parameters: ConnectorParameters;
1065 /**
1066 * The maximum allowed duration of the task.
1067 */
1068 timeoutInSeconds?: TimeoutInSeconds;
1069 }
1070 export interface TaskStartFailedEventDetails {
1071 /**
1072 * The action of the resource called by a task state.
1073 */
1074 resourceType: Name;
1075 /**
1076 * The service name of the resource in a task state.
1077 */
1078 resource: Name;
1079 /**
1080 * The error code of the failure.
1081 */
1082 error?: SensitiveError;
1083 /**
1084 * A more detailed explanation of the cause of the failure.
1085 */
1086 cause?: SensitiveCause;
1087 }
1088 export interface TaskStartedEventDetails {
1089 /**
1090 * The action of the resource called by a task state.
1091 */
1092 resourceType: Name;
1093 /**
1094 * The service name of the resource in a task state.
1095 */
1096 resource: Name;
1097 }
1098 export interface TaskSubmitFailedEventDetails {
1099 /**
1100 * The action of the resource called by a task state.
1101 */
1102 resourceType: Name;
1103 /**
1104 * The service name of the resource in a task state.
1105 */
1106 resource: Name;
1107 /**
1108 * The error code of the failure.
1109 */
1110 error?: SensitiveError;
1111 /**
1112 * A more detailed explanation of the cause of the failure.
1113 */
1114 cause?: SensitiveCause;
1115 }
1116 export interface TaskSubmittedEventDetails {
1117 /**
1118 * The action of the resource called by a task state.
1119 */
1120 resourceType: Name;
1121 /**
1122 * The service name of the resource in a task state.
1123 */
1124 resource: Name;
1125 /**
1126 * The response from a resource when a task has started.
1127 */
1128 output?: SensitiveData;
1129 }
1130 export interface TaskSucceededEventDetails {
1131 /**
1132 * The action of the resource called by a task state.
1133 */
1134 resourceType: Name;
1135 /**
1136 * The service name of the resource in a task state.
1137 */
1138 resource: Name;
1139 /**
1140 * The full JSON response from a resource when a task has succeeded. This response becomes the output of the related task.
1141 */
1142 output?: SensitiveData;
1143 }
1144 export interface TaskTimedOutEventDetails {
1145 /**
1146 * The action of the resource called by a task state.
1147 */
1148 resourceType: Name;
1149 /**
1150 * The service name of the resource in a task state.
1151 */
1152 resource: Name;
1153 /**
1154 * The error code of the failure.
1155 */
1156 error?: SensitiveError;
1157 /**
1158 * A more detailed explanation of the cause of the failure.
1159 */
1160 cause?: SensitiveCause;
1161 }
1162 export type TaskToken = string;
1163 export type TimeoutInSeconds = number;
1164 export type Timestamp = Date;
1165 export type UnsignedInteger = number;
1166 export interface UntagResourceInput {
1167 /**
1168 * The Amazon Resource Name (ARN) for the Step Functions state machine or activity.
1169 */
1170 resourceArn: Arn;
1171 /**
1172 * The list of tags to remove from the resource.
1173 */
1174 tagKeys: TagKeyList;
1175 }
1176 export interface UntagResourceOutput {
1177 }
1178 export interface UpdateStateMachineInput {
1179 /**
1180 * The Amazon Resource Name (ARN) of the state machine.
1181 */
1182 stateMachineArn: Arn;
1183 /**
1184 * The Amazon States Language definition of the state machine. See Amazon States Language.
1185 */
1186 definition?: Definition;
1187 /**
1188 * The Amazon Resource Name (ARN) of the IAM role of the state machine.
1189 */
1190 roleArn?: Arn;
1191 /**
1192 * The LoggingConfiguration data type is used to set CloudWatch Logs options.
1193 */
1194 loggingConfiguration?: LoggingConfiguration;
1195 }
1196 export interface UpdateStateMachineOutput {
1197 /**
1198 * The date and time the state machine was updated.
1199 */
1200 updateDate: Timestamp;
1201 }
1202 /**
1203 * 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.
1204 */
1205 export type apiVersion = "2016-11-23"|"latest"|string;
1206 export interface ClientApiVersions {
1207 /**
1208 * 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.
1209 */
1210 apiVersion?: apiVersion;
1211 }
1212 export type ClientConfiguration = ServiceConfigurationOptions & ClientApiVersions;
1213 /**
1214 * Contains interfaces for use with the StepFunctions client.
1215 */
1216 export import Types = StepFunctions;
1217}
1218export = StepFunctions;