@hatchet-dev/typescript-sdk 0.20.3 → 1.0.0-alpha1

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

@@ -62,7 +62,6 @@ class CronClient {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             const workflowId = typeof workflow === 'string' ? workflow : workflow.id;
-            console.log('workflowId', workflowId);
             // Validate cron input with zod schema
             try {
                 const parsedCron = exports.CreateCronTriggerSchema.parse(cron);

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

@@ -2,10 +2,11 @@ import { EventClient } from '../event/event-client';
 import { DispatcherClient } from '../dispatcher/dispatcher-client';
 import { AdminClient } from '../admin/admin-client';
 import { CallOptions, ChannelCredentials, ClientMiddlewareCall } from 'nice-grpc';
-import { Workflow } from '../../workflow';
-import { Worker, WorkerOpts } from '../worker';
+import { Workflow as V0Workflow } from '../../workflow';
+import { V0Worker, WorkerOpts } from '../worker';
 import { AxiosRequestConfig } from 'axios';
 import { Logger } from '../../util/logger';
+import { WorkflowDeclaration as V1Workflow } from '../../v1/workflow';
 import { ClientConfig } from './client-config';
 import { ListenerClient } from '../listener/listener-client';
 import { Api } from '../rest/generated/Api';
@@ -17,7 +18,7 @@ export interface HatchetClientOptions {
 }
 export declare const channelFactory: (config: ClientConfig, credentials: ChannelCredentials) => import("nice-grpc").Channel;
 export declare const addTokenMiddleware: (token: string) => <Request, Response>(call: ClientMiddlewareCall<Request, Response>, options: CallOptions) => AsyncGenerator<Awaited<Response>, Awaited<Response> | undefined, undefined>;
-export declare class HatchetClient {
+export declare class InternalHatchetClient {
     config: ClientConfig;
     credentials: ChannelCredentials;
     event: EventClient;
@@ -30,8 +31,8 @@ export declare class HatchetClient {
     cron: CronClient;
     schedule: ScheduleClient;
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig);
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
-    run(workflow: string | Workflow): Promise<Worker>;
-    worker(workflow: string | Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<Worker>;
-    webhooks(workflows: Workflow[]): import("../worker/handler").WebhookHandler;
+    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): InternalHatchetClient;
+    run(workflow: string | V0Workflow): Promise<V0Worker>;
+    worker(workflow: string | V0Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<V0Worker>;
+    webhooks(workflows: Array<V1Workflow<any, any> | V0Workflow>): import("../worker/handler").WebhookHandler;
 }

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

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HatchetClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
+exports.InternalHatchetClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
 const zod_1 = require("zod");
 const config_loader_1 = require("../../util/config-loader");
 const event_client_1 = require("../event/event-client");
@@ -46,6 +46,7 @@ const admin_client_1 = require("../admin/admin-client");
 const nice_grpc_1 = require("nice-grpc");
 const worker_1 = require("../worker");
 const hatchet_logger_1 = require("./hatchet-logger");
+const worker_2 = require("../../v1/client/worker");
 const client_config_1 = require("./client-config");
 const listener_client_1 = require("../listener/listener-client");
 const rest_1 = __importDefault(require("../rest"));
@@ -88,7 +89,7 @@ const addTokenMiddleware = (token) => function _(call, options) {
     });
 };
 exports.addTokenMiddleware = addTokenMiddleware;
-class HatchetClient {
+class InternalHatchetClient {
     constructor(config, options, axiosOpts) {
         // Initializes a new Client instance.
         // Loads config in the following order: config param > yaml file > env vars
@@ -120,13 +121,13 @@ class HatchetClient {
         this.listener = new listener_client_1.ListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.admin = new admin_client_1.AdminClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api, this.tenantId, this.listener);
         this.logger = this.config.logger('HatchetClient', this.config.log_level);
-        this.logger.info(`Initialized HatchetClient`);
+        this.logger.debug(`Initialized HatchetClient`);
         // Feature Clients
         this.cron = new cron_client_1.CronClient(this.tenantId, this.config, this.api, this.admin);
         this.schedule = new schedule_client_1.ScheduleClient(this.tenantId, this.config, this.api, this.admin);
     }
     static init(config, options, axiosConfig) {
-        return new HatchetClient(config, options, axiosConfig);
+        return new InternalHatchetClient(config, options, axiosConfig);
     }
     // @deprecated
     run(workflow) {
@@ -150,7 +151,7 @@ class HatchetClient {
             else {
                 options = Object.assign(Object.assign({}, options), opts);
             }
-            const worker = new worker_1.Worker(this, options);
+            const worker = new worker_1.V0Worker(this, options);
             if (typeof workflow !== 'string') {
                 yield worker.registerWorkflow(workflow);
                 return worker;
@@ -159,10 +160,10 @@ class HatchetClient {
         });
     }
     webhooks(workflows) {
-        const worker = new worker_1.Worker(this, {
+        const worker = new worker_1.V0Worker(this, {
             name: 'webhook-worker',
         });
-        return worker.getHandler(workflows);
+        return worker.getHandler(workflows.map(worker_2.toV0Workflow));
     }
 }
-exports.HatchetClient = HatchetClient;
+exports.InternalHatchetClient = InternalHatchetClient;

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

@@ -20,7 +20,6 @@ class HatchetLogger {
                 minute: '2-digit',
                 second: '2-digit',
             });
-            // eslint-disable-next-line no-console
             // eslint-disable-next-line prefer-destructuring
             let print = console.log;
             if (level === 'ERROR') {

package/clients/worker/handler.d.ts

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

package/clients/worker/worker.d.ts

@@ -1,4 +1,4 @@
-import { HatchetClient } from '../hatchet-client';
+import { InternalHatchetClient } from '../hatchet-client';
 import { Action, ActionListener } from '../dispatcher/action-listener';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../protoc/dispatcher';
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
@@ -15,8 +15,8 @@ export interface WorkerOpts {
     maxRuns?: number;
     labels?: WorkerLabels;
 }
-export declare class Worker {
-    client: HatchetClient;
+export declare class V0Worker {
+    client: InternalHatchetClient;
     name: string;
     workerId: string | undefined;
     killing: boolean;
@@ -30,7 +30,7 @@ export declare class Worker {
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
     labels: WorkerLabels;
-    constructor(client: HatchetClient, options: {
+    constructor(client: InternalHatchetClient, options: {
         name: string;
         handleKill?: boolean;
         maxRuns?: number;

package/clients/worker/worker.js

@@ -19,14 +19,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
+exports.V0Worker = 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 handler_1 = require("./handler");
 const step_1 = require("../../step");
-class Worker {
+class V0Worker {
     constructor(client, options) {
         this.workflow_registry = [];
         this.futures = {};
@@ -482,7 +482,7 @@ class Worker {
         });
     }
 }
-exports.Worker = Worker;
+exports.V0Worker = V0Worker;
 function toPbWorkerLabel(in_) {
     if (!in_) {
         return {};

package/examples/api.js

@@ -49,7 +49,7 @@ function main() {
         const { admin } = hatchet;
         yield admin.putWorkflow(opts);
         const worker = yield hatchet.worker('example-worker');
-        worker.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
+        worker.v0.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
             const setData = ctx.userData();
             console.log('executed step1!', setData);
             return { step1: 'step1' };

package/examples/example-event-with-results.js

@@ -27,7 +27,7 @@ function main() {
         const ref = yield hatchet.admin.runWorkflow('simple-workflow', {
             test: 'test',
         });
-        const listener = yield hatchet.listener.stream(yield ref.getWorkflowRunId());
+        const listener = yield hatchet.v0.listener.stream(yield ref.getWorkflowRunId());
         console.log('listening for events');
         try {
             for (var _d = true, listener_1 = __asyncValues(listener), listener_1_1; listener_1_1 = yield listener_1.next(), _a = listener_1_1.done, !_a; _d = true) {

package/examples/stream-by-additional-meta.js

@@ -34,7 +34,7 @@ function main() {
         // and can have an arbitrary property name.
         yield hatchet.admin.runWorkflow('parent-workflow', {}, { additionalMetadata: { [streamKey]: streamVal } });
         // Stream all events for the additional meta key value
-        const stream = yield hatchet.listener.streamByAdditionalMeta(streamKey, streamVal);
+        const stream = yield hatchet.v0.listener.streamByAdditionalMeta(streamKey, streamVal);
         try {
             for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
                 _c = stream_1_1.value;

package/index.d.ts

@@ -1,9 +1,12 @@
-import { HatchetClient as Hatchet } from './clients/hatchet-client';
+import { HatchetClient as Hatchet } from './v1/client/client';
 export * from './workflow';
 export * from './step';
 export * from './clients/worker';
 export * from './clients/rest';
 export * from './clients/admin';
 export * from './util/workflow-run-ref';
+export * from './v1/client/client';
+export * from './v1/client/worker';
+export * from './v1/workflow';
 export default Hatchet;
 export { Hatchet };

package/index.js

@@ -15,12 +15,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hatchet = void 0;
-const hatchet_client_1 = require("./clients/hatchet-client");
-Object.defineProperty(exports, "Hatchet", { enumerable: true, get: function () { return hatchet_client_1.HatchetClient; } });
+const client_1 = require("./v1/client/client");
+Object.defineProperty(exports, "Hatchet", { enumerable: true, get: function () { return client_1.HatchetClient; } });
 __exportStar(require("./workflow"), exports);
 __exportStar(require("./step"), exports);
 __exportStar(require("./clients/worker"), exports);
 __exportStar(require("./clients/rest"), exports);
 __exportStar(require("./clients/admin"), exports);
 __exportStar(require("./util/workflow-run-ref"), exports);
-exports.default = hatchet_client_1.HatchetClient;
+__exportStar(require("./v1/client/client"), exports);
+__exportStar(require("./v1/client/worker"), exports);
+__exportStar(require("./v1/workflow"), exports);
+exports.default = client_1.HatchetClient;

package/package.json

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

package/sdk.d.ts

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

package/sdk.js

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

package/step.d.ts

@@ -3,11 +3,13 @@ import { Workflow } from './workflow';
 import { Action } from './clients/dispatcher/action-listener';
 import { LogLevel } from './clients/event/event-client';
 import { Logger } from './util/logger';
-import { HatchetClient } from './clients/hatchet-client';
+import { InternalHatchetClient } from './clients/hatchet-client';
 import WorkflowRunRef from './util/workflow-run-ref';
-import { Worker } from './clients/worker';
+import { V0Worker } from './clients/worker';
 import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
 import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
+import { CreateTaskOpts } from './v1/task';
+import { WorkflowDeclaration as WorkflowV1 } from './v1/workflow';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     staticKey: z.ZodOptional<z.ZodString>;
@@ -166,7 +168,7 @@ interface ContextData<T, K> {
 }
 export declare class ContextWorker {
     private worker;
-    constructor(worker: Worker);
+    constructor(worker: V0Worker);
     id(): string | undefined;
     hasWorkflow(workflowName: string): boolean;
     labels(): WorkerLabels;
@@ -177,13 +179,14 @@ export declare class Context<T, K = {}> {
     input: T;
     controller: AbortController;
     action: Action;
-    client: HatchetClient;
+    client: InternalHatchetClient;
     worker: ContextWorker;
     overridesData: Record<string, any>;
     logger: Logger;
     spawnIndex: number;
-    constructor(action: Action, client: HatchetClient, worker: Worker);
-    stepOutput(step: string): NextStep;
+    constructor(action: Action, client: InternalHatchetClient, worker: V0Worker);
+    parentData<L = NextStep>(task: CreateTaskOpts<any, L> | string): Promise<L>;
+    stepOutput<L = NextStep>(step: string): L;
     stepRunErrors(): Record<string, string>;
     triggeredByEvent(): boolean;
     workflowInput(): T;
@@ -203,14 +206,43 @@ export declare class Context<T, K = {}> {
     refreshTimeout(incrementBy: string): Promise<void>;
     releaseSlot(): Promise<void>;
     putStream(data: string | Uint8Array): Promise<void>;
+    /**
+     * Enqueues multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of workflow run references to the enqueued runs
+     */
+    bulkEnqueueChildren<Q extends JsonObject = any, P extends JsonObject = any>(children: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: {
+            key?: string;
+            sticky?: boolean;
+            additionalMetadata?: Record<string, string>;
+        };
+    }>): Promise<WorkflowRunRef<P>[]>;
+    /**
+     * Runs multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of results from the children workflows
+     */
+    bulkRunChildren<Q extends JsonObject = any, P extends JsonObject = any>(children: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: {
+            key?: string;
+            sticky?: boolean;
+            additionalMetadata?: Record<string, string>;
+        };
+    }>): Promise<P[]>;
     /**
      * Spawns multiple workflows.
      *
      * @param workflows an array of objects containing the workflow name, input data, and options for each workflow
      * @returns a list of references to the spawned workflow runs
+     * @deprecated use bulkEnqueueChildren or bulkRunChildren instead
      */
-    spawnWorkflows<Q = JsonValue, P = JsonValue>(workflows: Array<{
-        workflow: string | Workflow;
+    spawnWorkflows<Q extends JsonObject = any, P extends JsonObject = any>(workflows: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
         input: Q;
         options?: {
             key?: string;
@@ -218,6 +250,39 @@ export declare class Context<T, K = {}> {
             additionalMetadata?: Record<string, string>;
         };
     }>): Promise<WorkflowRunRef<P>[]>;
+    /**
+     * Runs a new workflow.
+     *
+     * @param workflow the workflow to run
+     * @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 <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return the result of the workflow
+     */
+    runChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+        key?: string;
+        sticky?: boolean;
+        additionalMetadata?: Record<string, string>;
+    }): Promise<P>;
+    /**
+     * Enqueues a new workflow.
+     *
+     * @param workflowName the name of the workflow to spawn
+     * @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.
+     *                If an object is provided, it can include:
+     *                - key: a unique identifier for the workflow (deprecated, use options.key instead)
+     *                - sticky: a boolean indicating whether to use sticky execution
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return a reference to the spawned workflow run
+     */
+    enqueueChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+        key?: string;
+        sticky?: boolean;
+        additionalMetadata?: Record<string, string>;
+    }): WorkflowRunRef<P>;
     /**
      * Spawns a new workflow.
      *
@@ -230,8 +295,9 @@ export declare class Context<T, K = {}> {
      * @param <Q> the type of the input data
      * @param <P> the type of the output data
      * @return a reference to the spawned workflow run
+     * @deprecated use runChild or enqueueChild instead
      */
-    spawnWorkflow<Q = JsonValue, P = JsonValue>(workflow: string | Workflow, input: Q, options?: string | {
+    spawnWorkflow<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;

package/step.js

@@ -50,7 +50,6 @@ exports.mapRateLimit = mapRateLimit;
 /* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
-const workflow_1 = require("./workflow");
 const parse_1 = require("./util/parse");
 const workflows_1 = require("./protoc/workflows");
 exports.CreateRateLimitSchema = z.object({
@@ -79,7 +78,7 @@ exports.DesiredWorkerLabelSchema = z
 exports.CreateStepSchema = z.object({
     name: z.string(),
     parents: z.array(z.string()).optional(),
-    timeout: workflow_1.HatchetTimeoutSchema.optional(),
+    timeout: z.string().optional(),
     retries: z.number().optional(),
     rate_limits: z.array(exports.CreateRateLimitSchema).optional(),
     worker_labels: z.record(z.lazy(() => exports.DesiredWorkerLabelSchema)).optional(),
@@ -133,6 +132,16 @@ class Context {
             throw new hatchet_error_1.default(`Could not parse payload: ${e.message}`);
         }
     }
+    // NOTE: parentData is async since we plan on potentially making this a cacheable server call
+    parentData(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof task === 'string') {
+                return this.stepOutput(task);
+            }
+            return this.stepOutput(task.name);
+        });
+    }
+    // TODO deprecated
     stepOutput(step) {
         if (!this.data.parents) {
             throw new hatchet_error_1.default('Step output not found');
@@ -227,11 +236,32 @@ class Context {
             yield this.client.event.putStream(stepRunId, data);
         });
     }
+    /**
+     * Enqueues multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of workflow run references to the enqueued runs
+     */
+    bulkEnqueueChildren(children) {
+        return this.spawnWorkflows(children);
+    }
+    /**
+     * Runs multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of results from the children workflows
+     */
+    bulkRunChildren(children) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runs = yield this.bulkEnqueueChildren(children);
+            const res = runs.map((run) => run.result());
+            return Promise.all(res);
+        });
+    }
     /**
      * Spawns multiple workflows.
      *
      * @param workflows an array of objects containing the workflow name, input data, and options for each workflow
      * @returns a list of references to the spawned workflow runs
+     * @deprecated use bulkEnqueueChildren or bulkRunChildren instead
      */
     spawnWorkflows(workflows) {
         const { workflowRunId, stepRunId } = this.action;
@@ -278,6 +308,38 @@ class Context {
             throw new hatchet_error_1.default(e.message);
         }
     }
+    /**
+     * Runs a new workflow.
+     *
+     * @param workflow the workflow to run
+     * @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 <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return the result of the workflow
+     */
+    runChild(workflow, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const run = yield this.spawnWorkflow(workflow, input, options);
+            return run.result();
+        });
+    }
+    /**
+     * Enqueues a new workflow.
+     *
+     * @param workflowName the name of the workflow to spawn
+     * @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.
+     *                If an object is provided, it can include:
+     *                - key: a unique identifier for the workflow (deprecated, use options.key instead)
+     *                - sticky: a boolean indicating whether to use sticky execution
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return a reference to the spawned workflow run
+     */
+    enqueueChild(workflow, input, options) {
+        return this.spawnWorkflow(workflow, input, options);
+    }
     /**
      * Spawns a new workflow.
      *
@@ -290,6 +352,7 @@ class Context {
      * @param <Q> the type of the input data
      * @param <P> the type of the output data
      * @return a reference to the spawned workflow run
+     * @deprecated use runChild or enqueueChild instead
      */
     spawnWorkflow(workflow, input, options) {
         const { workflowRunId, stepRunId } = this.action;

package/util/hatchet-promise/hatchet-promise.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 class HatchetPromise {
     constructor(promise) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         this.cancel = (reason) => { };
         this.promise = new Promise((resolve, reject) => {
             this.cancel = reject;

package/v1/client/client.d.ts

@@ -0,0 +1,82 @@
+import { ClientConfig, InternalHatchetClient, HatchetClientOptions } from '../../clients/hatchet-client';
+import { AxiosRequestConfig } from 'axios';
+import WorkflowRunRef from '../../util/workflow-run-ref';
+import { Workflow as V0Workflow } from '../../workflow';
+import { JsonObject } from '../../step';
+import { CreateWorkflowOpts, RunOpts, WorkflowDeclaration } from '../workflow';
+import { IHatchetClient } from './client.interface';
+import { CreateWorkerOpts, Worker } from './worker';
+/**
+ * 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.
+ */
+export declare class HatchetClient implements IHatchetClient {
+    /** The underlying v0 client instance */
+    v0: InternalHatchetClient;
+    /** The tenant ID for the Hatchet client */
+    get tenantId(): string;
+    /**
+     * Creates a new Hatchet client instance.
+     * @param config - Optional configuration for the client
+     * @param options - Optional client options
+     * @param axiosConfig - Optional Axios configuration for HTTP requests
+     */
+    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
+    /**
+     * Static factory method to create a new Hatchet client instance.
+     * @param config - Optional configuration for the client
+     * @param options - Optional client options
+     * @param axiosConfig - Optional Axios configuration for HTTP requests
+     * @returns A new Hatchet client instance
+     */
+    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
+     * @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>;
+    /**
+     * Triggers a workflow run without waiting for completion.
+     * @template T - The input type for the workflow
+     * @template K - 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
+     */
+    enqueue<T extends JsonObject = any, K extends JsonObject = any>(workflow: WorkflowDeclaration<T, K> | string | V0Workflow, input: T, options: RunOpts): WorkflowRunRef<K>;
+    /**
+     * 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
+     * @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: WorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    get cron(): import("../../clients/hatchet-client/features/cron-client").CronClient;
+    get schedule(): import("../../clients/hatchet-client/features/schedule-client").ScheduleClient;
+    get event(): import("../../clients/event/event-client").EventClient;
+    get api(): import("../..").Api<unknown>;
+    /**
+     * @deprecated use workflow.run or client.run instead
+     */
+    get admin(): import("../..").AdminClient;
+    /**
+     * Creates a new worker instance for processing workflow tasks.
+     * @param options - Configuration options for creating the worker
+     * @returns A promise that resolves with a new HatchetWorker instance
+     */
+    worker(name: string, options?: CreateWorkerOpts | number): Promise<Worker>;
+    /**
+     * Register a webhook with the worker
+     * @param workflows - The workflows to register on the webhooks
+     * @returns A promise that resolves when the webhook is registered
+     */
+    webhooks(workflows: WorkflowDeclaration<any, any>[] | V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
+}

package/v1/client/client.interface.d.ts

@@ -0,0 +1,4 @@
+import { InternalHatchetClient } from '../../clients/hatchet-client';
+export interface IHatchetClient {
+    v0: InternalHatchetClient;
+}

package/v1/client/client.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });