@superdurable/dex 1.9.0 → 1.10.0

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

@@ -1,9 +1,24 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientReadableStream, type ClientUnaryCall, type handleServerStreamingCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { type CallOptions, type ChannelCredentials, Client, type ClientDuplexStream, type ClientOptions, type ClientReadableStream, type ClientUnaryCall, type handleBidiStreamingCall, type handleServerStreamingCall, 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";
+/** Explains why a Worker declined a task. */
+export declare enum PollWorkerTaskRejectReason {
+    /** POLL_WORKER_TASK_REJECT_REASON_UNSPECIFIED - No rejection reason was supplied. */
+    POLL_WORKER_TASK_REJECT_REASON_UNSPECIFIED = 0,
+    /** POLL_WORKER_TASK_REJECT_REASON_NO_CAPACITY - All Worker execution slots are occupied. */
+    POLL_WORKER_TASK_REJECT_REASON_NO_CAPACITY = 1,
+    UNRECOGNIZED = -1
+}
+/** Distinguishes absence of a Worker from loss of an assigned Worker. */
+export declare enum DispatchTaskErrorReason {
+    DISPATCH_TASK_ERROR_REASON_UNSPECIFIED = 0,
+    DISPATCH_TASK_ERROR_REASON_NO_WORKER_AVAILABLE = 1,
+    DISPATCH_TASK_ERROR_REASON_WORKER_DISCONNECTED = 2,
+    UNRECOGNIZED = -1
+}
 export declare enum IndexType {
     INDEX_TYPE_UNSPECIFIED = 0,
     /** INDEX_TYPE_KEYWORD - Default for string/object when type is omitted. */
@@ -199,6 +214,200 @@ export interface ServerInfo {
     /** Newest protocol version implemented by this Server. */
     currentProtocolVersion: number;
 }
+/** Carries one Worker frame on a pull stream. Register must be the first frame. */
+export interface PollWorkerTaskRequest {
+    frame: //
+    /** Starts this queue stream; no other frame may precede registration. */
+    {
+        $case: "register";
+        value: PollWorkerTaskRegister;
+    } | //
+    /** Reports task progress or its final result. */
+    {
+        $case: "taskFrame";
+        value: PollWorkerTaskFrame;
+    } | //
+    /** Declines an assigned task when the Worker has no capacity. */
+    {
+        $case: "reject";
+        value: PollWorkerTaskReject;
+    } | //
+    /** Acknowledges a server liveness check. */
+    {
+        $case: "pong";
+        value: PollWorkerTaskPong;
+    } | undefined;
+}
+/** Registers one queue stream for a Worker process. */
+export interface PollWorkerTaskRegister {
+    /** Names this stream's queue: app_worker_id or one declared flow_type. */
+    queue: string;
+    /** Identifies this Worker process across reconnects; a restart uses a new ID. */
+    appWorkerId: string;
+    /** Lists the Flow types this Worker can execute. */
+    flowTypes: string[];
+    /** Identifies the SDK implementation for diagnostics. */
+    sdkName: string;
+    /** Identifies the SDK release for diagnostics. */
+    sdkVersion: string;
+}
+/** Carries a task's heartbeat, stream write, result, or Worker error. */
+export interface PollWorkerTaskFrame {
+    /** Matches the task_id sent by Dex on this stream. */
+    taskId: string;
+    output: //
+    /** Includes heartbeat, stream write, and final result variants. */
+    {
+        $case: "waitFor";
+        value: InvokeWaitForMethodOutput;
+    } | //
+    /** Includes heartbeat, stream write, and final result variants. */
+    {
+        $case: "execute";
+        value: InvokeExecuteMethodOutput;
+    } | //
+    /** Completes an RPC task. */
+    {
+        $case: "rpc";
+        value: InvokeWorkerRPCResponse;
+    } | //
+    /** Ends the task with a Worker error. */
+    {
+        $case: "workerError";
+        value: WorkerErrorResponse;
+    } | undefined;
+}
+/** Declines a task so Dex can assign it to another available Worker stream. */
+export interface PollWorkerTaskReject {
+    /** Matches the declined task on this stream. */
+    taskId: string;
+    /** Explains why the Worker cannot accept the task. */
+    reason: PollWorkerTaskRejectReason;
+}
+/** Acknowledges a server Ping on the same stream. */
+export interface PollWorkerTaskPong {
+}
+/** Carries one server frame on a pull stream. */
+export interface PollWorkerTaskResponse {
+    frame: //
+    /** Confirms that Dex accepted this stream's queue registration. */
+    {
+        $case: "registered";
+        value: PollWorkerTaskRegistered;
+    } | //
+    /** Assigns work to the registered Worker. */
+    {
+        $case: "task";
+        value: PollWorkerTask;
+    } | //
+    /** Requests cancellation of the assigned task. */
+    {
+        $case: "cancelTask";
+        value: PollWorkerTaskCancelTask;
+    } | //
+    /** Requests a reconnect after the current task finishes. */
+    {
+        $case: "reconnect";
+        value: PollWorkerTaskReconnect;
+    } | //
+    /** Checks whether an idle stream remains responsive. */
+    {
+        $case: "ping";
+        value: PollWorkerTaskPing;
+    } | undefined;
+}
+/** Confirms that Dex accepted the queue registration. */
+export interface PollWorkerTaskRegistered {
+}
+/** Assigns one task to this stream until its final result, error, or rejection. */
+export interface PollWorkerTask {
+    /** Identifies the assignment for result and cancellation frames. */
+    taskId: string;
+    /** Bounds task execution, including Worker processing time. */
+    deadline: Date | undefined;
+    request: //
+    /** Runs a Step's WaitFor method. */
+    {
+        $case: "waitFor";
+        value: InvokeWaitForMethodRequest;
+    } | //
+    /** Runs a Step's Execute method. */
+    {
+        $case: "execute";
+        value: InvokeExecuteMethodRequest;
+    } | //
+    /** Runs a Worker RPC. */
+    {
+        $case: "rpc";
+        value: InvokeWorkerRPCRequest;
+    } | undefined;
+}
+/** Requests cancellation of the task currently assigned to this stream. */
+export interface PollWorkerTaskCancelTask {
+    /** Matches the task currently assigned on this stream. */
+    taskId: string;
+}
+/** Asks the Worker to finish its task and reconnect for queue ownership changes or shutdown. */
+export interface PollWorkerTaskReconnect {
+    /** Explains why Dex needs a new queue stream. */
+    reason: string;
+}
+/** Checks that an idle pull stream remains responsive. */
+export interface PollWorkerTaskPing {
+}
+/** Describes one task dispatched to a Dex task queue. */
+export interface DispatchTaskRequest {
+    /** Selects the initial queue: a sticky Worker ID or a Flow type. */
+    queue: string;
+    /** Names the Flow type queue after a sticky wait expires. */
+    fallbackQueue: string;
+    /** Identifies the Flow for Worker affinity within a Flow type queue. */
+    flowId: string;
+    /** Limits waiting on a sticky queue before trying fallback_queue. */
+    stickyWait: Duration | undefined;
+    /** Limits total waiting for a Worker to accept the task. */
+    dispatchWait: Duration | undefined;
+    /** Bounds task execution, including Worker processing time. */
+    deadline: Date | undefined;
+    /** Identifies this dispatch across Worker and server streams. */
+    taskId: string;
+    request: {
+        $case: "waitFor";
+        value: InvokeWaitForMethodRequest;
+    } | {
+        $case: "execute";
+        value: InvokeExecuteMethodRequest;
+    } | {
+        $case: "rpc";
+        value: InvokeWorkerRPCRequest;
+    } | undefined;
+}
+/** Relays Worker output, then ends with a result, Worker error, or dispatch error. */
+export interface DispatchTaskResponse {
+    output: {
+        $case: "waitFor";
+        value: InvokeWaitForMethodOutput;
+    } | {
+        $case: "execute";
+        value: InvokeExecuteMethodOutput;
+    } | {
+        $case: "rpc";
+        value: InvokeWorkerRPCResponse;
+    } | {
+        $case: "workerError";
+        value: WorkerErrorResponse;
+    } | {
+        $case: "dispatchError";
+        value: DispatchTaskError;
+    } | undefined;
+    /** Identifies the Worker that produced the final result or Worker error. */
+    servedByAppWorkerId: string;
+}
+/** Reports a failure before Dex receives a Worker result. */
+export interface DispatchTaskError {
+    reason: DispatchTaskErrorReason;
+    detail: string;
+}
 export interface Value {
     kind: //
     /** Hydrate from blob storage, then replace with string_value. */
@@ -360,6 +569,8 @@ export interface WorkerTarget {
     /** Plaintext gRPC dial target, not an HTTP URL. */
     address: string;
     isHeadlessAddress: boolean;
+    /** Routes work through a connected pull Worker; mutually exclusive with address. */
+    isPullMode: boolean;
 }
 export interface StartFlowRequest {
     flowId: string;
@@ -926,6 +1137,8 @@ export interface WorkerErrorResponse {
     errorType: string;
     stackTrace: string;
     retryAfterSeconds: number;
+    /** Pull Workers set the gRPC code push mode would return; push mode uses its transport status. */
+    grpcStatus: number;
 }
 export interface InternalActivityError {
     serverDetail: string;
@@ -1259,6 +1472,8 @@ export interface ContinueAsNewDump {
     /** Stored values only; index metadata remains in backend search attributes. */
     attributes: KV[];
     pendingAttributeSyncItems: AttributeSyncItem[];
+    /** Retains the last serving Worker's sticky queue across a Flow continuation. */
+    dexTaskQueue: string;
 }
 export interface ContinueAsNewDump_ChannelReceivedEntry {
     key: string;
@@ -1280,16 +1495,6 @@ export interface InterpreterWorkflowInput {
     isResumeFromContinueAsNew: boolean;
     continueAsNewInput: ContinueAsNewInput | undefined;
     timeoutHandlerOptions: FlowTimeoutHandlerOptions | undefined;
-    /** Tenant of a multi-tenant Flow, set at start and copied to SubFlows. Empty in single-tenant mode. */
-    tenantId: string;
-    /** Verified claims of the starting tenant principal, used to check worker targets at every dispatch. */
-    tenantClaims: {
-        [key: string]: string;
-    };
-}
-export interface InterpreterWorkflowInput_TenantClaimsEntry {
-    key: string;
-    value: string;
 }
 export interface InterpreterWorkflowOutput {
     stepCompletionOutputs: StepCompletionOutput[];
@@ -1303,33 +1508,27 @@ export interface BlobStoreCleanupWorkflowOutput {
 export interface InvokeWaitForMethodActivityInput {
     workerTarget: WorkerTarget | undefined;
     request: InvokeWaitForMethodRequest | undefined;
-    /** Tenant of the dispatching Flow; empty in single-tenant mode. */
-    tenantId: string;
-    /** Claims of the Flow's tenant principal; empty in single-tenant mode. */
-    tenantClaims: {
-        [key: string]: string;
-    };
-}
-export interface InvokeWaitForMethodActivityInput_TenantClaimsEntry {
-    key: string;
-    value: string;
+    /** Selects the sticky Worker queue; empty selects the request's Flow type queue. */
+    dexTaskQueue: string;
+    /** Limits total waiting for a pull Worker to accept this attempt. */
+    dispatchWait: Duration | undefined;
+    /** Limits waiting on the sticky queue before the Flow type queue. */
+    stickyWait: Duration | undefined;
 }
 export interface InvokeWaitForMethodActivityOutput {
     response: InvokeWaitForMethodResponse | undefined;
+    /** Identifies the Worker that completed this pull task for sticky routing. */
+    servedByAppWorkerId: string;
 }
 export interface InvokeExecuteMethodActivityInput {
     workerTarget: WorkerTarget | undefined;
     request: InvokeExecuteMethodRequest | undefined;
-    /** Tenant of the dispatching Flow; empty in single-tenant mode. */
-    tenantId: string;
-    /** Claims of the Flow's tenant principal; empty in single-tenant mode. */
-    tenantClaims: {
-        [key: string]: string;
-    };
-}
-export interface InvokeExecuteMethodActivityInput_TenantClaimsEntry {
-    key: string;
-    value: string;
+    /** Selects the sticky Worker queue; empty selects the request's Flow type queue. */
+    dexTaskQueue: string;
+    /** Limits total waiting for a pull Worker to accept this attempt. */
+    dispatchWait: Duration | undefined;
+    /** Limits waiting on the sticky queue before the Flow type queue. */
+    stickyWait: Duration | undefined;
 }
 export interface RecoveryErrorInfo {
     detail: string;
@@ -1344,6 +1543,8 @@ export interface InternalLocalStepActivityFailure {
 }
 export interface InvokeExecuteMethodActivityOutput {
     response: InvokeExecuteMethodResponse | undefined;
+    /** Identifies the Worker that completed this pull task for sticky routing. */
+    servedByAppWorkerId: string;
 }
 export interface DumpFlowForContinueAsNewActivityInput {
     request: ContinueAsNewDumpRequest | undefined;
@@ -1354,21 +1555,13 @@ export interface DumpFlowForContinueAsNewActivityOutput {
 export interface InvokeWorkerRPCActivityInput {
     rpcPrep: PrepareRpcQueryResponse | undefined;
     request: InvokeRPCRequest | undefined;
-    /** Tenant of the Flow; empty in single-tenant mode. */
-    tenantId: string;
-    /** Claims of the Flow's tenant principal; empty in single-tenant mode. */
-    tenantClaims: {
-        [key: string]: string;
-    };
-}
-export interface InvokeWorkerRPCActivityInput_TenantClaimsEntry {
-    key: string;
-    value: string;
 }
 export interface InvokeWorkerRPCActivityOutput {
     response: InvokeWorkerRPCResponse | undefined;
     /** Correlates this local Activity result with its InvokeRpc Update. */
     requestId: string;
+    /** Identifies the Worker that completed this pull task for sticky routing. */
+    servedByAppWorkerId: string;
 }
 export interface CleanupBlobStoreActivityInput {
     storeId: string;
@@ -1391,16 +1584,6 @@ export interface StartSubFlowActivityInput {
     parentFlowConfig: FlowConfig | undefined;
     /** Source Step; activity context supplies parent Flow and run IDs. */
     parentStepExecutionId: string;
-    /** Tenant of the parent Flow, inherited by the SubFlow; empty in single-tenant mode. */
-    tenantId: string;
-    /** Claims of the Flow's tenant principal; empty in single-tenant mode. */
-    tenantClaims: {
-        [key: string]: string;
-    };
-}
-export interface StartSubFlowActivityInput_TenantClaimsEntry {
-    key: string;
-    value: string;
 }
 export interface StartSubFlowActivityOutput {
     immediateFlowResult: FlowResult | undefined;
@@ -1462,6 +1645,8 @@ export interface PrepareRpcQueryResponse {
     loadedAttributeMapInstances: string[];
     loadedChannelNames: string[];
     loadedChannelMapInstances: string[];
+    /** Selects the last Worker queue for RPC dispatch. */
+    dexTaskQueue: string;
 }
 export interface PrepareRpcQueryResponse_ChannelInfosEntry {
     key: string;
@@ -1506,38 +1691,21 @@ export interface InvokeRpcUpdateResult {
 export interface StepExecutionNumbers {
     numbers: number[];
 }
-export interface TenantAdminState {
-    tenantId: string;
-    isTombstoned: boolean;
-    tombstonedTime: Date | undefined;
-    /** Set when a purge has found nothing left in two queries a confirmation delay apart. */
-    purgeDoneTime: Date | undefined;
-    /** After this time the tombstone is removed and the tenant ID may be reused. */
-    tombstoneExpiryTime: Date | undefined;
-}
-export interface TombstoneTenantRequest {
-    tenantId: string;
-}
-export interface TombstoneTenantResponse {
-    state: TenantAdminState | undefined;
-}
-export interface PurgeTenantRequest {
-    tenantId: string;
-}
-export interface PurgeTenantResponse {
-    state: TenantAdminState | undefined;
-    terminatedExecutions: number;
-    deletedExecutions: number;
-    deletedBlobObjects: number;
-    done: boolean;
-}
-export interface DescribeTenantRequest {
-    tenantId: string;
-}
-export interface DescribeTenantResponse {
-    state: TenantAdminState | undefined;
-}
 export declare const ServerInfo: MessageFns<ServerInfo>;
+export declare const PollWorkerTaskRequest: MessageFns<PollWorkerTaskRequest>;
+export declare const PollWorkerTaskRegister: MessageFns<PollWorkerTaskRegister>;
+export declare const PollWorkerTaskFrame: MessageFns<PollWorkerTaskFrame>;
+export declare const PollWorkerTaskReject: MessageFns<PollWorkerTaskReject>;
+export declare const PollWorkerTaskPong: MessageFns<PollWorkerTaskPong>;
+export declare const PollWorkerTaskResponse: MessageFns<PollWorkerTaskResponse>;
+export declare const PollWorkerTaskRegistered: MessageFns<PollWorkerTaskRegistered>;
+export declare const PollWorkerTask: MessageFns<PollWorkerTask>;
+export declare const PollWorkerTaskCancelTask: MessageFns<PollWorkerTaskCancelTask>;
+export declare const PollWorkerTaskReconnect: MessageFns<PollWorkerTaskReconnect>;
+export declare const PollWorkerTaskPing: MessageFns<PollWorkerTaskPing>;
+export declare const DispatchTaskRequest: MessageFns<DispatchTaskRequest>;
+export declare const DispatchTaskResponse: MessageFns<DispatchTaskResponse>;
+export declare const DispatchTaskError: MessageFns<DispatchTaskError>;
 export declare const Value: MessageFns<Value>;
 export declare const EncodedObject: MessageFns<EncodedObject>;
 export declare const AttributeWrite: MessageFns<AttributeWrite>;
@@ -1688,29 +1856,24 @@ 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 InterpreterWorkflowInput_TenantClaimsEntry: MessageFns<InterpreterWorkflowInput_TenantClaimsEntry>;
 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 InvokeWaitForMethodActivityInput_TenantClaimsEntry: MessageFns<InvokeWaitForMethodActivityInput_TenantClaimsEntry>;
 export declare const InvokeWaitForMethodActivityOutput: MessageFns<InvokeWaitForMethodActivityOutput>;
 export declare const InvokeExecuteMethodActivityInput: MessageFns<InvokeExecuteMethodActivityInput>;
-export declare const InvokeExecuteMethodActivityInput_TenantClaimsEntry: MessageFns<InvokeExecuteMethodActivityInput_TenantClaimsEntry>;
 export declare const RecoveryErrorInfo: MessageFns<RecoveryErrorInfo>;
 export declare const InternalLocalStepActivityFailure: MessageFns<InternalLocalStepActivityFailure>;
 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 InvokeWorkerRPCActivityInput_TenantClaimsEntry: MessageFns<InvokeWorkerRPCActivityInput_TenantClaimsEntry>;
 export declare const InvokeWorkerRPCActivityOutput: MessageFns<InvokeWorkerRPCActivityOutput>;
 export declare const CleanupBlobStoreActivityInput: MessageFns<CleanupBlobStoreActivityInput>;
 export declare const CleanupBlobStoreActivityOutput: MessageFns<CleanupBlobStoreActivityOutput>;
 export declare const AttributeSyncItem: MessageFns<AttributeSyncItem>;
 export declare const SyncAttributeBatchActivityInput: MessageFns<SyncAttributeBatchActivityInput>;
 export declare const StartSubFlowActivityInput: MessageFns<StartSubFlowActivityInput>;
-export declare const StartSubFlowActivityInput_TenantClaimsEntry: MessageFns<StartSubFlowActivityInput_TenantClaimsEntry>;
 export declare const StartSubFlowActivityOutput: MessageFns<StartSubFlowActivityOutput>;
 export declare const SubFlowCompletionSignalRequest: MessageFns<SubFlowCompletionSignalRequest>;
 export declare const ReportSubFlowCompletionActivityInput: MessageFns<ReportSubFlowCompletionActivityInput>;
@@ -1732,13 +1895,6 @@ export declare const GetScheduledGreedyTimerTimesQueryResponse: MessageFns<GetSc
 export declare const DebugDumpResponse: MessageFns<DebugDumpResponse>;
 export declare const InvokeRpcUpdateResult: MessageFns<InvokeRpcUpdateResult>;
 export declare const StepExecutionNumbers: MessageFns<StepExecutionNumbers>;
-export declare const TenantAdminState: MessageFns<TenantAdminState>;
-export declare const TombstoneTenantRequest: MessageFns<TombstoneTenantRequest>;
-export declare const TombstoneTenantResponse: MessageFns<TombstoneTenantResponse>;
-export declare const PurgeTenantRequest: MessageFns<PurgeTenantRequest>;
-export declare const PurgeTenantResponse: MessageFns<PurgeTenantResponse>;
-export declare const DescribeTenantRequest: MessageFns<DescribeTenantRequest>;
-export declare const DescribeTenantResponse: MessageFns<DescribeTenantResponse>;
 /** Hosted by Dex server; SDKs call these RPCs. */
 export type FlowServiceService = typeof FlowServiceService;
 export declare const FlowServiceService: {
@@ -2156,68 +2312,80 @@ export declare const WorkerServiceClient: {
     service: typeof WorkerServiceService;
     serviceName: string;
 };
-/**
- * Server-internal only (interpreter CAN activity → API). Not SDK-facing.
- * TenantAdminService manages the tenants of a multi-tenant server. Only operator principals may call it.
- * Every RPC names its tenant explicitly and never returns Flow data.
- */
-export type TenantAdminServiceService = typeof TenantAdminServiceService;
-export declare const TenantAdminServiceService: {
-    /** Refuses every credential of the tenant within the tombstone refresh interval. Idempotent. */
-    readonly tombstoneTenant: {
-        readonly path: "/dex.TenantAdminService/TombstoneTenant";
-        readonly requestStream: false;
-        readonly responseStream: false;
-        readonly requestSerialize: (value: TombstoneTenantRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => TombstoneTenantRequest;
-        readonly responseSerialize: (value: TombstoneTenantResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => TombstoneTenantResponse;
+/** Hosted by Dex server; pull Workers open one queue stream for at most one task at a time. */
+export type WorkerTaskServiceService = typeof WorkerTaskServiceService;
+export declare const WorkerTaskServiceService: {
+    /** Exchanges registration, task, result, and control frames for one Dex task queue. */
+    readonly pollWorkerTask: {
+        readonly path: "/dex.WorkerTaskService/PollWorkerTask";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: PollWorkerTaskRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PollWorkerTaskRequest;
+        readonly responseSerialize: (value: PollWorkerTaskResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PollWorkerTaskResponse;
     };
-    /** Deletes one bounded batch of the tombstoned tenant's data. Repeat until done is true. */
-    readonly purgeTenant: {
-        readonly path: "/dex.TenantAdminService/PurgeTenant";
+};
+export interface WorkerTaskServiceServer extends UntypedServiceImplementation {
+    /** Exchanges registration, task, result, and control frames for one Dex task queue. */
+    pollWorkerTask: handleBidiStreamingCall<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export interface WorkerTaskServiceClient extends Client {
+    /** Exchanges registration, task, result, and control frames for one Dex task queue. */
+    pollWorkerTask(): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    pollWorkerTask(options: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    pollWorkerTask(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export declare const WorkerTaskServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): WorkerTaskServiceClient;
+    service: typeof WorkerTaskServiceService;
+    serviceName: string;
+};
+/** Hosted on the internal listener; server instances route tasks and Worker streams to queue owners. */
+export type MatchingServiceService = typeof MatchingServiceService;
+export declare const MatchingServiceService: {
+    /** Streams Worker output frames and a final result or dispatch error. */
+    readonly dispatchTask: {
+        readonly path: "/dex.MatchingService/DispatchTask";
         readonly requestStream: false;
-        readonly responseStream: false;
-        readonly requestSerialize: (value: PurgeTenantRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => PurgeTenantRequest;
-        readonly responseSerialize: (value: PurgeTenantResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => PurgeTenantResponse;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: DispatchTaskRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DispatchTaskRequest;
+        readonly responseSerialize: (value: DispatchTaskResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DispatchTaskResponse;
     };
-    readonly describeTenant: {
-        readonly path: "/dex.TenantAdminService/DescribeTenant";
-        readonly requestStream: false;
-        readonly responseStream: false;
-        readonly requestSerialize: (value: DescribeTenantRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => DescribeTenantRequest;
-        readonly responseSerialize: (value: DescribeTenantResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => DescribeTenantResponse;
+    /** Proxies a Worker's queue stream from its receiving instance to the queue owner. */
+    readonly forwardPollWorkerTask: {
+        readonly path: "/dex.MatchingService/ForwardPollWorkerTask";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: PollWorkerTaskRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PollWorkerTaskRequest;
+        readonly responseSerialize: (value: PollWorkerTaskResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PollWorkerTaskResponse;
     };
 };
-export interface TenantAdminServiceServer extends UntypedServiceImplementation {
-    /** Refuses every credential of the tenant within the tombstone refresh interval. Idempotent. */
-    tombstoneTenant: handleUnaryCall<TombstoneTenantRequest, TombstoneTenantResponse>;
-    /** Deletes one bounded batch of the tombstoned tenant's data. Repeat until done is true. */
-    purgeTenant: handleUnaryCall<PurgeTenantRequest, PurgeTenantResponse>;
-    describeTenant: handleUnaryCall<DescribeTenantRequest, DescribeTenantResponse>;
-}
-export interface TenantAdminServiceClient extends Client {
-    /** Refuses every credential of the tenant within the tombstone refresh interval. Idempotent. */
-    tombstoneTenant(request: TombstoneTenantRequest, callback: (error: ServiceError | null, response: TombstoneTenantResponse) => void): ClientUnaryCall;
-    tombstoneTenant(request: TombstoneTenantRequest, metadata: Metadata, callback: (error: ServiceError | null, response: TombstoneTenantResponse) => void): ClientUnaryCall;
-    tombstoneTenant(request: TombstoneTenantRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: TombstoneTenantResponse) => void): ClientUnaryCall;
-    /** Deletes one bounded batch of the tombstoned tenant's data. Repeat until done is true. */
-    purgeTenant(request: PurgeTenantRequest, callback: (error: ServiceError | null, response: PurgeTenantResponse) => void): ClientUnaryCall;
-    purgeTenant(request: PurgeTenantRequest, metadata: Metadata, callback: (error: ServiceError | null, response: PurgeTenantResponse) => void): ClientUnaryCall;
-    purgeTenant(request: PurgeTenantRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: PurgeTenantResponse) => void): ClientUnaryCall;
-    describeTenant(request: DescribeTenantRequest, callback: (error: ServiceError | null, response: DescribeTenantResponse) => void): ClientUnaryCall;
-    describeTenant(request: DescribeTenantRequest, metadata: Metadata, callback: (error: ServiceError | null, response: DescribeTenantResponse) => void): ClientUnaryCall;
-    describeTenant(request: DescribeTenantRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: DescribeTenantResponse) => void): ClientUnaryCall;
-}
-export declare const TenantAdminServiceClient: {
-    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): TenantAdminServiceClient;
-    service: typeof TenantAdminServiceService;
+export interface MatchingServiceServer extends UntypedServiceImplementation {
+    /** Streams Worker output frames and a final result or dispatch error. */
+    dispatchTask: handleServerStreamingCall<DispatchTaskRequest, DispatchTaskResponse>;
+    /** Proxies a Worker's queue stream from its receiving instance to the queue owner. */
+    forwardPollWorkerTask: handleBidiStreamingCall<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export interface MatchingServiceClient extends Client {
+    /** Streams Worker output frames and a final result or dispatch error. */
+    dispatchTask(request: DispatchTaskRequest, options?: Partial<CallOptions>): ClientReadableStream<DispatchTaskResponse>;
+    dispatchTask(request: DispatchTaskRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<DispatchTaskResponse>;
+    /** Proxies a Worker's queue stream from its receiving instance to the queue owner. */
+    forwardPollWorkerTask(): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    forwardPollWorkerTask(options: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    forwardPollWorkerTask(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export declare const MatchingServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): MatchingServiceClient;
+    service: typeof MatchingServiceService;
     serviceName: string;
 };
+/** Server-internal only (interpreter CAN activity → API). Not SDK-facing. */
 export type InternalServiceService = typeof InternalServiceService;
 export declare const InternalServiceService: {
     readonly dumpFlowForContinueAsNew: {