@hatchet-dev/typescript-sdk 1.12.1 → 1.13.0

package/v1/declaration.js

@@ -327,18 +327,36 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
     }
 }
 exports.WorkflowDeclaration = WorkflowDeclaration;
+/**
+ * A standalone task workflow that can be run, scheduled, or triggered via cron.
+ *
+ * @template I - The task-specific input type.
+ * @template O - The task output type.
+ * @template GlobalInput - Global input type from the client, merged into all run/schedule/cron input signatures.
+ * @template MiddlewareBefore - Extra fields added to the task fn input by pre-middleware hooks.
+ * @template MiddlewareAfter - Extra fields merged into the task output by post-middleware hooks.
+ */
 class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
     constructor(options, client) {
         super(Object.assign({}, options), client);
         this._standalone_task_name = options.name;
         this.definition._tasks.push(Object.assign({}, options));
     }
+    runAndWait(input, options) {
+        const _super = Object.create(null, {
+            runAndWait: { get: () => super.runAndWait }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return Array.isArray(input)
+                ? _super.runAndWait.call(this, input, options, this._standalone_task_name)
+                : _super.runAndWait.call(this, input, options, this._standalone_task_name);
+        });
+    }
     run(input, options) {
         const _super = Object.create(null, {
             run: { get: () => super.run }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            // note: typescript is not smart enough to infer that input is an array
             return Array.isArray(input)
                 ? _super.run.call(this, input, options, this._standalone_task_name)
                 : _super.run.call(this, input, options, this._standalone_task_name);
@@ -349,12 +367,58 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
             runNoWait: { get: () => super.runNoWait }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            // note: typescript is not smart enough to infer that input is an array
             return Array.isArray(input)
                 ? _super.runNoWait.call(this, input, options, this._standalone_task_name)
                 : _super.runNoWait.call(this, input, options, this._standalone_task_name);
         });
     }
+    /**
+     * Schedules the task to run at a specific date and time.
+     * @param enqueueAt - The date when the task should be triggered.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     */
+    schedule(enqueueAt, input, options) {
+        const _super = Object.create(null, {
+            schedule: { get: () => super.schedule }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.schedule.call(this, enqueueAt, input, options);
+        });
+    }
+    /**
+     * Schedules the task to run after a specified delay.
+     * @param duration - The delay in seconds before the task should run.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     */
+    delay(duration, input, options) {
+        const _super = Object.create(null, {
+            delay: { get: () => super.delay }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.delay.call(this, duration, input, options);
+        });
+    }
+    /**
+     * Creates a cron schedule for the task.
+     * @param name - The name of the cron schedule.
+     * @param expression - The cron expression defining the schedule.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the cron workflow details.
+     */
+    cron(name, expression, input, options) {
+        const _super = Object.create(null, {
+            cron: { get: () => super.cron }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.cron.call(this, name, expression, input, options);
+        });
+    }
+    /** Returns the underlying task definition for this declaration. */
     get taskDef() {
         return this.definition._tasks[0];
     }

package/v1/examples/cancellations/workflow.d.ts

@@ -1,4 +1,4 @@
 export declare const cancellation: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     Completed: true;
-}>;
-export declare const abortSignal: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void>;
+}, {}, {}, {}, {}>;
+export declare const abortSignal: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;

package/v1/examples/child_workflows/workflow.d.ts

@@ -3,17 +3,17 @@ type ChildInput = {
 };
 export declare const child: import("../..").TaskWorkflowDeclaration<ChildInput, {
     Value: number;
-}>;
+}, {}, {}, {}, {}>;
 type ParentInput = {
     N: number;
 };
 export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
     Result: number;
-}>;
+}, {}, {}, {}, {}>;
 export declare const parentSingleChild: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     Result: number;
-}>;
+}, {}, {}, {}, {}>;
 export declare const withErrorHandling: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     Result: number;
-}>;
+}, {}, {}, {}, {}>;
 export {};

package/v1/examples/concurrency-rr/workflow.d.ts

@@ -7,6 +7,6 @@ type SimpleOutput = {
         TransformedMessage: string;
     };
 };
-export declare const simpleConcurrency: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput>;
-export declare const multipleConcurrencyKeys: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput>;
+export declare const simpleConcurrency: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput, {}>;
+export declare const multipleConcurrencyKeys: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput, {}>;
 export {};

package/v1/examples/dag/interface-workflow.d.ts

@@ -8,5 +8,5 @@ interface DagOutput extends WorkflowOutputType {
         Transformed: string;
     };
 }
-export declare const dag: import("../..").WorkflowDeclaration<DagInput, DagOutput>;
+export declare const dag: import("../..").WorkflowDeclaration<DagInput, DagOutput, {}>;
 export {};

package/v1/examples/dag/workflow.d.ts

@@ -7,5 +7,5 @@ type DagOutput = {
         Transformed: string;
     };
 };
-export declare const dag: import("../..").WorkflowDeclaration<DagInput, DagOutput>;
+export declare const dag: import("../..").WorkflowDeclaration<DagInput, DagOutput, {}>;
 export {};

package/v1/examples/dag_match_condition/complex-workflow.d.ts

@@ -1 +1 @@
-export declare const taskConditionWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
+export declare const taskConditionWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/dag_match_condition/workflow.d.ts

@@ -7,5 +7,5 @@ type DagOutput = {
         Completed: boolean;
     };
 };
-export declare const dagWithConditions: import("../..").WorkflowDeclaration<DagInput, DagOutput>;
+export declare const dagWithConditions: import("../..").WorkflowDeclaration<DagInput, DagOutput, {}>;
 export {};

package/v1/examples/deep/workflow.d.ts

@@ -7,12 +7,12 @@ type Output = {
         Sum: number;
     };
 };
-export declare const child1: import("../..").WorkflowDeclaration<SimpleInput, Output>;
-export declare const child2: import("../..").WorkflowDeclaration<SimpleInput, Output>;
-export declare const child3: import("../..").WorkflowDeclaration<SimpleInput, Output>;
-export declare const child4: import("../..").WorkflowDeclaration<SimpleInput, Output>;
-export declare const child5: import("../..").WorkflowDeclaration<SimpleInput, Output>;
+export declare const child1: import("../..").WorkflowDeclaration<SimpleInput, Output, {}>;
+export declare const child2: import("../..").WorkflowDeclaration<SimpleInput, Output, {}>;
+export declare const child3: import("../..").WorkflowDeclaration<SimpleInput, Output, {}>;
+export declare const child4: import("../..").WorkflowDeclaration<SimpleInput, Output, {}>;
+export declare const child5: import("../..").WorkflowDeclaration<SimpleInput, Output, {}>;
 export declare const parent: import("../..").WorkflowDeclaration<SimpleInput, {
     parent: Output["transformer"];
-}>;
+}, {}>;
 export {};

package/v1/examples/durable-event/workflow.d.ts

@@ -1,6 +1,6 @@
 export declare const durableEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     Value: string;
-}>;
+}, {}, {}, {}, {}>;
 export declare const durableEventWithFilter: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     Value: string;
-}>;
+}, {}, {}, {}, {}>;

package/v1/examples/durable-sleep/workflow.d.ts

@@ -1 +1 @@
-export declare const durableSleep: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
+export declare const durableSleep: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/hatchet-client.d.ts

@@ -1,2 +1,2 @@
 import { HatchetClient } from './..';
-export declare const hatchet: HatchetClient;
+export declare const hatchet: HatchetClient<{}, {}, {}, {}>;

package/v1/examples/high-memory/workflow-with-child.d.ts

@@ -6,7 +6,7 @@ export type ParentInput = {
 };
 export declare const child: import("../..").TaskWorkflowDeclaration<ChildInput, {
     TransformedMessage: string;
-}>;
+}, {}, {}, {}, {}>;
 export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
     TransformedMessage: string;
-}>;
+}, {}, {}, {}, {}>;

package/v1/examples/inferred-typing/workflow.d.ts

@@ -4,12 +4,12 @@ type SimpleInput = {
 type SimpleOutput = {
     TransformedMessage: string;
 };
-export declare const declaredType: import("../..").TaskWorkflowDeclaration<SimpleInput, SimpleOutput>;
+export declare const declaredType: import("../..").TaskWorkflowDeclaration<SimpleInput, SimpleOutput, {}, {}, {}, {}>;
 export declare const inferredType: import("../..").TaskWorkflowDeclaration<SimpleInput, {
     TransformedMessage: string;
-}>;
+}, {}, {}, {}, {}>;
 export declare const inferredTypeDurable: import("../..").TaskWorkflowDeclaration<SimpleInput, {
     TransformedMessage: string;
-}>;
-export declare const crazyWorkflow: import("../..").WorkflowDeclaration<any, any>;
+}, {}, {}, {}, {}>;
+export declare const crazyWorkflow: import("../..").WorkflowDeclaration<any, any, {}>;
 export {};

