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

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
`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
`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_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 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 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 - sixth 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 - sixth 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 - sixth workflow function parameter
    
    arg6 - sixth workflow function parameter
    
    Returns:
    
    WorkflowExecution that contains WorkflowId and RunId of the started workflow.
  - 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 - sixth 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 - sixth 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 - sixth 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_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

execute

execute

execute

execute

execute

execute

execute

execute

execute

execute

execute

execute

execute

execute

getInternal