@hatchet-dev/typescript-sdk 0.8.0-alpha.2 → 0.8.0-alpha.3

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

@@ -3,7 +3,7 @@ import { CreateWorkflowVersionOpts, RateLimitDuration, WorkflowServiceClient } f
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { Api } from '../rest';
-import { WebhookWorkerCreateRequest, WorkflowRunStatus } from '../rest/generated/data-contracts';
+import { WebhookWorkerCreateRequest, WorkflowRunStatus, WorkflowRunStatusList } from '../rest/generated/data-contracts';
 type WorkflowMetricsQuery = {
     workflowId?: string;
     workflowName?: string;
@@ -33,71 +33,133 @@ export declare class AdminClient {
     tenantId: string;
     logger: Logger;
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string);
+    /**
+     * @deprecated use putWorkflow instead
+     */
+    put_workflow(opts: CreateWorkflowVersionOpts): Promise<void>;
     /**
      * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
      * determine if the workflow definition has changed and create a new version if necessary.
      * @param workflow a workflow definition to create
      */
-    put_workflow(workflow: CreateWorkflowVersionOpts): Promise<void>;
-    put_rate_limit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
+    putWorkflow(workflow: CreateWorkflowVersionOpts): Promise<void>;
+    /**
+     * @deprecated use putRateLimit instead
+     */
+    put_rate_limit(key: string, limit: number, duration: RateLimitDuration): Promise<void>;
+    putRateLimit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
     webhook_create(data: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorker, any>>;
+    /**
+     * @deprecated use runWorkflow instead
+     */
+    run_workflow<T = object>(workflowName: string, input: T, options?: {
+        parentId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        childIndex?: number | undefined;
+        childKey?: string | undefined;
+        additionalMetadata?: Record<string, string> | undefined;
+    }): Promise<string>;
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.
      * @param workflowName the name of the workflow to run
      * @param input an object containing the input to the workflow
+     * @param options an object containing the options to run the workflow
      * @returns the ID of the new workflow run
      */
-    run_workflow<T = object>(workflowName: string, input: T, options?: {
+    runWorkflow<T = object>(workflowName: string, input: T, options?: {
         parentId?: string | undefined;
         parentStepRunId?: string | undefined;
         childIndex?: number | undefined;
         childKey?: string | undefined;
         additionalMetadata?: Record<string, string> | undefined;
     }): Promise<string>;
+    /**
+     * @deprecated use listWorkflows instead
+     */
+    list_workflows(): Promise<import("../rest/generated/data-contracts").WorkflowList>;
     /**
      * List workflows in the tenant associated with the API token.
      * @returns a list of all workflows in the tenant
      */
-    list_workflows(): Promise<import("../rest/generated/data-contracts").WorkflowList>;
+    listWorkflows(): Promise<import("../rest/generated/data-contracts").WorkflowList>;
+    /**
+     * @deprecated use getWorkflow instead
+     */
+    get_workflow(workflowId: string): Promise<import("../rest/generated/data-contracts").Workflow>;
     /**
      * Get a workflow by its ID.
      * @param workflowId the workflow ID (**note:** this is not the same as the workflow version id)
      * @returns
      */
-    get_workflow(workflowId: string): Promise<import("../rest/generated/data-contracts").Workflow>;
+    getWorkflow(workflowId: string): Promise<import("../rest/generated/data-contracts").Workflow>;
+    /**
+     * @deprecated use getWorkflowVersion instead
+     */
+    get_workflow_version(workflowId: string, version?: string): Promise<import("../rest/generated/data-contracts").WorkflowVersion>;
     /**
      * Get a workflow version.
      * @param workflowId the workflow ID
      * @param version the version of the workflow to get. If not provided, the latest version will be returned.
      * @returns the workflow version
      */
-    get_workflow_version(workflowId: string, version?: string): Promise<import("../rest/generated/data-contracts").WorkflowVersion>;
+    getWorkflowVersion(workflowId: string, version?: string): Promise<import("../rest/generated/data-contracts").WorkflowVersion>;
+    /**
+     * @deprecated use getWorkflowRun instead
+     */
+    get_workflow_run(workflowRunId: string): Promise<import("../rest/generated/data-contracts").WorkflowRun>;
     /**
      * Get a workflow run.
      * @param workflowRunId the id of the workflow run to get
      * @returns the workflow run
      */
-    get_workflow_run(workflowRunId: string): Promise<import("../rest/generated/data-contracts").WorkflowRun>;
+    getWorkflowRun(workflowRunId: string): Promise<import("../rest/generated/data-contracts").WorkflowRun>;
+    /**
+     * @deprecated use listWorkflowRuns instead
+     */
+    list_workflow_runs(query: {
+        offset?: number | undefined;
+        limit?: number | undefined;
+        eventId?: string | undefined;
+        workflowId?: string | undefined;
+        parentWorkflowRunId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        statuses?: WorkflowRunStatusList | undefined;
+        additionalMetadata?: string[] | undefined;
+    }): Promise<import("../rest/generated/data-contracts").WorkflowRunList>;
     /**
      * List workflow runs in the tenant associated with the API token.
      * @param query the query to filter the list of workflow runs
      * @returns
      */
-    list_workflow_runs(query: {
+    listWorkflowRuns(query: {
         offset?: number | undefined;
         limit?: number | undefined;
         eventId?: string | undefined;
         workflowId?: string | undefined;
+        parentWorkflowRunId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        statuses?: WorkflowRunStatusList | undefined;
+        additionalMetadata?: string[] | undefined;
     }): Promise<import("../rest/generated/data-contracts").WorkflowRunList>;
+    /**
+     * @deprecated use scheduleWorkflow instead
+     */
+    schedule_workflow(name: string, options?: {
+        schedules?: Date[];
+    }): Promise<void>;
     /**
      * Schedule a workflow to run at a specific time or times.
      * @param name the name of the workflow to schedule
      * @param options an object containing the schedules to set
      */
-    schedule_workflow(name: string, options?: {
+    scheduleWorkflow(name: string, options?: {
         schedules?: Date[];
     }): void;
+    /**
+     * @deprecated use getWorkflowMetrics instead
+     */
+    get_workflow_metrics(data: WorkflowMetricsQuery): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WorkflowMetrics, any>>;
     /**
      * Get the metrics for a workflow.
      *
@@ -105,6 +167,6 @@ export declare class AdminClient {
      * @param workflowName the name of the workflow to get metrics for
      * @param query an object containing query parameters to filter the metrics
      */
-    get_workflow_metrics({ workflowId, workflowName, status, groupKey }: WorkflowMetricsQuery): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WorkflowMetrics, any>>;
+    getWorkflowMetrics({ workflowId, workflowName, status, groupKey }: WorkflowMetricsQuery): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WorkflowMetrics, any>>;
 }
 export {};

package/clients/admin/admin-client.js

@@ -41,12 +41,20 @@ class AdminClient {
         this.tenantId = tenantId;
         this.logger = new logger_1.Logger(`Admin`, config.log_level);
     }
+    /**
+     * @deprecated use putWorkflow instead
+     */
+    put_workflow(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.putWorkflow(opts);
+        });
+    }
     /**
      * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
      * determine if the workflow definition has changed and create a new version if necessary.
      * @param workflow a workflow definition to create
      */
-    put_workflow(workflow) {
+    putWorkflow(workflow) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.putWorkflow({ opts: workflow }); }), this.logger);
@@ -56,7 +64,15 @@ class AdminClient {
             }
         });
     }