package/v1/examples/landing_page/event-signaling.d.ts

@@ -3,4 +3,4 @@ export type SimpleInput = {
 };
 export declare const simple: import("../..").TaskWorkflowDeclaration<SimpleInput, {
     TransformedMessage: string;
-}>;
+}, {}, {}, {}, {}>;

package/v1/examples/landing_page/flow-control.d.ts

@@ -3,4 +3,4 @@ export type SimpleInput = {
 };
 export declare const simple: import("../..").TaskWorkflowDeclaration<SimpleInput, {
     TransformedMessage: string;
-}>;
+}, {}, {}, {}, {}>;

package/v1/examples/landing_page/task-routing.d.ts

@@ -3,4 +3,4 @@ export type SimpleInput = {
 };
 export declare const simple: import("../..").TaskWorkflowDeclaration<SimpleInput, {
     TransformedMessage: string;
-}>;
+}, {}, {}, {}, {}>;

package/v1/examples/middleware/client.d.ts

@@ -0,0 +1,26 @@
+import { HatchetClient } from '../..';
+export type GlobalInputType = {
+    first: number;
+    second: number;
+};
+export type GlobalOutputType = {
+    extra: number;
+};
+export declare const hatchetWithMiddleware: HatchetClient<GlobalInputType, GlobalOutputType, {
+    dependency: string;
+    first: number;
+    second: number;
+}, {
+    additionalData: number;
+    extra: number;
+}>;
+export declare const hatchetWithMiddlewareChaining: HatchetClient<GlobalInputType, {}, {
+    dependency: string;
+    first: number;
+    second: number;
+} & {
+    anotherDep: boolean;
+    first: number;
+    second: number;
+    dependency: string;
+}, any>;

package/v1/examples/middleware/client.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hatchetWithMiddlewareChaining = exports.hatchetWithMiddleware = void 0;
+// > Init a client with middleware
+const v1_1 = require("../..");
+const myMiddleware = {
+    before: (input, ctx) => {
+        console.log('before', input.first);
+        return Object.assign(Object.assign({}, input), { dependency: 'abc-123' });
+    },
+    after: (output, ctx, input) => {
+        return Object.assign(Object.assign({}, output), { additionalData: 2 });
+    },
+};
+exports.hatchetWithMiddleware = v1_1.HatchetClient.init().withMiddleware(myMiddleware);
+// !!
+// > Chaining middleware
+const firstMiddleware = {
+    before: (input, ctx) => {
+        console.log('before', input.first);
+        return Object.assign(Object.assign({}, input), { dependency: 'abc-123' });
+    },
+    after: (output, ctx, input) => {
+        return Object.assign(Object.assign({}, output), { firstExtra: 3 });
+    },
+};
+const secondMiddleware = {
+    before: (input, ctx) => {
+        console.log('before', input.dependency); // available from previous middleware
+        return Object.assign(Object.assign({}, input), { anotherDep: true });
+    },
+    after: (output, ctx, input) => {
+        return Object.assign(Object.assign({}, output), { secondExtra: 4 });
+    },
+};
+exports.hatchetWithMiddlewareChaining = v1_1.HatchetClient.init()
+    .withMiddleware(firstMiddleware)
+    .withMiddleware(secondMiddleware);
+// !!

package/v1/examples/middleware/recipes.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/middleware/recipes.js

