```
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:

Workflow, Activity, Worker

Field Summary

Fields
Modifier and Type	Field	Description
`static java.lang.String`	`QUERY_TYPE_REPLAY_ONLY`	Replays workflow to the current state and returns empty result or error if replay failed.
`static java.lang.String`	`QUERY_TYPE_STACK_TRACE`	Use this constant as a query type to get a workflow stack trace.
`static java.lang.String`	`QUERY_TYPE_WORKFLOW_METADATA`	Use this constant as a query type to get the workflow metadata.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`static <R> java.util.concurrent.CompletableFuture<R>`	`execute(Functions.Func<R> workflow)`	Executes zero argument workflow.
`static <A1,R> java.util.concurrent.CompletableFuture<R>`	`execute(Functions.Func1<A1,R> workflow, A1 arg1)`	Executes one argument workflow asynchronously.
`static <A1,A2,R> java.util.concurrent.CompletableFuture<R>`	`execute(Functions.Func2<A1,A2,R> workflow, A1 arg1, A2 arg2)`	Executes two argument workflow asynchronously.
`static <A1,A2,A3,R> java.util.concurrent.CompletableFuture<R>`	`execute(Functions.Func3<A1,A2,A3,R> workflow, A1 arg1, A2 arg2, A3 arg3)`	Executes three argument workflow asynchronously.
`static <A1,A2,A3,A4,R> java.util.concurrent.CompletableFuture<R>`	`execute(Functions.Func4<A1,A2,A3,A4,R> workflow, A1 arg1, A2 arg2, A3 arg3, A4 arg4)`	Executes four argument workflow asynchronously.
`static <A1,A2,A3,A4,A5,R> java.util.concurrent.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.
`static <A1,A2,A3,A4,A5,A6,R> java.util.concurrent.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.
`static java.util.concurrent.CompletableFuture<java.lang.Void>`	`execute(Functions.Proc workflow)`	Executes zero argument workflow with void return type
`static <A1> java.util.concurrent.CompletableFuture<java.lang.Void>`	`execute(Functions.Proc1<A1> workflow, A1 arg1)`	Executes one argument workflow with void return type
`static <A1,A2> java.util.concurrent.CompletableFuture<java.lang.Void>`	`execute(Functions.Proc2<A1,A2> workflow, A1 arg1, A2 arg2)`	Executes two argument workflow with void return type
`static <A1,A2,A3> java.util.concurrent.CompletableFuture<java.lang.Void>`	`execute(Functions.Proc3<A1,A2,A3> workflow, A1 arg1, A2 arg2, A3 arg3)`	Executes three argument workflow with void return type
`static <A1,A2,A3,A4> java.util.concurrent.CompletableFuture<java.lang.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
`static <A1,A2,A3,A4,A5> java.util.concurrent.CompletableFuture<java.lang.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
`static <A1,A2,A3,A4,A5,A6> java.util.concurrent.CompletableFuture<java.lang.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
`static <R> R`	`executeUpdateWithStart(Functions.Func<R> updateMethod, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Executes zero argument workflow.
`static <A1,R> R`	`executeUpdateWithStart(Functions.Func1<A1,R> updateMethod, A1 arg1, UpdateOptions<R> updateOptions, WithStartWorkflowOperation<?> startOperation)`	Executes one argument workflow together with an update workflow request.
`static <A1,A2,R> R`	`executeUpdateWithStart(Functions.Func2<A1,A2,R> updateMethod, A1 arg1, A2 arg2, UpdateOptions<R> updateOptions, WithStartWorkflowOperation<?> startOperation)`	Executes two argument workflow together with an update workflow request.
`static <A1,A2,A3,R> R`	`executeUpdateWithStart(Functions.Func3<A1,A2,A3,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Executes three argument workflow together with an update workflow request.
`static <A1,A2,A3,A4,R> R`	`executeUpdateWithStart(Functions.Func4<A1,A2,A3,A4,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Executes four argument workflow together with an update workflow request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Executes five argument workflow together with an update workflow request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Executes six argument workflow together with an update workflow request.
`static <R,A1> R`	`executeUpdateWithStart(Functions.Proc1<A1> updateMethod, A1 arg1, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a one argument update workflow request synchronously, along with a workflow start request.
`static <R,A1,A2> R`	`executeUpdateWithStart(Functions.Proc2<A1,A2> updateMethod, A1 arg1, A2 arg2, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a two argument update workflow request synchronously, along with a workflow start request.
`static <R,A1,A2,A3> R`	`executeUpdateWithStart(Functions.Proc3<A1,A2,A3> updateMethod, A1 arg1, A2 arg2, A3 arg3, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a three argument update workflow request synchronously, along with a workflow start request.
`static <R,A1,A2,A3,A4> R`	`executeUpdateWithStart(Functions.Proc4<A1,A2,A3,A4> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a four argument update workflow request synchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a five argument update workflow request synchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a six argument update workflow request synchronously, along with a workflow start request.
`static <R> R`	`executeUpdateWithStart(Functions.Proc updateMethod, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Execute a zero argument update workflow request synchronously, along with a workflow start request.
`WorkflowExecutionHistory`	`fetchHistory(java.lang.String workflowId)`	Downloads workflow execution history for the provided `workflowId`.
`WorkflowExecutionHistory`	`fetchHistory(java.lang.String workflowId, java.lang.String runId)`	Downloads workflow execution history for the provided `workflowId` and `runId`.
`java.lang.Object`	`getInternal()`	For SDK Internal usage only.
`WorkflowClientOptions`	`getOptions()`
`WorkerBuildIdVersionSets`	`getWorkerBuildIdCompatability(java.lang.String taskQueue)`	Returns the worker-build-id based version sets for a particular task queue.
`WorkerTaskReachability`	`getWorkerTaskReachability(java.lang.Iterable<java.lang.String> buildIds, java.lang.Iterable<java.lang.String> taskQueues, io.temporal.api.enums.v1.TaskReachability reachability)`	Determine if some Build IDs for certain Task Queues could have tasks dispatched to them.
`io.temporal.serviceclient.WorkflowServiceStubs`	`getWorkflowServiceStubs()`
`java.util.stream.Stream<WorkflowExecutionMetadata>`	`listExecutions(java.lang.String query)`	A wrapper around {WorkflowServiceStub#listWorkflowExecutions(ListWorkflowExecutionsRequest)}
`ActivityCompletionClient`	`newActivityCompletionClient()`	Creates new `ActivityCompletionClient` that can be used to complete activities asynchronously.
`static WorkflowClient`	`newInstance(io.temporal.serviceclient.WorkflowServiceStubs service)`	Creates client that connects to an instance of the Temporal Service.
`static WorkflowClient`	`newInstance(io.temporal.serviceclient.WorkflowServiceStubs service, WorkflowClientOptions options)`	Creates client that connects to an instance of the Temporal Service.
`BatchRequest`	`newSignalWithStartRequest()`	Creates BatchRequest that can be used to signal an existing workflow or start a new one if not running.
`WorkflowStub`	`newUntypedWorkflowStub(io.temporal.api.common.v1.WorkflowExecution execution, java.util.Optional<java.lang.String> workflowType)`	Creates workflow untyped client stub for a known execution.
`WorkflowStub`	`newUntypedWorkflowStub(java.lang.String workflowId)`	Creates workflow untyped client stub that can be used to start a single workflow execution.
`WorkflowStub`	`newUntypedWorkflowStub(java.lang.String workflowType, WorkflowOptions options)`	Creates workflow untyped client stub that can be used to start a single workflow execution.
`WorkflowStub`	`newUntypedWorkflowStub(java.lang.String workflowId, java.util.Optional<java.lang.String> runId, java.util.Optional<java.lang.String> workflowType)`	Creates workflow untyped client stub for a known execution.
`<T> T`	`newWorkflowStub(java.lang.Class<T> workflowInterface, WorkflowOptions options)`	Creates workflow client stub that can be used to start a single workflow execution.
`<T> T`	`newWorkflowStub(java.lang.Class<T> workflowInterface, java.lang.String workflowId)`	Creates workflow client stub for a known execution.
`<T> T`	`newWorkflowStub(java.lang.Class<T> workflowInterface, java.lang.String workflowId, java.util.Optional<java.lang.String> runId)`	Creates workflow client stub for a known execution.
`io.temporal.api.common.v1.WorkflowExecution`	`signalWithStart(BatchRequest signalWithStartBatch)`	Invoke SignalWithStart operation.
`static <R> io.temporal.api.common.v1.WorkflowExecution`	`start(Functions.Func<R> workflow)`	Executes zero argument workflow.
`static <A1,R> io.temporal.api.common.v1.WorkflowExecution`	`start(Functions.Func1<A1,R> workflow, A1 arg1)`	Executes one argument workflow asynchronously.
`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.
`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.
`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.
`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.
`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.
`static io.temporal.api.common.v1.WorkflowExecution`	`start(Functions.Proc workflow)`	Executes zero argument workflow with void return type
`static <A1> io.temporal.api.common.v1.WorkflowExecution`	`start(Functions.Proc1<A1> workflow, A1 arg1)`	Executes one argument workflow with void return type
`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
`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
`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
`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
`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
`static <R> WorkflowUpdateHandle<R>`	`startUpdate(Functions.Func<R> updateMethod, UpdateOptions<R> options)`	Start a zero argument update workflow request asynchronously.
`static <R,A1> WorkflowUpdateHandle<R>`	`startUpdate(Functions.Func1<A1,R> updateMethod, A1 arg1, UpdateOptions<R> options)`	Start a one argument update workflow request asynchronously.
`static <R,A1,A2> WorkflowUpdateHandle<R>`	`startUpdate(Functions.Func2<A1,A2,R> updateMethod, A1 arg1, A2 arg2, UpdateOptions<R> options)`	Start a two argument update workflow request asynchronously.
`static <R,A1,A2,A3> WorkflowUpdateHandle<R>`	`startUpdate(Functions.Func3<A1,A2,A3,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, UpdateOptions<R> options)`	Start a three argument update workflow request asynchronously.
`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, UpdateOptions<R> options)`	Start a four argument update workflow request asynchronously.
`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, UpdateOptions<R> options)`	Start a five argument update workflow request asynchronously.
`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, UpdateOptions<R> options)`	Start a six argument update workflow request asynchronously.
`static <A1> WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc1<A1> updateMethod, A1 arg1, UpdateOptions<java.lang.Void> options)`	Start a one argument workflow update with a void return type
`static <A1,A2> WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc2<A1,A2> updateMethod, A1 arg1, A2 arg2, UpdateOptions<java.lang.Void> options)`	Start a two argument workflow update with a void return type
`static <A1,A2,A3> WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc3<A1,A2,A3> updateMethod, A1 arg1, A2 arg2, A3 arg3, UpdateOptions<java.lang.Void> options)`	Start a three argument workflow update with a void return type
`static <A1,A2,A3,A4> WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc4<A1,A2,A3,A4> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, UpdateOptions<java.lang.Void> options)`	Start a four argument workflow update with a void return type
`static <A1,A2,A3,A4,A5> WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc5<A1,A2,A3,A4,A5> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, UpdateOptions<java.lang.Void> options)`	Start a five argument workflow update with a void return type
`static <A1,A2,A3,A4,A5,A6> WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc6<A1,A2,A3,A4,A5,A6> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, UpdateOptions<java.lang.Void> options)`	Start a six argument workflow update with a void return type
`static WorkflowUpdateHandle<java.lang.Void>`	`startUpdate(Functions.Proc updateMethod, UpdateOptions<java.lang.Void> options)`	Start a zero argument workflow update with a void return type
`static <R> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Func<R> updateMethod, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a zero argument update workflow request asynchronously, along with a workflow start request.
`static <A1,R> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Func1<A1,R> updateMethod, A1 arg1, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a one argument update workflow request asynchronously, along with a workflow start request.
`static <A1,A2,R> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Func2<A1,A2,R> updateMethod, A1 arg1, A2 arg2, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a two argument update workflow request asynchronously, along with a workflow start request.
`static <A1,A2,A3,R> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Func3<A1,A2,A3,R> updateMethod, A1 arg1, A2 arg2, A3 arg3, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a three argument update workflow request asynchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a four argument update workflow request asynchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a five argument update workflow request asynchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a six argument update workflow request asynchronously, along with a workflow start request.
`static <R,A1> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Proc1<A1> updateMethod, A1 arg1, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a one argument update workflow request asynchronously, along with a workflow start request.
`static <R,A1,A2> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Proc2<A1,A2> updateMethod, A1 arg1, A2 arg2, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a two argument update workflow request asynchronously, along with a workflow start request.
`static <R,A1,A2,A3> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Proc3<A1,A2,A3> updateMethod, A1 arg1, A2 arg2, A3 arg3, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a three argument update workflow request asynchronously, along with a workflow start request.
`static <R,A1,A2,A3,A4> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Proc4<A1,A2,A3,A4> updateMethod, A1 arg1, A2 arg2, A3 arg3, A4 arg4, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a four argument update workflow request asynchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a five argument update workflow request asynchronously, along with a workflow start request.
`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, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a six argument update workflow request asynchronously, along with a workflow start request.
`static <R> WorkflowUpdateHandle<R>`	`startUpdateWithStart(Functions.Proc updateMethod, UpdateOptions<R> options, WithStartWorkflowOperation<?> startOperation)`	Start a zero argument update workflow request asynchronously, along with a workflow start request.
`java.util.stream.Stream<io.temporal.api.history.v1.HistoryEvent>`	`streamHistory(java.lang.String workflowId)`	Streams history events for a workflow execution for the provided `workflowId`.
`java.util.stream.Stream<io.temporal.api.history.v1.HistoryEvent>`	`streamHistory(java.lang.String workflowId, java.lang.String runId)`	Streams history events for a workflow execution for the provided `workflowId` and `runId`.
`void`	`updateWorkerBuildIdCompatability(java.lang.String taskQueue, BuildIdOperation operation)`	Allows you to update the worker-build-id based version sets for a particular task queue.

Field Detail
- QUERY_TYPE_STACK_TRACE
```
static final java.lang.String QUERY_TYPE_STACK_TRACE
```
  Use this constant as a query type to get a workflow stack trace.
  
  See Also:
  
  Constant Field Values
- QUERY_TYPE_WORKFLOW_METADATA
```
static final java.lang.String QUERY_TYPE_WORKFLOW_METADATA
```
  Use this constant as a query type to get the workflow metadata.
  
  See Also:
  
  Constant Field Values
- QUERY_TYPE_REPLAY_ONLY
```
static final java.lang.String QUERY_TYPE_REPLAY_ONLY
```
  Replays workflow to the current state and returns empty result or error if replay failed.
  
  See Also:
  
  Constant Field Values

Method Detail

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(java.lang.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(java.lang.Class<T> workflowInterface,
                      java.lang.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
```
<T> T newWorkflowStub(java.lang.Class<T> workflowInterface,
                      java.lang.String workflowId,
                      java.util.Optional<java.lang.String> 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.

newUntypedWorkflowStub
```
WorkflowStub newUntypedWorkflowStub(java.lang.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(java.lang.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
```
WorkflowStub newUntypedWorkflowStub(java.lang.String workflowId,
                                    java.util.Optional<java.lang.String> runId,
                                    java.util.Optional<java.lang.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:

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,
                                    java.util.Optional<java.lang.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:

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.

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
```
java.util.stream.Stream<WorkflowExecutionMetadata> listExecutions(@Nullable
                                                                  java.lang.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

streamHistory
```
java.util.stream.Stream<io.temporal.api.history.v1.HistoryEvent> streamHistory(@Nonnull
                                                                               java.lang.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:

to get a history of a specific run., for a user-friendly eager version of this method

streamHistory
```
java.util.stream.Stream<io.temporal.api.history.v1.HistoryEvent> streamHistory(@Nonnull
                                                                               java.lang.String workflowId,
                                                                               @Nullable
                                                                               java.lang.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:

to get a history of workflow excution by workflowId without providing a specific run., for a user-friendly eagert version of this method

fetchHistory
```
WorkflowExecutionHistory fetchHistory(@Nonnull
                                      java.lang.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:

to get a history of a specific run., for a lazy memory-efficient version of this method

fetchHistory
```
WorkflowExecutionHistory fetchHistory(@Nonnull
                                      java.lang.String workflowId,
                                      @Nullable
                                      java.lang.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:

to get a history of workflow excution by workflowId without providing a specific run., for a lazy memory-efficient version of this method

updateWorkerBuildIdCompatability
```
void updateWorkerBuildIdCompatability(@Nonnull
                                      java.lang.String taskQueue,
                                      @Nonnull
                                      BuildIdOperation operation)
```
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
```
WorkerBuildIdVersionSets getWorkerBuildIdCompatability(@Nonnull
                                                       java.lang.String taskQueue)
```
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
```
WorkerTaskReachability getWorkerTaskReachability(@Nonnull
                                                 java.lang.Iterable<java.lang.String> buildIds,
                                                 @Nonnull
                                                 java.lang.Iterable<java.lang.String> taskQueues,
                                                 io.temporal.api.enums.v1.TaskReachability reachability)
```
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<java.lang.Void> startUpdate(Functions.Proc updateMethod,
                                                        @Nonnull
                                                        UpdateOptions<java.lang.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<java.lang.Void> startUpdate(Functions.Proc1<A1> updateMethod,
                                                             A1 arg1,
                                                             @Nonnull
                                                             UpdateOptions<java.lang.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<java.lang.Void> startUpdate(Functions.Proc2<A1,A2> updateMethod,
                                                                      A1 arg1,
                                                                      A2 arg2,
                                                                      @Nonnull
                                                                      UpdateOptions<java.lang.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<java.lang.Void> startUpdate(Functions.Proc3<A1,A2,A3> updateMethod,
                                                                               A1 arg1,
                                                                               A2 arg2,
                                                                               A3 arg3,
                                                                               @Nonnull
                                                                               UpdateOptions<java.lang.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<java.lang.Void> startUpdate(Functions.Proc4<A1,A2,A3,A4> updateMethod,
                                                                                        A1 arg1,
                                                                                        A2 arg2,
                                                                                        A3 arg3,
                                                                                        A4 arg4,
                                                                                        @Nonnull
                                                                                        UpdateOptions<java.lang.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<java.lang.Void> startUpdate(Functions.Proc5<A1,A2,A3,A4,A5> updateMethod,
                                                                                                 A1 arg1,
                                                                                                 A2 arg2,
                                                                                                 A3 arg3,
                                                                                                 A4 arg4,
                                                                                                 A5 arg5,
                                                                                                 @Nonnull
                                                                                                 UpdateOptions<java.lang.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<java.lang.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<java.lang.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 java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.CompletableFuture<java.lang.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> java.util.concurrent.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> java.util.concurrent.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> java.util.concurrent.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> java.util.concurrent.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> java.util.concurrent.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> java.util.concurrent.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> java.util.concurrent.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
```
java.lang.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.

Interface WorkflowClient

Field Summary

Method Summary

Field Detail

QUERY_TYPE_STACK_TRACE

QUERY_TYPE_WORKFLOW_METADATA

QUERY_TYPE_REPLAY_ONLY

Method Detail

newInstance

newInstance

getOptions

getWorkflowServiceStubs

newWorkflowStub

newWorkflowStub

newWorkflowStub

newUntypedWorkflowStub

newUntypedWorkflowStub

newUntypedWorkflowStub

newUntypedWorkflowStub

newActivityCompletionClient

newSignalWithStartRequest

signalWithStart

listExecutions

streamHistory

streamHistory

fetchHistory

fetchHistory

updateWorkerBuildIdCompatability

getWorkerBuildIdCompatability

getWorkerTaskReachability

start

start

start

start

start

start

start

start

start

start

start

start

start

start

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdate

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

startUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart

executeUpdateWithStart