@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/src/v1/examples/run_details/workflow.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDetailTestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.runDetailTestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'run-detail-test',
+});
+const step1 = exports.runDetailTestWorkflow.task({
+    name: 'step1',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            random_number: Math.floor(Math.random() * 100) + 1,
+        });
+    }),
+});
+const step2 = exports.runDetailTestWorkflow.task({
+    name: 'step2',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(5000);
+        return {
+            random_number: Math.floor(Math.random() * 100) + 1,
+        };
+    }),
+});
+exports.runDetailTestWorkflow.task({
+    name: 'cancel_step',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.cancel();
+        yield (0, sleep_1.default)(10000);
+        return {};
+    }),
+});
+exports.runDetailTestWorkflow.task({
+    name: 'fail_step',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        throw new Error('Intentional Failure');
+    }),
+});
+const step3 = exports.runDetailTestWorkflow.task({
+    name: 'step3',
+    parents: [step1, step2],
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const one = (yield ctx.parentOutput(step1)).random_number;
+        const two = (yield ctx.parentOutput(step2)).random_number;
+        return { sum: one + two };
+    }),
+});
+exports.runDetailTestWorkflow.task({
+    name: 'step4',
+    parents: [step1, step3],
+    fn: () => __awaiter(void 0, void 0, void 0, function* () { return ({ step4: 'step4' }); }),
+});

package/src/v1/examples/runtime_affinity/workflow.d.ts

@@ -0,0 +1,3 @@
+export declare const affinityExampleTask: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    worker_id: string | undefined;
+}, {}, {}, {}, {}>;

package/src/v1/examples/runtime_affinity/workflow.js

@@ -0,0 +1,19 @@
+"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 });
+exports.affinityExampleTask = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.affinityExampleTask = hatchet_client_1.hatchet.task({
+    name: 'affinity-example-task',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return { worker_id: ctx.worker.id() };
+    }),
+});

package/src/v1/examples/simple/bulk.d.ts

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

package/src/v1/examples/simple/client-run.d.ts

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

package/src/v1/examples/simple/cron.d.ts

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

package/src/v1/examples/simple/delay.d.ts

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

package/src/v1/examples/simple/e2e-workflows.d.ts

@@ -0,0 +1,14 @@
+export declare const helloWorld: import("../../../../v1").TaskWorkflowDeclaration<{
+    [x: string]: import("../../../../v1").JsonValue;
+} & {
+    [x: string]: import("../../../../v1").JsonValue;
+}, {
+    result: string;
+}, {}, {}, {}, {}>;
+export declare const helloWorldDurable: import("../../../../v1").TaskWorkflowDeclaration<{
+    [x: string]: import("../../../../v1").JsonValue;
+} & {
+    [x: string]: import("../../../../v1").JsonValue;
+}, {
+    result: string;
+}, {}, {}, {}, {}>;

package/src/v1/examples/simple/e2e-workflows.js

@@ -0,0 +1,27 @@
+"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 });
+exports.helloWorldDurable = exports.helloWorld = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+// Mirrors `sdks/python/examples/simple/worker.py` outputs for e2e.
+exports.helloWorld = hatchet_client_1.hatchet.task({
+    name: 'hello-world',
+    fn: (_input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { result: 'Hello, world!' };
+    }),
+});
+exports.helloWorldDurable = hatchet_client_1.hatchet.durableTask({
+    name: 'hello-world-durable',
+    executionTimeout: '10m',
+    fn: (_input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { result: 'Hello, world!' };
+    }),
+});

package/src/v1/examples/simple/enqueue.d.ts

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

package/{v1 → src/v1}/examples/simple/enqueue.js

@@ -29,11 +29,11 @@ function main() {
         // !!
         // > Subscribing to results
         // the return object of the enqueue method is a WorkflowRunRef which includes a listener for the result of the workflow
-        const result = yield run.result();
+        const result = yield run.output;
         console.log(result);
         // if you need to subscribe to the result of the workflow at a later time, you can use the runRef method and the stored runId
         const ref = hatchet_client_1.hatchet.runRef(runId);
-        const result2 = yield ref.result();
+        const result2 = yield ref.output;
         console.log(result2);
         // !!
     });