-    put_rate_limit(key_1, limit_1) {
+    /**
+     * @deprecated use putRateLimit instead
+     */
+    put_rate_limit(key, limit, duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.putRateLimit(key, limit, duration);
+        });
+    }
+    putRateLimit(key_1, limit_1) {
         return __awaiter(this, arguments, void 0, function* (key, limit, duration = workflows_1.RateLimitDuration.SECOND) {
             try {
                 yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
@@ -77,14 +93,23 @@ class AdminClient {
             return this.api.webhookCreate(this.tenantId, data);
         });
     }
+    /**
+     * @deprecated use runWorkflow instead
+     */
+    run_workflow(workflowName, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runWorkflow(workflowName, input, options);
+        });
+    }
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.
      * @param workflowName the name of the workflow to run
      * @param input an object containing the input to the workflow
+     * @param options an object containing the options to run the workflow
      * @returns the ID of the new workflow run
      */
-    run_workflow(workflowName, input, options) {
+    runWorkflow(workflowName, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             let computedName = workflowName;
             try {
@@ -102,34 +127,58 @@ class AdminClient {
             }
         });
     }
+    /**
+     * @deprecated use listWorkflows instead
+     */
+    list_workflows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listWorkflows();
+        });
+    }
     /**
      * List workflows in the tenant associated with the API token.
      * @returns a list of all workflows in the tenant
      */
-    list_workflows() {
+    listWorkflows() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.api.workflowList(this.tenantId);
             return res.data;
         });
     }
+    /**
+     * @deprecated use getWorkflow instead
+     */
+    get_workflow(workflowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWorkflow(workflowId);
+        });
+    }
     /**
      * Get a workflow by its ID.
      * @param workflowId the workflow ID (**note:** this is not the same as the workflow version id)
      * @returns
      */
-    get_workflow(workflowId) {
+    getWorkflow(workflowId) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.api.workflowGet(workflowId);
             return res.data;
         });
     }
+    /**
+     * @deprecated use getWorkflowVersion instead
+     */
+    get_workflow_version(workflowId, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWorkflowVersion(workflowId, version);
+        });
+    }
     /**
      * Get a workflow version.
      * @param workflowId the workflow ID
      * @param version the version of the workflow to get. If not provided, the latest version will be returned.
      * @returns the workflow version
      */
-    get_workflow_version(workflowId, version) {
+    getWorkflowVersion(workflowId, version) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.api.workflowVersionGet(workflowId, {
                 version,
@@ -137,34 +186,58 @@ class AdminClient {
             return res.data;
         });
     }
+    /**
+     * @deprecated use getWorkflowRun instead
+     */
+    get_workflow_run(workflowRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWorkflowRun(workflowRunId);
+        });
+    }
     /**
      * Get a workflow run.
      * @param workflowRunId the id of the workflow run to get
      * @returns the workflow run
      */
-    get_workflow_run(workflowRunId) {
+    getWorkflowRun(workflowRunId) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.api.workflowRunGet(this.tenantId, workflowRunId);
             return res.data;
         });
     }
+    /**
+     * @deprecated use listWorkflowRuns instead
+     */
+    list_workflow_runs(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listWorkflowRuns(query);
+        });
+    }
     /**
      * List workflow runs in the tenant associated with the API token.
      * @param query the query to filter the list of workflow runs
      * @returns
      */
-    list_workflow_runs(query) {
+    listWorkflowRuns(query) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.api.workflowRunList(this.tenantId, query);
             return res.data;
         });
     }
+    /**
+     * @deprecated use scheduleWorkflow instead
+     */
+    schedule_workflow(name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.scheduleWorkflow(name, options);
+        });
+    }
     /**
      * Schedule a workflow to run at a specific time or times.
      * @param name the name of the workflow to schedule
      * @param options an object containing the schedules to set
      */
