Interface WorkflowClient

public interface WorkflowClient
Client to the Temporal service used to start and query workflows by external processes. Also, it supports creation of ActivityCompletionClient instances used to complete activities asynchronously. Do not create this object for each request, keep it for the duration of the process.

Given a workflow interface executing a workflow requires initializing a WorkflowClient instance, creating a client side stub to the workflow, and then calling a method annotated with @WorkflowMethod. 


 WorkflowClient workflowClient =  WorkflowClient.newInstance(service, clientOptions);
 // Create a workflow stub.
 FileProcessingWorkflow workflow = workflowClient.newWorkflowStub(FileProcessingWorkflow.class);
There are two ways to start workflow execution: synchronously and asynchronously. Synchronous invocation starts a workflow and then waits for its completion. If the process that started the workflow crashes or stops waiting, the workflow continues executing. Because workflows are potentially long-running, and crashes of clients happen, it is not very commonly found in production use. Asynchronous start initiates workflow execution and immediately returns to the caller. This is the most common way to start workflows in production code.

Synchronous start: 


 // Start a workflow and wait for a result.
 // Note that if the waiting process is killed, the workflow will continue executing.
 String result = workflow.processFile(workflowArgs);
Asynchronous when the workflow result is not needed: 

 // Returns as soon as the workflow is scheduled to start on the server.
 WorkflowExecution workflowExecution = WorkflowClient.start(workflow::processFile, workflowArgs);

 System.out.println("Started process file workflow with workflowId=\"" + workflowExecution.getWorkflowId()
                     + "\" and runId=\"" + workflowExecution.getRunId() + "\"");
Asynchronous when the result is needed: 

 // Returns a CompletableFuture<String> on the workflow result as soon as the workflow is scheduled to start on the server.
 CompletableFuture<String> result = WorkflowClient.execute(workflow::helloWorld, "User");
If you need to wait for a workflow completion after an asynchronous start, maybe even from a different process, the simplest way is to call the blocking version again. If WorkflowOptions.getWorkflowIdReusePolicy() is not AllowDuplicate then instead of throwing WorkflowExecutionAlreadyStarted, it reconnects to an existing workflow and waits for its completion. The following example shows how to do this from a different process than the one that started the workflow. All this process needs is a WorkflowId. 

 FileProcessingWorkflow workflow = workflowClient.newWorkflowStub(FileProcessingWorkflow.class, workflowId);
 // Returns result potentially waiting for workflow to complete.
 String result = workflow.processFile(workflowArgs);