package/src/v1/examples/simple/replay-cancel.d.ts

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

package/{v1 → src/v1}/examples/simple/replay-cancel.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const data_contracts_1 = require("../../../clients/rest/generated/data-contracts");
+const data_contracts_1 = require("../../../../clients/rest/generated/data-contracts");
 const hatchet_client_1 = require("../hatchet-client");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/src/v1/examples/simple/schedule.d.ts

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

package/src/v1/examples/simple/typed-run-methods.d.ts

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

package/src/v1/examples/simple/worker.d.ts

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

package/src/v1/examples/sticky/run.d.ts

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

package/src/v1/examples/sticky/worker.d.ts

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

package/src/v1/examples/sticky/workflow.d.ts

@@ -0,0 +1,5 @@
+export declare const sticky: import("../../../../v1").TaskWorkflowDeclaration<import("../../../../v1").UnknownInputType, {
+    result: {
+        Value: number;
+    };
+}, {}, {}, {}, {}>;

package/{v1 → src/v1}/examples/sticky/workflow.js

@@ -11,14 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sticky = void 0;
 /* eslint-disable no-console */
-const workflows_1 = require("../../../protoc/workflows");
+const v1_1 = require("../../../../v1");
 const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("../child_workflows/workflow");
 // > Sticky Task
 exports.sticky = hatchet_client_1.hatchet.task({
     name: 'sticky',
     retries: 3,
-    sticky: workflows_1.StickyStrategy.SOFT,
+    sticky: v1_1.StickyStrategy.SOFT,
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // specify a child workflow to run on the same worker
         const result = yield workflow_1.child.run({

package/src/v1/examples/streaming/run.d.ts

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

package/src/v1/examples/streaming/worker.d.ts

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

package/src/v1/examples/timeout/run.d.ts

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

package/src/v1/examples/timeout/run.js

@@ -0,0 +1,30 @@
+"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 });
+/* eslint-disable no-console */
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield workflow_1.timeoutTask.run({ Message: 'hello' });
+        }
+        catch (e) {
+            console.log('timeoutTask failed as expected', e);
+        }
+        const res = yield workflow_1.refreshTimeoutTask.run({ Message: 'hello' });
+        console.log(res);
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/src/v1/examples/timeout/worker.d.ts

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

package/src/v1/examples/timeout/worker.js

@@ -0,0 +1,25 @@
+"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 hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('timeout-worker', {
+            workflows: [workflow_1.timeoutTask, workflow_1.refreshTimeoutTask],
+            slots: 50,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/src/v1/examples/timeout/workflow.d.ts

@@ -0,0 +1,10 @@
+export type SimpleInput = {
+    Message: string;
+};
+export declare const timeoutTask: import("../..").TaskWorkflowDeclaration<SimpleInput, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const refreshTimeoutTask: import("../..").TaskWorkflowDeclaration<SimpleInput, {
+    status: string;
+    message: string;
+}, {}, {}, {}, {}>;

package/src/v1/examples/timeout/workflow.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshTimeoutTask = exports.timeoutTask = void 0;
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// > Execution Timeout
+// Mirrors Python `examples/timeout/test_timeout.py::test_execution_timeout`
+exports.timeoutTask = hatchet_client_1.hatchet.task({
+    name: 'timeout',
+    executionTimeout: '3s',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield (0, sleep_1.default)(10 * 1000, ctx.abortController.signal);
+        }
+        catch (_a) {
+            throw new Error('Task was cancelled');
+        }
+        return {
+            status: 'success',
+        };
+    }),
+});
+// !!
+// > Refresh Timeout
+// Mirrors Python `examples/timeout/test_timeout.py::test_run_refresh_timeout`
+exports.refreshTimeoutTask = hatchet_client_1.hatchet.task({
+    name: 'refresh-timeout',
+    executionTimeout: '3s',
+    scheduleTimeout: '5s',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.refreshTimeout('5s');
+        try {
+            yield (0, sleep_1.default)(4000, ctx.abortController.signal);
+        }
+        catch (_a) {
+            throw new Error('cancelled');
+        }
+        return {
+            status: 'success',
+            message: input.Message.toLowerCase(),
+        };
+    }),
+});
+// !!