@@ -0,0 +1,95 @@
+"use strict";
+// @ts-nocheck
+// These snippets demonstrate common middleware patterns.
+// They reference external packages (@aws-sdk/*) that are NOT
+// dependencies of the Hatchet SDK — install them in your own project.
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// > End-to-end encryption
+const v1_1 = require("../..");
+const crypto_1 = require("crypto");
+// !!
+// > Offloading large payloads to S3
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const ALGORITHM = 'aes-256-gcm';
+const KEY = Buffer.from(process.env.ENCRYPTION_KEY, 'hex');
+function encrypt(plaintext) {
+    const iv = (0, crypto_1.randomBytes)(16);
+    const cipher = (0, crypto_1.createCipheriv)(ALGORITHM, KEY, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    return {
+        ciphertext: encrypted.toString('base64'),
+        iv: iv.toString('base64'),
+        tag: cipher.getAuthTag().toString('base64'),
+    };
+}
+function decrypt(ciphertext, iv, tag) {
+    const decipher = (0, crypto_1.createDecipheriv)(ALGORITHM, KEY, Buffer.from(iv, 'base64'));
+    decipher.setAuthTag(Buffer.from(tag, 'base64'));
+    return decipher.update(ciphertext, 'base64', 'utf8') + decipher.final('utf8');
+}
+const e2eEncryption = {
+    before: (input) => {
+        if (!input.encrypted)
+            return input;
+        const { ciphertext, iv, tag } = input.encrypted;
+        const decrypted = JSON.parse(decrypt(ciphertext, iv, tag));
+        return Object.assign(Object.assign(Object.assign({}, input), decrypted), { encrypted: undefined });
+    },
+    after: (output) => {
+        const payload = JSON.stringify(output);
+        return { encrypted: encrypt(payload) };
+    },
+};
+const encryptionClient = v1_1.HatchetClient.init().withMiddleware(e2eEncryption);
+const s3 = new client_s3_1.S3Client({ region: process.env.AWS_REGION });
+const BUCKET = process.env.S3_BUCKET;
+const PAYLOAD_THRESHOLD = 256 * 1024; // 256 KB
+function uploadToS3(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const key = `hatchet-payloads/${(0, crypto_1.randomUUID)()}.json`;
+        yield s3.send(new client_s3_1.PutObjectCommand({
+            Bucket: BUCKET,
+            Key: key,
+            Body: JSON.stringify(data),
+            ContentType: 'application/json',
+        }));
+        return (0, s3_request_presigner_1.getSignedUrl)(s3, new client_s3_1.GetObjectCommand({ Bucket: BUCKET, Key: key }), {
+            expiresIn: 3600,
+        });
+    });
+}
+function downloadFromS3(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield fetch(url);
+        return res.json();
+    });
+}
+const s3Offload = {
+    before: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        if (input.s3Url) {
+            const restored = (yield downloadFromS3(input.s3Url));
+            return Object.assign(Object.assign({}, restored), { s3Url: undefined });
+        }
+        return input;
+    }),
+    after: (output) => __awaiter(void 0, void 0, void 0, function* () {
+        const serialized = JSON.stringify(output);
+        if (serialized.length > PAYLOAD_THRESHOLD) {
+            const url = yield uploadToS3(output);
+            return { s3Url: url };
+        }
+        return output;
+    }),
+};
+const s3Client = v1_1.HatchetClient.init().withMiddleware(s3Offload);
+// !!

package/v1/examples/middleware/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/middleware/run.js

@@ -0,0 +1,29 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Running a task with middleware
+        const result = yield workflow_1.taskWithMiddleware.run({
+            message: 'hello', // string  (from TaskInput)
+            first: 1, // number  (from GlobalInputType)
+            second: 2, // number  (from GlobalInputType)
+        });
+        console.log('result', result.message); // string  (from TaskOutput)
+        console.log('result', result.extra); // number  (from GlobalOutputType)
+        console.log('result', result.additionalData); // number  (from Post Middleware)
+        // !!
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/middleware/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/middleware/worker.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("./client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchetWithMiddleware.worker('task-with-middleware', {
+            workflows: [workflow_1.taskWithMiddleware],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/middleware/workflow.d.ts

@@ -0,0 +1,15 @@
+type TaskInput = {
+    message: string;
+};
+type TaskOutput = {
+    message: string;
+};
+export declare const taskWithMiddleware: import("../..").TaskWorkflowDeclaration<TaskInput, TaskOutput, import("./client").GlobalInputType, import("./client").GlobalOutputType, {
+    dependency: string;
+    first: number;
+    second: number;
+}, {
+    additionalData: number;
+    extra: number;
+}>;
+export {};

package/v1/examples/middleware/workflow.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskWithMiddleware = void 0;
+const client_1 = require("./client");
+exports.taskWithMiddleware = client_1.hatchetWithMiddleware.task({
+    name: 'task-with-middleware',
+    fn: (input, _ctx) => {
+        console.log('task', input.message); // string  (from TaskInput)
+        console.log('task', input.first); // number  (from GlobalInputType)
+        console.log('task', input.second); // number  (from GlobalInputType)
+        console.log('task', input.dependency); // string  (from Pre Middleware)
+        return {
+            message: input.message,
+            extra: 1,
+        };
+    },
+});
+// !!

package/v1/examples/migration-guides/hatchet-client.d.ts

@@ -1,2 +1,2 @@
 import HatchetClient from '../../../sdk';
-export declare const hatchet: HatchetClient;
+export declare const hatchet: HatchetClient<{}, {}, {}, {}>;

package/v1/examples/migration-guides/mergent.d.ts

@@ -19,5 +19,5 @@ type ImageProcessOutput = {
         appliedFilters: string[];
     };
 };