See Also:

  • Field Details

    • QUERY_TYPE_STACK_TRACE

      static final String QUERY_TYPE_STACK_TRACE
      Use this constant as a query type to get a workflow stack trace.
      See Also:

    • QUERY_TYPE_WORKFLOW_METADATA

      static final String QUERY_TYPE_WORKFLOW_METADATA
      Use this constant as a query type to get the workflow metadata.
      See Also:

    • QUERY_TYPE_REPLAY_ONLY

      static final String QUERY_TYPE_REPLAY_ONLY
      Replays workflow to the current state and returns empty result or error if replay failed.
      See Also:

  • Method Details

    • newInstance

      static WorkflowClient newInstance(io.temporal.serviceclient.WorkflowServiceStubs service)
      Creates client that connects to an instance of the Temporal Service.
      Parameters:
      service - client to the Temporal Service endpoint.

    • newInstance

      static WorkflowClient newInstance(io.temporal.serviceclient.WorkflowServiceStubs service, WorkflowClientOptions options)
      Creates client that connects to an instance of the Temporal Service.
      Parameters:
      service - client to the Temporal Service endpoint.
      options - Options (like DataConverterer override) for configuring client.

    • getOptions

      WorkflowClientOptions getOptions()

    • getWorkflowServiceStubs

      io.temporal.serviceclient.WorkflowServiceStubs getWorkflowServiceStubs()

    • newWorkflowStub

      <T> T newWorkflowStub(Class<T> workflowInterface, WorkflowOptions options)
      Creates workflow client stub that can be used to start a single workflow execution. The first call must be to a method annotated with @WorkflowMethod. After workflow is started it can be also used to send signals or queries to it. IMPORTANT! Stub is per workflow instance. So new stub should be created for each new one.
      Parameters:
      workflowInterface - interface that given workflow implements
      options - options that will be used to configure and start a new workflow. At least WorkflowOptions.Builder.setTaskQueue(String) needs to be specified.
      Returns:
      Stub that implements workflowInterface and can be used to start workflow and signal or query it after the start.

    • newWorkflowStub

      <T> T newWorkflowStub(Class<T> workflowInterface, String workflowId)
      Creates workflow client stub for a known execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowInterface - interface that given workflow implements.
      workflowId - Workflow id.
      Returns:
      Stub that implements workflowInterface and can be used to signal or query it.

    • newWorkflowStub

      @Deprecated <T> T newWorkflowStub(Class<T> workflowInterface, String workflowId, Optional<String> runId)
      Deprecated.
      Use newWorkflowStub(Class, WorkflowTargetOptions) instead. This method is deprecated because the returned stub does not properly account for the runId.
      Creates workflow client stub for a known execution. Use it to send signals, updates, or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowInterface - interface that given workflow implements.
      workflowId - Workflow id.
      runId - Run id of the workflow execution.
      Returns:
      Stub that implements workflowInterface and can be used to signal, update, or query it.

    • newWorkflowStub

      <T> T newWorkflowStub(Class<T> workflowInterface, WorkflowTargetOptions workflowTargetOptions)
      Creates workflow client stub for a known execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowInterface - interface that given workflow implements.
      workflowTargetOptions - options that specify target workflow execution.
      Returns:
      Stub that implements workflowInterface and can be used to signal or query it.

    • newUntypedWorkflowStub

      WorkflowStub newUntypedWorkflowStub(String workflowId)
      Creates workflow untyped client stub that can be used to start a single workflow execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowId - Workflow id.
      Returns:
      Stub that can be used to start workflow and later to signal or query it.

    • newUntypedWorkflowStub

      WorkflowStub newUntypedWorkflowStub(String workflowType, WorkflowOptions options)
      Creates workflow untyped client stub that can be used to start a single workflow execution. After workflow is started it can be also used to send signals or queries to it. IMPORTANT! Stub is per workflow instance. So new stub should be created for each new one.
      Parameters:
      workflowType - name of the workflow type
      options - options used to start a workflow through returned stub
      Returns:
      Stub that can be used to start workflow and later to signal or query it.

    • newUntypedWorkflowStub

      @Deprecated WorkflowStub newUntypedWorkflowStub(String workflowId, Optional<String> runId, Optional<String> workflowType)
      Deprecated.
      Use newUntypedWorkflowStub(WorkflowTargetOptions, Optional) instead. This method is deprecated because the returned stub does not properly account for the runId.
      Creates workflow untyped client stub for a known execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowId - workflow id and optional run id for execution
      runId - runId of the workflow execution. If not provided the last workflow with the given workflowId is assumed.
      workflowType - type of the workflow. Optional as it is used for error reporting only.
      Returns:
      Stub that can be used to start workflow and later to signal or query it.

    • newUntypedWorkflowStub

      WorkflowStub newUntypedWorkflowStub(io.temporal.api.common.v1.WorkflowExecution execution, Optional<String> workflowType)
      Deprecated.
      Use newUntypedWorkflowStub(WorkflowTargetOptions, Optional) instead. This method is deprecated because the returned stub does not properly account for the runId.
      Creates workflow untyped client stub for a known execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      execution - workflow id and optional run id for execution
      workflowType - type of the workflow. Optional as it is used for error reporting only.
      Returns:
      Stub that can be used to start workflow and later to signal or query it.

    • newUntypedWorkflowStub

      WorkflowStub newUntypedWorkflowStub(WorkflowTargetOptions workflowTargetOptions)
      Creates workflow untyped client stub for a known execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowTargetOptions - options that specify target workflow execution.
      Returns:
      Stub that can be used to start workflow and later to signal or query it.

    • newUntypedWorkflowStub

      WorkflowStub newUntypedWorkflowStub(WorkflowTargetOptions workflowTargetOptions, Optional<String> workflowType)
      Creates workflow untyped client stub for a known execution. Use it to send signals or queries to a running workflow. Do not call methods annotated with @WorkflowMethod.
      Parameters:
      workflowTargetOptions - options that specify target workflow execution.
      workflowType - type of the workflow. Optional as it is used for error reporting only.
      Returns:
      Stub that can be used to start workflow and later to signal or query it.

    • newActivityCompletionClient

      ActivityCompletionClient newActivityCompletionClient()
      Creates new ActivityCompletionClient that can be used to complete activities asynchronously. Only relevant for activity implementations that called ActivityExecutionContext.doNotCompleteOnReturn().

      TODO: Activity completion options with retries and timeouts.

    • newSignalWithStartRequest

      BatchRequest newSignalWithStartRequest()
      Creates BatchRequest that can be used to signal an existing workflow or start a new one if not running. The batch before invocation must contain exactly two operations. One annotated with @WorkflowMethod and another with @SignalMethod.
      Returns:
      batch request used to call signalWithStart(BatchRequest)

    • signalWithStart

      io.temporal.api.common.v1.WorkflowExecution signalWithStart(BatchRequest signalWithStartBatch)
      Invoke SignalWithStart operation.
      Parameters:
      signalWithStartBatch - Must be created with newSignalWithStartRequest()
      Returns:
      workflowId and runId of the signaled or started workflow.

    • listExecutions

      Stream<WorkflowExecutionMetadata> listExecutions(@Nullable String query)
      A wrapper around {WorkflowServiceStub#listWorkflowExecutions(ListWorkflowExecutionsRequest)}
      Parameters:
      query - Temporal Visibility Query, for syntax see Visibility docs
      Returns:
      sequential stream that performs remote pagination under the hood

    • countWorkflows

      WorkflowExecutionCount countWorkflows(@Nullable String query)
      Count workflow executions using the Visibility API.
      Parameters:
      query - Temporal Visibility query, for syntax see Visibility docs
      Returns:
      count result object

    • streamHistory

      Stream<io.temporal.api.history.v1.HistoryEvent> streamHistory(@Nonnull String workflowId)
      Streams history events for a workflow execution for the provided workflowId.
      Parameters:
      workflowId - Workflow Id of the workflow to export the history for
      Returns:
      stream of history events of the workflow with the specified Workflow Id.
      See Also:

    • streamHistory

      Stream<io.temporal.api.history.v1.HistoryEvent> streamHistory(@Nonnull String workflowId, @Nullable String runId)
      Streams history events for a workflow execution for the provided workflowId and runId.
      Parameters:
      workflowId - Workflow Id of the workflow to export the history for
      runId - Fixed Run Id of the workflow to export the history for. If not provided, the latest run will be used. Optional, can be null.
      Returns:
      stream of history events of the specified run of the workflow execution.
      See Also:

    • fetchHistory

      WorkflowExecutionHistory fetchHistory(@Nonnull String workflowId)
      Downloads workflow execution history for the provided workflowId.
      Parameters:
      workflowId - Workflow Id of the workflow to export the history for
      Returns:
      execution history of the workflow with the specified Workflow Id.
      See Also:

    • fetchHistory

      WorkflowExecutionHistory fetchHistory(@Nonnull String workflowId, @Nullable String runId)
      Downloads workflow execution history for the provided workflowId and runId.
      Parameters:
      workflowId - Workflow Id of the workflow to export the history for
      runId - Fixed Run Id of the workflow to export the history for. If not provided, the latest run will be used. Optional, can be null.
      Returns:
      execution history of the specified run of the workflow execution.
      See Also:

    • updateWorkerBuildIdCompatability

      @Experimental @Deprecated void updateWorkerBuildIdCompatability(@Nonnull String taskQueue, @Nonnull BuildIdOperation operation)
      Deprecated.
      Worker Versioning is now deprecated please migrate to the Worker Deployment API.
      Allows you to update the worker-build-id based version sets for a particular task queue. This is used in conjunction with workers who specify their build id and thus opt into the feature.
      Parameters:
      taskQueue - The task queue to update the version set(s) of.
      operation - The operation to perform. See BuildIdOperation for more.
      Throws:
      WorkflowServiceException - for any failures including networking and service availability issues.

    • getWorkerBuildIdCompatability

      @Experimental @Deprecated WorkerBuildIdVersionSets getWorkerBuildIdCompatability(@Nonnull String taskQueue)
      Deprecated.
      Worker Versioning is now deprecated please migrate to the Worker Deployment API.
      Returns the worker-build-id based version sets for a particular task queue.
      Parameters:
      taskQueue - The task queue to fetch the version set(s) of.
      Returns:
      The version set(s) for the task queue.
      Throws:
      WorkflowServiceException - for any failures including networking and service availability issues.

    • getWorkerTaskReachability

      @Experimental @Deprecated WorkerTaskReachability getWorkerTaskReachability(@Nonnull Iterable<String> buildIds, @Nonnull Iterable<String> taskQueues, io.temporal.api.enums.v1.TaskReachability reachability)
      Deprecated.
      Worker Versioning is now deprecated please migrate to the Worker Deployment API.
      Determine if some Build IDs for certain Task Queues could have tasks dispatched to them.
      Parameters:
      buildIds - The Build IDs to query the reachability of. At least one must be specified.
      taskQueues - Task Queues to restrict the query to. If not specified, all Task Queues will be searched. When requesting a large number of task queues or all task queues associated with the given Build IDs in a namespace, all Task Queues will be listed in the response but some of them may not contain reachability information due to a server enforced limit.
      reachability - The kind of reachability this request is concerned with.
      Returns:
      The reachability information.
      Throws:
      WorkflowServiceException - for any failures including networking and service availability issues.

    • start

      static io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc workflow)
      Executes zero argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1> io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc1<A1> workflow, A1 arg1)
      Executes one argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2> io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc2<A1,A2> workflow, A1 arg1, A2 arg2)
      Executes two argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3> io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc3<A1,A2,A3> workflow, A1 arg1, A2 arg2, A3 arg3)
      Executes three argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, A4> io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc4<A1,A2,A3,A4> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4)
      Executes four argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, A4, A5> io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc5<A1,A2,A3,A4,A5> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
      Executes five argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, A4, A5, A6> io.temporal.api.common.v1.WorkflowExecution start(Functions.Proc6<A1,A2,A3,A4,A5,A6> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
      Executes six argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      arg6 - sixth workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func<R> workflow)
      Executes zero argument workflow.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func1<A1,R> workflow, A1 arg1)
      Executes one argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func2<A1,A2,R> workflow, A1 arg1, A2 arg2)
      Executes two argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func3<A1,A2,A3,R> workflow, A1 arg1, A2 arg2, A3 arg3)
      Executes three argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, A4, R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func4<A1,A2,A3,A4,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4)
      Executes four argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, A4, A5, R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func5<A1,A2,A3,A4,A5,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
      Executes five argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • start

      static <A1, A2, A3, A4, A5, A6, R> io.temporal.api.common.v1.WorkflowExecution start(Functions.Func6<A1,A2,A3,A4,A5,A6,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
      Executes six argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      arg6 - sixth workflow function parameter
      Returns:
      WorkflowExecution that contains WorkflowId and RunId of the started workflow.

    • startUpdate

      static WorkflowUpdateHandle<Void> startUpdate(Functions.Proc updateMethod, @Nonnull UpdateOptions<Void> options)
      Start a zero argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <A1> WorkflowUpdateHandle<Void> startUpdate(Functions.Proc1<A1> updateMethod, A1 arg1, @Nonnull UpdateOptions<Void> options)
      Start a one argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <A1, A2> WorkflowUpdateHandle<Void> startUpdate(Functions.Proc2<A1,A2> updateMethod, A1 arg1, A2 arg2, @Nonnull UpdateOptions<Void> options)
      Start a two argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <A1, A2, A3> WorkflowUpdateHandle<Void> startUpdate(Functions.Proc3<A1,A2,A3> updateMethod, A1 arg1, A2 arg2, A3 arg3, @Nonnull UpdateOptions<Void> options)
      Start a three argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <A1, A2, A3, A4> WorkflowUpdateHandle<Void> startUpdate(Functions.Proc4<A1,A2,A3,A4> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, @Nonnull UpdateOptions<Void> options)
      Start a four argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      arg4 - fourth update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <A1, A2, A3, A4, A5> WorkflowUpdateHandle<Void> startUpdate(Functions.Proc5<A1,A2,A3,A4,A5> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, @Nonnull UpdateOptions<Void> options)
      Start a five argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      arg4 - fourth update method parameter
      arg5 - fifth update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <A1, A2, A3, A4, A5, A6> WorkflowUpdateHandle<Void> startUpdate(Functions.Proc6<A1,A2,A3,A4,A5,A6> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, @Nonnull UpdateOptions<Void> options)
      Start a six argument workflow update with a void return type
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      arg4 - fourth update method parameter
      arg5 - fifth update method parameter
      arg6 - sixth update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R> WorkflowUpdateHandle<R> startUpdate(Functions.Func<R> updateMethod, @Nonnull UpdateOptions<R> options)
      Start a zero argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R, A1> WorkflowUpdateHandle<R> startUpdate(Functions.Func1<A1,R> updateMethod, A1 arg1, @Nonnull UpdateOptions<R> options)
      Start a one argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R, A1, A2> WorkflowUpdateHandle<R> startUpdate(Functions.Func2<A1,A2,R> updateMethod, A1 arg1, A2 arg2, @Nonnull UpdateOptions<R> options)
      Start a two argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R, A1, A2, A3> WorkflowUpdateHandle<R> startUpdate(Functions.Func3<A1,A2,A3,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, @Nonnull UpdateOptions<R> options)
      Start a three argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R, A1, A2, A3, A4> WorkflowUpdateHandle<R> startUpdate(Functions.Func4<A1,A2,A3,A4,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, @Nonnull UpdateOptions<R> options)
      Start a four argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      arg4 - fourth update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R, A1, A2, A3, A4, A5> WorkflowUpdateHandle<R> startUpdate(Functions.Func5<A1,A2,A3,A4,A5,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, @Nonnull UpdateOptions<R> options)
      Start a five argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      arg4 - fourth update method parameter
      arg5 - firth update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdate

      static <R, A1, A2, A3, A4, A5, A6> WorkflowUpdateHandle<R> startUpdate(Functions.Func6<A1,A2,A3,A4,A5,A6,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, @Nonnull UpdateOptions<R> options)
      Start a six argument update workflow request asynchronously.
      Parameters:
      updateMethod - method reference annotated with @UpdateMethod of a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update method parameter
      arg2 - second update method parameter
      arg3 - third update method parameter
      arg4 - fourth update method parameter
      arg5 - firth update method parameter
      arg6 - sixth update method parameter
      options - update options
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc updateMethod, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a zero argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R, A1> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc1<A1> updateMethod, A1 arg1, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a one argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R, A1, A2> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc2<A1,A2> updateMethod, A1 arg1, A2 arg2, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a two argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R, A1, A2, A3> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc3<A1,A2,A3> updateMethod, A1 arg1, A2 arg2, A3 arg3, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a three argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R, A1, A2, A3, A4> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc4<A1,A2,A3,A4> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a four argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R, A1, A2, A3, A4, A5> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc5<A1,A2,A3,A4,A5> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a five argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R, A1, A2, A3, A4, A5, A6> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Proc6<A1,A2,A3,A4,A5,A6> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a six argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      arg6 - sixth update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func<R> updateMethod, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a zero argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <A1, R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func1<A1,R> updateMethod, A1 arg1, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a one argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <A1, A2, R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func2<A1,A2,R> updateMethod, A1 arg1, A2 arg2, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a two argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <A1, A2, A3, R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func3<A1,A2,A3,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a three argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <A1, A2, A3, A4, R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func4<A1,A2,A3,A4,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a four argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <A1, A2, A3, A4, A5, R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func5<A1,A2,A3,A4,A5,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a five argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • startUpdateWithStart

      static <A1, A2, A3, A4, A5, A6, R> WorkflowUpdateHandle<R> startUpdateWithStart(Functions.Func6<A1,A2,A3,A4,A5,A6,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Start a six argument update workflow request asynchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      arg6 - sixth update function parameter
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • executeUpdateWithStart

      static <R> R executeUpdateWithStart(Functions.Proc updateMethod, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a zero argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      startOperation - start workflow operation
      Returns:
      WorkflowUpdateHandle that can be used to get the result of the update

    • executeUpdateWithStart

      static <R, A1> R executeUpdateWithStart(Functions.Proc1<A1> updateMethod, A1 arg1, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a one argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <R, A1, A2> R executeUpdateWithStart(Functions.Proc2<A1,A2> updateMethod, A1 arg1, A2 arg2, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a two argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <R, A1, A2, A3> R executeUpdateWithStart(Functions.Proc3<A1,A2,A3> updateMethod, A1 arg1, A2 arg2, A3 arg3, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a three argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <R, A1, A2, A3, A4> R executeUpdateWithStart(Functions.Proc4<A1,A2,A3,A4> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a four argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <R, A1, A2, A3, A4, A5> R executeUpdateWithStart(Functions.Proc5<A1,A2,A3,A4,A5> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a five argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <R, A1, A2, A3, A4, A5, A6> R executeUpdateWithStart(Functions.Proc6<A1,A2,A3,A4,A5,A6> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Execute a six argument update workflow request synchronously, along with a workflow start request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      arg6 - sixth update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <R> R executeUpdateWithStart(Functions.Func<R> updateMethod, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes zero argument workflow.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <A1, R> R executeUpdateWithStart(Functions.Func1<A1,R> updateMethod, A1 arg1, @Nonnull UpdateOptions<R> updateOptions, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes one argument workflow together with an update workflow request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <A1, A2, R> R executeUpdateWithStart(Functions.Func2<A1,A2,R> updateMethod, A1 arg1, A2 arg2, @Nonnull UpdateOptions<R> updateOptions, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes two argument workflow together with an update workflow request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <A1, A2, A3, R> R executeUpdateWithStart(Functions.Func3<A1,A2,A3,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes three argument workflow together with an update workflow request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <A1, A2, A3, A4, R> R executeUpdateWithStart(Functions.Func4<A1,A2,A3,A4,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes four argument workflow together with an update workflow request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <A1, A2, A3, A4, A5, R> R executeUpdateWithStart(Functions.Func5<A1,A2,A3,A4,A5,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes five argument workflow together with an update workflow request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first update function parameter
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • executeUpdateWithStart

      static <A1, A2, A3, A4, A5, A6, R> R executeUpdateWithStart(Functions.Func6<A1,A2,A3,A4,A5,A6,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, @Nonnull UpdateOptions<R> options, @Nonnull WithStartWorkflowOperation<?> startOperation)
      Executes six argument workflow together with an update workflow request.
      Parameters:
      updateMethod - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      arg2 - second update function parameter
      arg3 - third update function parameter
      arg4 - fourth update function parameter
      arg5 - fifth update function parameter
      arg6 - sixth update function parameter
      startOperation - start workflow operation
      Returns:
      update result

    • execute

      static CompletableFuture<Void> execute(Functions.Proc workflow)
      Executes zero argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <A1> CompletableFuture<Void> execute(Functions.Proc1<A1> workflow, A1 arg1)
      Executes one argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <A1, A2> CompletableFuture<Void> execute(Functions.Proc2<A1,A2> workflow, A1 arg1, A2 arg2)
      Executes two argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <A1, A2, A3> CompletableFuture<Void> execute(Functions.Proc3<A1,A2,A3> workflow, A1 arg1, A2 arg2, A3 arg3)
      Executes three argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <A1, A2, A3, A4> CompletableFuture<Void> execute(Functions.Proc4<A1,A2,A3,A4> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4)
      Executes four argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <A1, A2, A3, A4, A5> CompletableFuture<Void> execute(Functions.Proc5<A1,A2,A3,A4,A5> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
      Executes five argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <A1, A2, A3, A4, A5, A6> CompletableFuture<Void> execute(Functions.Proc6<A1,A2,A3,A4,A5,A6> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
      Executes six argument workflow with void return type
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      arg6 - sixth workflow function parameter
      Returns:
      future becomes ready upon workflow completion with null value or failure

    • execute

      static <R> CompletableFuture<R> execute(Functions.Func<R> workflow)
      Executes zero argument workflow.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      Returns:
      future that contains workflow result or failure

    • execute

      static <A1, R> CompletableFuture<R> execute(Functions.Func1<A1,R> workflow, A1 arg1)
      Executes one argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      Returns:
      future that contains workflow result or failure

    • execute

      static <A1, A2, R> CompletableFuture<R> execute(Functions.Func2<A1,A2,R> workflow, A1 arg1, A2 arg2)
      Executes two argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      Returns:
      future that contains workflow result or failure

    • execute

      static <A1, A2, A3, R> CompletableFuture<R> execute(Functions.Func3<A1,A2,A3,R> workflow, A1 arg1, A2 arg2, A3 arg3)
      Executes three argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      Returns:
      future that contains workflow result or failure

    • execute

      static <A1, A2, A3, A4, R> CompletableFuture<R> execute(Functions.Func4<A1,A2,A3,A4,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4)
      Executes four argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      Returns:
      future that contains workflow result or failure

    • execute

      static <A1, A2, A3, A4, A5, R> CompletableFuture<R> execute(Functions.Func5<A1,A2,A3,A4,A5,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
      Executes five argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow function parameter
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      Returns:
      future that contains workflow result or failure

    • execute

      static <A1, A2, A3, A4, A5, A6, R> CompletableFuture<R> execute(Functions.Func6<A1,A2,A3,A4,A5,A6,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
      Executes six argument workflow asynchronously.
      Parameters:
      workflow - The only supported value is method reference to a proxy created through newWorkflowStub(Class, WorkflowOptions).
      arg1 - first workflow argument
      arg2 - second workflow function parameter
      arg3 - third workflow function parameter
      arg4 - fourth workflow function parameter
      arg5 - fifth workflow function parameter
      arg6 - sixth workflow function parameter
      Returns:
      future that contains workflow result or failure

    • getInternal

      Object getInternal()
      For SDK Internal usage only. This method should not be used by users. If implementing a proxy or an adapter over a WorkflowClient provided by the SDK, users should pass an object returned by this method as-is.