-    schedule_workflow(name, options) {
+    scheduleWorkflow(name, options) {
         try {
             this.client.scheduleWorkflow({
                 name,
@@ -175,6 +248,14 @@ class AdminClient {
             throw new hatchet_error_1.default(e.message);
         }
     }
+    /**
+     * @deprecated use getWorkflowMetrics instead
+     */
+    get_workflow_metrics(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWorkflowMetrics(data);
+        });
+    }
     /**
      * Get the metrics for a workflow.
      *
@@ -182,13 +263,13 @@ class AdminClient {
      * @param workflowName the name of the workflow to get metrics for
      * @param query an object containing query parameters to filter the metrics
      */
-    get_workflow_metrics({ workflowId, workflowName, status, groupKey }) {
+    getWorkflowMetrics({ workflowId, workflowName, status, groupKey }) {
         const params = {
             status,
             groupKey,
         };
         if (workflowName) {
-            this.list_workflows().then((res) => {
+            this.listWorkflows().then((res) => {
                 var _a;
                 const workflow = (_a = res.rows) === null || _a === void 0 ? void 0 : _a.find((row) => row.name === workflowName);
                 if (workflow) {

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

@@ -29,5 +29,5 @@ export declare class HatchetClient {
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     run(workflow: string | Workflow): Promise<Worker>;
     worker(workflow: string | Workflow, maxRuns?: number): Promise<Worker>;
-    webhooks(workflow: Workflow): import("../worker/handler").WebhookHandler;
+    webhooks(workflows: Workflow[]): import("../worker/handler").WebhookHandler;
 }

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

@@ -142,11 +142,11 @@ class HatchetClient {
             return worker;
         });
     }
-    webhooks(workflow) {
+    webhooks(workflows) {
         const worker = new worker_1.Worker(this, {
-            name: workflow.id,
+            name: 'webhook-worker',
         });
-        return worker.getHandler(workflow);
+        return worker.getHandler(workflows);
     }
 }
 exports.HatchetClient = HatchetClient;

package/clients/worker/handler.d.ts

@@ -1,12 +1,14 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
+import { Workflow } from '../../workflow';
 import { Worker } from './worker';
 export interface HandlerOpts {
     secret: string;
 }
 export declare class WebhookHandler {
     private worker;
-    constructor(worker: Worker);
+    private workflows;
+    constructor(worker: Worker, workflows: Workflow[]);
     /**
      * Handles a request with a provided body, secret, and signature.
      *

package/clients/worker/handler.js

@@ -17,9 +17,12 @@ const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error
 const crypto_1 = require("crypto");
 const action_listener_1 = require("../dispatcher/action-listener");
 class WebhookHandler {
-    // eslint-disable-next-line no-useless-constructor,no-empty-function
-    constructor(worker) {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(worker, workflows
+    // eslint-disable-next-line no-empty-function
+    ) {
         this.worker = worker;
+        this.workflows = workflows;
     }
     /**
      * Handles a request with a provided body, secret, and signature.
@@ -53,9 +56,14 @@ class WebhookHandler {
         });
     }
     getHealthcheckResponse() {
-        return {
-            actions: Object.keys(this.worker.action_registry),
-        };
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const workflow of this.workflows) {
+                yield this.worker.registerWorkflow(workflow);
+            }
+            return {
+                actions: Object.keys(this.worker.action_registry),
+            };
+        });
     }
     /**
      * Express Handler
@@ -72,7 +80,7 @@ class WebhookHandler {
         return (req, res) => {
             if (req.method === 'GET') {
                 res.sendStatus(200);
-                res.json(this.getHealthcheckResponse());
+                res.send('OK!');
                 return;
             }
             if (req.method !== 'POST') {
@@ -80,13 +88,25 @@ class WebhookHandler {
                 res.json({ error: 'Method not allowed' });
                 return;
             }
+            if (req.headers['x-healthcheck']) {
+                this.getHealthcheckResponse()
+                    .then((resp) => {
+                    res.sendStatus(200);
+                    res.json(resp);
+                })
+                    .catch((err) => {
+                    res.sendStatus(500);
+                    this.worker.logger.error(`Error handling request: ${err.message}`);
+                });
+                return;
+            }
             this.handle(req.body, req.headers['x-hatchet-signature'], secret)
                 .then(() => {
                 res.sendStatus(200);
             })
-                .catch((e) => {
+                .catch((err) => {
                 res.sendStatus(500);
-                this.worker.logger.error(`Error handling request: ${e.message}`);
+                this.worker.logger.error(`Error handling request: ${err.message}`);
             });
         };
     }
@@ -102,7 +122,7 @@ class WebhookHandler {
             const handle = () => __awaiter(this, void 0, void 0, function* () {
                 if (req.method === 'GET') {
                     res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.write(JSON.stringify(this.getHealthcheckResponse()));
+                    res.write('OK!');
                     res.end();
                     return;
                 }
@@ -112,6 +132,13 @@ class WebhookHandler {
                     res.end();
                     return;
                 }
+                if (req.headers['x-healthcheck']) {
+                    const resp = yield this.getHealthcheckResponse();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.write(JSON.stringify(resp));
+                    res.end();
+                    return;
+                }
                 const body = yield this.getBody(req);
                 yield this.handle(body, secret, req.headers['x-hatchet-signature']);
                 res.writeHead(200, 'OK');
@@ -132,15 +159,19 @@ class WebhookHandler {
      * @return {Promise<Response>} - A Promise that resolves with a Response object.
      */
     nextJSHandler({ secret }) {
-        const healthcheck = () => __awaiter(this, void 0, void 0, function* () {
-            return new Response(JSON.stringify(this.getHealthcheckResponse()), { status: 200 });
+        const ok = () => __awaiter(this, void 0, void 0, function* () {
+            return new Response('OK!', { status: 200 });
         });
         const f = (req) => __awaiter(this, void 0, void 0, function* () {
+            if (req.headers.get('x-healthcheck')) {
+                const resp = yield this.getHealthcheckResponse();
+                return new Response(JSON.stringify(resp), { status: 200 });
+            }
             yield this.handle(yield req.text(), secret, req.headers.get('x-hatchet-signature'));
             return new Response('ok', { status: 200 });
         });
         return {
-            GET: healthcheck,
+            GET: ok,
             POST: f,
             PUT: f,
         };

package/clients/worker/worker.d.ts

@@ -27,10 +27,13 @@ export declare class Worker {
         maxRuns?: number;
     });
     private registerActions;
-    getHandler(workflow: Workflow): WebhookHandler;
+    getHandler(workflows: Workflow[]): WebhookHandler;
     registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorker, any>>;
-    registerWorkflow(initWorkflow: Workflow): Promise<void>;
+    /**
+     * @deprecated use registerWorkflow instead
+     */
     register_workflow(initWorkflow: Workflow): Promise<void>;
+    registerWorkflow(initWorkflow: Workflow): Promise<void>;
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
     handleStartStepRun(action: Action): Promise<void>;
     handleStartGroupKeyRun(action: Action): Promise<void>;

package/clients/worker/worker.js

@@ -58,23 +58,27 @@ class Worker {
         this.action_registry = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
             ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
     }
-    getHandler(workflow) {
-        const wf = Object.assign(Object.assign({}, workflow), { id: this.client.config.namespace + workflow.id });
-        this.registerActions(wf);
-        return new handler_1.WebhookHandler(this);
+    getHandler(workflows) {
+        for (const workflow of workflows) {
+            const wf = Object.assign(Object.assign({}, workflow), { id: this.client.config.namespace + workflow.id });
+            this.registerActions(wf);
+        }
+        return new handler_1.WebhookHandler(this, workflows);
     }
     registerWebhook(webhook) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.client.admin.webhook_create(Object.assign(Object.assign({}, webhook), { workflows: this.registeredWorkflowIds }));
         });
     }
-    // @deprecated
-    registerWorkflow(initWorkflow) {
+    /**
+     * @deprecated use registerWorkflow instead
+     */
+    register_workflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.register_workflow(initWorkflow);
+            return this.registerWorkflow(initWorkflow);
         });
     }
-    register_workflow(initWorkflow) {
+    registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const workflow = Object.assign(Object.assign({}, initWorkflow), { id: this.client.config.namespace + initWorkflow.id });
@@ -105,12 +109,14 @@ class Worker {
                     }
                     : undefined;
                 this.registeredWorkflowIds.push(workflow.id);
-                const registeredWorkflow = this.client.admin.put_workflow({
+                const registeredWorkflow = this.client.admin.putWorkflow({
                     name: workflow.id,
                     description: workflow.description,
                     version: workflow.version || '',
-                    eventTriggers: workflow.on.event ? [this.client.config.namespace + workflow.on.event] : [],
-                    cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
+                    eventTriggers: workflow.on && workflow.on.event
+                        ? [this.client.config.namespace + workflow.on.event]
+                        : [],
+                    cronTriggers: workflow.on && workflow.on.cron ? [workflow.on.cron] : [],
                     scheduledTriggers: [],
                     concurrency,
                     scheduleTimeout: workflow.scheduleTimeout,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.8.0-alpha.2",
+  "version": "0.8.0-alpha.3",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/protoc/dispatcher/dispatcher.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.178.0
+//   protoc-gen-ts_proto  v1.180.0
 //   protoc               v3.19.1
 // source: dispatcher/dispatcher.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

package/protoc/events/events.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.178.0
+//   protoc-gen-ts_proto  v1.180.0
 //   protoc               v3.19.1
 // source: events/events.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

package/protoc/google/protobuf/timestamp.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.178.0
+//   protoc-gen-ts_proto  v1.180.0
 //   protoc               v3.19.1
 // source: google/protobuf/timestamp.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

package/protoc/workflows/workflows.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.178.0
+//   protoc-gen-ts_proto  v1.180.0
 //   protoc               v3.19.1
 // source: workflows/workflows.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

package/step.d.ts

@@ -67,7 +67,7 @@ declare class ChildWorkflowRef<T> {
     result(): Promise<T>;
     toJSON(): Promise<string>;
 }
-export declare class Context<T, K> {
+export declare class Context<T, K = {}> {
     data: ContextData<T, K>;
     input: T;
     controller: AbortController;

package/step.js

@@ -229,7 +229,7 @@ class Context {
     spawnWorkflow(workflowName, input, key) {
         const { workflowRunId, stepRunId } = this.action;
         const name = this.client.config.namespace + workflowName;
-        const childWorkflowRunIdPromise = this.client.admin.run_workflow(name, input, {
+        const childWorkflowRunIdPromise = this.client.admin.runWorkflow(name, input, {
             parentId: workflowRunId,
             parentStepRunId: stepRunId,
             childKey: key,

package/workflow.d.ts

@@ -60,7 +60,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
      * @deprecated Workflow timeout is deprecated. Use step timeouts instead.
      */
     timeout: z.ZodOptional<z.ZodString>;
-    on: z.ZodUnion<[z.ZodObject<{
+    on: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         cron: z.ZodString;
         event: z.ZodUndefined;
     }, "strip", z.ZodTypeAny, {
@@ -78,7 +78,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
     }, {
         event: string;
         cron?: undefined;
-    }>]>;
+    }>]>>;
     steps: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -160,16 +160,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         }[] | undefined;
     }[];
     id: string;
-    on: {
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    timeout?: string | undefined;
+    on?: {
         cron: string;
         event?: undefined;
     } | {
         event: string;
         cron?: undefined;
-    };
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    timeout?: string | undefined;
+    } | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;
@@ -193,16 +193,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         }[] | undefined;
     }[];
     id: string;
-    on: {
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    timeout?: string | undefined;
+    on?: {
         cron: string;
         event?: undefined;
     } | {
         event: string;
         cron?: undefined;
-    };
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    timeout?: string | undefined;
+    } | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;

package/workflow.js

@@ -35,7 +35,7 @@ const EventConfigSchema = z.object({
     cron: z.undefined(),
     event: z.string(),
 });
-const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
+const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]).optional();
 const StepsSchema = z.array(step_1.CreateStepSchema);
 exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
 exports.WorkflowConcurrency = z.object({