@hatchet-dev/typescript-sdk 0.0.7 → 0.0.8

package/clients/worker/worker.js

@@ -0,0 +1,317 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const dispatcher_1 = require("../../protoc/dispatcher");
+const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
+const workflows_1 = require("../../protoc/workflows");
+const logger_1 = require("../../util/logger");
+const sleep_1 = __importDefault(require("../../util/sleep"));
+const step_1 = require("../../step");
+class Worker {
+    constructor(client, options) {
+        this.serviceName = 'default';
+        this.futures = {};
+        this.contexts = {};
+        this.client = client;
+        this.name = options.name;
+        this.action_registry = {};
+        this.concurrency_action_registry = {};
+        process.on('SIGTERM', () => this.exitGracefully());
+        process.on('SIGINT', () => this.exitGracefully());
+        this.killing = false;
+        this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
+        this.logger = new logger_1.Logger(`Worker/${this.name}`, this.client.config.log_level);
+    }
+    registerWorkflow(workflow) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.action)
+                    ? {
+                        action: `${this.serviceName}:${workflow.concurrency.action}`,
+                        maxRuns: workflow.concurrency.maxRuns || 1,
+                        limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
+                    }
+                    : undefined;
+                yield this.client.admin.put_workflow({
+                    name: workflow.id,
+                    description: workflow.description,
+                    version: workflow.version || '',
+                    eventTriggers: workflow.on.event ? [workflow.on.event] : [],
+                    cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
+                    scheduledTriggers: [],
+                    concurrency,
+                    jobs: [
+                        {
+                            name: workflow.id,
+                            timeout: workflow.timeout || '60s',
+                            description: workflow.description,
+                            steps: workflow.steps.map((step) => {
+                                var _a;
+                                return ({
+                                    readableId: step.name,
+                                    action: `${this.serviceName}:${step.name}`,
+                                    timeout: step.timeout || '60s',
+                                    inputs: '{}',
+                                    parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
+                                });
+                            }),
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
+            }
+            this.action_registry = workflow.steps.reduce((acc, step) => {
+                acc[`${this.serviceName}:${step.name}`] = step.run;
+                return acc;
+            }, {});
+            this.concurrency_action_registry = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.action)
+                ? {
+                    [`${this.serviceName}:${workflow.concurrency.action}`]: workflow.concurrency.key,
+                }
+                : {};
+        });
+    }
+    handleStartStepRun(action) {
+        const { actionId } = action;
+        const context = new step_1.Context(action.actionPayload);
+        this.contexts[action.stepRunId] = context;
+        const step = this.action_registry[actionId];
+        if (!step) {
+            this.logger.error(`Could not find step '${actionId}'`);
+            return;
+        }
+        const run = () => __awaiter(this, void 0, void 0, function* () {
+            return step(context);
+        });
+        const success = (result) => {
+            this.logger.info(`Step run ${action.stepRunId} succeeded`);
+            try {
+                // Send the action event to the dispatcher
+                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result);
+                this.client.dispatcher.sendStepActionEvent(event);
+                // delete the run from the futures
+                delete this.futures[action.stepRunId];
+            }
+            catch (e) {
+                this.logger.error(`Could not send action event: ${e.message}`);
+            }
+        };
+        const failure = (error) => {
+            this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
+            try {
+                // Send the action event to the dispatcher
+                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, error);
+                this.client.dispatcher.sendStepActionEvent(event);
+                // delete the run from the futures
+                delete this.futures[action.stepRunId];
+            }
+            catch (e) {
+                this.logger.error(`Could not send action event: ${e.message}`);
+            }
+        };
+        const future = new hatchet_promise_1.default(run().then(success).catch(failure));
+        this.futures[action.stepRunId] = future;
+        try {
+            // Send the action event to the dispatcher
+            const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
+            this.client.dispatcher.sendStepActionEvent(event);
+        }
+        catch (e) {
+            this.logger.error(`Could not send action event: ${e.message}`);
+        }
+    }
+    handleStartGroupKeyRun(action) {
+        const { actionId } = action;
+        const context = new step_1.Context(action.actionPayload);
+        const key = action.getGroupKeyRunId;
+        this.contexts[key] = context;
+        const step = this.action_registry[actionId];
+        if (!step) {
+            this.logger.error(`Could not find step '${actionId}'`);
+            return;
+        }
+        const run = () => __awaiter(this, void 0, void 0, function* () {
+            return step(context);
+        });
+        const success = (result) => {
+            this.logger.info(`Step run ${action.stepRunId} succeeded`);
+            try {
+                // Send the action event to the dispatcher
+                const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
+                this.client.dispatcher.sendGroupKeyActionEvent(event);
+                // delete the run from the futures
+                delete this.futures[key];
+            }
+            catch (e) {
+                this.logger.error(`Could not send action event: ${e.message}`);
+            }
+        };
+        const failure = (error) => {
+            this.logger.error(`Step run ${key} failed: ${error.message}`);
+            try {
+                // Send the action event to the dispatcher
+                const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
+                this.client.dispatcher.sendGroupKeyActionEvent(event);
+                // delete the run from the futures
+                delete this.futures[key];
+            }
+            catch (e) {
+                this.logger.error(`Could not send action event: ${e.message}`);
+            }
+        };
+        const future = new hatchet_promise_1.default(run().then(success).catch(failure));
+        this.futures[action.getGroupKeyRunId] = future;
+        try {
+            // Send the action event to the dispatcher
+            const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
+            this.client.dispatcher.sendStepActionEvent(event);
+        }
+        catch (e) {
+            this.logger.error(`Could not send action event: ${e.message}`);
+        }
+    }
+    getStepActionEvent(action, eventType, payload = '') {
+        return {
+            workerId: this.name,
+            jobId: action.jobId,
+            jobRunId: action.jobRunId,
+            stepId: action.stepId,
+            stepRunId: action.stepRunId,
+            actionId: action.actionId,
+            eventTimestamp: new Date(),
+            eventType,
+            eventPayload: JSON.stringify(payload),
+        };
+    }
+    getGroupKeyActionEvent(action, eventType, payload = '') {
+        return {
+            workerId: this.name,
+            workflowRunId: action.workflowRunId,
+            getGroupKeyRunId: action.getGroupKeyRunId,
+            actionId: action.actionId,
+            eventTimestamp: new Date(),
+            eventType,
+            eventPayload: JSON.stringify(payload),
+        };
+    }
+    handleCancelStepRun(action) {
+        const { stepRunId } = action;
+        const future = this.futures[stepRunId];
+        const context = this.contexts[stepRunId];
+        //  TODO send cancel signal to context
+        // if (context && context.cancel) {
+        //   context.cancel();
+        //   delete this.contexts[stepRunId];
+        // }
+        if (future) {
+            future.cancel();
+            delete this.futures[stepRunId];
+        }
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.exitGracefully();
+        });
+    }
+    exitGracefully() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.killing = true;
+            this.logger.info('Starting to exit...');
+            try {
+                (_a = this.listener) === null || _a === void 0 ? void 0 : _a.unregister();
+            }
+            catch (e) {
+                this.logger.error(`Could not unregister listener: ${e.message}`);
+            }
+            this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
+            // attempt to wait for futures to finish
+            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
+            if (this.handle_kill) {
+                this.logger.info('Exiting hatchet worker...');
+                process.exit(0);
+            }
+        });
+    }
+    start() {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let retries = 0;
+            while (retries < 5) {
+                try {
+                    this.listener = yield this.client.dispatcher.getActionListener({
+                        workerName: this.name,
+                        services: ['default'],
+                        actions: Object.keys(this.action_registry),
+                    });
+                    const generator = this.listener.actions();
+                    this.logger.info(`Worker ${this.name} listening for actions`);
+                    try {
+                        for (var _d = true, generator_1 = (e_1 = void 0, __asyncValues(generator)), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
+                            _c = generator_1_1.value;
+                            _d = false;
+                            const action = _c;
+                            this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
+                            if (action.actionType === dispatcher_1.ActionType.START_STEP_RUN) {
+                                this.handleStartStepRun(action);
+                            }
+                            else if (action.actionType === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
+                                this.handleCancelStepRun(action);
+                            }
+                            else if (action.actionType === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
+                                this.handleStartGroupKeyRun(action);
+                            }
+                            else {
+                                this.logger.error(`Worker ${this.name} received unknown action type ${action.actionType}`);
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    break;
+                }
+                catch (e) {
+                    this.logger.error(`Could not start worker: ${e.message}`);
+                    retries += 1;
+                    const wait = 500;
+                    this.logger.error(`Could not start worker, retrying in ${500} seconds`);
+                    yield (0, sleep_1.default)(wait);
+                }
+            }
+            if (this.killing)
+                return;
+            if (retries > 5) {
+                throw new hatchet_error_1.default('Could not start worker after 5 retries');
+            }
+        });
+    }
+}
+exports.Worker = Worker;