package/src/v1/examples/timeouts/run.d.ts

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

package/src/v1/examples/timeouts/worker.d.ts

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

package/{v1 → src/v1}/examples/timeouts/workflow.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cancellation = void 0;
 // > Declaring a Task
-const sleep_1 = __importDefault(require("../../../util/sleep"));
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
 const hatchet_client_1 = require("../hatchet-client");
 // (optional) Define the input type for the workflow
 exports.cancellation = hatchet_client_1.hatchet.task({

package/src/v1/examples/webhooks/workflow.d.ts

@@ -0,0 +1,5 @@
+export type WebhookInput = {
+    type: string;
+    message: string;
+};
+export declare const webhookWorkflow: import("../..").WorkflowDeclaration<WebhookInput, {}, {}>;

package/src/v1/examples/webhooks/workflow.js

@@ -0,0 +1,23 @@
+"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 });
+exports.webhookWorkflow = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.webhookWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'webhook-workflow',
+    onEvents: ['webhook:test'],
+});
+exports.webhookWorkflow.task({
+    name: 'webhook-task',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return input;
+    }),
+});

package/{v1 → src/v1}/examples/with_timeouts/workflow.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refreshTimeout = exports.withTimeouts = void 0;
-const sleep_1 = __importDefault(require("../../../util/sleep"));
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
 const hatchet_client_1 = require("../hatchet-client");
 // > Execution Timeout
 exports.withTimeouts = hatchet_client_1.hatchet.task({

package/{v1 → src/v1}/index.d.ts

@@ -8,3 +8,4 @@ export * from './types';
 export * from './task';
 export * from './client/worker/context';
 export * from './slot-types';
+export * from '../legacy/legacy-transformer';

package/{v1 → src/v1}/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./task"), exports);
 __exportStar(require("./client/worker/context"), exports);
 __exportStar(require("./slot-types"), exports);
+__exportStar(require("../legacy/legacy-transformer"), exports);

package/{v1 → src/v1}/parent-run-context-vars.d.ts

@@ -6,10 +6,16 @@ export interface ParentRunContext {
     parentTaskRunExternalId: string;
     desiredWorkerId: string;
     childIndex?: number;
+    /**
+     * (optional) AbortSignal inherited by nested `run()` calls.
+     * Used to cancel local "wait for result" subscriptions when the parent task is cancelled.
+     */
+    signal?: AbortSignal;
 }
 export declare class ParentRunContextManager {
     private storage;
     constructor();
+    runWithContext<T>(opts: ParentRunContext, fn: () => T): T;
     setContext(opts: ParentRunContext): void;
     setParentRunIdAndIncrementChildIndex(opts: ParentRunContext): void;
     incrementChildIndex(n: number): void;

package/{v1 → src/v1}/parent-run-context-vars.js

@@ -6,6 +6,9 @@ class ParentRunContextManager {
     constructor() {
         this.storage = new async_hooks_1.AsyncLocalStorage();
     }
+    runWithContext(opts, fn) {
+        return this.storage.run(Object.assign({}, opts), fn);
+    }
     setContext(opts) {
         this.storage.enterWith(Object.assign({}, opts));
     }

package/{v1 → src/v1}/task.d.ts

@@ -1,9 +1,9 @@
-import { ConcurrencyLimitStrategy } from '../protoc/v1/workflows';
-import { CreateStep } from '../step';
+import { ConcurrencyLimitStrategy, RateLimitDuration, WorkerLabelComparator } from '../../protoc/v1/workflows';
 import { Conditions } from './conditions';
 import { Duration } from './client/duration';
 import { InputType, OutputType, UnknownInputType } from './types';
 import { Context, DurableContext } from './client/worker/context';
+export { ConcurrencyLimitStrategy, WorkerLabelComparator };
 /**
  * Options for configuring the concurrency for a task.
  */
@@ -59,7 +59,7 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
     /**
      * @deprecated use executionTimeout instead
      */
-    timeout?: CreateStep<I, O>['timeout'];
+    timeout?: Duration;
     /**
      * (optional) execution timeout duration for the task after it starts running
      * go duration format (e.g., "1s", "5m", "1h").
@@ -79,17 +79,27 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      *
      * default: 0
      */
-    retries?: CreateStep<I, O>['retries'];
+    retries?: number;
     /**
      * (optional) backoff strategy configuration for retries.
      * - factor: Base of the exponential backoff (base ^ retry count)
      * - maxSeconds: Maximum backoff duration in seconds
      */
-    backoff?: CreateStep<I, O>['backoff'];
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    };
     /**
      * (optional) rate limits for the task.
      */
-    rateLimits?: CreateStep<I, O>['rate_limits'];
+    rateLimits?: {
+        units: string | number;
+        key?: string;
+        staticKey?: string;
+        dynamicKey?: string;
+        limit?: string | number;
+        duration?: RateLimitDuration;
+    }[];
     /**
      * (optional) worker labels for task routing and scheduling.
      * Each label can be a simple string/number value or an object with additional configuration:
@@ -98,7 +108,12 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      * - weight: Priority weight for worker selection
      * - comparator: Custom comparison logic for label matching
      */
-    desiredWorkerLabels?: CreateStep<I, O>['worker_labels'];
+    desiredWorkerLabels?: Record<string, {
+        value: string | number;
+        required?: boolean;
+        weight?: number;
+        comparator?: WorkerLabelComparator;
+    }>;
     /**
      * (optional) the concurrency options for the task
      */

package/src/v1/task.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonRetryableError = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = void 0;
+const workflows_1 = require("../../protoc/v1/workflows");
+Object.defineProperty(exports, "ConcurrencyLimitStrategy", { enumerable: true, get: function () { return workflows_1.ConcurrencyLimitStrategy; } });
+Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return workflows_1.WorkerLabelComparator; } });
+class NonRetryableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NonRetryableError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.NonRetryableError = NonRetryableError;

