@hatchet-dev/typescript-sdk 1.0.2 → 1.0.4

package/clients/dispatcher/heartbeat/heartbeat-controller.d.ts

@@ -3,6 +3,11 @@ import { DispatcherClient as PbDispatcherClient } from '../../../protoc/dispatch
 import { Worker } from 'worker_threads';
 import { ClientConfig } from '../../hatchet-client';
 import { DispatcherClient } from '../dispatcher-client';
+export interface HeartbeatMessage {
+    type: 'info' | 'warn' | 'error' | 'debug';
+    message: string;
+}
+export declare const STOP_HEARTBEAT = "stop";
 export declare class Heartbeat {
     config: ClientConfig;
     client: PbDispatcherClient;

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

@@ -12,9 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heartbeat = void 0;
+exports.Heartbeat = exports.STOP_HEARTBEAT = void 0;
 const path_1 = __importDefault(require("path"));
 const thread_helper_1 = require("../../../util/thread-helper");
+exports.STOP_HEARTBEAT = 'stop';
 class Heartbeat {
     constructor(client, workerId) {
         this.config = client.config;
@@ -31,13 +32,16 @@ class Heartbeat {
                         workerId: this.workerId,
                     },
                 });
+                this.heartbeatWorker.on('message', (message) => {
+                    this.logger[message.type](message.message);
+                });
             }
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            (_a = this.heartbeatWorker) === null || _a === void 0 ? void 0 : _a.postMessage('stop');
+            (_a = this.heartbeatWorker) === null || _a === void 0 ? void 0 : _a.postMessage(exports.STOP_HEARTBEAT);
             (_b = this.heartbeatWorker) === null || _b === void 0 ? void 0 : _b.terminate();
             this.heartbeatWorker = undefined;
         });

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

@@ -14,16 +14,25 @@ const hatchet_client_1 = require("../../hatchet-client");
 const config_loader_1 = require("../../../util/config-loader");
 const nice_grpc_1 = require("nice-grpc");
 const dispatcher_client_1 = require("../dispatcher-client");
+const heartbeat_controller_1 = require("./heartbeat-controller");
 const HEARTBEAT_INTERVAL = 4000;
+const postMessage = (message) => {
+    worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage(message);
+};
 class HeartbeatWorker {
     constructor(config, workerId) {
         this.timeLastHeartbeat = new Date().getTime();
         this.workerId = workerId;
-        this.logger = new hatchet_client_1.HatchetLogger(`Heartbeat`, config.log_level);
+        this.logger = new hatchet_client_1.HatchetLogger(`HeartbeatThread`, config.log_level);
+        this.logger.debug('Heartbeat thread starting...');
         const credentials = config_loader_1.ConfigLoader.createCredentials(config.tls_config);
         const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, hatchet_client_1.addTokenMiddleware)(config.token));
         const dispatcher = new dispatcher_client_1.DispatcherClient(Object.assign(Object.assign({}, config), { logger: (ctx, level) => new hatchet_client_1.HatchetLogger(ctx, level) }), (0, hatchet_client_1.channelFactory)(config, credentials), clientFactory);
         this.client = dispatcher.client;