-export declare const imageProcessor: import("../..").TaskWorkflowDeclaration<ImageProcessInput, ImageProcessOutput>;
+export declare const imageProcessor: import("../..").TaskWorkflowDeclaration<ImageProcessInput, ImageProcessOutput, {}, {}, {}, {}>;
 export {};

package/v1/examples/multiple_wf_concurrency/workflow.d.ts

@@ -7,5 +7,5 @@ type SimpleOutput = {
         TransformedMessage: string;
     };
 };
-export declare const multiConcurrency: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput>;
+export declare const multiConcurrency: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput, {}>;
 export {};

package/v1/examples/non_retryable/workflow.d.ts

@@ -1 +1 @@
-export declare const nonRetryableWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
+export declare const nonRetryableWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/on_cron/workflow.d.ts

@@ -6,5 +6,5 @@ type OnCronOutput = {
         TransformedMessage: string;
     };
 };
-export declare const onCron: import("../..").WorkflowDeclaration<Input, OnCronOutput>;
+export declare const onCron: import("../..").WorkflowDeclaration<Input, OnCronOutput, {}>;
 export {};

package/v1/examples/on_event/workflow.d.ts

@@ -8,12 +8,12 @@ type LowerOutput = {
         TransformedMessage: string;
     };
 };
-export declare const lower: import("../..").WorkflowDeclaration<Input, LowerOutput>;
-export declare const lowerWithFilter: import("../..").WorkflowDeclaration<Input, LowerOutput>;
+export declare const lower: import("../..").WorkflowDeclaration<Input, LowerOutput, {}>;
+export declare const lowerWithFilter: import("../..").WorkflowDeclaration<Input, LowerOutput, {}>;
 type UpperOutput = {
     upper: {
         TransformedMessage: string;
     };
 };
-export declare const upper: import("../..").WorkflowDeclaration<Input, UpperOutput>;
+export declare const upper: import("../..").WorkflowDeclaration<Input, UpperOutput, {}>;
 export {};

package/v1/examples/on_failure/workflow.d.ts

@@ -1 +1 @@
-export declare const failureWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
+export declare const failureWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/on_success/workflow.d.ts

@@ -1 +1 @@
-export declare const onSuccessDag: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
+export declare const onSuccessDag: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/v1/examples/priority/workflow.d.ts

@@ -1,8 +1,8 @@
 import { Priority } from '../..';
 export declare const priority: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     priority: Priority | undefined;
-}>;
-export declare const priorityWf: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
-export declare const priorityTasks: (import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}> | import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+}, {}, {}, {}, {}>;
+export declare const priorityWf: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;
+export declare const priorityTasks: (import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}> | import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     priority: Priority | undefined;
-}>)[];
+}, {}, {}, {}, {}>)[];

package/v1/examples/quickstart/hatchet-client.d.ts

@@ -1,2 +1,2 @@
 import Hatchet from '../../../sdk';
-export declare const hatchet: Hatchet;
+export declare const hatchet: Hatchet<{}, {}, {}, {}>;

package/v1/examples/quickstart/workflows/first-task.d.ts

@@ -4,5 +4,5 @@ type SimpleInput = {
 type SimpleOutput = {
     TransformedMessage: string;
 };
-export declare const firstTask: import("../../..").TaskWorkflowDeclaration<SimpleInput, SimpleOutput>;
+export declare const firstTask: import("../../..").TaskWorkflowDeclaration<SimpleInput, SimpleOutput, {}, {}, {}, {}>;
 export {};

package/v1/examples/retries/workflow.d.ts

@@ -1,5 +1,5 @@
-export declare const retries: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, never>;
+export declare const retries: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, never, {}, {}, {}, {}>;
 export declare const retriesWithCount: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     message: string;
-}>;
-export declare const withBackoff: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, never>;
+}, {}, {}, {}, {}>;
+export declare const withBackoff: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, never, {}, {}, {}, {}>;

package/v1/examples/simple/stub-workflow.d.ts

@@ -6,4 +6,4 @@ export type SimpleOutput = {
         TransformedMessage: string;
     };
 };
-export declare const simple: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput>;
+export declare const simple: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput, {}>;