@superdurable/dex 0.1.0

package/dist/src/gen/dex.d.ts

@@ -0,0 +1,1529 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Duration } from "./google/protobuf/duration.js";
+import { Empty } from "./google/protobuf/empty.js";
+import { NullValue } from "./google/protobuf/struct.js";
+export declare const protobufPackage = "dex";
+export declare enum IndexType {
+    INDEX_TYPE_UNSPECIFIED = 0,
+    /** INDEX_TYPE_KEYWORD - Default for string/object when type is omitted. */
+    INDEX_TYPE_KEYWORD = 1,
+    INDEX_TYPE_TEXT = 2,
+    INDEX_TYPE_KEYWORD_ARRAY = 3,
+    /** INDEX_TYPE_INT - Usually inferred from Value; optional to set explicitly. */
+    INDEX_TYPE_INT = 4,
+    INDEX_TYPE_DOUBLE = 5,
+    INDEX_TYPE_BOOL = 6,
+    INDEX_TYPE_DATETIME = 7,
+    UNRECOGNIZED = -1
+}
+export declare enum WaitForMethodFailurePolicy {
+    WAIT_FOR_METHOD_FAILURE_POLICY_UNSPECIFIED = 0,
+    WAIT_FOR_METHOD_FAILURE_POLICY_FAIL_FLOW_ON_FAILURE = 1,
+    WAIT_FOR_METHOD_FAILURE_POLICY_PROCEED_ON_FAILURE = 2,
+    UNRECOGNIZED = -1
+}
+export declare enum ExecuteMethodFailurePolicy {
+    EXECUTE_METHOD_FAILURE_POLICY_UNSPECIFIED = 0,
+    EXECUTE_METHOD_FAILURE_POLICY_FAIL_FLOW_ON_EXECUTE_METHOD_FAILURE = 1,
+    EXECUTE_METHOD_FAILURE_POLICY_PROCEED_TO_CONFIGURED_STEP = 2,
+    UNRECOGNIZED = -1
+}
+export declare enum IdReusePolicy {
+    ID_REUSE_POLICY_UNSPECIFIED = 0,
+    ID_REUSE_POLICY_ALLOW_IF_PREVIOUS_EXISTS_ABNORMALLY = 1,
+    ID_REUSE_POLICY_ALLOW_IF_NO_RUNNING = 2,
+    ID_REUSE_POLICY_DISALLOW_REUSE = 3,
+    ID_REUSE_POLICY_ALLOW_TERMINATE_IF_RUNNING = 4,
+    UNRECOGNIZED = -1
+}
+export declare enum ActiveStepSearchMode {
+    ACTIVE_STEP_SEARCH_MODE_UNSPECIFIED = 0,
+    ACTIVE_STEP_SEARCH_MODE_ENABLED_FOR_ALL = 1,
+    ACTIVE_STEP_SEARCH_MODE_ENABLED_FOR_STEPS_WITH_WAIT_FOR = 2,
+    ACTIVE_STEP_SEARCH_MODE_DISABLED = 3,
+    UNRECOGNIZED = -1
+}
+/** Was optimize_activity: false=SYNC, true=ASYNC. Timer is always optimized by the server. */
+export declare enum StepDurability {
+    STEP_DURABILITY_UNSPECIFIED = 0,
+    STEP_DURABILITY_SYNC = 1,
+    STEP_DURABILITY_ASYNC = 2,
+    UNRECOGNIZED = -1
+}
+export declare enum StopType {
+    STOP_TYPE_UNSPECIFIED = 0,
+    STOP_TYPE_CANCEL = 1,
+    STOP_TYPE_TERMINATE = 2,
+    STOP_TYPE_FAIL = 3,
+    UNRECOGNIZED = -1
+}
+export declare enum FlowStatus {
+    FLOW_STATUS_UNSPECIFIED = 0,
+    FLOW_STATUS_RUNNING = 1,
+    FLOW_STATUS_COMPLETED = 2,
+    FLOW_STATUS_FAILED = 3,
+    FLOW_STATUS_TIMEOUT = 4,
+    FLOW_STATUS_TERMINATED = 5,
+    FLOW_STATUS_CANCELED = 6,
+    FLOW_STATUS_CONTINUED_AS_NEW = 7,
+    UNRECOGNIZED = -1
+}
+export declare enum FlowErrorType {
+    FLOW_ERROR_TYPE_UNSPECIFIED = 0,
+    FLOW_ERROR_TYPE_STEP_DECISION_FAILING_FLOW = 1,
+    FLOW_ERROR_TYPE_CLIENT_API_FAILING_FLOW = 2,
+    /** FLOW_ERROR_TYPE_WORKER_API_FAIL - includes waitFor/execute/rpc methods */
+    FLOW_ERROR_TYPE_WORKER_API_FAIL = 3,
+    FLOW_ERROR_TYPE_INVALID_USER_FLOW_CODE = 4,
+    /** FLOW_ERROR_TYPE_INTERNAL - either bug in sdk or server */
+    FLOW_ERROR_TYPE_INTERNAL = 6,
+    UNRECOGNIZED = -1
+}
+export declare enum ActiveStepPhase {
+    ACTIVE_STEP_PHASE_UNSPECIFIED = 0,
+    ACTIVE_STEP_PHASE_ACTIVE = 1,
+    ACTIVE_STEP_PHASE_WAITING = 2,
+    UNRECOGNIZED = -1
+}
+export declare enum FlowResetType {
+    FLOW_RESET_TYPE_UNSPECIFIED = 0,
+    FLOW_RESET_TYPE_HISTORY_EVENT_ID = 1,
+    FLOW_RESET_TYPE_BEGINNING = 2,
+    FLOW_RESET_TYPE_HISTORY_EVENT_TIME = 3,
+    FLOW_RESET_TYPE_STEP_TYPE = 4,
+    FLOW_RESET_TYPE_STEP_EXECUTION_ID = 5,
+    UNRECOGNIZED = -1
+}
+export declare enum ErrorSubStatus {
+    ERROR_SUB_STATUS_UNSPECIFIED = 0,
+    ERROR_SUB_STATUS_UNCATEGORIZED = 1,
+    ERROR_SUB_STATUS_FLOW_ALREADY_STARTED = 2,
+    ERROR_SUB_STATUS_FLOW_NOT_EXISTS = 3,
+    ERROR_SUB_STATUS_WORKER_API_ERROR = 4,
+    ERROR_SUB_STATUS_LONG_POLL_TIME_OUT = 5,
+    UNRECOGNIZED = -1
+}
+export declare enum CloseDecisionType {
+    CLOSE_DECISION_TYPE_UNSPECIFIED = 0,
+    CLOSE_DECISION_TYPE_FORCE_COMPLETE_ON_CHANNELS_EMPTY = 1,
+    CLOSE_DECISION_TYPE_GRACEFUL_COMPLETE = 2,
+    CLOSE_DECISION_TYPE_FORCE_COMPLETE = 3,
+    CLOSE_DECISION_TYPE_FORCE_FAIL = 4,
+    CLOSE_DECISION_TYPE_DEAD_END = 5,
+    UNRECOGNIZED = -1
+}
+export declare enum WaitingConditionType {
+    WAITING_CONDITION_TYPE_UNSPECIFIED = 0,
+    WAITING_CONDITION_TYPE_ALL_COMPLETED = 1,
+    WAITING_CONDITION_TYPE_ANY_COMPLETED = 2,
+    WAITING_CONDITION_TYPE_ANY_COMBINATION_COMPLETED = 3,
+    UNRECOGNIZED = -1
+}
+export declare enum ConditionStatus {
+    CONDITION_STATUS_UNSPECIFIED = 0,
+    CONDITION_STATUS_WAITING = 1,
+    CONDITION_STATUS_COMPLETED = 2,
+    UNRECOGNIZED = -1
+}
+export declare enum InternalTimerStatus {
+    INTERNAL_TIMER_STATUS_UNSPECIFIED = 0,
+    INTERNAL_TIMER_STATUS_PENDING = 1,
+    INTERNAL_TIMER_STATUS_FIRED = 2,
+    INTERNAL_TIMER_STATUS_SKIPPED = 3,
+    UNRECOGNIZED = -1
+}
+export declare enum UpdateErrorType {
+    UPDATE_ERROR_TYPE_UNSPECIFIED = 0,
+    UPDATE_ERROR_TYPE_CONTINUE_AS_NEW_PREEMPTED = 1,
+    UPDATE_ERROR_TYPE_INVALID_ARGUMENT = 2,
+    UPDATE_ERROR_TYPE_FAILED_PRECONDITION = 3,
+    UPDATE_ERROR_TYPE_DEADLINE_EXCEEDED = 4,
+    UPDATE_ERROR_TYPE_RPC_ACQUIRE_LOCK_FAILURE = 5,
+    UPDATE_ERROR_TYPE_SERVER_INTERNAL = 6,
+    UNRECOGNIZED = -1
+}
+export interface Value {
+    kind: //
+    /** Hydrate from blob storage, then replace with string_value. */
+    {
+        $case: "internalBlobIdForStringValue";
+        value: string;
+    } | //
+    /** Hydrate from blob storage, then replace with obj_value. */
+    {
+        $case: "internalBlobIdForObjValue";
+        value: string;
+    } | {
+        $case: "stringValue";
+        value: string;
+    } | {
+        $case: "objValue";
+        value: EncodedObject;
+    } | {
+        $case: "intValue";
+        value: bigint;
+    } | {
+        $case: "doubleValue";
+        value: number;
+    } | {
+        $case: "boolValue";
+        value: boolean;
+    } | //
+    /** Null deletes an attribute in storage. */
+    {
+        $case: "nullValue";
+        value: NullValue;
+    } | undefined;
+}
+export interface EncodedObject {
+    encoding: string;
+    payload: Uint8Array;
+}
+export interface AttributeWrite {
+    key: string;
+    value: Value | undefined;
+    /** Omit when indexing is inferred or attribute is not indexed. */
+    indexConfig: IndexConfig | undefined;
+}
+export interface KV {
+    key: string;
+    value: Value | undefined;
+}
+export interface IndexConfig {
+    enable: boolean;
+    type: IndexType;
+    /** Omit to use the attribute key; set for dynamic attrs. */
+    indexKey: string;
+}
+export interface Context {
+    flowId: string;
+    runId: string;
+    flowStartedTimestamp: bigint;
+    stepExecutionId: string;
+    firstAttemptTimestamp: bigint;
+    attempt: number;
+    /** Step execution that scheduled this execution, or a reserved source. */
+    fromStepExecutionId: string;
+}
+export interface LocalActivityInput {
+    currentStepExecutionId: string;
+    fromStepExecutionId: string;
+}
+export interface RetryPolicy {
+    initialIntervalSeconds: number;
+    backoffCoefficient: number;
+    maximumIntervalSeconds: number;
+    maximumAttempts: number;
+    totalDurationSeconds: number;
+}
+export interface FlowRetryPolicy {
+    initialIntervalSeconds: number;
+    backoffCoefficient: number;
+    maximumIntervalSeconds: number;
+    maximumAttempts: number;
+}
+export interface StepOptions {
+    waitForTimeoutSeconds: number;
+    executeTimeoutSeconds: number;
+    waitForRetryPolicy: RetryPolicy | undefined;
+    executeRetryPolicy: RetryPolicy | undefined;
+    waitForFailurePolicy: WaitForMethodFailurePolicy;
+    executeFailurePolicy: ExecuteMethodFailurePolicy;
+    executeFailureProceedStepType: string;
+    executeFailureProceedStepOptions: StepOptions | undefined;
+    skipWaitFor: boolean;
+    waitForDurabilityOverride: StepDurability;
+    executeDurabilityOverride: StepDurability;
+    waitForLockAttributeKeys: string[];
+    executeLockAttributeKeys: string[];
+}
+export interface FlowAlreadyStartedOptions {
+    ignoreAlreadyStartedError: boolean;
+}
+export interface FlowStartOptions {
+    idReusePolicy: IdReusePolicy;
+    cronSchedule: string;
+    flowStartDelaySeconds: number;
+    retryPolicy: FlowRetryPolicy | undefined;
+    attributes: AttributeWrite[];
+    flowConfigOverride: FlowConfig | undefined;
+    flowAlreadyStartedOptions: FlowAlreadyStartedOptions | undefined;
+}
+export interface FlowConfig {
+    activeStepSearchMode?: ActiveStepSearchMode | undefined;
+    continueAsNewThreshold?: number | undefined;
+    continueAsNewPageSizeInBytes?: number | undefined;
+    stepDurability?: StepDurability | undefined;
+    workerTarget: WorkerTarget | undefined;
+}
+export interface WorkerTarget {
+    /** Plaintext gRPC dial target, not an HTTP URL. */
+    address: string;
+    isHeadlessAddress: boolean;
+}
+export interface StartFlowRequest {
+    flowId: string;
+    flowType: string;
+    flowTimeoutSeconds: number;
+    startStepType: string;
+    stepInput: Value | undefined;
+    stepOptions: StepOptions | undefined;
+    flowStartOptions: FlowStartOptions | undefined;
+    requestId: string;
+}
+export interface StartFlowResponse {
+    runId: string;
+}
+export interface PublishToChannelRequest {
+    flowId: string;
+    runId: string;
+    messages: ChannelMessage[];
+}
+export interface ChannelMessage {
+    channelName: string;
+    value: Value | undefined;
+}
+export interface StopFlowRequest {
+    flowId: string;
+    runId: string;
+    reason: string;
+    stopType: StopType;
+}
+export interface GetAttributesRequest {
+    flowId: string;
+    runId: string;
+    keys: string[];
+    /** When true, return all attributes (keys is ignored). */
+    allKeys: boolean;
+}
+export interface GetAttributesResponse {
+    attributes: KV[];
+}
+export interface SetAttributesRequest {
+    flowId: string;
+    runId: string;
+    attributes: AttributeWrite[];
+    requestId: string;
+}
+export interface LoadBlobsRequest {
+    /**
+     * Each value must be a blob-id only
+     * (internal_blob_id_for_string_value or internal_blob_id_for_obj_value).
+     * Concrete payload arms (string_value / obj_value) are rejected.
+     */
+    values: Value[];
+}
+export interface LoadBlobsResponse {
+    /** Hydrated concrete values keyed by blob id. */
+    values: {
+        [key: string]: Value;
+    };
+}
+export interface LoadBlobsResponse_ValuesEntry {
+    key: string;
+    value: Value | undefined;
+}
+export interface WaitForFlowRequest {
+    flowId: string;
+    runId: string;
+    needsResults: boolean;
+    /** Zero/omit uses the configured API maximum wait. */
+    waitTimeSeconds: number;
+}
+export interface StepCompletionOutput {
+    completedStepType: string;
+    completedStepExecutionId: string;
+    completedStepOutput: Value | undefined;
+}
+export interface WaitForFlowResponse {
+    flowStatus: FlowStatus;
+    results: StepCompletionOutput[];
+    errorType: FlowErrorType;
+    errorMessage: string;
+}
+export interface SearchFlowsRequest {
+    query: string;
+    pageSize: number;
+    nextPageToken: string;
+}
+export interface SearchFlowsResponse {
+    flowRuns: SearchFlowsResponseEntry[];
+    nextPageToken: string;
+}
+export interface SearchFlowsResponseEntry {
+    flowId: string;
+    runId: string;
+    searchAttributes: KV[];
+    flowType: string;
+    flowStatus: FlowStatus;
+    startTime: Date | undefined;
+    closeTime: Date | undefined;
+}
+export interface FlowExecutionID {
+    flowId: string;
+    runId: string;
+}
+export interface GetFlowSummaryRequest {
+    flowId: string;
+    runId: string;
+}
+export interface GetFlowSummaryResponse {
+    flowExecutionId: FlowExecutionID | undefined;
+    firstRunId: string;
+    requestId: string;
+    flowType: string;
+    flowStatus: FlowStatus;
+    startTime: Date | undefined;
+    closeTime: Date | undefined;
+}
+export interface InternalAsyncStepInputSnapshot {
+    methodOptions: StepMethodOptions | undefined;
+    request: {
+        $case: "waitForRequest";
+        value: InvokeWaitForMethodRequest;
+    } | {
+        $case: "executeRequest";
+        value: InvokeExecuteMethodRequest;
+    } | undefined;
+}
+export interface InternalLocalActivityInput {
+    currentRunStartedTimestamp: bigint;
+    methodOptions: StepMethodOptions | undefined;
+}
+export interface GetHistoryEventsRequest {
+    flowId: string;
+    runId: string;
+    startInternalEventId: bigint;
+    estimatePageSize: number;
+    nextPageToken: Uint8Array;
+}
+export interface GetHistoryEventsResponse {
+    events: FlowHistoryEvent[];
+    nextPageToken: Uint8Array;
+    nextInternalEventId: bigint;
+}
+export interface FlowHistoryEvent {
+    eventId: bigint;
+    eventTime: Date | undefined;
+    payload: {
+        $case: "flowStartedOrContinued";
+        value: FlowStartedOrContinuedHistoryEvent;
+    } | {
+        $case: "flowClosed";
+        value: FlowClosedHistoryEvent;
+    } | {
+        $case: "stepWaitForCompleted";
+        value: StepWaitForCompletedEvent;
+    } | {
+        $case: "stepWaitForFailed";
+        value: StepWaitForFailedEvent;
+    } | {
+        $case: "stepExecuteCompleted";
+        value: StepExecuteCompletedEvent;
+    } | {
+        $case: "stepExecuteFailed";
+        value: StepExecuteFailedEvent;
+    } | {
+        $case: "rpcExecutionCompleted";
+        value: RpcExecutionCompletedEvent;
+    } | {
+        $case: "channelExternalPublish";
+        value: ChannelExternalPublishEvent;
+    } | undefined;
+}
+export interface FlowStartedOrContinuedHistoryEvent {
+    flowExecutionId: FlowExecutionID | undefined;
+    flowType: string;
+    flowConfig: FlowConfig | undefined;
+    flowTimeout: Duration | undefined;
+    startOrContinue: {
+        $case: "initialStart";
+        value: FlowInitialStart;
+    } | {
+        $case: "continuedStart";
+        value: FlowContinuedStart;
+    } | undefined;
+}
+export interface FlowInitialStart {
+    startStepType: string;
+    stepInput: Value | undefined;
+    stepOptions: StepOptions | undefined;
+    initialAttributes: KV[];
+}
+export interface FlowContinuedStart {
+    previousRunId: string;
+    stepsToStart: StepMovement[];
+    stepsToResume: StepExecutionResumeInfo[];
+    pendingChannelMessages: {
+        [key: string]: ChannelValues;
+    };
+    attributes: KV[];
+    completedSteps: StepCompletionOutput[];
+}
+export interface FlowContinuedStart_PendingChannelMessagesEntry {
+    key: string;
+    value: ChannelValues | undefined;
+}
+export interface FlowClosedHistoryEvent {
+    flowStatus: FlowStatus;
+    results: StepCompletionOutput[];
+    errorType: FlowErrorType;
+    errorMessage: string;
+    continuedToRunId: string;
+}
+export interface StepMethodFailure {
+    message: string;
+    errorType: string;
+    stackTrace: string;
+    retryState: string;
+    details: ErrorResponse | undefined;
+    attempt: number;
+}
+export interface StepMethodOptions {
+    timeoutSeconds: number;
+    retryPolicy: RetryPolicy | undefined;
+}
+export interface StepMethodEventInput {
+    unavailable: boolean;
+    stepInput: Value | undefined;
+    conditionResults: ConditionResults | undefined;
+    attributes: KV[];
+    stepExecutionLocals: KV[];
+}
+export interface StepMethodEventContext {
+    stepExecutionId: string;
+    fromStepExecutionId: string;
+    stepType: string;
+    durability: StepDurability;
+    finalAttempt: number;
+    startedTime: Date | undefined;
+    duration: Duration | undefined;
+    methodOptions: StepMethodOptions | undefined;
+    isTransientStep?: boolean | undefined;
+    lastFailureInfo: StepMethodFailure | undefined;
+}
+export interface StepWaitForCompletedOutput {
+    waitForCondition: WaitingCondition | undefined;
+    upsertAttributes: AttributeWrite[];
+    publishToChannel: ChannelMessage[];
+    recordEvents: KV[];
+    upsertStepExecutionLocals: KV[];
+    transientStepMovement: StepMovement | undefined;
+}
+export interface StepExecuteCompletedOutput {
+    stepDecision: StepDecision | undefined;
+    upsertAttributes: AttributeWrite[];
+    publishToChannel: ChannelMessage[];
+    recordEvents: KV[];
+    upsertStepExecutionLocals: KV[];
+}
+export interface StepMethodFailedOutput {
+    failure: StepMethodFailure | undefined;
+}
+export interface StepWaitForCompletedEvent {
+    input: StepMethodEventInput | undefined;
+    output: StepWaitForCompletedOutput | undefined;
+    context: StepMethodEventContext | undefined;
+}
+export interface StepWaitForFailedEvent {
+    input: StepMethodEventInput | undefined;
+    output: StepMethodFailedOutput | undefined;
+    context: StepMethodEventContext | undefined;
+}
+export interface StepExecuteCompletedEvent {
+    input: StepMethodEventInput | undefined;
+    output: StepExecuteCompletedOutput | undefined;
+    context: StepMethodEventContext | undefined;
+}
+export interface StepExecuteFailedEvent {
+    input: StepMethodEventInput | undefined;
+    output: StepMethodFailedOutput | undefined;
+    context: StepMethodEventContext | undefined;
+}
+export interface RpcExecutionCompletedEvent {
+    rpcName: string;
+    input: Value | undefined;
+    output: Value | undefined;
+    stepDecision: StepDecision | undefined;
+    upsertAttributes: AttributeWrite[];
+    recordEvents: KV[];
+    publishToChannel: ChannelMessage[];
+}
+export interface ChannelExternalPublishEvent {
+    messages: ChannelMessage[];
+}
+export interface WaitForHistoryEventRequest {
+    flowId: string;
+    runId: string;
+    nextInternalEventId: bigint;
+}
+export interface WaitForHistoryEventResponse {
+    eventAvailable: boolean;
+    availableInternalEventId: bigint;
+    flowStatus: FlowStatus;
+}
+export interface ActiveStepExecutionState {
+    stepExecutionId: string;
+    fromStepExecutionId: string;
+    stepType: string;
+    phase: ActiveStepPhase;
+    movement: StepMovement | undefined;
+    waitingCondition: WaitingCondition | undefined;
+    completedConditions: StepExecutionCompletedConditions | undefined;
+    stepExecutionLocals: KV[];
+    timers: TimerInfo[];
+}
+export interface GetFlowStateRequest {
+    flowId: string;
+    runId: string;
+}
+export interface GetFlowStateResponse {
+    flowConfig: FlowConfig | undefined;
+    attributes: KV[];
+    activeStepExecutions: ActiveStepExecutionState[];
+    queuedSteps: StepMovement[];
+    pendingChannelMessages: {
+        [key: string]: ChannelValues;
+    };
+    completedSteps: StepCompletionOutput[];
+}
+export interface GetFlowStateResponse_PendingChannelMessagesEntry {
+    key: string;
+    value: ChannelValues | undefined;
+}
+export interface ResetFlowRequest {
+    flowId: string;
+    runId: string;
+    resetType: FlowResetType;
+    historyEventId: number;
+    reason: string;
+    historyEventTime: string;
+    stepType: string;
+    stepExecutionId: string;
+    skipChannelMessagesReapply: boolean;
+    skipLockingRpcReapply: boolean;
+}
+export interface ResetFlowResponse {
+    runId: string;
+}
+export interface InvokeRPCRequest {
+    flowId: string;
+    runId: string;
+    rpcName: string;
+    input: Value | undefined;
+    timeoutSeconds: number;
+    /**
+     * Acquire exclusive lock on these attribute keys for the RPC's
+     * read-modify-write. Empty = non-locking RPC.
+     */
+    lockAttributeKeys: string[];
+    /** Locking RPCs require per-call UUID, SDK-generated and future-overridable; identical retries reuse it. Server forwards run-scoped UpdateID; Continue-as-New resets scope. */
+    requestId: string;
+}
+export interface InvokeRPCResponse {
+    output: Value | undefined;
+}
+export interface SkipTimerRequest {
+    flowId: string;
+    runId: string;
+    stepExecutionId: string;
+    timerConditionId: string;
+    timerConditionIndex?: number | undefined;
+}
+export interface UpdateFlowConfigRequest {
+    flowId: string;
+    runId: string;
+    flowConfig: FlowConfig | undefined;
+}
+export interface WaitForStepCompletionRequest {
+    flowId: string;
+    /** Identifies a step execution by type and its per-type execution number. */
+    stepType: string;
+    stepExecutionNumber: string;
+    waitTimeSeconds: number;
+    /** Required per-call UUID is SDK-generated and future-overridable; identical retries reuse it. Server forwards run-scoped UpdateID; Continue-as-New resets scope. */
+    requestId: string;
+}
+export interface WaitForStepCompletionResponse {
+}
+export interface WaitForAttributeRequest {
+    flowId: string;
+    runId: string;
+    condition: WaitForAttributeCondition | undefined;
+    /** Zero/omit checks once; positive waits until match or timeout. */
+    waitTimeSeconds: number;
+    /** Required per-call UUID is SDK-generated and future-overridable; identical retries reuse it. Server forwards run-scoped UpdateID; Continue-as-New resets scope. */
+    requestId: string;
+}
+export interface WaitForAttributeCondition {
+    kind: {
+        $case: "equal";
+        value: WaitForAttributeEqual;
+    } | undefined;
+}
+export interface WaitForAttributeEqual {
+    key: string;
+    value: Value | undefined;
+}
+export interface TriggerContinueAsNewRequest {
+    flowId: string;
+    runId: string;
+}
+export interface HealthInfo {
+    condition: string;
+    hostname: string;
+    duration: number;
+}
+export interface ErrorResponse {
+    detail: string;
+    subStatus: ErrorSubStatus;
+    originalWorkerErrorDetail: string;
+    originalWorkerErrorType: string;
+    originalWorkerErrorStatus: number;
+}
+export interface WorkerErrorResponse {
+    detail: string;
+    errorType: string;
+}
+export interface ChannelInfo {
+    size: number;
+}
+export interface InvokeWaitForMethodRequest {
+    context: Context | undefined;
+    flowType: string;
+    stepType: string;
+    stepInput: Value | undefined;
+    attributes: KV[];
+}
+export interface InvokeWaitForMethodResponse {
+    /** Server-populated lineage input for local activity history. */
+    localActivityInput: LocalActivityInput | undefined;
+    upsertAttributes: AttributeWrite[];
+    waitingCondition: WaitingCondition | undefined;
+    upsertStepExeLocals: KV[];
+    recordEvents: KV[];
+    publishToChannel: ChannelMessage[];
+    transientStepMovement: StepMovement | undefined;
+}
+export interface InvokeExecuteMethodRequest {
+    context: Context | undefined;
+    flowType: string;
+    stepType: string;
+    stepInput: Value | undefined;
+    attributes: KV[];
+    stepExeLocals: KV[];
+    conditionResults: ConditionResults | undefined;
+}
+export interface InvokeExecuteMethodResponse {
+    /** Server-populated lineage input for local activity history. */
+    localActivityInput: LocalActivityInput | undefined;
+    stepDecision: StepDecision | undefined;
+    upsertAttributes: AttributeWrite[];
+    recordEvents: KV[];
+    upsertStepExeLocals: KV[];
+    publishToChannel: ChannelMessage[];
+}
+export interface InvokeWorkerRPCRequest {
+    context: Context | undefined;
+    flowType: string;
+    rpcName: string;
+    input: Value | undefined;
+    attributes: KV[];
+    channelInfos: {
+        [key: string]: ChannelInfo;
+    };
+}
+export interface InvokeWorkerRPCRequest_ChannelInfosEntry {
+    key: string;
+    value: ChannelInfo | undefined;
+}
+export interface InvokeWorkerRPCResponse {
+    output: Value | undefined;
+    stepDecision: StepDecision | undefined;
+    upsertAttributes: AttributeWrite[];
+    recordEvents: KV[];
+    publishToChannel: ChannelMessage[];
+}
+export interface StepDecision {
+    nextSteps: StepMovement[];
+    closeDecision: CloseDecision | undefined;
+}
+export interface CloseDecision {
+    closeDecisionType: CloseDecisionType;
+    conditionalChannelNames: string[];
+    closeInput: Value | undefined;
+}
+export interface StepMovement {
+    stepType: string;
+    stepInput: Value | undefined;
+    stepOptions: StepOptions | undefined;
+    /** Server-owned scheduling source; workers must leave this empty. */
+    fromStepExecutionIdInternalOnly: string;
+}
+export interface ConditionCombination {
+    conditionIds: string[];
+}
+export interface WaitingCondition {
+    waitingConditionType: WaitingConditionType;
+    timerConditions: TimerCondition[];
+    channelConditions: ChannelCondition[];
+    conditionCombinations: ConditionCombination[];
+}
+export interface TimerCondition {
+    /** Optional unless waiting_condition_type is ANY_COMBINATION_COMPLETED. */
+    conditionId: string;
+    /** Worker-relative delay; interpreter clears this after converted to firing_unix_timestamp_seconds. */
+    durationSeconds: bigint;
+    /** Interpreter-normalized deadline; workers leave this zero. */
+    firingUnixTimestampSeconds: bigint;
+}
+export interface ChannelCondition {
+    /** Optional unless waiting_condition_type is ANY_COMBINATION_COMPLETED. */
+    conditionId: string;
+    channelName: string;
+    /** Both omitted means exact one. Omitted at_least means zero; omitted at_most means unbounded. */
+    atLeast?: number | undefined;
+    atMost?: number | undefined;
+}
+export interface ConditionResults {
+    channelResults: ChannelResult[];
+    timerResults: TimerResult[];
+    waitForFailed: boolean;
+}
+export interface TimerResult {
+    conditionId: string;
+    conditionStatus: ConditionStatus;
+}
+export interface ChannelResult {
+    conditionId: string;
+    conditionStatus: ConditionStatus;
+    channelName: string;
+    values: Value[];
+}
+export interface ContinueAsNewDumpRequest {
+    flowId: string;
+    runId: string;
+    pageNum: number;
+    pageSizeInBytes: number;
+}
+export interface ContinueAsNewDumpResponse {
+    /** Slice of the deterministic proto-marshaled ContinueAsNewDump. */
+    pageContent: Uint8Array;
+    pageNum: number;
+    totalPages: number;
+    /** Hash of the full marshaled dump; guards snapshot drift across pages. */
+    checksum: string;
+}
+export interface ChannelValues {
+    values: Value[];
+}
+export interface StepExecutionCompletedConditions {
+    completedTimerConditions: {
+        [key: number]: InternalTimerStatus;
+    };
+}
+export interface StepExecutionCompletedConditions_CompletedTimerConditionsEntry {
+    key: number;
+    value: InternalTimerStatus;
+}
+export interface StepExecutionResumeInfo {
+    stepExecutionId: string;
+    step: StepMovement | undefined;
+    completedConditions: StepExecutionCompletedConditions | undefined;
+    waitingCondition: WaitingCondition | undefined;
+    stepExeLocals: KV[];
+}
+export interface StepExecutionCounterInfo {
+    stepTypeStartedCount: {
+        [key: string]: number;
+    };
+    stepTypeCurrentlyExecutingCount: {
+        [key: string]: number;
+    };
+    totalCurrentlyExecutingCount: number;
+    stepActiveExecutionNums: {
+        [key: string]: StepExecutionNumbers;
+    };
+}
+export interface StepExecutionCounterInfo_StepTypeStartedCountEntry {
+    key: string;
+    value: number;
+}
+export interface StepExecutionCounterInfo_StepTypeCurrentlyExecutingCountEntry {
+    key: string;
+    value: number;
+}
+export interface StepExecutionCounterInfo_StepActiveExecutionNumsEntry {
+    key: string;
+    value: StepExecutionNumbers | undefined;
+}
+export interface StaleSkipTimer {
+    stepExecutionId: string;
+    timerConditionId: string;
+    timerConditionIndex: number;
+}
+export interface ContinueAsNewDump {
+    stepsToStartFromBeginning: StepMovement[];
+    stepExecutionsToResume: StepExecutionResumeInfo[];
+    channelReceived: {
+        [key: string]: ChannelValues;
+    };
+    counterInfo: StepExecutionCounterInfo | undefined;
+    stepOutputs: StepCompletionOutput[];
+    staleSkipTimers: StaleSkipTimer[];
+    /** Stored values only; index metadata remains in backend search attributes. */
+    attributes: KV[];
+}
+export interface ContinueAsNewDump_ChannelReceivedEntry {
+    key: string;
+    value: ChannelValues | undefined;
+}
+export interface ContinueAsNewInput {
+    previousInternalRunId: string;
+}
+export interface InterpreterWorkflowInput {
+    flowType: string;
+    startStepType: string;
+    stepInput: Value | undefined;
+    stepOptions: StepOptions | undefined;
+    /** IndexConfig is processed before workflow start. */
+    initAttributes: KV[];
+    config: FlowConfig | undefined;
+    /** When true, ignore start_step_type / step_input / step_options / init_attributes. */
+    isResumeFromContinueAsNew: boolean;
+    continueAsNewInput: ContinueAsNewInput | undefined;
+}
+export interface InterpreterWorkflowOutput {
+    stepCompletionOutputs: StepCompletionOutput[];
+}
+export interface BlobStoreCleanupWorkflowInput {
+    storeId: string;
+}
+export interface BlobStoreCleanupWorkflowOutput {
+    totalDeleted: number;
+}
+export interface InvokeWaitForMethodActivityInput {
+    workerTarget: WorkerTarget | undefined;
+    request: InvokeWaitForMethodRequest | undefined;
+}
+export interface InvokeWaitForMethodActivityOutput {
+    response: InvokeWaitForMethodResponse | undefined;
+}
+export interface InvokeExecuteMethodActivityInput {
+    workerTarget: WorkerTarget | undefined;
+    request: InvokeExecuteMethodRequest | undefined;
+    /** Requires a DeadEnd close decision without next steps. */
+    isTransientStep: boolean;
+}
+export interface InvokeExecuteMethodActivityOutput {
+    response: InvokeExecuteMethodResponse | undefined;
+}
+export interface DumpFlowForContinueAsNewActivityInput {
+    request: ContinueAsNewDumpRequest | undefined;
+}
+export interface DumpFlowForContinueAsNewActivityOutput {
+    response: ContinueAsNewDumpResponse | undefined;
+}
+export interface InvokeWorkerRPCActivityInput {
+    rpcPrep: PrepareRpcQueryResponse | undefined;
+    request: InvokeRPCRequest | undefined;
+}
+export interface InvokeWorkerRPCActivityOutput {
+    response: InvokeWorkerRPCResponse | undefined;
+}
+export interface CleanupBlobStoreActivityInput {
+    storeId: string;
+}
+export interface CleanupBlobStoreActivityOutput {
+    totalDeleted: number;
+}
+export interface ExecuteRpcSignalRequest {
+    rpcInput: Value | undefined;
+    rpcOutput: Value | undefined;
+    upsertAttributes: AttributeWrite[];
+    stepDecision: StepDecision | undefined;
+    recordEvents: KV[];
+    publishToChannel: ChannelMessage[];
+}
+export interface SkipTimerSignalRequest {
+    stepExecutionId: string;
+    timerConditionId: string;
+    timerConditionIndex: number;
+}
+export interface FailFlowSignalRequest {
+    reason: string;
+}
+export interface GetAttributesQueryRequest {
+    keys: string[];
+    allKeys: boolean;
+}
+export interface GetAttributesQueryResponse {
+    attributes: KV[];
+}
+export interface PrepareRpcQueryRequest {
+    lockAttributeKeys: string[];
+}
+export interface PrepareRpcQueryResponse {
+    attributes: KV[];
+    runId: string;
+    flowStartedTimestamp: bigint;
+    flowType: string;
+    workerTarget: WorkerTarget | undefined;
+    channelInfos: {
+        [key: string]: ChannelInfo;
+    };
+}
+export interface PrepareRpcQueryResponse_ChannelInfosEntry {
+    key: string;
+    value: ChannelInfo | undefined;
+}
+export interface TimerInfo {
+    /** Empty when the timer has no condition id. */
+    conditionId: string;
+    firingUnixTimestampSeconds: bigint;
+    status: InternalTimerStatus;
+}
+export interface TimerInfoList {
+    timers: TimerInfo[];
+}
+export interface GetCurrentTimerInfosQueryResponse {
+    /** Key is step_execution_id. */
+    stepExecutionCurrentTimerInfos: {
+        [key: string]: TimerInfoList;
+    };
+}
+export interface GetCurrentTimerInfosQueryResponse_StepExecutionCurrentTimerInfosEntry {
+    key: string;
+    value: TimerInfoList | undefined;
+}
+export interface GetScheduledGreedyTimerTimesQueryResponse {
+    pendingScheduled: TimerInfo[];
+}
+export interface DebugDumpResponse {
+    config: FlowConfig | undefined;
+    snapshot: ContinueAsNewDump | undefined;
+    firingTimersUnixTimestamps: bigint[];
+    activeStepExecutions: ActiveStepExecutionState[];
+}
+/** Sync-update InvokeRPC handler result when response and error are multiplexed. */
+export interface InvokeRpcUpdateResult {
+    response: InvokeRPCResponse | undefined;
+}
+export interface StepExecutionNumbers {
+    numbers: number[];
+}
+export declare const Value: MessageFns<Value>;
+export declare const EncodedObject: MessageFns<EncodedObject>;
+export declare const AttributeWrite: MessageFns<AttributeWrite>;
+export declare const KV: MessageFns<KV>;
+export declare const IndexConfig: MessageFns<IndexConfig>;
+export declare const Context: MessageFns<Context>;
+export declare const LocalActivityInput: MessageFns<LocalActivityInput>;
+export declare const RetryPolicy: MessageFns<RetryPolicy>;
+export declare const FlowRetryPolicy: MessageFns<FlowRetryPolicy>;
+export declare const StepOptions: MessageFns<StepOptions>;
+export declare const FlowAlreadyStartedOptions: MessageFns<FlowAlreadyStartedOptions>;
+export declare const FlowStartOptions: MessageFns<FlowStartOptions>;
+export declare const FlowConfig: MessageFns<FlowConfig>;
+export declare const WorkerTarget: MessageFns<WorkerTarget>;
+export declare const StartFlowRequest: MessageFns<StartFlowRequest>;
+export declare const StartFlowResponse: MessageFns<StartFlowResponse>;
+export declare const PublishToChannelRequest: MessageFns<PublishToChannelRequest>;
+export declare const ChannelMessage: MessageFns<ChannelMessage>;
+export declare const StopFlowRequest: MessageFns<StopFlowRequest>;
+export declare const GetAttributesRequest: MessageFns<GetAttributesRequest>;
+export declare const GetAttributesResponse: MessageFns<GetAttributesResponse>;
+export declare const SetAttributesRequest: MessageFns<SetAttributesRequest>;
+export declare const LoadBlobsRequest: MessageFns<LoadBlobsRequest>;
+export declare const LoadBlobsResponse: MessageFns<LoadBlobsResponse>;
+export declare const LoadBlobsResponse_ValuesEntry: MessageFns<LoadBlobsResponse_ValuesEntry>;
+export declare const WaitForFlowRequest: MessageFns<WaitForFlowRequest>;
+export declare const StepCompletionOutput: MessageFns<StepCompletionOutput>;
+export declare const WaitForFlowResponse: MessageFns<WaitForFlowResponse>;
+export declare const SearchFlowsRequest: MessageFns<SearchFlowsRequest>;
+export declare const SearchFlowsResponse: MessageFns<SearchFlowsResponse>;
+export declare const SearchFlowsResponseEntry: MessageFns<SearchFlowsResponseEntry>;
+export declare const FlowExecutionID: MessageFns<FlowExecutionID>;
+export declare const GetFlowSummaryRequest: MessageFns<GetFlowSummaryRequest>;
+export declare const GetFlowSummaryResponse: MessageFns<GetFlowSummaryResponse>;
+export declare const InternalAsyncStepInputSnapshot: MessageFns<InternalAsyncStepInputSnapshot>;
+export declare const InternalLocalActivityInput: MessageFns<InternalLocalActivityInput>;
+export declare const GetHistoryEventsRequest: MessageFns<GetHistoryEventsRequest>;
+export declare const GetHistoryEventsResponse: MessageFns<GetHistoryEventsResponse>;
+export declare const FlowHistoryEvent: MessageFns<FlowHistoryEvent>;
+export declare const FlowStartedOrContinuedHistoryEvent: MessageFns<FlowStartedOrContinuedHistoryEvent>;
+export declare const FlowInitialStart: MessageFns<FlowInitialStart>;
+export declare const FlowContinuedStart: MessageFns<FlowContinuedStart>;
+export declare const FlowContinuedStart_PendingChannelMessagesEntry: MessageFns<FlowContinuedStart_PendingChannelMessagesEntry>;
+export declare const FlowClosedHistoryEvent: MessageFns<FlowClosedHistoryEvent>;
+export declare const StepMethodFailure: MessageFns<StepMethodFailure>;
+export declare const StepMethodOptions: MessageFns<StepMethodOptions>;
+export declare const StepMethodEventInput: MessageFns<StepMethodEventInput>;
+export declare const StepMethodEventContext: MessageFns<StepMethodEventContext>;
+export declare const StepWaitForCompletedOutput: MessageFns<StepWaitForCompletedOutput>;
+export declare const StepExecuteCompletedOutput: MessageFns<StepExecuteCompletedOutput>;
+export declare const StepMethodFailedOutput: MessageFns<StepMethodFailedOutput>;
+export declare const StepWaitForCompletedEvent: MessageFns<StepWaitForCompletedEvent>;
+export declare const StepWaitForFailedEvent: MessageFns<StepWaitForFailedEvent>;
+export declare const StepExecuteCompletedEvent: MessageFns<StepExecuteCompletedEvent>;
+export declare const StepExecuteFailedEvent: MessageFns<StepExecuteFailedEvent>;
+export declare const RpcExecutionCompletedEvent: MessageFns<RpcExecutionCompletedEvent>;
+export declare const ChannelExternalPublishEvent: MessageFns<ChannelExternalPublishEvent>;
+export declare const WaitForHistoryEventRequest: MessageFns<WaitForHistoryEventRequest>;
+export declare const WaitForHistoryEventResponse: MessageFns<WaitForHistoryEventResponse>;
+export declare const ActiveStepExecutionState: MessageFns<ActiveStepExecutionState>;
+export declare const GetFlowStateRequest: MessageFns<GetFlowStateRequest>;
+export declare const GetFlowStateResponse: MessageFns<GetFlowStateResponse>;
+export declare const GetFlowStateResponse_PendingChannelMessagesEntry: MessageFns<GetFlowStateResponse_PendingChannelMessagesEntry>;
+export declare const ResetFlowRequest: MessageFns<ResetFlowRequest>;
+export declare const ResetFlowResponse: MessageFns<ResetFlowResponse>;
+export declare const InvokeRPCRequest: MessageFns<InvokeRPCRequest>;
+export declare const InvokeRPCResponse: MessageFns<InvokeRPCResponse>;
+export declare const SkipTimerRequest: MessageFns<SkipTimerRequest>;
+export declare const UpdateFlowConfigRequest: MessageFns<UpdateFlowConfigRequest>;
+export declare const WaitForStepCompletionRequest: MessageFns<WaitForStepCompletionRequest>;
+export declare const WaitForStepCompletionResponse: MessageFns<WaitForStepCompletionResponse>;
+export declare const WaitForAttributeRequest: MessageFns<WaitForAttributeRequest>;
+export declare const WaitForAttributeCondition: MessageFns<WaitForAttributeCondition>;
+export declare const WaitForAttributeEqual: MessageFns<WaitForAttributeEqual>;
+export declare const TriggerContinueAsNewRequest: MessageFns<TriggerContinueAsNewRequest>;
+export declare const HealthInfo: MessageFns<HealthInfo>;
+export declare const ErrorResponse: MessageFns<ErrorResponse>;
+export declare const WorkerErrorResponse: MessageFns<WorkerErrorResponse>;
+export declare const ChannelInfo: MessageFns<ChannelInfo>;
+export declare const InvokeWaitForMethodRequest: MessageFns<InvokeWaitForMethodRequest>;
+export declare const InvokeWaitForMethodResponse: MessageFns<InvokeWaitForMethodResponse>;
+export declare const InvokeExecuteMethodRequest: MessageFns<InvokeExecuteMethodRequest>;
+export declare const InvokeExecuteMethodResponse: MessageFns<InvokeExecuteMethodResponse>;
+export declare const InvokeWorkerRPCRequest: MessageFns<InvokeWorkerRPCRequest>;
+export declare const InvokeWorkerRPCRequest_ChannelInfosEntry: MessageFns<InvokeWorkerRPCRequest_ChannelInfosEntry>;
+export declare const InvokeWorkerRPCResponse: MessageFns<InvokeWorkerRPCResponse>;
+export declare const StepDecision: MessageFns<StepDecision>;
+export declare const CloseDecision: MessageFns<CloseDecision>;
+export declare const StepMovement: MessageFns<StepMovement>;
+export declare const ConditionCombination: MessageFns<ConditionCombination>;
+export declare const WaitingCondition: MessageFns<WaitingCondition>;
+export declare const TimerCondition: MessageFns<TimerCondition>;
+export declare const ChannelCondition: MessageFns<ChannelCondition>;
+export declare const ConditionResults: MessageFns<ConditionResults>;
+export declare const TimerResult: MessageFns<TimerResult>;
+export declare const ChannelResult: MessageFns<ChannelResult>;
+export declare const ContinueAsNewDumpRequest: MessageFns<ContinueAsNewDumpRequest>;
+export declare const ContinueAsNewDumpResponse: MessageFns<ContinueAsNewDumpResponse>;
+export declare const ChannelValues: MessageFns<ChannelValues>;
+export declare const StepExecutionCompletedConditions: MessageFns<StepExecutionCompletedConditions>;
+export declare const StepExecutionCompletedConditions_CompletedTimerConditionsEntry: MessageFns<StepExecutionCompletedConditions_CompletedTimerConditionsEntry>;
+export declare const StepExecutionResumeInfo: MessageFns<StepExecutionResumeInfo>;
+export declare const StepExecutionCounterInfo: MessageFns<StepExecutionCounterInfo>;
+export declare const StepExecutionCounterInfo_StepTypeStartedCountEntry: MessageFns<StepExecutionCounterInfo_StepTypeStartedCountEntry>;
+export declare const StepExecutionCounterInfo_StepTypeCurrentlyExecutingCountEntry: MessageFns<StepExecutionCounterInfo_StepTypeCurrentlyExecutingCountEntry>;
+export declare const StepExecutionCounterInfo_StepActiveExecutionNumsEntry: MessageFns<StepExecutionCounterInfo_StepActiveExecutionNumsEntry>;
+export declare const StaleSkipTimer: MessageFns<StaleSkipTimer>;
+export declare const ContinueAsNewDump: MessageFns<ContinueAsNewDump>;
+export declare const ContinueAsNewDump_ChannelReceivedEntry: MessageFns<ContinueAsNewDump_ChannelReceivedEntry>;
+export declare const ContinueAsNewInput: MessageFns<ContinueAsNewInput>;
+export declare const InterpreterWorkflowInput: MessageFns<InterpreterWorkflowInput>;
+export declare const InterpreterWorkflowOutput: MessageFns<InterpreterWorkflowOutput>;
+export declare const BlobStoreCleanupWorkflowInput: MessageFns<BlobStoreCleanupWorkflowInput>;
+export declare const BlobStoreCleanupWorkflowOutput: MessageFns<BlobStoreCleanupWorkflowOutput>;
+export declare const InvokeWaitForMethodActivityInput: MessageFns<InvokeWaitForMethodActivityInput>;
+export declare const InvokeWaitForMethodActivityOutput: MessageFns<InvokeWaitForMethodActivityOutput>;
+export declare const InvokeExecuteMethodActivityInput: MessageFns<InvokeExecuteMethodActivityInput>;
+export declare const InvokeExecuteMethodActivityOutput: MessageFns<InvokeExecuteMethodActivityOutput>;
+export declare const DumpFlowForContinueAsNewActivityInput: MessageFns<DumpFlowForContinueAsNewActivityInput>;
+export declare const DumpFlowForContinueAsNewActivityOutput: MessageFns<DumpFlowForContinueAsNewActivityOutput>;
+export declare const InvokeWorkerRPCActivityInput: MessageFns<InvokeWorkerRPCActivityInput>;
+export declare const InvokeWorkerRPCActivityOutput: MessageFns<InvokeWorkerRPCActivityOutput>;
+export declare const CleanupBlobStoreActivityInput: MessageFns<CleanupBlobStoreActivityInput>;
+export declare const CleanupBlobStoreActivityOutput: MessageFns<CleanupBlobStoreActivityOutput>;
+export declare const ExecuteRpcSignalRequest: MessageFns<ExecuteRpcSignalRequest>;
+export declare const SkipTimerSignalRequest: MessageFns<SkipTimerSignalRequest>;
+export declare const FailFlowSignalRequest: MessageFns<FailFlowSignalRequest>;
+export declare const GetAttributesQueryRequest: MessageFns<GetAttributesQueryRequest>;
+export declare const GetAttributesQueryResponse: MessageFns<GetAttributesQueryResponse>;
+export declare const PrepareRpcQueryRequest: MessageFns<PrepareRpcQueryRequest>;
+export declare const PrepareRpcQueryResponse: MessageFns<PrepareRpcQueryResponse>;
+export declare const PrepareRpcQueryResponse_ChannelInfosEntry: MessageFns<PrepareRpcQueryResponse_ChannelInfosEntry>;
+export declare const TimerInfo: MessageFns<TimerInfo>;
+export declare const TimerInfoList: MessageFns<TimerInfoList>;
+export declare const GetCurrentTimerInfosQueryResponse: MessageFns<GetCurrentTimerInfosQueryResponse>;
+export declare const GetCurrentTimerInfosQueryResponse_StepExecutionCurrentTimerInfosEntry: MessageFns<GetCurrentTimerInfosQueryResponse_StepExecutionCurrentTimerInfosEntry>;
+export declare const GetScheduledGreedyTimerTimesQueryResponse: MessageFns<GetScheduledGreedyTimerTimesQueryResponse>;
+export declare const DebugDumpResponse: MessageFns<DebugDumpResponse>;
+export declare const InvokeRpcUpdateResult: MessageFns<InvokeRpcUpdateResult>;
+export declare const StepExecutionNumbers: MessageFns<StepExecutionNumbers>;
+/** Hosted by Dex server; SDKs call these RPCs. */
+export type FlowServiceService = typeof FlowServiceService;
+export declare const FlowServiceService: {
+    readonly startFlow: {
+        readonly path: "/dex.FlowService/StartFlow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: StartFlowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StartFlowRequest;
+        readonly responseSerialize: (value: StartFlowResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => StartFlowResponse;
+    };
+    readonly publishToChannel: {
+        readonly path: "/dex.FlowService/PublishToChannel";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: PublishToChannelRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PublishToChannelRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly stopFlow: {
+        readonly path: "/dex.FlowService/StopFlow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: StopFlowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StopFlowRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly getAttributes: {
+        readonly path: "/dex.FlowService/GetAttributes";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetAttributesRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetAttributesRequest;
+        readonly responseSerialize: (value: GetAttributesResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetAttributesResponse;
+    };
+    readonly setAttributes: {
+        readonly path: "/dex.FlowService/SetAttributes";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SetAttributesRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SetAttributesRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly loadBlobs: {
+        readonly path: "/dex.FlowService/LoadBlobs";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: LoadBlobsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => LoadBlobsRequest;
+        readonly responseSerialize: (value: LoadBlobsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => LoadBlobsResponse;
+    };
+    readonly waitForFlow: {
+        readonly path: "/dex.FlowService/WaitForFlow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: WaitForFlowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => WaitForFlowRequest;
+        readonly responseSerialize: (value: WaitForFlowResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WaitForFlowResponse;
+    };
+    readonly searchFlows: {
+        readonly path: "/dex.FlowService/SearchFlows";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SearchFlowsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SearchFlowsRequest;
+        readonly responseSerialize: (value: SearchFlowsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => SearchFlowsResponse;
+    };
+    readonly getFlowSummary: {
+        readonly path: "/dex.FlowService/GetFlowSummary";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetFlowSummaryRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetFlowSummaryRequest;
+        readonly responseSerialize: (value: GetFlowSummaryResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetFlowSummaryResponse;
+    };
+    readonly getHistoryEvents: {
+        readonly path: "/dex.FlowService/GetHistoryEvents";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetHistoryEventsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetHistoryEventsRequest;
+        readonly responseSerialize: (value: GetHistoryEventsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetHistoryEventsResponse;
+    };
+    readonly waitForHistoryEvent: {
+        readonly path: "/dex.FlowService/WaitForHistoryEvent";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: WaitForHistoryEventRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => WaitForHistoryEventRequest;
+        readonly responseSerialize: (value: WaitForHistoryEventResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WaitForHistoryEventResponse;
+    };
+    readonly getFlowState: {
+        readonly path: "/dex.FlowService/GetFlowState";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetFlowStateRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetFlowStateRequest;
+        readonly responseSerialize: (value: GetFlowStateResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetFlowStateResponse;
+    };
+    readonly resetFlow: {
+        readonly path: "/dex.FlowService/ResetFlow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ResetFlowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ResetFlowRequest;
+        readonly responseSerialize: (value: ResetFlowResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ResetFlowResponse;
+    };
+    readonly invokeRpc: {
+        readonly path: "/dex.FlowService/InvokeRPC";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: InvokeRPCRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => InvokeRPCRequest;
+        readonly responseSerialize: (value: InvokeRPCResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => InvokeRPCResponse;
+    };
+    readonly skipTimer: {
+        readonly path: "/dex.FlowService/SkipTimer";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SkipTimerRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SkipTimerRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly updateFlowConfig: {
+        readonly path: "/dex.FlowService/UpdateFlowConfig";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateFlowConfigRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateFlowConfigRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly waitForStepCompletion: {
+        readonly path: "/dex.FlowService/WaitForStepCompletion";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: WaitForStepCompletionRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => WaitForStepCompletionRequest;
+        readonly responseSerialize: (value: WaitForStepCompletionResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WaitForStepCompletionResponse;
+    };
+    readonly waitForAttribute: {
+        readonly path: "/dex.FlowService/WaitForAttribute";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: WaitForAttributeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => WaitForAttributeRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly triggerContinueAsNew: {
+        readonly path: "/dex.FlowService/TriggerContinueAsNew";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: TriggerContinueAsNewRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => TriggerContinueAsNewRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly healthCheck: {
+        readonly path: "/dex.FlowService/HealthCheck";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: Empty) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => Empty;
+        readonly responseSerialize: (value: HealthInfo) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => HealthInfo;
+    };
+};
+export interface FlowServiceServer extends UntypedServiceImplementation {
+    startFlow: handleUnaryCall<StartFlowRequest, StartFlowResponse>;
+    publishToChannel: handleUnaryCall<PublishToChannelRequest, Empty>;
+    stopFlow: handleUnaryCall<StopFlowRequest, Empty>;
+    getAttributes: handleUnaryCall<GetAttributesRequest, GetAttributesResponse>;
+    setAttributes: handleUnaryCall<SetAttributesRequest, Empty>;
+    loadBlobs: handleUnaryCall<LoadBlobsRequest, LoadBlobsResponse>;
+    waitForFlow: handleUnaryCall<WaitForFlowRequest, WaitForFlowResponse>;
+    searchFlows: handleUnaryCall<SearchFlowsRequest, SearchFlowsResponse>;
+    getFlowSummary: handleUnaryCall<GetFlowSummaryRequest, GetFlowSummaryResponse>;
+    getHistoryEvents: handleUnaryCall<GetHistoryEventsRequest, GetHistoryEventsResponse>;
+    waitForHistoryEvent: handleUnaryCall<WaitForHistoryEventRequest, WaitForHistoryEventResponse>;
+    getFlowState: handleUnaryCall<GetFlowStateRequest, GetFlowStateResponse>;
+    resetFlow: handleUnaryCall<ResetFlowRequest, ResetFlowResponse>;
+    invokeRpc: handleUnaryCall<InvokeRPCRequest, InvokeRPCResponse>;
+    skipTimer: handleUnaryCall<SkipTimerRequest, Empty>;
+    updateFlowConfig: handleUnaryCall<UpdateFlowConfigRequest, Empty>;
+    waitForStepCompletion: handleUnaryCall<WaitForStepCompletionRequest, WaitForStepCompletionResponse>;
+    waitForAttribute: handleUnaryCall<WaitForAttributeRequest, Empty>;
+    triggerContinueAsNew: handleUnaryCall<TriggerContinueAsNewRequest, Empty>;
+    healthCheck: handleUnaryCall<Empty, HealthInfo>;
+}
+export interface FlowServiceClient extends Client {
+    startFlow(request: StartFlowRequest, callback: (error: ServiceError | null, response: StartFlowResponse) => void): ClientUnaryCall;
+    startFlow(request: StartFlowRequest, metadata: Metadata, callback: (error: ServiceError | null, response: StartFlowResponse) => void): ClientUnaryCall;
+    startFlow(request: StartFlowRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: StartFlowResponse) => void): ClientUnaryCall;
+    publishToChannel(request: PublishToChannelRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    publishToChannel(request: PublishToChannelRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    publishToChannel(request: PublishToChannelRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    stopFlow(request: StopFlowRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    stopFlow(request: StopFlowRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    stopFlow(request: StopFlowRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    getAttributes(request: GetAttributesRequest, callback: (error: ServiceError | null, response: GetAttributesResponse) => void): ClientUnaryCall;
+    getAttributes(request: GetAttributesRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetAttributesResponse) => void): ClientUnaryCall;
+    getAttributes(request: GetAttributesRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetAttributesResponse) => void): ClientUnaryCall;
+    setAttributes(request: SetAttributesRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    setAttributes(request: SetAttributesRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    setAttributes(request: SetAttributesRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    loadBlobs(request: LoadBlobsRequest, callback: (error: ServiceError | null, response: LoadBlobsResponse) => void): ClientUnaryCall;
+    loadBlobs(request: LoadBlobsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: LoadBlobsResponse) => void): ClientUnaryCall;
+    loadBlobs(request: LoadBlobsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: LoadBlobsResponse) => void): ClientUnaryCall;
+    waitForFlow(request: WaitForFlowRequest, callback: (error: ServiceError | null, response: WaitForFlowResponse) => void): ClientUnaryCall;
+    waitForFlow(request: WaitForFlowRequest, metadata: Metadata, callback: (error: ServiceError | null, response: WaitForFlowResponse) => void): ClientUnaryCall;
+    waitForFlow(request: WaitForFlowRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: WaitForFlowResponse) => void): ClientUnaryCall;
+    searchFlows(request: SearchFlowsRequest, callback: (error: ServiceError | null, response: SearchFlowsResponse) => void): ClientUnaryCall;
+    searchFlows(request: SearchFlowsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: SearchFlowsResponse) => void): ClientUnaryCall;
+    searchFlows(request: SearchFlowsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: SearchFlowsResponse) => void): ClientUnaryCall;
+    getFlowSummary(request: GetFlowSummaryRequest, callback: (error: ServiceError | null, response: GetFlowSummaryResponse) => void): ClientUnaryCall;
+    getFlowSummary(request: GetFlowSummaryRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetFlowSummaryResponse) => void): ClientUnaryCall;
+    getFlowSummary(request: GetFlowSummaryRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetFlowSummaryResponse) => void): ClientUnaryCall;
+    getHistoryEvents(request: GetHistoryEventsRequest, callback: (error: ServiceError | null, response: GetHistoryEventsResponse) => void): ClientUnaryCall;
+    getHistoryEvents(request: GetHistoryEventsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetHistoryEventsResponse) => void): ClientUnaryCall;
+    getHistoryEvents(request: GetHistoryEventsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetHistoryEventsResponse) => void): ClientUnaryCall;
+    waitForHistoryEvent(request: WaitForHistoryEventRequest, callback: (error: ServiceError | null, response: WaitForHistoryEventResponse) => void): ClientUnaryCall;
+    waitForHistoryEvent(request: WaitForHistoryEventRequest, metadata: Metadata, callback: (error: ServiceError | null, response: WaitForHistoryEventResponse) => void): ClientUnaryCall;
+    waitForHistoryEvent(request: WaitForHistoryEventRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: WaitForHistoryEventResponse) => void): ClientUnaryCall;
+    getFlowState(request: GetFlowStateRequest, callback: (error: ServiceError | null, response: GetFlowStateResponse) => void): ClientUnaryCall;
+    getFlowState(request: GetFlowStateRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetFlowStateResponse) => void): ClientUnaryCall;
+    getFlowState(request: GetFlowStateRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetFlowStateResponse) => void): ClientUnaryCall;
+    resetFlow(request: ResetFlowRequest, callback: (error: ServiceError | null, response: ResetFlowResponse) => void): ClientUnaryCall;
+    resetFlow(request: ResetFlowRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ResetFlowResponse) => void): ClientUnaryCall;
+    resetFlow(request: ResetFlowRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ResetFlowResponse) => void): ClientUnaryCall;
+    invokeRpc(request: InvokeRPCRequest, callback: (error: ServiceError | null, response: InvokeRPCResponse) => void): ClientUnaryCall;
+    invokeRpc(request: InvokeRPCRequest, metadata: Metadata, callback: (error: ServiceError | null, response: InvokeRPCResponse) => void): ClientUnaryCall;
+    invokeRpc(request: InvokeRPCRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: InvokeRPCResponse) => void): ClientUnaryCall;
+    skipTimer(request: SkipTimerRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    skipTimer(request: SkipTimerRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    skipTimer(request: SkipTimerRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    updateFlowConfig(request: UpdateFlowConfigRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    updateFlowConfig(request: UpdateFlowConfigRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    updateFlowConfig(request: UpdateFlowConfigRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    waitForStepCompletion(request: WaitForStepCompletionRequest, callback: (error: ServiceError | null, response: WaitForStepCompletionResponse) => void): ClientUnaryCall;
+    waitForStepCompletion(request: WaitForStepCompletionRequest, metadata: Metadata, callback: (error: ServiceError | null, response: WaitForStepCompletionResponse) => void): ClientUnaryCall;
+    waitForStepCompletion(request: WaitForStepCompletionRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: WaitForStepCompletionResponse) => void): ClientUnaryCall;
+    waitForAttribute(request: WaitForAttributeRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    waitForAttribute(request: WaitForAttributeRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    waitForAttribute(request: WaitForAttributeRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    triggerContinueAsNew(request: TriggerContinueAsNewRequest, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    triggerContinueAsNew(request: TriggerContinueAsNewRequest, metadata: Metadata, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    triggerContinueAsNew(request: TriggerContinueAsNewRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: Empty) => void): ClientUnaryCall;
+    healthCheck(request: Empty, callback: (error: ServiceError | null, response: HealthInfo) => void): ClientUnaryCall;
+    healthCheck(request: Empty, metadata: Metadata, callback: (error: ServiceError | null, response: HealthInfo) => void): ClientUnaryCall;
+    healthCheck(request: Empty, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: HealthInfo) => void): ClientUnaryCall;
+}
+export declare const FlowServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): FlowServiceClient;
+    service: typeof FlowServiceService;
+    serviceName: string;
+};
+/** Hosted by Dex worker; server calls these RPCs. */
+export type WorkerServiceService = typeof WorkerServiceService;
+export declare const WorkerServiceService: {
+    readonly invokeWaitForMethod: {
+        readonly path: "/dex.WorkerService/InvokeWaitForMethod";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: InvokeWaitForMethodRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => InvokeWaitForMethodRequest;
+        readonly responseSerialize: (value: InvokeWaitForMethodResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => InvokeWaitForMethodResponse;
+    };
+    readonly invokeExecuteMethod: {
+        readonly path: "/dex.WorkerService/InvokeExecuteMethod";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: InvokeExecuteMethodRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => InvokeExecuteMethodRequest;
+        readonly responseSerialize: (value: InvokeExecuteMethodResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => InvokeExecuteMethodResponse;
+    };
+    readonly invokeWorkerRpc: {
+        readonly path: "/dex.WorkerService/InvokeWorkerRPC";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: InvokeWorkerRPCRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => InvokeWorkerRPCRequest;
+        readonly responseSerialize: (value: InvokeWorkerRPCResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => InvokeWorkerRPCResponse;
+    };
+};
+export interface WorkerServiceServer extends UntypedServiceImplementation {
+    invokeWaitForMethod: handleUnaryCall<InvokeWaitForMethodRequest, InvokeWaitForMethodResponse>;
+    invokeExecuteMethod: handleUnaryCall<InvokeExecuteMethodRequest, InvokeExecuteMethodResponse>;
+    invokeWorkerRpc: handleUnaryCall<InvokeWorkerRPCRequest, InvokeWorkerRPCResponse>;
+}
+export interface WorkerServiceClient extends Client {
+    invokeWaitForMethod(request: InvokeWaitForMethodRequest, callback: (error: ServiceError | null, response: InvokeWaitForMethodResponse) => void): ClientUnaryCall;
+    invokeWaitForMethod(request: InvokeWaitForMethodRequest, metadata: Metadata, callback: (error: ServiceError | null, response: InvokeWaitForMethodResponse) => void): ClientUnaryCall;
+    invokeWaitForMethod(request: InvokeWaitForMethodRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: InvokeWaitForMethodResponse) => void): ClientUnaryCall;
+    invokeExecuteMethod(request: InvokeExecuteMethodRequest, callback: (error: ServiceError | null, response: InvokeExecuteMethodResponse) => void): ClientUnaryCall;
+    invokeExecuteMethod(request: InvokeExecuteMethodRequest, metadata: Metadata, callback: (error: ServiceError | null, response: InvokeExecuteMethodResponse) => void): ClientUnaryCall;
+    invokeExecuteMethod(request: InvokeExecuteMethodRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: InvokeExecuteMethodResponse) => void): ClientUnaryCall;
+    invokeWorkerRpc(request: InvokeWorkerRPCRequest, callback: (error: ServiceError | null, response: InvokeWorkerRPCResponse) => void): ClientUnaryCall;
+    invokeWorkerRpc(request: InvokeWorkerRPCRequest, metadata: Metadata, callback: (error: ServiceError | null, response: InvokeWorkerRPCResponse) => void): ClientUnaryCall;
+    invokeWorkerRpc(request: InvokeWorkerRPCRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: InvokeWorkerRPCResponse) => void): ClientUnaryCall;
+}
+export declare const WorkerServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): WorkerServiceClient;
+    service: typeof WorkerServiceService;
+    serviceName: string;
+};
+/** Server-internal only (interpreter CAN activity → API). Not SDK-facing. */
+export type InternalServiceService = typeof InternalServiceService;
+export declare const InternalServiceService: {
+    readonly dumpFlowForContinueAsNew: {
+        readonly path: "/dex.InternalService/DumpFlowForContinueAsNew";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ContinueAsNewDumpRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ContinueAsNewDumpRequest;
+        readonly responseSerialize: (value: ContinueAsNewDumpResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ContinueAsNewDumpResponse;
+    };
+};
+export interface InternalServiceServer extends UntypedServiceImplementation {
+    dumpFlowForContinueAsNew: handleUnaryCall<ContinueAsNewDumpRequest, ContinueAsNewDumpResponse>;
+}
+export interface InternalServiceClient extends Client {
+    dumpFlowForContinueAsNew(request: ContinueAsNewDumpRequest, callback: (error: ServiceError | null, response: ContinueAsNewDumpResponse) => void): ClientUnaryCall;
+    dumpFlowForContinueAsNew(request: ContinueAsNewDumpRequest, metadata: Metadata, callback: (error: ServiceError | null, response: ContinueAsNewDumpResponse) => void): ClientUnaryCall;
+    dumpFlowForContinueAsNew(request: ContinueAsNewDumpRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: ContinueAsNewDumpResponse) => void): ClientUnaryCall;
+}
+export declare const InternalServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): InternalServiceClient;
+    service: typeof InternalServiceService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+    value: unknown;
+} ? {
+    $case: T["$case"];
+    value?: DeepPartial<T["value"]>;
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};