@hatchet-dev/typescript-sdk 1.15.2 → 1.17.0

package/README.md

@@ -63,9 +63,21 @@ pnpm install
 pnpm build
 ```
 
-3. Run tests:
+3. Run unit tests:
 ```bash
-pnpm test
+pnpm test:unit
+```
+
+4. Run e2e tests (requires a running Hatchet engine):
+```bash
+# Run all e2e tests
+pnpm test:e2e
+
+# Run a specific e2e test file
+pnpm test:e2e durable.e2e.ts
+
+# Run a specific test by name
+pnpm test:e2e durable.e2e.ts -t "durable replay reset"
 ```
 
 ## Contributing

package/clients/admin/admin-client.d.ts

@@ -1,10 +1,10 @@
 import { Channel, ClientFactory } from 'nice-grpc';
-import { CreateWorkflowVersionOpts, RateLimitDuration, WorkerLabelComparator, WorkflowServiceClient } from '../../protoc/workflows';
+import { CreateWorkflowVersionOpts, RateLimitDuration, WorkflowServiceClient } from '../../protoc/workflows';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
-import { Priority, RunsClient } from '../../v1';
+import { Priority, RunsClient, WorkerLabelComparator } from '../../v1';
 import { Api } from '../rest';
 import { WebhookWorkerCreateRequest, WorkflowRunStatus, WorkflowRunStatusList } from '../rest/generated/data-contracts';
 import { RunListenerClient } from '../listeners/run-listener/child-listener-client';

package/clients/admin/admin-client.js

@@ -25,7 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
 const workflows_1 = require("../../protoc/workflows");
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const hatchet_error_1 = require("../../util/errors/hatchet-error");
 const retrier_1 = require("../../util/retrier");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
 const workflows_2 = require("../../protoc/v1/workflows");
@@ -72,7 +72,7 @@ class AdminClient {
                 return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.putWorkflow({ opts: workflow }); }), this.logger);
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }
@@ -87,7 +87,7 @@ class AdminClient {
                 return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.v1Client.putWorkflow(workflow); }), this.logger);
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }
@@ -114,7 +114,7 @@ class AdminClient {
                 }), this.logger);
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }
@@ -153,7 +153,7 @@ class AdminClient {
             return new workflow_run_ref_1.default(resp, this.listenerClient, this.workflows, options === null || options === void 0 ? void 0 : options.parentId);
         }
         catch (e) {
-            throw new hatchet_error_1.default(e.message);
+            throw (0, hatchet_error_1.toHatchetError)(e);
         }
     }
     /**
@@ -186,7 +186,7 @@ class AdminClient {
             });
         }
         catch (e) {
-            throw new hatchet_error_1.default(e.message);
+            throw (0, hatchet_error_1.toHatchetError)(e);
         }
     }
     /**
@@ -301,9 +301,8 @@ class AdminClient {
      * @deprecated use hatchet.schedules.create instead
      */
     scheduleWorkflow(name, options) {
-        let computedName = name;
         try {
-            computedName = (0, apply_namespace_1.applyNamespace)(name, this.config.namespace);
+            const computedName = (0, apply_namespace_1.applyNamespace)(name, this.config.namespace);
             let input;
             if (options === null || options === void 0 ? void 0 : options.input) {
                 input = JSON.stringify(options.input);
@@ -315,7 +314,7 @@ class AdminClient {
             });
         }
         catch (e) {
-            throw new hatchet_error_1.default(e.message);
+            throw (0, hatchet_error_1.toHatchetError)(e);
         }
     }
     /**

package/clients/dispatcher/action-listener.d.ts

@@ -7,14 +7,11 @@ declare enum ListenStrategy {
     LISTEN_STRATEGY_V1 = 1,
     LISTEN_STRATEGY_V2 = 2
 }
+export type ActionKey = `${string}/${number}`;
 export type Action = AssignedAction & {
-    /** @deprecated use taskRunId */
-    stepRunId?: string;
-    /** @deprecated use taskId */
-    stepId?: string;
+    readonly key: ActionKey;
 };
-export type ActionKey = string;
-export declare function createActionKey(action: Action): ActionKey;
+export declare function createAction(assignedAction: AssignedAction): Action;
 export declare class ActionListener {
     config: ClientConfig;
     client: PbDispatcherClient;

package/clients/dispatcher/action-listener.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -33,34 +66,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionListener = void 0;
-exports.createActionKey = createActionKey;
-const dispatcher_1 = require("../../protoc/dispatcher");
+exports.createAction = createAction;
 const nice_grpc_1 = require("nice-grpc");
+const grpc_error_1 = require("../../util/grpc-error");
 const abort_controller_x_1 = require("abort-controller-x");
 const sleep_1 = __importDefault(require("../../util/sleep"));
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const hatchet_error_1 = __importStar(require("../../util/errors/hatchet-error"));
 const heartbeat_controller_1 = require("./heartbeat/heartbeat-controller");
 const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 20;
-// eslint-disable-next-line no-shadow
 var ListenStrategy;
 (function (ListenStrategy) {
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
 })(ListenStrategy || (ListenStrategy = {}));
-function createActionKey(action) {
-    switch (action.actionType) {
-        case dispatcher_1.ActionType.START_GET_GROUP_KEY:
-            return `${action.getGroupKeyRunId}/${action.retryCount}`;
-        case dispatcher_1.ActionType.CANCEL_STEP_RUN:
-        case dispatcher_1.ActionType.START_STEP_RUN:
-        case dispatcher_1.ActionType.UNRECOGNIZED:
-            return `${action.taskRunExternalId}/${action.retryCount}`;
-        default:
-            // eslint-disable-next-line no-case-declarations
-            const exhaustivenessCheck = action.actionType;
-            throw new Error(`Unhandled action type: ${exhaustivenessCheck}`);
-    }
+function createAction(assignedAction) {
+    const action = assignedAction;
+    Object.defineProperty(action, 'key', {
+        get() {
+            return `${this.taskRunExternalId}/${this.retryCount}`;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    return action;
 }
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
@@ -84,8 +113,7 @@ class ActionListener {
                                 _c = listenClient_1_1.value;
                                 _d = false;
                                 const assignedAction = _c;
-                                const action = Object.assign(Object.assign({}, assignedAction), { stepRunId: assignedAction.taskRunExternalId, stepId: assignedAction.taskId });
-                                yield yield __await(action);
+                                yield yield __await(createAction(assignedAction));
                             }
                         }
                         catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -108,11 +136,11 @@ class ActionListener {
                             throw e;
                         }
                         if ((yield __await(client.getListenStrategy())) === ListenStrategy.LISTEN_STRATEGY_V2 &&
-                            e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                            (0, grpc_error_1.getGrpcErrorCode)(e) === nice_grpc_1.Status.UNIMPLEMENTED) {
                             client.setListenStrategy(ListenStrategy.LISTEN_STRATEGY_V1);
                         }
                         client.incrementRetries();
-                        client.logger.error(`Listener encountered an error: ${e.message}`);
+                        client.logger.error(`Listener encountered an error: ${(0, hatchet_error_1.getErrorMessage)(e)}`);
                         if (client.retries > 1) {
                             client.logger.info(`Retrying in ${client.retryInterval}ms...`);
                             yield __await((0, sleep_1.default)(client.retryInterval));
@@ -186,7 +214,7 @@ class ActionListener {
             catch (e) {
                 this.retries += 1;
                 this.logger.error(`Attempt ${this.retries}: Failed to connect, retrying...`);
-                if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
+                if ((0, grpc_error_1.getGrpcErrorCode)(e) === nice_grpc_1.Status.UNAVAILABLE) {
                     // Connection lost, reset heartbeat interval and retry connection
                     this.heartbeat.stop();
                     return this.getListenClient();
@@ -209,7 +237,10 @@ class ActionListener {
                 });
             }
             catch (e) {
-                throw new hatchet_error_1.default(`Failed to unsubscribe: ${e.message}`);
+                throw (0, hatchet_error_1.toHatchetError)(e, {
+                    defaultMessage: 'Failed to unsubscribe',
+                    prefix: 'Failed to unsubscribe: ',
+                });
             }
         });
     }

package/clients/dispatcher/dispatcher-client.js

@@ -19,14 +19,11 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DispatcherClient = void 0;
 exports.mapLabels = mapLabels;
 const dispatcher_1 = require("../../protoc/dispatcher");
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const hatchet_error_1 = require("../../util/errors/hatchet-error");
 const retrier_1 = require("../../util/retrier");
 const version_1 = require("../../version");
 const slot_types_1 = require("../../v1/slot-types");
@@ -82,7 +79,7 @@ class DispatcherClient {
                 return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendStepActionEvent(event); }), this.logger);
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }
@@ -92,7 +89,7 @@ class DispatcherClient {
                 return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendGroupKeyActionEvent(in_); }), this.logger);
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }
@@ -112,7 +109,7 @@ class DispatcherClient {
                 });
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }
@@ -125,7 +122,7 @@ class DispatcherClient {
                 });
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                throw (0, hatchet_error_1.toHatchetError)(e);
             }
         });
     }

package/clients/dispatcher/heartbeat/heartbeat-worker.js

@@ -13,6 +13,8 @@ const worker_threads_1 = require("worker_threads");
 const hatchet_client_1 = require("../../hatchet-client");
 const config_loader_1 = require("../../../util/config-loader");
 const nice_grpc_1 = require("nice-grpc");
+const hatchet_error_1 = require("../../../util/errors/hatchet-error");
+const grpc_error_1 = require("../../../util/grpc-error");
 const grpc_helpers_1 = require("../../../util/grpc-helpers");
 const dispatcher_client_1 = require("../dispatcher-client");
 const heartbeat_controller_1 = require("./heartbeat-controller");
@@ -69,7 +71,7 @@ class HeartbeatWorker {
                     this.timeLastHeartbeat = now;
                 }
                 catch (e) {
-                    if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                    if ((0, grpc_error_1.getGrpcErrorCode)(e) === nice_grpc_1.Status.UNIMPLEMENTED) {
                         // break out of interval
                         const message = 'Heartbeat not implemented, closing heartbeat';
                         this.logger.debug(message);
@@ -80,7 +82,7 @@ class HeartbeatWorker {
                         this.stop();
                         return;
                     }
-                    const message = `Failed to send heartbeat: ${e.message}`;
+                    const message = `Failed to send heartbeat: ${(0, hatchet_error_1.getErrorMessage)(e)}`;
                     this.logger.debug(message);
                     postMessage({
                         type: 'error',
@@ -96,13 +98,14 @@ class HeartbeatWorker {
     stop() {
         if (this.heartbeatInterval) {
             clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
+            this.heartbeatInterval = undefined;
         }
     }
 }
 const heartbeat = new HeartbeatWorker(worker_threads_1.workerData.config, worker_threads_1.workerData.workerId);
 heartbeat.start();
 worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.on('message', (msg) => {
-    if (msg === heartbeat_controller_1.STOP_HEARTBEAT)
+    if (msg === heartbeat_controller_1.STOP_HEARTBEAT) {
         heartbeat.stop();
+    }
 });

package/clients/event/event-client.d.ts

@@ -17,7 +17,7 @@ export interface PushEventOptions {
 }
 export interface EventWithMetadata<T> {
     payload: T;
-    additionalMetadata?: Record<string, any>;
+    additionalMetadata?: Record<string, unknown>;
     priority?: number;
     scope?: string;
 }
@@ -31,7 +31,7 @@ export declare class EventClient {
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: HatchetClient['api']);
     push<T>(type: string, input: T, options?: PushEventOptions): Promise<import("../../protoc/events/events").Event>;
     bulkPush<T>(type: string, inputs: EventWithMetadata<T>[], options?: PushEventOptions): Promise<import("../../protoc/events/events").Events>;
-    putLog(taskRunExternalId: string, log: string, level?: LogLevel, taskRetryCount?: number, metadata?: Record<string, any>): Promise<void>;
+    putLog(taskRunExternalId: string, log: string, level?: LogLevel, taskRetryCount?: number, metadata?: Record<string, unknown>): Promise<void>;
     putStream(taskRunExternalId: string, data: string | Uint8Array, index: number | undefined): Promise<void>;
     list(opts?: Parameters<typeof this.api.v1EventList>[1]): Promise<import("../rest/generated/data-contracts").V1EventList>;
 }

package/clients/event/event-client.js

@@ -8,16 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventClient = exports.LogLevel = void 0;
 const events_1 = require("../../protoc/events/events");
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const hatchet_error_1 = require("../../util/errors/hatchet-error");
 const retrier_1 = require("../../util/retrier");
 const apply_namespace_1 = require("../../util/apply-namespace");
-// eslint-disable-next-line no-shadow
 var LogLevel;
 (function (LogLevel) {
     LogLevel["INFO"] = "INFO";
@@ -52,7 +48,7 @@ class EventClient {
             return e;
         }
         catch (e) {
-            throw new hatchet_error_1.default(e.message);
+            throw (0, hatchet_error_1.toHatchetError)(e);
         }
     }
     bulkPush(type, inputs, options = {}) {
@@ -84,7 +80,7 @@ class EventClient {
             return res;
         }
         catch (e) {
-            throw new hatchet_error_1.default(e.message);
+            throw (0, hatchet_error_1.toHatchetError)(e);
         }
     }
     putLog(taskRunExternalId, log, level, taskRetryCount, metadata) {
@@ -105,8 +101,7 @@ class EventClient {
                 metadata: metadata ? JSON.stringify(metadata) : undefined,
             })
                 .catch((e) => {
-                // log a warning, but this is not a fatal error
-                this.logger.warn(`Could not put log: ${e.message}`);
+                this.logger.warn(`Could not put log: ${(0, hatchet_error_1.getErrorMessage)(e)}`);
             });
         });
     }
@@ -131,8 +126,7 @@ class EventClient {
                     eventIndex: index,
                 });
             }), this.logger).catch((e) => {
-                // log a warning, but this is not a fatal error
-                this.logger.warn(`Could not put log: ${e.message}`);
+                this.logger.warn(`Could not put log: ${(0, hatchet_error_1.getErrorMessage)(e)}`);
             });
         });
     }

package/clients/hatchet-client/hatchet-logger.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HatchetLogger = exports.DEFAULT_LOGGER = void 0;
-/* eslint-disable no-console */
 const logger_1 = require("../../util/logger");
 const DEFAULT_LOGGER = (context, logLevel) => new HatchetLogger(context, logLevel);
 exports.DEFAULT_LOGGER = DEFAULT_LOGGER;
@@ -20,6 +19,7 @@ class HatchetLogger {
         this.context = context;
     }
     log(level, message, color = '37') {
+        var _a;
         if (logger_1.LogLevelEnum[level] >= logger_1.LogLevelEnum[this.logLevel]) {
             const time = new Date().toLocaleString('en-US', {
                 month: '2-digit',
@@ -29,22 +29,13 @@ class HatchetLogger {
                 minute: '2-digit',
                 second: '2-digit',
             });
-            // eslint-disable-next-line prefer-destructuring
-            let print = console.log;
-            if (level === 'ERROR') {
-                print = console.error;
-            }
-            if (level === 'WARN') {
-                print = console.warn;
-            }
-            if (level === 'INFO') {
-                print = console.info;
-            }
-            if (level === 'DEBUG') {
-                print = console.debug;
-            }
-            // eslint-disable-next-line no-console
-            print(`🪓 ${process.pid} | ${time} ${color && `\x1b[${color || ''}m`} [${level}/${this.context}] ${message}\x1b[0m`);
+            const logFn = {
+                ERROR: console.error,
+                WARN: console.warn,
+                INFO: console.info,
+                DEBUG: console.debug,
+            };
+            ((_a = logFn[level]) !== null && _a !== void 0 ? _a : console.log)(`🪓 ${process.pid} | ${time} ${color && `\x1b[${color || ''}m`} [${level}/${this.context}] ${message}\x1b[0m`);
         }
     }
     debug(message) {

package/clients/listeners/durable-listener/durable-listener-client.d.ts

@@ -1,31 +1,131 @@
+import { EventEmitter } from 'events';
 import { Channel, ClientFactory } from 'nice-grpc';
 import { ClientConfig } from '../../hatchet-client/client-config';
 import { Logger } from '../../../util/logger';
-import { V1DispatcherClient } from '../../../protoc/v1/dispatcher';
-import { SleepMatchCondition, UserEventMatchCondition } from '../../../protoc/v1/shared/condition';
-import { Api } from '../../rest';
-import { DurableEventGrpcPooledListener } from './pooled-durable-listener-client';
+import { V1DispatcherClient, DurableEvent, RegisterDurableEventResponse } from '../../../protoc/v1/dispatcher';
+import { DurableEventListenerConditions, SleepMatchCondition, UserEventMatchCondition } from '../../../protoc/v1/shared/condition';
+import { TriggerWorkflowRequest } from '../../../protoc/v1/shared/trigger';
+export interface DurableTaskRunAckEntryResult {
+    nodeId: number;
+    branchId: number;
+}
+export interface DurableTaskEventRunAck {
+    ackType: 'run';
+    invocationCount: number;
+    durableTaskExternalId: string;
+    runEntries: DurableTaskRunAckEntryResult[];
+}
+export interface DurableTaskEventMemoAck {
+    ackType: 'memo';
+    invocationCount: number;
+    durableTaskExternalId: string;
+    branchId: number;
+    nodeId: number;
+    memoAlreadyExisted: boolean;
+    memoResultPayload?: Uint8Array;
+}
+export interface DurableTaskEventWaitForAck {
+    ackType: 'waitFor';
+    invocationCount: number;
+    durableTaskExternalId: string;
+    branchId: number;
+    nodeId: number;
+}
+export type DurableTaskEventAck = DurableTaskEventRunAck | DurableTaskEventMemoAck | DurableTaskEventWaitForAck;
+export interface DurableTaskEventLogEntryResult {
+    durableTaskExternalId: string;
+    nodeId: number;
+    payload: Record<string, unknown> | undefined;
+}
+export interface WaitForEvent {
+    kind: 'waitFor';
+    waitForConditions: DurableEventListenerConditions;
+}
+export interface RunChildrenEvent {
+    kind: 'runChildren';
+    triggerOpts: TriggerWorkflowRequest[];
+}
+export interface MemoEvent {
+    kind: 'memo';
+    memoKey: Uint8Array;
+    payload?: Uint8Array;
+}
+export type DurableTaskSendEvent = WaitForEvent | RunChildrenEvent | MemoEvent;
 export declare class DurableListenerClient {
     config: ClientConfig;
     client: V1DispatcherClient;
     logger: Logger;
-    api: Api;
-    pooledListener: DurableEventGrpcPooledListener | undefined;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api);
+    private _workerId;
+    private _running;
+    private _requestQueue;
+    private _requestNotify;
+    private _pendingEventAcks;
+    private _pendingCallbacks;
+    private _bufferedCompletions;
+    private _pendingEvictionAcks;
+    private _receiveAbort;
+    private _statusInterval;
+    private _startLock;
+    onServerEvict: ((durableTaskExternalId: string, invocationCount: number) => void) | undefined;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    get workerId(): string | undefined;
+    start(workerId: string): Promise<void>;
+    private _doStart;
+    ensureStarted(workerId: string): Promise<void>;
+    stop(): Promise<void>;
+    private _connect;
+    private _streamLoop;
+    private _requestIterator;
+    private _enqueueRequest;
+    private _startStatusPolling;
+    private _pollWorkerStatus;
+    private _failPendingAcks;
+    private _failAllPending;
+    private _handleResponse;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: RunChildrenEvent): Promise<DurableTaskEventRunAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: WaitForEvent): Promise<DurableTaskEventWaitForAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: MemoEvent): Promise<DurableTaskEventMemoAck>;
+    waitForCallback(durableTaskExternalId: string, invocationCount: number, branchId: number, nodeId: number, opts?: {
+        signal?: AbortSignal;
+    }): Promise<DurableTaskEventLogEntryResult>;
+    cleanupTaskState(durableTaskExternalId: string, invocationCount: number): void;
+    sendEvictInvocation(durableTaskExternalId: string, invocationCount: number, reason?: string): Promise<void>;
+    sendMemoCompletedNotification(durableTaskExternalId: string, nodeId: number, branchId: number, invocationCount: number, memoKey: Uint8Array, memoResultPayload?: Uint8Array): Promise<void>;
+    /**
+     * @deprecated Legacy backward-compat: uses the old unary RegisterDurableEvent RPC.
+     */
+    registerDurableEvent(request: {
+        taskId: string;
+        signalKey: string;
+        sleepConditions: Array<SleepMatchCondition>;
+        userEventConditions: Array<UserEventMatchCondition>;
+    }): Promise<RegisterDurableEventResponse>;
+    /**
+     * @deprecated Legacy backward-compat: uses the old streaming ListenForDurableEvent RPC.
+     */
     subscribe(request: {
         taskId: string;
         signalKey: string;
-    }): import("./pooled-durable-listener-client").DurableEventStreamable;
+    }): LegacyDurableEventStreamable;
+    /**
+     * @deprecated Legacy backward-compat: subscribes and waits for a single result.
+     */
     result(request: {
         taskId: string;
         signalKey: string;
     }, opts?: {
         signal?: AbortSignal;
-    }): Promise<import("../../../protoc/v1/dispatcher").DurableEvent>;
-    registerDurableEvent(request: {
-        taskId: string;
-        signalKey: string;
-        sleepConditions: Array<SleepMatchCondition>;
-        userEventConditions: Array<UserEventMatchCondition>;
-    }): Promise<import("../../../protoc/v1/dispatcher").RegisterDurableEventResponse>;
+    }): Promise<DurableEvent>;
+    private _legacyPooledListener;
+}
+/**
+ * @deprecated Legacy support for the old streaming ListenForDurableEvent RPC.
+ */
+export declare class LegacyDurableEventStreamable {
+    responseEmitter: EventEmitter<[never]>;
+    private _onCleanup;
+    constructor(onCleanup: () => void);
+    get(opts?: {
+        signal?: AbortSignal;
+    }): Promise<DurableEvent>;
 }