+        postMessage({
+            type: 'debug',
+            message: 'Heartbeat thread started.',
+        });
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -33,6 +42,10 @@ class HeartbeatWorker {
             const beat = () => __awaiter(this, void 0, void 0, function* () {
                 try {
                     this.logger.debug('Heartbeat sending...');
+                    postMessage({
+                        type: 'debug',
+                        message: 'Heartbeat sending...',
+                    });
                     yield this.client.heartbeat({
                         workerId: this.workerId,
                         heartbeatAt: new Date(),
@@ -40,19 +53,38 @@ class HeartbeatWorker {
                     const now = new Date().getTime();
                     const actualInterval = now - this.timeLastHeartbeat;
                     if (actualInterval > HEARTBEAT_INTERVAL * 1.2) {
-                        this.logger.warn(`Heartbeat interval delay (${actualInterval}ms >> ${HEARTBEAT_INTERVAL}ms)`);
+                        const message = `Heartbeat interval delay (${actualInterval}ms >> ${HEARTBEAT_INTERVAL}ms)`;
+                        this.logger.warn(message);
+                        postMessage({
+                            type: 'warn',
+                            message,
+                        });
                     }
                     this.logger.debug(`Heartbeat sent ${actualInterval}ms ago`);
+                    postMessage({
+                        type: 'debug',
+                        message: `Heartbeat sent ${actualInterval}ms ago`,
+                    });
                     this.timeLastHeartbeat = now;
                 }
                 catch (e) {
                     if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
                         // break out of interval
-                        this.logger.error('Heartbeat not implemented, closing heartbeat');
+                        const message = 'Heartbeat not implemented, closing heartbeat';
+                        this.logger.debug(message);
+                        postMessage({
+                            type: 'error',
+                            message,
+                        });
                         this.stop();
                         return;
                     }
-                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                    const message = `Failed to send heartbeat: ${e.message}`;
+                    this.logger.debug(message);
+                    postMessage({
+                        type: 'error',
+                        message,
+                    });
                 }
             });
             // start with a heartbeat
@@ -69,6 +101,6 @@ class HeartbeatWorker {
 }
 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('stop', () => {
+worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.on(heartbeat_controller_1.STOP_HEARTBEAT, () => {
     heartbeat.stop();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -70,7 +70,8 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "@types/jest": "^29.5.11",
+    "@tsd/typescript": "^5.8.2",
+    "@types/jest": "^29.5.14",
     "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^6.4.0",
     "autoprefixer": "^10.4.16",
@@ -91,6 +92,7 @@
     "eslint-plugin-unused-imports": "^4.1.3",
     "grpc-tools": "^1.12.4",
     "jest": "^29.7.0",
+    "jest-tsd": "^0.2.2",
     "pino": "^9.6.0",
     "prettier": "^3.1.1",
     "resolve-tspaths": "^0.8.17",

package/step.d.ts

@@ -12,6 +12,7 @@ import { CreateWorkflowTaskOpts } from './v1/task';
 import { BaseWorkflowDeclaration as WorkflowV1 } from './v1/declaration';
 import { Conditions } from './v1/conditions';
 import { Duration } from './v1/client/duration';
+import { JsonObject, JsonValue, OutputType } from './v1/types';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     staticKey: z.ZodOptional<z.ZodString>;
@@ -150,14 +151,6 @@ export declare const CreateStepSchema: z.ZodObject<{
         maxSeconds?: number | undefined;
     } | undefined;
 }>;
-export type JsonObject = {
-    [Key in string]: JsonValue;
-} & {
-    [Key in string]?: JsonValue | undefined;
-};
-export type JsonArray = JsonValue[] | readonly JsonValue[];
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 export type NextStep = {
     [key: string]: JsonValue;
 };
@@ -211,12 +204,11 @@ export declare class Context<T, K = {}> {
     get cancelled(): boolean;
     /**
      * Retrieves the output of a parent task.
-     * @param task - The name of the task or a CreateTaskOpts object.
+     * @param parentTask - The a CreateTaskOpts or string of the parent task name.
      * @returns The output of the specified parent task.
      * @throws An error if the task output is not found.
-     *
      */
-    parentOutput<L = NextStep>(task: CreateWorkflowTaskOpts<any, L> | string): Promise<L>;
+    parentOutput<L extends OutputType>(parentTask: CreateWorkflowTaskOpts<any, L> | string): Promise<L>;
     /**
      * Get the output of a task.
      * @param task - The name of the task to get the output for.
@@ -229,7 +221,7 @@ export declare class Context<T, K = {}> {
      * Returns errors from any task runs in the workflow.
      * @returns A record mapping task names to error messages.
      * @throws A warning if no errors are found (this method should be used in on-failure tasks).
-     * @deprecated use ctx.errors instead
+     * @deprecated use ctx.errors() instead
      */
     stepRunErrors(): Record<string, string>;
     /**
@@ -251,6 +243,7 @@ export declare class Context<T, K = {}> {
     /**
      * Gets the input data for the current workflow.
      * @returns The input data for the workflow.
+     * @deprecated use task input parameter instead
      */
     workflowInput(): T;
     /**
@@ -279,6 +272,11 @@ export declare class Context<T, K = {}> {
      * @returns The workflow run ID.
      */
     workflowRunId(): string;
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     */
+    taskRunId(): string;
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.
@@ -357,10 +355,10 @@ export declare class Context<T, K = {}> {
      *
      * @param workflow - The workflow to run (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow. If a string is provided, it is used as the key.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns The result of the workflow.
      */
-    runChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+    runChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, optionsOrKey?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;
@@ -370,10 +368,10 @@ export declare class Context<T, K = {}> {
      *
      * @param workflow - The workflow to enqueue (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns A reference to the spawned workflow run.
      */
-    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, optionsOrKey?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;

package/step.js

@@ -162,18 +162,17 @@ class Context {
     }
     /**
      * Retrieves the output of a parent task.
-     * @param task - The name of the task or a CreateTaskOpts object.
+     * @param parentTask - The a CreateTaskOpts or string of the parent task name.
      * @returns The output of the specified parent task.
      * @throws An error if the task output is not found.
-     *
      */
-    parentOutput(task) {
+    parentOutput(parentTask) {
         return __awaiter(this, void 0, void 0, function* () {
             // NOTE: parentOutput is async since we plan on potentially making this a cacheable server call
-            if (typeof task === 'string') {
-                return this.stepOutput(task);
+            if (typeof parentTask === 'string') {
+                return this.stepOutput(parentTask);
             }
-            return this.stepOutput(task.name);
+            return this.stepOutput(parentTask.name);
         });
     }
     /**
@@ -185,10 +184,10 @@ class Context {
      */
     stepOutput(step) {
         if (!this.data.parents) {
-            throw new hatchet_error_1.default('output not found');
+            throw new hatchet_error_1.default('Parent task outputs not found');
         }
         if (!this.data.parents[step]) {
-            throw new hatchet_error_1.default(`output for '${step}' not found`);
+            throw new hatchet_error_1.default(`Output for parent task '${step}' not found`);
         }
         return this.data.parents[step];
     }
@@ -196,7 +195,7 @@ class Context {
      * Returns errors from any task runs in the workflow.
      * @returns A record mapping task names to error messages.
      * @throws A warning if no errors are found (this method should be used in on-failure tasks).
-     * @deprecated use ctx.errors instead
+     * @deprecated use ctx.errors() instead
      */
     stepRunErrors() {
         return this.errors();
@@ -231,6 +230,7 @@ class Context {
     /**
      * Gets the input data for the current workflow.
      * @returns The input data for the workflow.
+     * @deprecated use task input parameter instead
      */
     workflowInput() {
         return this.input;
@@ -272,6 +272,13 @@ class Context {
     workflowRunId() {
         return this.action.workflowRunId;
     }
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     */
+    taskRunId() {
+        return this.action.stepRunId;
+    }
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.
@@ -414,12 +421,12 @@ class Context {
      *
      * @param workflow - The workflow to run (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow. If a string is provided, it is used as the key.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns The result of the workflow.
      */
-    runChild(workflow, input, options) {
+    runChild(workflow, input, optionsOrKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const run = yield this.spawnWorkflow(workflow, input, options);
+            const run = yield this.spawnWorkflow(workflow, input, optionsOrKey);
             return run.output;
         });
     }
@@ -428,11 +435,11 @@ class Context {
      *
      * @param workflow - The workflow to enqueue (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns A reference to the spawned workflow run.
      */
-    runNoWaitChild(workflow, input, options) {
-        return this.spawnWorkflow(workflow, input, options);
+    runNoWaitChild(workflow, input, optionsOrKey) {
+        return this.spawnWorkflow(workflow, input, optionsOrKey);
     }
     /**
      * Spawns a new workflow.

package/v1/client/client.d.ts

@@ -2,7 +2,7 @@ import { ClientConfig, InternalHatchetClient, HatchetClientOptions } from '../..
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
-import { JsonObject, DurableContext } from '../../step';
+import { DurableContext } from '../../step';
 import { Api } from '../../clients/rest';
 import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration } from '../declaration';
 import { IHatchetClient } from './client.interface';
@@ -12,6 +12,7 @@ import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
 import { CreateStandaloneDurableTaskOpts } from '../task';
+import { InputType, OutputType, UnknownInputType, WorkflowOutputType } from '../types';
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -45,80 +46,80 @@ export declare class HatchetClient implements IHatchetClient {
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     /**
      * Creates a new workflow definition.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param options - Configuration options for creating the workflow
      * @returns A new Workflow instance
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
      */
-    workflow<T extends JsonObject = any, K extends JsonObject = any>(options: CreateWorkflowOpts): WorkflowDeclaration<T, K>;
+    workflow<I extends InputType = UnknownInputType, O extends WorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
     /**
      * Creates a new task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
-     * @template T The input type for the task
-     * @template K The output type of the task
+     * @template I The input type for the task
+     * @template O The output type of the task
      * @param options Task configuration options
      * @returns A TaskWorkflowDeclaration instance
      */
-    task<T extends JsonObject, K extends JsonObject>(options: CreateTaskWorkflowOpts<T, K>): TaskWorkflowDeclaration<T, K>;
+    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
     /**
      * Creates a new task workflow with types inferred from the function parameter.
      * @template Fn The type of the task function with input and output extending JsonObject
      * @param options Task configuration options with function that defines types
      * @returns A TaskWorkflowDeclaration instance with inferred types
      */
-    task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+    task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends InputType = Parameters<Fn>[0] | UnknownInputType, O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
     } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
     /**
      * Creates a new durable task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
-     * @template T The input type for the durable task
-     * @template K The output type of the durable task
+     * @template I The input type for the durable task
+     * @template O The output type of the durable task
      * @param options Durable task configuration options
      * @returns A TaskWorkflowDeclaration instance for a durable task
      */
-    durableTask<T extends JsonObject, K extends JsonObject>(options: CreateStandaloneDurableTaskOpts<T, K>): TaskWorkflowDeclaration<T, K>;
+    durableTask<I extends InputType, O extends OutputType>(options: CreateStandaloneDurableTaskOpts<I, O>): TaskWorkflowDeclaration<I, O>;
     /**
      * Creates a new durable task workflow with types inferred from the function parameter.
      * @template Fn The type of the durable task function with input and output extending JsonObject
      * @param options Durable task configuration options with function that defines types
      * @returns A TaskWorkflowDeclaration instance with inferred types
      */
-    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
     } & Omit<CreateStandaloneDurableTaskOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
     /**
      * Triggers a workflow run without waiting for completion.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    runNoWait<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options: RunOpts): WorkflowRunRef<K>;
+    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): WorkflowRunRef<O>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    runAndWait<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    runAndWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<O>;
     /**
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    run<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    run<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<O>;
     /**
      * Get the cron client for creating and managing cron workflow runs
      * @returns A cron client instance

package/v1/client/client.js

@@ -82,8 +82,8 @@ class HatchetClient {
     }
     /**
      * Creates a new workflow definition.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param options - Configuration options for creating the workflow
      * @returns A new Workflow instance
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
@@ -105,8 +105,8 @@ class HatchetClient {
     }
     /**
      * Triggers a workflow run without waiting for completion.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
@@ -128,8 +128,8 @@ class HatchetClient {
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
@@ -142,8 +142,8 @@ class HatchetClient {
     }
     /**
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run