/* * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with * the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions * and limitations under the License. */ package com.amazonaws.services.stepfunctions; import javax.annotation.Generated; import com.amazonaws.services.stepfunctions.model.*; /** * Interface for accessing AWS SFN asynchronously. Each asynchronous method will return a Java Future object * representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive * notification when an asynchronous operation completes. *

* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from * {@link com.amazonaws.services.stepfunctions.AbstractAWSStepFunctionsAsync} instead. *

* Step Functions *

* Step Functions is a service that lets you coordinate the components of distributed applications and microservices * using visual workflows. *

* You can use Step Functions to build applications from individual components, each of which performs a discrete * function, or task, allowing you to scale and change applications quickly. Step Functions provides a console * that helps visualize the components of your application as a series of steps. Step Functions automatically triggers * and tracks each step, and retries steps when there are errors, so your application executes predictably and in the * right order every time. Step Functions logs the state of each step, so you can quickly diagnose and debug any issues. *

* Step Functions manages operations and underlying infrastructure to ensure your application is available at any scale. * You can run tasks on Amazon Web Services, your own servers, or any system that has access to Amazon Web Services. You * can access and use Step Functions using the console, the Amazon Web Services SDKs, or an HTTP API. For more * information about Step Functions, see the Step Functions Developer Guide . *

*/ @Generated("com.amazonaws:aws-java-sdk-code-generator") public interface AWSStepFunctionsAsync extends AWSStepFunctions { /** *

* Creates an activity. An activity is a task that you write in any programming language and host on any machine * that has access to 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. *

* * * @param createActivityRequest * @return A Java Future containing the result of the CreateActivity operation returned by the service. * @sample AWSStepFunctionsAsync.CreateActivity * @see AWS API * Documentation */ java.util.concurrent.Future createActivityAsync(CreateActivityRequest createActivityRequest); /** *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* *

* * * @param createActivityRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the CreateActivity operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.CreateActivity * @see AWS API * Documentation */ java.util.concurrent.Future createActivityAsync(CreateActivityRequest createActivityRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* 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 Step Functions User Guide. *

* If you set the publish parameter of this API action to true, it publishes version * 1 as the first revision of the state machine. *

* *

* 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, LoggingConfiguration, and * TracingConfiguration. The check is also based on the publish and * versionDescription parameters. 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. *

* * * @param createStateMachineRequest * @return A Java Future containing the result of the CreateStateMachine operation returned by the service. * @sample AWSStepFunctionsAsync.CreateStateMachine * @see AWS API * Documentation */ java.util.concurrent.Future createStateMachineAsync(CreateStateMachineRequest createStateMachineRequest); /** *

* If you set the publish parameter of this API action to true, it publishes version * 1 as the first revision of the state machine. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* *

* * * @param createStateMachineRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the CreateStateMachine operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.CreateStateMachine * @see AWS API * Documentation */ java.util.concurrent.Future createStateMachineAsync(CreateStateMachineRequest createStateMachineRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Creates an alias for a * state machine that points to one or two versions of * the same state machine. You can set your application to call StartExecution with an alias and update the * version the alias uses without changing the client's code. *

* You can also map an alias to split StartExecution requests between two versions of a state machine. To do * this, add a second RoutingConfig object in the routingConfiguration parameter. You must * also specify the percentage of execution run requests each version should receive in both * RoutingConfig objects. Step Functions randomly chooses which version runs a given execution based on * the percentage you specify. *

* To create an alias that points to a single version, specify a single RoutingConfig object with a * weight set to 100. *

* You can create up to 100 aliases for each state machine. You must delete unused aliases using the * DeleteStateMachineAlias API action. *

* CreateStateMachineAlias is an idempotent API. Step Functions bases the idempotency check on the * stateMachineArn, description, name, and routingConfiguration * parameters. Requests that contain the same values for these parameters return a successful idempotent response * without creating a duplicate resource. *

* Related operations: *

*
* DescribeStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* UpdateStateMachineAlias *
*
*
* DeleteStateMachineAlias *
*

* * @param createStateMachineAliasRequest * @return A Java Future containing the result of the CreateStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsync.CreateStateMachineAlias * @see AWS * API Documentation */ java.util.concurrent.Future createStateMachineAliasAsync(CreateStateMachineAliasRequest createStateMachineAliasRequest); /** *

* To create an alias that points to a single version, specify a single RoutingConfig object with a * weight set to 100. *

* You can create up to 100 aliases for each state machine. You must delete unused aliases using the * DeleteStateMachineAlias API action. *

* Related operations: *

*
* DescribeStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* UpdateStateMachineAlias *
*
*
* DeleteStateMachineAlias *
*

* * @param createStateMachineAliasRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the CreateStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.CreateStateMachineAlias * @see AWS * API Documentation */ java.util.concurrent.Future createStateMachineAliasAsync(CreateStateMachineAliasRequest createStateMachineAliasRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Deletes an activity. *

* * @param deleteActivityRequest * @return A Java Future containing the result of the DeleteActivity operation returned by the service. * @sample AWSStepFunctionsAsync.DeleteActivity * @see AWS API * Documentation */ java.util.concurrent.Future deleteActivityAsync(DeleteActivityRequest deleteActivityRequest); /** *

* Deletes an activity. *

* * @param deleteActivityRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DeleteActivity operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DeleteActivity * @see AWS API * Documentation */ java.util.concurrent.Future deleteActivityAsync(DeleteActivityRequest deleteActivityRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Deletes a state machine. This is an asynchronous operation: It sets the state machine's status to * DELETING and begins the deletion process. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine *
*

* This API action also deletes all versions and * aliases * associated with a state machine. *

* *

* For EXPRESS state machines, the deletion happens eventually (usually in less than a minute). Running * executions may emit logs after DeleteStateMachine API is called. *

* * * @param deleteStateMachineRequest * @return A Java Future containing the result of the DeleteStateMachine operation returned by the service. * @sample AWSStepFunctionsAsync.DeleteStateMachine * @see AWS API * Documentation */ java.util.concurrent.Future deleteStateMachineAsync(DeleteStateMachineRequest deleteStateMachineRequest); /** *

* Deletes a state machine. This is an asynchronous operation: It sets the state machine's status to * DELETING and begins the deletion process. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine *
*

* This API action also deletes all versions and * aliases * associated with a state machine. *

* *

* For EXPRESS state machines, the deletion happens eventually (usually in less than a minute). Running * executions may emit logs after DeleteStateMachine API is called. *

* * * @param deleteStateMachineRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DeleteStateMachine operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DeleteStateMachine * @see AWS API * Documentation */ java.util.concurrent.Future deleteStateMachineAsync(DeleteStateMachineRequest deleteStateMachineRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Deletes a state machine alias. *

* After you delete a state machine alias, you can't use it to start executions. When you delete a state machine * alias, Step Functions doesn't delete the state machine versions that alias references. *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* DescribeStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* UpdateStateMachineAlias *
*

* * @param deleteStateMachineAliasRequest * @return A Java Future containing the result of the DeleteStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsync.DeleteStateMachineAlias * @see AWS * API Documentation */ java.util.concurrent.Future deleteStateMachineAliasAsync(DeleteStateMachineAliasRequest deleteStateMachineAliasRequest); /** *

* Deletes a state machine alias. *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* DescribeStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* UpdateStateMachineAlias *
*

* * @param deleteStateMachineAliasRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DeleteStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DeleteStateMachineAlias * @see AWS * API Documentation */ java.util.concurrent.Future deleteStateMachineAliasAsync(DeleteStateMachineAliasRequest deleteStateMachineAliasRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Deletes a state machine version. * After you delete a version, you can't call StartExecution using that version's ARN or use the version with * a state machine alias. *

* *

* Deleting a state machine version won't terminate its in-progress executions. *

* *

* You can't delete a state machine version currently referenced by one or more aliases. Before you delete a * version, you must either delete the aliases or update them to point to another state machine version. *

* *

* Related operations: *

*
* PublishStateMachineVersion *
*
*
* ListStateMachineVersions *
*

* * @param deleteStateMachineVersionRequest * @return A Java Future containing the result of the DeleteStateMachineVersion operation returned by the service. * @sample AWSStepFunctionsAsync.DeleteStateMachineVersion * @see AWS API Documentation */ java.util.concurrent.Future deleteStateMachineVersionAsync( DeleteStateMachineVersionRequest deleteStateMachineVersionRequest); /** *

* Deletes a state machine version. * After you delete a version, you can't call StartExecution using that version's ARN or use the version with * a state machine alias. *

* *

* Deleting a state machine version won't terminate its in-progress executions. *

* *

* Related operations: *

*
* PublishStateMachineVersion *
*
*
* ListStateMachineVersions *
*

* * @param deleteStateMachineVersionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DeleteStateMachineVersion operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DeleteStateMachineVersion * @see AWS API Documentation */ java.util.concurrent.Future deleteStateMachineVersionAsync( DeleteStateMachineVersionRequest deleteStateMachineVersionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Describes an activity. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param describeActivityRequest * @return A Java Future containing the result of the DescribeActivity operation returned by the service. * @sample AWSStepFunctionsAsync.DescribeActivity * @see AWS API * Documentation */ java.util.concurrent.Future describeActivityAsync(DescribeActivityRequest describeActivityRequest); /** *

* Describes an activity. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param describeActivityRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DescribeActivity operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DescribeActivity * @see AWS API * Documentation */ java.util.concurrent.Future describeActivityAsync(DescribeActivityRequest describeActivityRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Provides information about a state machine execution, such as the state machine associated with the execution, * the execution input and output, and relevant execution metadata. Use this API action to return the Map Run Amazon * Resource Name (ARN) if the execution was dispatched by a Map Run. *

* If you specify a version or alias ARN when you call the StartExecution API action, * DescribeExecution returns that ARN. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* *

* Executions of an EXPRESS state machinearen't supported by DescribeExecution unless a * Map Run dispatched them. *

* * @param describeExecutionRequest * @return A Java Future containing the result of the DescribeExecution operation returned by the service. * @sample AWSStepFunctionsAsync.DescribeExecution * @see AWS API * Documentation */ java.util.concurrent.Future describeExecutionAsync(DescribeExecutionRequest describeExecutionRequest); /** *

* If you specify a version or alias ARN when you call the StartExecution API action, * DescribeExecution returns that ARN. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* *

* Executions of an EXPRESS state machinearen't supported by DescribeExecution unless a * Map Run dispatched them. *

* * @param describeExecutionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DescribeExecution operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DescribeExecution * @see AWS API * Documentation */ java.util.concurrent.Future describeExecutionAsync(DescribeExecutionRequest describeExecutionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Provides information about a Map Run's configuration, progress, and results. For more information, see Examining Map Run * in the Step Functions Developer Guide. *

* * @param describeMapRunRequest * @return A Java Future containing the result of the DescribeMapRun operation returned by the service. * @sample AWSStepFunctionsAsync.DescribeMapRun * @see AWS API * Documentation */ java.util.concurrent.Future describeMapRunAsync(DescribeMapRunRequest describeMapRunRequest); /** *

* Provides information about a Map Run's configuration, progress, and results. For more information, see Examining Map Run * in the Step Functions Developer Guide. *

* * @param describeMapRunRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DescribeMapRun operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DescribeMapRun * @see AWS API * Documentation */ java.util.concurrent.Future describeMapRunAsync(DescribeMapRunRequest describeMapRunRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Provides information about a state machine's definition, its IAM role Amazon Resource Name (ARN), and * configuration. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following qualified state machine ARN refers to an alias named PROD. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD> *
* *
* If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts * execution for that version or alias. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine> *
*

* This API action returns the details for a state machine version if the stateMachineArn you specify * is a state machine version ARN. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param describeStateMachineRequest * @return A Java Future containing the result of the DescribeStateMachine operation returned by the service. * @sample AWSStepFunctionsAsync.DescribeStateMachine * @see AWS * API Documentation */ java.util.concurrent.Future describeStateMachineAsync(DescribeStateMachineRequest describeStateMachineRequest); /** *

* Provides information about a state machine's definition, its IAM role Amazon Resource Name (ARN), and * configuration. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following qualified state machine ARN refers to an alias named PROD. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD> *
* *
* If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts * execution for that version or alias. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine> *
*

* This API action returns the details for a state machine version if the stateMachineArn you specify * is a state machine version ARN. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param describeStateMachineRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DescribeStateMachine operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DescribeStateMachine * @see AWS * API Documentation */ java.util.concurrent.Future describeStateMachineAsync(DescribeStateMachineRequest describeStateMachineRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Returns details about a state machine alias. *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* UpdateStateMachineAlias *
*
*
* DeleteStateMachineAlias *
*

* * @param describeStateMachineAliasRequest * @return A Java Future containing the result of the DescribeStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsync.DescribeStateMachineAlias * @see AWS API Documentation */ java.util.concurrent.Future describeStateMachineAliasAsync( DescribeStateMachineAliasRequest describeStateMachineAliasRequest); /** *

* Returns details about a state machine alias. *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* UpdateStateMachineAlias *
*
*
* DeleteStateMachineAlias *
*

* * @param describeStateMachineAliasRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DescribeStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.DescribeStateMachineAlias * @see AWS API Documentation */ java.util.concurrent.Future describeStateMachineAliasAsync( DescribeStateMachineAliasRequest describeStateMachineAliasRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Provides information about a state machine's definition, its execution role ARN, and configuration. If a Map Run * dispatched the execution, this action returns the Map Run Amazon Resource Name (ARN) in the response. The state * machine returned is the state machine associated with the Map Run. *

* *

* 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. *

* * @param describeStateMachineForExecutionRequest * @return A Java Future containing the result of the DescribeStateMachineForExecution operation returned by the * service. * @sample AWSStepFunctionsAsync.DescribeStateMachineForExecution * @see AWS API Documentation */ java.util.concurrent.Future describeStateMachineForExecutionAsync( DescribeStateMachineForExecutionRequest describeStateMachineForExecutionRequest); /** *

* *

* 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. *

* * @param describeStateMachineForExecutionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the DescribeStateMachineForExecution operation returned by the * service. * @sample AWSStepFunctionsAsyncHandler.DescribeStateMachineForExecution * @see AWS API Documentation */ java.util.concurrent.Future describeStateMachineForExecutionAsync( DescribeStateMachineForExecutionRequest describeStateMachineForExecutionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* 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. *

* *

* This API action isn't logged in CloudTrail. *

* *

* 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. *

* * * @param getActivityTaskRequest * @return A Java Future containing the result of the GetActivityTask operation returned by the service. * @sample AWSStepFunctionsAsync.GetActivityTask * @see AWS API * Documentation */ java.util.concurrent.Future getActivityTaskAsync(GetActivityTaskRequest getActivityTaskRequest); /** *

* *

* This API action isn't logged in CloudTrail. *

* *

* 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. *

* * * @param getActivityTaskRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the GetActivityTask operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.GetActivityTask * @see AWS API * Documentation */ java.util.concurrent.Future getActivityTaskAsync(GetActivityTaskRequest getActivityTaskRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* 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. *

* * @param getExecutionHistoryRequest * @return A Java Future containing the result of the GetExecutionHistory operation returned by the service. * @sample AWSStepFunctionsAsync.GetExecutionHistory * @see AWS API * Documentation */ java.util.concurrent.Future getExecutionHistoryAsync(GetExecutionHistoryRequest getExecutionHistoryRequest); /** *

* This API action is not supported by EXPRESS state machines. *

* * @param getExecutionHistoryRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the GetExecutionHistory operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.GetExecutionHistory * @see AWS API * Documentation */ java.util.concurrent.Future getExecutionHistoryAsync(GetExecutionHistoryRequest getExecutionHistoryRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Lists the existing activities. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param listActivitiesRequest * @return A Java Future containing the result of the ListActivities operation returned by the service. * @sample AWSStepFunctionsAsync.ListActivities * @see AWS API * Documentation */ java.util.concurrent.Future listActivitiesAsync(ListActivitiesRequest listActivitiesRequest); /** *

* Lists the existing activities. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param listActivitiesRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListActivities operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListActivities * @see AWS API * Documentation */ java.util.concurrent.Future listActivitiesAsync(ListActivitiesRequest listActivitiesRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Lists all executions of a state machine or a Map Run. You can list all executions related to a state machine by * specifying a state machine Amazon Resource Name (ARN), or those related to a Map Run by specifying a Map Run ARN. *

* You can also provide a state machine alias ARN or version ARN * to list the executions associated with a specific alias or version. *

* Results are sorted by time, with the most recent execution first. *

* *

* 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. *

* * @param listExecutionsRequest * @return A Java Future containing the result of the ListExecutions operation returned by the service. * @sample AWSStepFunctionsAsync.ListExecutions * @see AWS API * Documentation */ java.util.concurrent.Future listExecutionsAsync(ListExecutionsRequest listExecutionsRequest); /** *

* You can also provide a state machine alias ARN or version ARN * to list the executions associated with a specific alias or version. *

* Results are sorted by time, with the most recent execution first. *

* *

* 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. *

* * @param listExecutionsRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListExecutions operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListExecutions * @see AWS API * Documentation */ java.util.concurrent.Future listExecutionsAsync(ListExecutionsRequest listExecutionsRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Lists all Map Runs that were started by a given state machine execution. Use this API action to obtain Map Run * ARNs, and then call DescribeMapRun to obtain more information, if needed. *

* * @param listMapRunsRequest * @return A Java Future containing the result of the ListMapRuns operation returned by the service. * @sample AWSStepFunctionsAsync.ListMapRuns * @see AWS API * Documentation */ java.util.concurrent.Future listMapRunsAsync(ListMapRunsRequest listMapRunsRequest); /** *

* Lists all Map Runs that were started by a given state machine execution. Use this API action to obtain Map Run * ARNs, and then call DescribeMapRun to obtain more information, if needed. *

* * @param listMapRunsRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListMapRuns operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListMapRuns * @see AWS API * Documentation */ java.util.concurrent.Future listMapRunsAsync(ListMapRunsRequest listMapRunsRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Lists aliases for a * specified state machine ARN. Results are sorted by time, with the most recently created aliases listed first. *

* To list aliases that reference a state machine version, you * can specify the version ARN in the stateMachineArn parameter. *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* DescribeStateMachineAlias *
*
*
* UpdateStateMachineAlias *
*
*
* DeleteStateMachineAlias *
*

* * @param listStateMachineAliasesRequest * @return A Java Future containing the result of the ListStateMachineAliases operation returned by the service. * @sample AWSStepFunctionsAsync.ListStateMachineAliases * @see AWS * API Documentation */ java.util.concurrent.Future listStateMachineAliasesAsync(ListStateMachineAliasesRequest listStateMachineAliasesRequest); /** *

* Lists aliases for a * specified state machine ARN. Results are sorted by time, with the most recently created aliases listed first. *

* To list aliases that reference a state machine version, you * can specify the version ARN in the stateMachineArn parameter. *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* DescribeStateMachineAlias *
*
*
* UpdateStateMachineAlias *
*
*
* DeleteStateMachineAlias *
*

* * @param listStateMachineAliasesRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListStateMachineAliases operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListStateMachineAliases * @see AWS * API Documentation */ java.util.concurrent.Future listStateMachineAliasesAsync(ListStateMachineAliasesRequest listStateMachineAliasesRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Lists versions for * the specified state machine Amazon Resource Name (ARN). *

* The results are sorted in descending order of the version creation time. *

* Related operations: *

*
* PublishStateMachineVersion *
*
*
* DeleteStateMachineVersion *
*

* * @param listStateMachineVersionsRequest * @return A Java Future containing the result of the ListStateMachineVersions operation returned by the service. * @sample AWSStepFunctionsAsync.ListStateMachineVersions * @see AWS API Documentation */ java.util.concurrent.Future listStateMachineVersionsAsync(ListStateMachineVersionsRequest listStateMachineVersionsRequest); /** *

* Lists versions for * the specified state machine Amazon Resource Name (ARN). *

* The results are sorted in descending order of the version creation time. *

* Related operations: *

*
* PublishStateMachineVersion *
*
*
* DeleteStateMachineVersion *
*

* * @param listStateMachineVersionsRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListStateMachineVersions operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListStateMachineVersions * @see AWS API Documentation */ java.util.concurrent.Future listStateMachineVersionsAsync(ListStateMachineVersionsRequest listStateMachineVersionsRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Lists the existing state machines. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param listStateMachinesRequest * @return A Java Future containing the result of the ListStateMachines operation returned by the service. * @sample AWSStepFunctionsAsync.ListStateMachines * @see AWS API * Documentation */ java.util.concurrent.Future listStateMachinesAsync(ListStateMachinesRequest listStateMachinesRequest); /** *

* Lists the existing state machines. *

* *

* This operation is eventually consistent. The results are best effort and may not reflect very recent updates and * changes. *

* * * @param listStateMachinesRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListStateMachines operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListStateMachines * @see AWS API * Documentation */ java.util.concurrent.Future listStateMachinesAsync(ListStateMachinesRequest listStateMachinesRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* List tags for a given resource. *

* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @. *

* * @param listTagsForResourceRequest * @return A Java Future containing the result of the ListTagsForResource operation returned by the service. * @sample AWSStepFunctionsAsync.ListTagsForResource * @see AWS API * Documentation */ java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest); /** *

* List tags for a given resource. *

* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @. *

* * @param listTagsForResourceRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the ListTagsForResource operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.ListTagsForResource * @see AWS API * Documentation */ java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Creates a version from * the current revision of a state machine. Use versions to create immutable snapshots of your state machine. You * can start executions from versions either directly or with an alias. To create an alias, use * CreateStateMachineAlias. *

* You can publish up to 1000 versions for each state machine. You must manually delete unused versions using the * DeleteStateMachineVersion API action. *

* PublishStateMachineVersion is an idempotent API. It doesn't create a duplicate state machine version * if it already exists for the current revision. Step Functions bases PublishStateMachineVersion's * idempotency check on the stateMachineArn, name, and revisionId parameters. * Requests with the same parameters return a successful idempotent response. If you don't specify a * revisionId, Step Functions checks for a previously published version of the state machine's current * revision. *

* Related operations: *

*
* DeleteStateMachineVersion *
*
*
* ListStateMachineVersions *
*

* * @param publishStateMachineVersionRequest * @return A Java Future containing the result of the PublishStateMachineVersion operation returned by the service. * @sample AWSStepFunctionsAsync.PublishStateMachineVersion * @see AWS API Documentation */ java.util.concurrent.Future publishStateMachineVersionAsync( PublishStateMachineVersionRequest publishStateMachineVersionRequest); /** *

* You can publish up to 1000 versions for each state machine. You must manually delete unused versions using the * DeleteStateMachineVersion API action. *

* Related operations: *

*
* DeleteStateMachineVersion *
*
*
* ListStateMachineVersions *
*

* * @param publishStateMachineVersionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the PublishStateMachineVersion operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.PublishStateMachineVersion * @see AWS API Documentation */ java.util.concurrent.Future publishStateMachineVersionAsync( PublishStateMachineVersionRequest publishStateMachineVersionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken failed. *

* * @param sendTaskFailureRequest * @return A Java Future containing the result of the SendTaskFailure operation returned by the service. * @sample AWSStepFunctionsAsync.SendTaskFailure * @see AWS API * Documentation */ java.util.concurrent.Future sendTaskFailureAsync(SendTaskFailureRequest sendTaskFailureRequest); /** *

* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken failed. *

* * @param sendTaskFailureRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the SendTaskFailure operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.SendTaskFailure * @see AWS API * Documentation */ java.util.concurrent.Future sendTaskFailureAsync(SendTaskFailureRequest sendTaskFailureRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* 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. *

* * * @param sendTaskHeartbeatRequest * @return A Java Future containing the result of the SendTaskHeartbeat operation returned by the service. * @sample AWSStepFunctionsAsync.SendTaskHeartbeat * @see AWS API * Documentation */ java.util.concurrent.Future sendTaskHeartbeatAsync(SendTaskHeartbeatRequest sendTaskHeartbeatRequest); /** *

* *

* * * @param sendTaskHeartbeatRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the SendTaskHeartbeat operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.SendTaskHeartbeat * @see AWS API * Documentation */ java.util.concurrent.Future sendTaskHeartbeatAsync(SendTaskHeartbeatRequest sendTaskHeartbeatRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken completed successfully. *

* * @param sendTaskSuccessRequest * @return A Java Future containing the result of the SendTaskSuccess operation returned by the service. * @sample AWSStepFunctionsAsync.SendTaskSuccess * @see AWS API * Documentation */ java.util.concurrent.Future sendTaskSuccessAsync(SendTaskSuccessRequest sendTaskSuccessRequest); /** *

* Used by activity workers and task states using the callback pattern to report that the task identified by the taskToken completed successfully. *

* * @param sendTaskSuccessRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the SendTaskSuccess operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.SendTaskSuccess * @see AWS API * Documentation */ java.util.concurrent.Future sendTaskSuccessAsync(SendTaskSuccessRequest sendTaskSuccessRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Starts a state machine execution. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following qualified state machine ARN refers to an alias named PROD. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD> *
* *
* If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts * execution for that version or alias. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine> *
*

* If you start an execution with an unqualified state machine ARN, Step Functions uses the latest revision of the * state machine for the execution. *

* To start executions of a state machine version, call * StartExecution and provide the version ARN or the ARN of an alias that * points to the version. *

* *

* StartExecution is idempotent for STANDARD workflows. For a STANDARD * workflow, if you call StartExecution with the same name and input as a running execution, the call * succeeds and return the same response as the original request. If the execution is closed or if the input is * different, it returns a 400 ExecutionAlreadyExists error. You can reuse names after 90 days. *

* StartExecution isn't idempotent for EXPRESS workflows. *

* * * @param startExecutionRequest * @return A Java Future containing the result of the StartExecution operation returned by the service. * @sample AWSStepFunctionsAsync.StartExecution * @see AWS API * Documentation */ java.util.concurrent.Future startExecutionAsync(StartExecutionRequest startExecutionRequest); /** *

* Starts a state machine execution. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following qualified state machine ARN refers to an alias named PROD. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD> *
* *
* If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts * execution for that version or alias. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine> *
*

* If you start an execution with an unqualified state machine ARN, Step Functions uses the latest revision of the * state machine for the execution. *

* To start executions of a state machine version, call * StartExecution and provide the version ARN or the ARN of an alias that * points to the version. *

* *

* StartExecution isn't idempotent for EXPRESS workflows. *

* * * @param startExecutionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the StartExecution operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.StartExecution * @see AWS API * Documentation */ java.util.concurrent.Future startExecutionAsync(StartExecutionRequest startExecutionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Starts a Synchronous Express state machine execution. StartSyncExecution is not available for * STANDARD workflows. *

* *

* StartSyncExecution will return a 200 OK response, even if your execution fails, because * the status code in the API response doesn't reflect function errors. Error codes are reserved for errors that * prevent your execution from running, such as permissions errors, limit errors, or issues with your state machine * code and configuration. *

* *

* This API action isn't logged in CloudTrail. *

* * * @param startSyncExecutionRequest * @return A Java Future containing the result of the StartSyncExecution operation returned by the service. * @sample AWSStepFunctionsAsync.StartSyncExecution * @see AWS API * Documentation */ java.util.concurrent.Future startSyncExecutionAsync(StartSyncExecutionRequest startSyncExecutionRequest); /** *

* Starts a Synchronous Express state machine execution. StartSyncExecution is not available for * STANDARD workflows. *

* *

* This API action isn't logged in CloudTrail. *

* * * @param startSyncExecutionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the StartSyncExecution operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.StartSyncExecution * @see AWS API * Documentation */ java.util.concurrent.Future startSyncExecutionAsync(StartSyncExecutionRequest startSyncExecutionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Stops an execution. *

* This API action is not supported by EXPRESS state machines. *

* * @param stopExecutionRequest * @return A Java Future containing the result of the StopExecution operation returned by the service. * @sample AWSStepFunctionsAsync.StopExecution * @see AWS API * Documentation */ java.util.concurrent.Future stopExecutionAsync(StopExecutionRequest stopExecutionRequest); /** *

* Stops an execution. *

* This API action is not supported by EXPRESS state machines. *

* * @param stopExecutionRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the StopExecution operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.StopExecution * @see AWS API * Documentation */ java.util.concurrent.Future stopExecutionAsync(StopExecutionRequest stopExecutionRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Add a tag to a Step Functions resource. *

* An array of key-value pairs. For more information, see Using Cost Allocation * Tags in the Amazon Web Services Billing and Cost Management User Guide, and Controlling Access Using IAM * Tags. *

* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @. *

* * @param tagResourceRequest * @return A Java Future containing the result of the TagResource operation returned by the service. * @sample AWSStepFunctionsAsync.TagResource * @see AWS API * Documentation */ java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest); /** *

* Add a tag to a Step Functions resource. *

* An array of key-value pairs. For more information, see Using Cost Allocation * Tags in the Amazon Web Services Billing and Cost Management User Guide, and Controlling Access Using IAM * Tags. *

* Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @. *

* * @param tagResourceRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the TagResource operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.TagResource * @see AWS API * Documentation */ java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Remove a tag from a Step Functions resource *

* * @param untagResourceRequest * @return A Java Future containing the result of the UntagResource operation returned by the service. * @sample AWSStepFunctionsAsync.UntagResource * @see AWS API * Documentation */ java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest); /** *

* Remove a tag from a Step Functions resource *

* * @param untagResourceRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the UntagResource operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.UntagResource * @see AWS API * Documentation */ java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Updates an in-progress Map Run's configuration to include changes to the settings that control maximum * concurrency and Map Run failure. *

* * @param updateMapRunRequest * @return A Java Future containing the result of the UpdateMapRun operation returned by the service. * @sample AWSStepFunctionsAsync.UpdateMapRun * @see AWS API * Documentation */ java.util.concurrent.Future updateMapRunAsync(UpdateMapRunRequest updateMapRunRequest); /** *

* Updates an in-progress Map Run's configuration to include changes to the settings that control maximum * concurrency and Map Run failure. *

* * @param updateMapRunRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the UpdateMapRun operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.UpdateMapRun * @see AWS API * Documentation */ java.util.concurrent.Future updateMapRunAsync(UpdateMapRunRequest updateMapRunRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* 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. *

* A qualified state machine ARN refers to a Distributed Map state defined within a state machine. For * example, the qualified state machine ARN * arn:partition:states:region:account-id:stateMachine:stateMachineName/mapStateLabel refers to a * Distributed Map state with a label mapStateLabel in the state machine named * stateMachineName. *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following qualified state machine ARN refers to an alias named PROD. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD> *
* *
* If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts * execution for that version or alias. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine> *
*

* After you update your state machine, you can set the publish parameter to true in the * same action to publish a new version. This * way, you can opt-in to strict versioning of your state machine. *

* *

* Step Functions assigns monotonically increasing integers for state machine versions, starting at version number * 1. *

* *

* All StartExecution calls within a few seconds use the updated definition and * roleArn. Executions started immediately after you call UpdateStateMachine may use the * previous state machine definition and roleArn. *

* * * @param updateStateMachineRequest * @return A Java Future containing the result of the UpdateStateMachine operation returned by the service. * @sample AWSStepFunctionsAsync.UpdateStateMachine * @see AWS API * Documentation */ java.util.concurrent.Future updateStateMachineAsync(UpdateStateMachineRequest updateStateMachineRequest); /** *

* A qualified state machine ARN can either refer to a Distributed Map state defined within a state machine, * a version ARN, or an alias ARN. *

* The following are some examples of qualified and unqualified state machine ARNs: *

*
* The following qualified state machine ARN refers to a Distributed Map state with a label * mapStateLabel in a state machine named myStateMachine. *
*
* arn:partition:states:region:account-id:stateMachine:myStateMachine/mapStateLabel *
* *
* If you provide a qualified state machine ARN that refers to a Distributed Map state, the request fails * with ValidationException. *
*
*
* The following qualified state machine ARN refers to an alias named PROD. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine:PROD> *
* *
* If you provide a qualified state machine ARN that refers to a version ARN or an alias ARN, the request starts * execution for that version or alias. *
*
*
* The following unqualified state machine ARN refers to a state machine named myStateMachine. *
*
* arn:<partition>:states:<region>:<account-id>:stateMachine:<myStateMachine> *
*

* *

* Step Functions assigns monotonically increasing integers for state machine versions, starting at version number * 1. *

* *

* * * @param updateStateMachineRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the UpdateStateMachine operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.UpdateStateMachine * @see AWS API * Documentation */ java.util.concurrent.Future updateStateMachineAsync(UpdateStateMachineRequest updateStateMachineRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); /** *

* Updates the configuration of an existing state machine alias by * modifying its description or routingConfiguration. *

* You must specify at least one of the description or routingConfiguration parameters to * update a state machine alias. *

* *

* UpdateStateMachineAlias is an idempotent API. Step Functions bases the idempotency check on the * stateMachineAliasArn, description, and routingConfiguration parameters. * Requests with the same parameters return an idempotent response. *

* *

* This operation is eventually consistent. All StartExecution requests made within a few seconds use the * latest alias configuration. Executions started immediately after calling UpdateStateMachineAlias may * use the previous routing configuration. *

* *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* DescribeStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* DeleteStateMachineAlias *
*

* * @param updateStateMachineAliasRequest * @return A Java Future containing the result of the UpdateStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsync.UpdateStateMachineAlias * @see AWS * API Documentation */ java.util.concurrent.Future updateStateMachineAliasAsync(UpdateStateMachineAliasRequest updateStateMachineAliasRequest); /** *

* Updates the configuration of an existing state machine alias by * modifying its description or routingConfiguration. *

* You must specify at least one of the description or routingConfiguration parameters to * update a state machine alias. *

* *

* Related operations: *

*
* CreateStateMachineAlias *
*
*
* DescribeStateMachineAlias *
*
*
* ListStateMachineAliases *
*
*
* DeleteStateMachineAlias *
*

* * @param updateStateMachineAliasRequest * @param asyncHandler * Asynchronous callback handler for events in the lifecycle of the request. Users can provide an * implementation of the callback methods in this interface to receive notification of successful or * unsuccessful completion of the operation. * @return A Java Future containing the result of the UpdateStateMachineAlias operation returned by the service. * @sample AWSStepFunctionsAsyncHandler.UpdateStateMachineAlias * @see AWS * API Documentation */ java.util.concurrent.Future updateStateMachineAliasAsync(UpdateStateMachineAliasRequest updateStateMachineAliasRequest, com.amazonaws.handlers.AsyncHandler asyncHandler); }