package/{v1 → src/v1}/types.d.ts

@@ -28,4 +28,4 @@ export type StrictWorkflowOutputType<T = any> = IsValidWorkflowOutput<T> extends
     [ERROR_WORKFLOW_OUTPUT]?: 'Workflow output must be shaped as Record<"task-name", JsonObject>. Each property must be an object, not a primitive value.';
 };
 declare const ERROR_WORKFLOW_OUTPUT: unique symbol;
-export type { TaskMiddleware as HatchetMiddleware } from '../clients/hatchet-client/client-config';
+export type { TaskMiddleware as HatchetMiddleware } from '../../clients/hatchet-client/client-config';

package/src/v1/types.js

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

package/src/version.d.ts

@@ -0,0 +1 @@
+export declare const HATCHET_VERSION = "1.15.0";

package/{version.js → src/version.js}

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.13.1';
+exports.HATCHET_VERSION = '1.15.0';

package/src/workflow.d.ts

@@ -0,0 +1,3 @@
+import { ConcurrencyLimitStrategy, StickyStrategy } from '../v1';
+export * from './legacy/workflow';
+export { ConcurrencyLimitStrategy, StickyStrategy };

package/src/workflow.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StickyStrategy = exports.ConcurrencyLimitStrategy = void 0;
+const v1_1 = require("../v1");
+Object.defineProperty(exports, "ConcurrencyLimitStrategy", { enumerable: true, get: function () { return v1_1.ConcurrencyLimitStrategy; } });
+Object.defineProperty(exports, "StickyStrategy", { enumerable: true, get: function () { return v1_1.StickyStrategy; } });
+__exportStar(require("./legacy/workflow"), exports);
+console.warn('\x1b[31mDeprecation warning: The v0 sdk, including the workflow module has been deprecated and has been removed in release v1.14.0.\x1b[0m');
+console.warn('\x1b[31mPlease migrate to v1 SDK instead: https://docs.hatchet.run/home/v1-sdk-improvements\x1b[0m');
+console.warn('ConcurrencyLimitStrategy, StickyStrategy have been moved to @hatchet-dev/typescript-sdk/v1');
+console.warn('--------------------------------');