package/index.d.ts

@@ -0,0 +1,2 @@
+import { HatchetClient as Hatchet } from './clients/hatchet-client';
+export default Hatchet;

package/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("./clients/hatchet-client");
+exports.default = hatchet_client_1.HatchetClient;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist",
+    "*",
     "!**/*.test.js",
     "!**/*.test.d.ts"
   ],

package/protoc/dispatcher/dispatcher.d.ts

@@ -0,0 +1,333 @@
+import type { CallContext, CallOptions } from "nice-grpc-common";
+import * as _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "";
+export declare enum ActionType {
+    START_STEP_RUN = 0,
+    CANCEL_STEP_RUN = 1,
+    START_GET_GROUP_KEY = 2,
+    UNRECOGNIZED = -1
+}
+export declare function actionTypeFromJSON(object: any): ActionType;
+export declare function actionTypeToJSON(object: ActionType): string;
+export declare enum GroupKeyActionEventType {
+    GROUP_KEY_EVENT_TYPE_UNKNOWN = 0,
+    GROUP_KEY_EVENT_TYPE_STARTED = 1,
+    GROUP_KEY_EVENT_TYPE_COMPLETED = 2,
+    GROUP_KEY_EVENT_TYPE_FAILED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function groupKeyActionEventTypeFromJSON(object: any): GroupKeyActionEventType;
+export declare function groupKeyActionEventTypeToJSON(object: GroupKeyActionEventType): string;
+export declare enum StepActionEventType {
+    STEP_EVENT_TYPE_UNKNOWN = 0,
+    STEP_EVENT_TYPE_STARTED = 1,
+    STEP_EVENT_TYPE_COMPLETED = 2,
+    STEP_EVENT_TYPE_FAILED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function stepActionEventTypeFromJSON(object: any): StepActionEventType;
+export declare function stepActionEventTypeToJSON(object: StepActionEventType): string;
+export interface WorkerRegisterRequest {
+    /** the name of the worker */
+    workerName: string;
+    /** a list of actions that this worker can run */
+    actions: string[];
+    /** (optional) the services for this worker */
+    services: string[];
+}
+export interface WorkerRegisterResponse {
+    /** the tenant id */
+    tenantId: string;
+    /** the id of the worker */
+    workerId: string;
+    /** the name of the worker */
+    workerName: string;
+}
+export interface AssignedAction {
+    /** the tenant id */
+    tenantId: string;
+    /** the workflow run id (optional) */
+    workflowRunId: string;
+    /** the get group key run id (optional) */
+    getGroupKeyRunId: string;
+    /** the job id */
+    jobId: string;
+    /** the job name */
+    jobName: string;
+    /** the job run id */
+    jobRunId: string;
+    /** the step id */
+    stepId: string;
+    /** the step run id */
+    stepRunId: string;
+    /** the action id */
+    actionId: string;
+    /** the action type */
+    actionType: ActionType;
+    /** the action payload */
+    actionPayload: string;
+}
+export interface WorkerListenRequest {
+    /** the id of the worker */
+    workerId: string;
+}
+export interface WorkerUnsubscribeRequest {
+    /** the id of the worker */
+    workerId: string;
+}
+export interface WorkerUnsubscribeResponse {
+    /** the tenant id to unsubscribe from */
+    tenantId: string;
+    /** the id of the worker */
+    workerId: string;
+}
+export interface GroupKeyActionEvent {
+    /** the id of the worker */
+    workerId: string;
+    /** the id of the job */
+    workflowRunId: string;
+    getGroupKeyRunId: string;
+    /** the action id */
+    actionId: string;
+    eventTimestamp: Date | undefined;
+    /** the step event type */
+    eventType: GroupKeyActionEventType;
+    /** the event payload */
+    eventPayload: string;
+}
+export interface StepActionEvent {
+    /** the id of the worker */
+    workerId: string;
+    /** the id of the job */
+    jobId: string;
+    /** the job run id */
+    jobRunId: string;
+    /** the id of the step */
+    stepId: string;
+    /** the step run id */
+    stepRunId: string;
+    /** the action id */
+    actionId: string;
+    eventTimestamp: Date | undefined;
+    /** the step event type */
+    eventType: StepActionEventType;
+    /** the event payload */
+    eventPayload: string;
+}
+export interface ActionEventResponse {
+    /** the tenant id */
+    tenantId: string;
+    /** the id of the worker */
+    workerId: string;
+}
+export declare const WorkerRegisterRequest: {
+    encode(message: WorkerRegisterRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterRequest;
+    fromJSON(object: any): WorkerRegisterRequest;
+    toJSON(message: WorkerRegisterRequest): unknown;
+    create(base?: DeepPartial<WorkerRegisterRequest>): WorkerRegisterRequest;
+    fromPartial(object: DeepPartial<WorkerRegisterRequest>): WorkerRegisterRequest;
+};
+export declare const WorkerRegisterResponse: {
+    encode(message: WorkerRegisterResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterResponse;
+    fromJSON(object: any): WorkerRegisterResponse;
+    toJSON(message: WorkerRegisterResponse): unknown;
+    create(base?: DeepPartial<WorkerRegisterResponse>): WorkerRegisterResponse;
+    fromPartial(object: DeepPartial<WorkerRegisterResponse>): WorkerRegisterResponse;
+};
+export declare const AssignedAction: {
+    encode(message: AssignedAction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AssignedAction;
+    fromJSON(object: any): AssignedAction;
+    toJSON(message: AssignedAction): unknown;
+    create(base?: DeepPartial<AssignedAction>): AssignedAction;
+    fromPartial(object: DeepPartial<AssignedAction>): AssignedAction;
+};
+export declare const WorkerListenRequest: {
+    encode(message: WorkerListenRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): WorkerListenRequest;
+    fromJSON(object: any): WorkerListenRequest;
+    toJSON(message: WorkerListenRequest): unknown;
+    create(base?: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+    fromPartial(object: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+};
+export declare const WorkerUnsubscribeRequest: {
+    encode(message: WorkerUnsubscribeRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): WorkerUnsubscribeRequest;
+    fromJSON(object: any): WorkerUnsubscribeRequest;
+    toJSON(message: WorkerUnsubscribeRequest): unknown;
+    create(base?: DeepPartial<WorkerUnsubscribeRequest>): WorkerUnsubscribeRequest;
+    fromPartial(object: DeepPartial<WorkerUnsubscribeRequest>): WorkerUnsubscribeRequest;
+};
+export declare const WorkerUnsubscribeResponse: {
+    encode(message: WorkerUnsubscribeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): WorkerUnsubscribeResponse;
+    fromJSON(object: any): WorkerUnsubscribeResponse;
+    toJSON(message: WorkerUnsubscribeResponse): unknown;
+    create(base?: DeepPartial<WorkerUnsubscribeResponse>): WorkerUnsubscribeResponse;
+    fromPartial(object: DeepPartial<WorkerUnsubscribeResponse>): WorkerUnsubscribeResponse;
+};
+export declare const GroupKeyActionEvent: {
+    encode(message: GroupKeyActionEvent, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GroupKeyActionEvent;
+    fromJSON(object: any): GroupKeyActionEvent;
+    toJSON(message: GroupKeyActionEvent): unknown;
+    create(base?: DeepPartial<GroupKeyActionEvent>): GroupKeyActionEvent;
+    fromPartial(object: DeepPartial<GroupKeyActionEvent>): GroupKeyActionEvent;
+};
+export declare const StepActionEvent: {
+    encode(message: StepActionEvent, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StepActionEvent;
+    fromJSON(object: any): StepActionEvent;
+    toJSON(message: StepActionEvent): unknown;
+    create(base?: DeepPartial<StepActionEvent>): StepActionEvent;
+    fromPartial(object: DeepPartial<StepActionEvent>): StepActionEvent;
+};
+export declare const ActionEventResponse: {
+    encode(message: ActionEventResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ActionEventResponse;
+    fromJSON(object: any): ActionEventResponse;
+    toJSON(message: ActionEventResponse): unknown;
+    create(base?: DeepPartial<ActionEventResponse>): ActionEventResponse;
+    fromPartial(object: DeepPartial<ActionEventResponse>): ActionEventResponse;
+};
+export type DispatcherDefinition = typeof DispatcherDefinition;
+export declare const DispatcherDefinition: {
+    readonly name: "Dispatcher";
+    readonly fullName: "Dispatcher";
+    readonly methods: {
+        readonly register: {
+            readonly name: "Register";
+            readonly requestType: {
+                encode(message: WorkerRegisterRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterRequest;
+                fromJSON(object: any): WorkerRegisterRequest;
+                toJSON(message: WorkerRegisterRequest): unknown;
+                create(base?: DeepPartial<WorkerRegisterRequest>): WorkerRegisterRequest;
+                fromPartial(object: DeepPartial<WorkerRegisterRequest>): WorkerRegisterRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: WorkerRegisterResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterResponse;
+                fromJSON(object: any): WorkerRegisterResponse;
+                toJSON(message: WorkerRegisterResponse): unknown;
+                create(base?: DeepPartial<WorkerRegisterResponse>): WorkerRegisterResponse;
+                fromPartial(object: DeepPartial<WorkerRegisterResponse>): WorkerRegisterResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly listen: {
+            readonly name: "Listen";
+            readonly requestType: {
+                encode(message: WorkerListenRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerListenRequest;
+                fromJSON(object: any): WorkerListenRequest;
+                toJSON(message: WorkerListenRequest): unknown;
+                create(base?: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+                fromPartial(object: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: AssignedAction, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): AssignedAction;
+                fromJSON(object: any): AssignedAction;
+                toJSON(message: AssignedAction): unknown;
+                create(base?: DeepPartial<AssignedAction>): AssignedAction;
+                fromPartial(object: DeepPartial<AssignedAction>): AssignedAction;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        readonly sendStepActionEvent: {
+            readonly name: "SendStepActionEvent";
+            readonly requestType: {
+                encode(message: StepActionEvent, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StepActionEvent;
+                fromJSON(object: any): StepActionEvent;
+                toJSON(message: StepActionEvent): unknown;
+                create(base?: DeepPartial<StepActionEvent>): StepActionEvent;
+                fromPartial(object: DeepPartial<StepActionEvent>): StepActionEvent;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: ActionEventResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): ActionEventResponse;
+                fromJSON(object: any): ActionEventResponse;
+                toJSON(message: ActionEventResponse): unknown;
+                create(base?: DeepPartial<ActionEventResponse>): ActionEventResponse;
+                fromPartial(object: DeepPartial<ActionEventResponse>): ActionEventResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly sendGroupKeyActionEvent: {
+            readonly name: "SendGroupKeyActionEvent";
+            readonly requestType: {
+                encode(message: GroupKeyActionEvent, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): GroupKeyActionEvent;
+                fromJSON(object: any): GroupKeyActionEvent;
+                toJSON(message: GroupKeyActionEvent): unknown;
+                create(base?: DeepPartial<GroupKeyActionEvent>): GroupKeyActionEvent;
+                fromPartial(object: DeepPartial<GroupKeyActionEvent>): GroupKeyActionEvent;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: ActionEventResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): ActionEventResponse;
+                fromJSON(object: any): ActionEventResponse;
+                toJSON(message: ActionEventResponse): unknown;
+                create(base?: DeepPartial<ActionEventResponse>): ActionEventResponse;
+                fromPartial(object: DeepPartial<ActionEventResponse>): ActionEventResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly unsubscribe: {
+            readonly name: "Unsubscribe";
+            readonly requestType: {
+                encode(message: WorkerUnsubscribeRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerUnsubscribeRequest;
+                fromJSON(object: any): WorkerUnsubscribeRequest;
+                toJSON(message: WorkerUnsubscribeRequest): unknown;
+                create(base?: DeepPartial<WorkerUnsubscribeRequest>): WorkerUnsubscribeRequest;
+                fromPartial(object: DeepPartial<WorkerUnsubscribeRequest>): WorkerUnsubscribeRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: WorkerUnsubscribeResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerUnsubscribeResponse;
+                fromJSON(object: any): WorkerUnsubscribeResponse;
+                toJSON(message: WorkerUnsubscribeResponse): unknown;
+                create(base?: DeepPartial<WorkerUnsubscribeResponse>): WorkerUnsubscribeResponse;
+                fromPartial(object: DeepPartial<WorkerUnsubscribeResponse>): WorkerUnsubscribeResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface DispatcherServiceImplementation<CallContextExt = {}> {
+    register(request: WorkerRegisterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerRegisterResponse>>;
+    listen(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    sendStepActionEvent(request: StepActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
+    sendGroupKeyActionEvent(request: GroupKeyActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
+    unsubscribe(request: WorkerUnsubscribeRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerUnsubscribeResponse>>;
+}
+export interface DispatcherClient<CallOptionsExt = {}> {
+    register(request: DeepPartial<WorkerRegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerRegisterResponse>;
+    listen(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    sendStepActionEvent(request: DeepPartial<StepActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
+    sendGroupKeyActionEvent(request: DeepPartial<GroupKeyActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
+    unsubscribe(request: DeepPartial<WorkerUnsubscribeRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerUnsubscribeResponse>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export type ServerStreamingMethodResult<Response> = {
+    [Symbol.asyncIterator](): AsyncIterator<Response, void>;
+};
+export {};