@abinnovision/nestjs-hatchet 0.4.0 → 0.5.0-beta.2

package/README.md

@@ -7,7 +7,17 @@ handling for building robust workflows.
 ## Installation
 
 ```bash
-yarn add @abinnovision/nestjs-hatchet @hatchet-dev/typescript-sdk
+yarn add @abinnovision/nestjs-hatchet
+```
+
+### Hatchet SDK Re-export
+
+This package includes a patched version of `@hatchet-dev/typescript-sdk` that properly
+exports the `v1` subdirectory. You can import SDK types and classes directly without
+adding the Hatchet SDK as a separate dependency:
+
+```typescript
+import { HatchetClient, Context } from "@abinnovision/nestjs-hatchet/sdk";
 ```
 
 ## Quick Start

package/dist/sdk/types.d.ts

@@ -3,5 +3,5 @@
  * Used internally to avoid deep subpath imports from the SDK.
  */
 export interface WorkflowRunRef<T> {
-    get output(): Promise<T>;
+    readonly output: Promise<T>;
 }

package/dist/sdk-export/index.cjs

@@ -0,0 +1,9 @@
+var _hatchet_dev_typescript_sdk = require("@hatchet-dev/typescript-sdk");
+Object.keys(_hatchet_dev_typescript_sdk).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _hatchet_dev_typescript_sdk[k];
+		}
+	});
+});

package/dist/sdk-export/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-exports the @hatchet-dev/typescript-sdk entrypoint.
+ *
+ * This allows consumers to import SDK types and classes from @abinnovision/nestjs-hatchet/sdk
+ * without depending on the Hatchet SDK directly.
+ */
+export * from "@hatchet-dev/typescript-sdk";

package/dist/sdk-export/index.mjs

@@ -0,0 +1,2 @@
+export * from "@hatchet-dev/typescript-sdk";
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@abinnovision/nestjs-hatchet",
-  "version": "0.4.0",
+  "version": "0.5.0-beta.2",
   "keywords": [
     "nestjs",
     "hatchet"
@@ -25,9 +25,19 @@
         "default": "./dist/index.mjs"
       },
       "require": {
-        "types": "./dist/index.d.cts",
+        "types": "./dist/index.d.ts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./sdk": {
+      "import": {
+        "types": "./dist/sdk-export/index.d.ts",
+        "default": "./dist/sdk-export/index.mjs"
+      },
+      "require": {
+        "types": "./dist/sdk-export/index.d.ts",
+        "default": "./dist/sdk-export/index.cjs"
+      }
     }
   },
   "main": "./dist/index.cjs",
@@ -38,7 +48,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsdown && tsc --project tsconfig.build.json --emitDeclarationOnly && find dist -name '*.d.ts' -exec sh -c 'cp \"$1\" \"${1%.d.ts}.d.cts\"' _ {} \\; && publint",
+    "build": "tsdown && tsc --project tsconfig.build.json --emitDeclarationOnly && publint",
     "format:check": "prettier --check '{{src,test}/**/*,*}.{js,jsx,ts,tsx,json,json5,yml,yaml,md}'",
     "format:fix": "prettier --write '{{src,test}/**/*,*}.{js,jsx,ts,tsx,json,json5,yml,yaml,md}'",
     "lint:check": "eslint '{{src,test}/**/*,*}.{js,jsx,ts,tsx}'",
@@ -57,7 +67,7 @@
   },
   "prettier": "@abinnovision/prettier-config",
   "dependencies": {
-    "@hatchet-dev/typescript-sdk": "^1.10.0",
+    "@hatchet-dev/typescript-sdk": "^1.17.2",
     "@standard-schema/spec": "^1.0.0",
     "directed-graph-typed": "^2.1.0"
   },

package/dist/__fixtures__/test-hosts.d.cts

@@ -1,76 +0,0 @@
-import type { TaskCtx, WorkflowCtx } from "../execution/index.js";
-declare const TestTask_base: {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: {
-            data: string;
-        };
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
-            data: string;
-        }> | undefined;
-    };
-};
-/** Standard TaskHost with string data schema */
-export declare class TestTask extends TestTask_base {
-    execute(ctx: TaskCtx<typeof this>): {
-        result: string;
-    };
-}
-declare const NoMethodsTask_base: {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
-    };
-};
-/** TaskHost without any decorated methods (invalid) */
-export declare class NoMethodsTask extends NoMethodsTask_base {
-    notDecorated(): {};
-}
-declare const NoSchemaTask_base: {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
-    };
-};
-/** TaskHost without input schema */
-export declare class NoSchemaTask extends NoSchemaTask_base {
-    execute(_ctx: TaskCtx<typeof this>): {
-        result: string;
-    };
-}
-declare const TestWorkflow_base: {
-    new (): {
-        readonly __workflow_host_brand: void;
-        readonly __workflow_host_input: {
-            id: string;
-        };
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
-            id: string;
-        }> | undefined;
-    };
-};
-/** Standard WorkflowHost with two-step DAG */
-export declare class TestWorkflow extends TestWorkflow_base {
-    step1(_ctx: WorkflowCtx<typeof this>): {
-        step: number;
-    };
-    step2(_ctx: WorkflowCtx<typeof this>): {
-        step: number;
-    };
-}
-declare const NoMethodsWorkflow_base: {
-    new (): {
-        readonly __workflow_host_brand: void;
-        readonly __workflow_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
-    };
-};
-/** WorkflowHost without any decorated methods (invalid) */
-export declare class NoMethodsWorkflow extends NoMethodsWorkflow_base {
-    notDecorated(): {};
-}
-/** Sets design:paramtypes metadata for a method (needed in vitest) */
-export declare function setParamTypes(target: object, method: string, types: unknown[]): void;
-export {};

package/dist/__fixtures__/test-hosts.d.ts

@@ -1,76 +0,0 @@
-import type { TaskCtx, WorkflowCtx } from "../execution/index.js";
-declare const TestTask_base: {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: {
-            data: string;
-        };
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
-            data: string;
-        }> | undefined;
-    };
-};
-/** Standard TaskHost with string data schema */
-export declare class TestTask extends TestTask_base {
-    execute(ctx: TaskCtx<typeof this>): {
-        result: string;
-    };
-}
-declare const NoMethodsTask_base: {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
-    };
-};
-/** TaskHost without any decorated methods (invalid) */
-export declare class NoMethodsTask extends NoMethodsTask_base {
-    notDecorated(): {};
-}
-declare const NoSchemaTask_base: {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
-    };
-};
-/** TaskHost without input schema */
-export declare class NoSchemaTask extends NoSchemaTask_base {
-    execute(_ctx: TaskCtx<typeof this>): {
-        result: string;
-    };
-}
-declare const TestWorkflow_base: {
-    new (): {
-        readonly __workflow_host_brand: void;
-        readonly __workflow_host_input: {
-            id: string;
-        };
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, {
-            id: string;
-        }> | undefined;
-    };
-};
-/** Standard WorkflowHost with two-step DAG */
-export declare class TestWorkflow extends TestWorkflow_base {
-    step1(_ctx: WorkflowCtx<typeof this>): {
-        step: number;
-    };
-    step2(_ctx: WorkflowCtx<typeof this>): {
-        step: number;
-    };
-}
-declare const NoMethodsWorkflow_base: {
-    new (): {
-        readonly __workflow_host_brand: void;
-        readonly __workflow_host_input: unknown;
-        readonly inputSchema: () => import("@standard-schema/spec").StandardSchemaV1<import("@hatchet-dev/typescript-sdk/index.js").JsonObject, unknown> | undefined;
-    };
-};
-/** WorkflowHost without any decorated methods (invalid) */
-export declare class NoMethodsWorkflow extends NoMethodsWorkflow_base {
-    notDecorated(): {};
-}
-/** Sets design:paramtypes metadata for a method (needed in vitest) */
-export declare function setParamTypes(target: object, method: string, types: unknown[]): void;
-export {};

package/dist/abstracts/hosts.d.cts

@@ -1,66 +0,0 @@
-import type { InputType } from "@hatchet-dev/typescript-sdk";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-/**
- * Interface for classes that provide a schema for their input.
- */
-export interface InputSchemaProvider<T> {
-    /**
-     * Returns the schema for the input of the host.
-     * If undefined, the input is not validated.
-     */
-    inputSchema: () => StandardSchemaV1<InputType, T> | undefined;
-}
-/**
- * Marker class for Hatchet workflow host classes.
- */
-export declare abstract class WorkflowHost<I> implements InputSchemaProvider<I> {
-    readonly inputSchema: InputSchemaProvider<I>["inputSchema"];
-    readonly __workflow_host_brand: void;
-    readonly __workflow_host_input: I;
-    /**
-     * Constructor for the WorkflowHost class.
-     *
-     * @param inputSchema
-     * @protected
-     */
-    protected constructor(inputSchema: InputSchemaProvider<I>["inputSchema"]);
-}
-/**
- * Marker class for Hatchet task host classes.
- */
-export declare abstract class TaskHost<I> implements InputSchemaProvider<I> {
-    readonly inputSchema: InputSchemaProvider<I>["inputSchema"];
-    readonly __task_host_brand: void;
-    readonly __task_host_input: I;
-    /**
-     * Constructor for the TaskHost class.
-     *
-     * @param inputSchema
-     * @protected
-     */
-    protected constructor(inputSchema: InputSchemaProvider<I>["inputSchema"]);
-}
-/**
- * Creates a new WorkflowHost class with the provided input schema.
- *
- * @param input The input schema.
- */
-export declare function workflowHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]>): {
-    new (): {
-        readonly __workflow_host_brand: void;
-        readonly __workflow_host_input: I;
-        readonly inputSchema: () => StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, I> | undefined;
-    };
-};
-/**
- * Creates a new TaskHost class with the provided input schema.
- *
- * @param input The input schema.
- */
-export declare function taskHost<I>(input?: ReturnType<InputSchemaProvider<I>["inputSchema"]>): {
-    new (): {
-        readonly __task_host_brand: void;
-        readonly __task_host_input: I;
-        readonly inputSchema: () => StandardSchemaV1<import("@hatchet-dev/typescript-sdk").JsonObject, I> | undefined;
-    };
-};

package/dist/abstracts/index.d.cts

@@ -1 +0,0 @@
-export * from "./hosts.js";

package/dist/client/client.d.cts

@@ -1,48 +0,0 @@
-import { HatchetClient } from "@hatchet-dev/typescript-sdk";
-import type { AnyEventDefinition, EventInput } from "../events/index.js";
-import type { HostRunFn } from "../execution/index.js";
-type EventClient = HatchetClient["events"];
-type EventEmitOptions = Parameters<EventClient["push"]>[2];
-type Event = Awaited<ReturnType<EventClient["push"]>>;
-export declare class Client {
-    private readonly client;
-    readonly run: HostRunFn;
-    constructor(client: HatchetClient);
-    /**
-     * Access to the underlying HatchetClient SDK.
-     * Use for advanced features not wrapped by this library.
-     */
-    get sdk(): HatchetClient;
-    /**
-     * Emit a single event.
-     *
-     * @param event The event definition to emit.
-     * @param input The event payload (must match the event's schema).
-     * @param options Optional emit configuration.
-     * @returns The emitted event.
-     *
-     * @example
-     * ```typescript
-     * await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
-     * ```
-     */
-    emit<E extends AnyEventDefinition>(event: E, input: EventInput<E>, options?: EventEmitOptions): Promise<Event>;
-    /**
-     * Emit multiple events of the same type.
-     *
-     * @param event The event definition to emit.
-     * @param inputs Array of event payloads.
-     * @param options Optional emit configuration.
-     * @returns Array of emitted events.
-     *
-     * @example
-     * ```typescript
-     * await client.emitBulk(OrderPlacedEvent, [
-     *   { orderId: "1", userId: "123", total: 100 },
-     *   { orderId: "2", userId: "456", total: 200 },
-     * ]);
-     * ```
-     */
-    emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EventEmitOptions): Promise<Event[]>;
-}
-export {};

package/dist/client/index.d.cts

@@ -1 +0,0 @@
-export * from "./client.js";

package/dist/events/event-definition.d.cts

@@ -1,71 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-/**
- * Marker embedded in event payload to identify an event type.
- * Used by isCtx() type guard to determine which event triggered the workflow.
- */
-export declare const EVENT_MARKER = "__event_name";
-/**
- * Type-safe event definition.
- * Use with Client.emit() to publish events.
- *
- * @template TName The literal string type of the event name.
- * @template TSchema The StandardSchema type for input validation.
- */
-export declare class EventDefinition<TName extends string, TSchema extends StandardSchemaV1> {
-    readonly name: TName;
-    readonly schema: TSchema;
-    /**
-     * Phantom types for input/output inference.
-     * Do not access at runtime - will throw.
-     */
-    readonly __types: {
-        input: StandardSchemaV1.InferInput<TSchema>;
-        output: StandardSchemaV1.InferOutput<TSchema>;
-    };
-    constructor(name: TName, schema: TSchema);
-    /**
-     * Type guard: checks if the context was triggered by this event.
-     * Validates the input against the event schema and throws if malformed.
-     *
-     * @param ctx The context to check (TaskCtx, WorkflowCtx, HelperCtx, or SDK Context).
-     * @returns True if the context input contains the event marker matching this event.
-     * @throws Error if the event marker matches but the payload fails schema validation.
-     */
-    isCtx<C extends {
-        input: unknown;
-    }>(ctx: C): ctx is C & {
-        input: StandardSchemaV1.InferOutput<TSchema> & {
-            [EVENT_MARKER]: TName;
-        };
-    };
-}
-/**
- * Any event definition, used for generic constraints.
- */
-export type AnyEventDefinition = EventDefinition<string, StandardSchemaV1>;
-/**
- * Extracts the input type from an event definition.
- */
-export type EventInput<E extends AnyEventDefinition> = E["__types"]["input"];
-/**
- * Extracts the output type from an event definition.
- */
-export type EventOutput<E extends AnyEventDefinition> = E["__types"]["output"];
-/**
- * Factory function to create a type-safe event definition.
- *
- * @param name The event name (e.g., "user:created").
- * @param schema A StandardSchema-compatible schema (e.g., Zod schema).
- * @returns A new EventDefinition instance.
- *
- * @example
- * ```typescript
- * import { z } from "zod";
- *
- * const UserCreatedEvent = defineEvent("user:created", z.object({
- *   userId: z.string(),
- *   email: z.string().email(),
- * }));
- * ```
- */
-export declare const defineEvent: <TName extends string, TSchema extends StandardSchemaV1>(name: TName, schema: TSchema) => EventDefinition<TName, TSchema>;

package/dist/events/index.d.cts

@@ -1,2 +0,0 @@
-export { EventDefinition, defineEvent } from "./event-definition.js";
-export type { AnyEventDefinition, EventInput, EventOutput, } from "./event-definition.js";

package/dist/execution/context/factory.d.cts

@@ -1,22 +0,0 @@
-import { type BaseCtx, type HostTriggerConfig, type TaskCtx, type WorkflowCtx } from "./types.js";
-/**
- * Arguments for context factory functions.
- * Derived from BaseCtx using Pick to ensure type alignment.
- */
-type CreateCtxArgs<I> = Pick<BaseCtx<I>, "fromSDK" | "triggerSource"> & {
-    input: I;
-    hostConfig: HostTriggerConfig;
-};
-/**
- * Creates a TaskCtx from SDK Context for standalone task execution.
- *
- * @param args The arguments for creating the task context.
- */
-export declare const createTaskCtx: <I>(args: CreateCtxArgs<I>) => TaskCtx<any>;
-/**
- * Creates a WorkflowCtx from SDK Context for workflow task execution.
- *
- * @param args The arguments for creating the workflow context.
- */
-export declare const createWorkflowCtx: <I>(args: CreateCtxArgs<I>) => WorkflowCtx<any>;
-export {};

package/dist/execution/context/index.d.cts

@@ -1,4 +0,0 @@
-export type { BaseCtx, TaskCtx, WorkflowCtx, HelperCtx, TriggerSource, HostTriggerConfig, } from "./types.js";
-export { TASK_MARKER } from "./types.js";
-export type { TaskMarker } from "./types.js";
-export { createTaskCtx, createWorkflowCtx } from "./factory.js";

package/dist/execution/context/types.d.cts

@@ -1,108 +0,0 @@
-import type { TaskHost, WorkflowHost } from "../../abstracts/index.js";
-import type { AnyEventDefinition, EventOutput } from "../../events/index.js";
-import type { AnyTaskFn, OutputOfTaskFn } from "../../references/shared.js";
-import type { HostRunFn } from "../host-run/index.js";
-import type { Context } from "@hatchet-dev/typescript-sdk";
-export declare const TASK_MARKER: unique symbol;
-export type TaskMarker = typeof TASK_MARKER;
-/**
- * Type representing the source that triggered the task execution.
- *
- * - "run": Triggered with default payload via direct run.
- * - "event": Triggered by an event.
- * - "cron": Triggered by a cron schedule.
- *
- * Note that the detection of trigger source is best-effort and may not be accurate in all cases.
- * Hatchet does not currently provide first-class support for distinguishing all trigger sources.
- */
-export type TriggerSource = "run" | "event" | "cron";
-/**
- * Configuration extracted from host decorator for trigger introspection.
- */
-export interface HostTriggerConfig {
-    /**
-     * Event names this host listens to
-     */
-    onEvents: string[];
-    /**
-     * Cron schedules this host responds to
-     */
-    onCrons: string[];
-}
-/**
- * Type for the context when a task is running. This is universal for standalone and workflow tasks.
- * This partially implements the `Context` type from the SDK.
- *
- * @template I The input type of the task.
- */
-export interface BaseCtx<I> {
-    /**
-     * Host metadata accessor for introspection.
-     */
-    readonly hostConfig: HostTriggerConfig;
-    /**
-     * The source that triggered the task execution.
-     */
-    triggerSource: TriggerSource;
-    /**
-     * Provides access to the underlying SDK context.
-     */
-    fromSDK: Context<I, any>;
-    /**
-     * The input to the task.
-     */
-    input: I;
-    /**
-     * Function to run other tasks within the context of this task.
-     */
-    run: HostRunFn;
-    /**
-     * Returns true if triggered via direct run.
-     * When true, ctx.input is the validated host schema type.
-     */
-    isRun: () => this is BaseCtx<I> & {
-        triggerSource: "run";
-    };
-    /**
-     * Returns true if triggered via event.
-     * Optionally accepts an EventDefinition to check for a specific event type.
-     *
-     * @param eventDef Optional event definition to check for specific event
-     */
-    isEvent: <E extends AnyEventDefinition>(eventDef?: E) => this is BaseCtx<I> & {
-        triggerSource: "event";
-        input: E extends AnyEventDefinition ? EventOutput<E> : unknown;
-    };
-    /**
-     * Returns true if triggered via cron schedule.
-     * When true, ctx.input is void/empty.
-     */
-    isCron: () => this is BaseCtx<I> & {
-        triggerSource: "cron";
-        input: never;
-    };
-}
-/**
- * Context type of the run of a standalone task.
- * Branded with TASK_MARKER for compile-time task method detection.
- */
-export type TaskCtx<T extends TaskHost<any>> = BaseCtx<T extends TaskHost<infer I> ? I : never> & {
-    [TASK_MARKER]: true;
-};
-/**
- * Context type of the run of a workflow task.
- * Branded with TASK_MARKER for compile-time task method detection.
- */
-export type WorkflowCtx<T extends WorkflowHost<any>> = BaseCtx<T extends WorkflowHost<infer I> ? I : never> & {
-    [TASK_MARKER]: true;
-    /**
-     * Provides the output of a parent task.
-     */
-    parent: <F extends AnyTaskFn<any, any>>(method: F) => Promise<OutputOfTaskFn<F>>;
-};
-/**
- * Context type for helper methods that need access to the task context
- * but should not be counted as task methods.
- * This is essentially BaseCtx with the input type extracted from the host.
- */
-export type HelperCtx<T extends TaskHost<any> | WorkflowHost<any>> = BaseCtx<T extends TaskHost<infer I> ? I : T extends WorkflowHost<infer I> ? I : never>;

package/dist/execution/host-run/adapter-factory.d.cts

@@ -1,12 +0,0 @@
-import type { HostRunFn } from "./function-type.js";
-import type { Context, HatchetClient } from "@hatchet-dev/typescript-sdk";
-/**
- * Creates a HostRunFn that uses SDK Context for spawning child workflows.
- * Used within task execution contexts.
- */
-export declare function createHostRunForContext(ctx: Context<any, any>): HostRunFn;
-/**
- * Creates a HostRunFn that uses HatchetClient for external workflow triggering.
- * Used by HClient for triggering workflows from outside task contexts.
- */
-export declare function createHostRunForAdmin(client: HatchetClient): HostRunFn;

package/dist/execution/host-run/function-type.d.cts

@@ -1,24 +0,0 @@
-import type { AnyCallableRef, InputOfRef, OutputOfRef } from "../../references/index.js";
-import type { WorkflowRunRef } from "../../sdk/types.js";
-import type { RunOpts } from "@hatchet-dev/typescript-sdk";
-/**
- * Describes the return type of the {@link HostRunFn} function.
- *
- * @param I The input type of the callable reference.
- * @param R The callable reference.
- * @param W Whether to wait for the task to complete before returning.
- */
-export type HostRunReturn<I extends InputOfRef<R> | InputOfRef<R>[], R extends AnyCallableRef, W extends boolean> = I extends InputOfRef<R>[] ? W extends true ? OutputOfRef<R>[] : WorkflowRunRef<OutputOfRef<R>>[] : W extends true ? OutputOfRef<R> : WorkflowRunRef<OutputOfRef<R>>;
-export interface HostRunOpts<W extends boolean> extends RunOpts {
-    /**
-     * Whether to wait for the task to complete before returning.
-     *
-     * @default true
-     */
-    wait?: W;
-}
-/**
- * Runs a child task or workflow. This can be used to run multiple tasks in parallel.
- * If `wait` is set to `false`, a `WorkflowRunRef` is returned.
- */
-export type HostRunFn = <R extends AnyCallableRef, I extends InputOfRef<R> | InputOfRef<R>[], W extends boolean = true>(ref: R, input: I, options?: HostRunOpts<W>) => Promise<HostRunReturn<I, R, W>>;

package/dist/execution/host-run/index.d.cts

@@ -1,2 +0,0 @@
-export type { HostRunFn, HostRunOpts, HostRunReturn } from "./function-type.js";
-export { createHostRunForContext, createHostRunForAdmin, } from "./adapter-factory.js";

package/dist/execution/index.d.cts

@@ -1,2 +0,0 @@
-export type { BaseCtx, TaskCtx, WorkflowCtx, HelperCtx, TriggerSource, HostTriggerConfig, } from "./context/index.js";
-export type { HostRunFn, HostRunOpts, HostRunReturn, } from "./host-run/index.js";

package/dist/explorer/declaration-builder.service.d.cts

@@ -1,70 +0,0 @@
-import { TaskWorkflowDeclaration, WorkflowDeclaration } from "@hatchet-dev/typescript-sdk";
-import { ModuleRef } from "@nestjs/core";
-import { InterceptorRegistration } from "../internal/registrations.js";
-import { AnyHost } from "../references/shared.js";
-export declare class DeclarationBuilderService {
-    private readonly moduleRef;
-    private readonly interceptorRegistration?;
-    private readonly interceptors;
-    constructor(moduleRef: ModuleRef, interceptorRegistration?: InterceptorRegistration | undefined);
-    /**
-     * Creates a WorkflowDeclaration or TaskWorkflowDeclaration from the given host.
-     *
-     * @param host The host to create a declaration for.
-     * @returns A WorkflowDeclaration or TaskWorkflowDeclaration.
-     */
-    createDeclaration(host: AnyHost): WorkflowDeclaration | TaskWorkflowDeclaration;
-    private createTaskWorkflow;
-    private createWorkflow;
-    /**
-     *  Validates the given WorkflowHost with basic sanity checks.
-     *  This does not return, rather it throws an error if the host is invalid.
-     *
-     * @param input The host to validate.
-     * @private
-     */
-    private validateWorkflowHost;
-    /**
-     *  Validates the given TaskHost with basic sanity checks.
-     *  This does not return, rather it throws an error if the host is invalid.
-     *
-     * @param input The host to validate.
-     * @private
-     */
-    private validateTaskHost;
-    /**
-     * Builds a directed graph of the workflow host.
-     * The nodes are the methods of the host, and the edges are the dependencies between the methods.
-     *
-     * Note: This validates for cyclic dependencies and throws an
-     *
-     * @param host The host to build the graph for.
-     * @returns The directed graph.
-     * @private
-     */
-    private buildWorkflowHostGraph;
-    /**
-     * Pre-processes the context by inferring the trigger source and
-     * validating the input (if applicable).
-     *
-     * @returns The pre-processed context properties including hostConfig.
-     */
-    private preProcessContext;
-    /**
-     * Executes a function, optionally intercepted by the interceptors.
-     * Interceptors are chained in array order (first = outermost).
-     *
-     * @param ctx The context.
-     * @param fn The function to execute.
-     * @returns The result of the function.
-     */
-    private executeWithInterceptors;
-    /**
-     * Infers the trigger source from the given context.
-     *
-     * @param ctx The context.
-     * @returns The inferred trigger source.
-     * @private
-     */
-    private inferTriggerSource;
-}

package/dist/explorer/index.d.cts

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

package/dist/explorer/worker-management.service.d.cts

@@ -1,34 +0,0 @@
-import { HatchetClient } from "@hatchet-dev/typescript-sdk";
-import { OnApplicationBootstrap } from "@nestjs/common";
-import { ModuleRef } from "@nestjs/core";
-import { type HatchetModuleConfig } from "../hatchet.module-config.js";
-import { DeclarationBuilderService } from "./declaration-builder.service.js";
-export declare class WorkerManagementService implements OnApplicationBootstrap {
-    private readonly client;
-    private readonly declarationBuilder;
-    private readonly config;
-    private readonly moduleRef;
-    private static LOGGER;
-    constructor(client: HatchetClient, declarationBuilder: DeclarationBuilderService, config: HatchetModuleConfig, moduleRef: ModuleRef);
-    onApplicationBootstrap(): Promise<void>;
-    private initWorker;
-    /**
-     * Builds declarations from the discovered feature registrations.
-     */
-    private buildDeclarations;
-    /**
-     * Discovers all feature registrations from forFeature() calls.
-     */
-    private discoverFeatureRegistrations;
-    /**
-     * Detects workflows registered on the Hatchet server that have no
-     * corresponding local declaration. Logs a warning for each orphan found.
-     */
-    private detectOrphanWorkflows;
-    /**
-     * Fetches all workflows registered on the Hatchet server using pagination.
-     *
-     * @returns An array of workflow names registered on the server.
-     */
-    private fetchAllServerWorkflows;
-}

package/dist/hatchet.module-config.d.cts

@@ -1,31 +0,0 @@
-import type { CreateWorkerOpts, HatchetClient } from "@hatchet-dev/typescript-sdk";
-type ClientConfig = HatchetClient["config"];
-/**
- * Configuration for the Hatchet worker.
- */
-type HatchetModuleWorkerConfig = {
-    name: string;
-} & Omit<CreateWorkerOpts, "workflows">;
-/**
- * Configuration for the HatchetModule.
- */
-export interface HatchetModuleConfig {
-    /**
-     * Configuration for the Hatchet client.
-     * Certain, internally managed options are omitted.
-     */
-    config: Partial<Omit<ClientConfig, "logger" | "log_level">>;
-    /**
-     * Configuration for the Hatchet worker.
-     * If undefined, the worker will not be started.
-     */
-    worker: HatchetModuleWorkerConfig | undefined;
-    /**
-     * Whether to enable orphan workflow detection on application startup.
-     *
-     * @default true
-     */
-    enableOrphanDetection?: boolean | undefined;
-}
-export declare const hatchetModuleConfigToken: unique symbol;
-export {};

package/dist/hatchet.module.d.cts

@@ -1,23 +0,0 @@
-import { DynamicModule, Type } from "@nestjs/common";
-import { type HatchetModuleConfig } from "./hatchet.module-config.js";
-import { Interceptor } from "./interceptor/index.js";
-import type { AnyCallableRef } from "./references/index.js";
-/**
- * Extra options for the module (processed at module definition time).
- */
-interface HatchetModuleExtras {
-    /**
-     * Optional interceptor classes to intercept all task/workflow executions.
-     * Interceptors execute in array order (first = outermost).
-     */
-    interceptors?: Type<Interceptor>[] | undefined;
-}
-declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<HatchetModuleConfig, "forRoot", "create", HatchetModuleExtras>;
-export declare class HatchetModule extends ConfigurableModuleClass {
-    /**
-     * Registers workflows and tasks for the global worker.
-     * Call this in feature modules to register their hosts.
-     */
-    static forFeature(...refs: AnyCallableRef[]): DynamicModule;
-}
-export {};

package/dist/index.d.cts

@@ -1,9 +0,0 @@
-export * from "./hatchet.module.js";
-export * from "./abstracts/index.js";
-export * from "./client/index.js";
-export * from "./execution/index.js";
-export * from "./metadata/index.js";
-export * from "./events/index.js";
-export * from "./interceptor/index.js";
-export * from "./references/index.js";
-export type { HatchetModuleConfig } from "./hatchet.module-config.js";

package/dist/interceptor/index.d.cts

@@ -1 +0,0 @@
-export { Interceptor } from "./interceptor.js";

package/dist/interceptor/interceptor.d.cts

@@ -1,13 +0,0 @@
-import type { BaseCtx } from "../execution/index.js";
-/**
- * Token for optional interceptors injection.
- * Register providers with this token to intercept task/workflow execution.
- */
-export declare const INTERCEPTORS: unique symbol;
-/**
- * Abstract class for intercepting task/workflow execution.
- * Implement this to add cross-cutting concerns like ALS, tracing, logging.
- */
-export declare abstract class Interceptor {
-    abstract intercept<T>(ctx: BaseCtx<any>, next: () => Promise<T>): Promise<T>;
-}

package/dist/internal/registrations.d.cts

@@ -1,19 +0,0 @@
-import type { Interceptor } from "../interceptor/index.js";
-import type { AnyHostCtor } from "../references/shared.js";
-import type { Type } from "@nestjs/common";
-/**
- * Token class for feature registration discovery.
- * Each forFeature() call creates a provider with this class as token.
- */
-export declare class HatchetFeatureRegistration {
-    readonly refs: AnyHostCtor[];
-    constructor(refs: AnyHostCtor[]);
-}
-/**
- * Token class for interceptor registration.
- * Stores interceptor class references for later resolution via ModuleRef.
- */
-export declare class InterceptorRegistration {
-    readonly refs: Type<Interceptor>[];
-    constructor(refs: Type<Interceptor>[]);
-}

package/dist/metadata/accessor.d.cts

@@ -1,33 +0,0 @@
-import type { HostOpts, TaskOpts, WorkflowTaskOpts } from "./decorators/index.js";
-import type { SdkHostOpts } from "./translator.js";
-import type { AnyHost, AnyHostCtor } from "../references/shared.js";
-/**
- * Accessor for host metadata and methods.
- */
-declare class HostAccessor {
-    readonly ctor: AnyHostCtor;
-    constructor(ctor: AnyHostCtor);
-    /**
-     * Returns raw enhanced metadata from @Host() decorator.
-     */
-    get metadata(): HostOpts;
-    /**
-     * Returns SDK-compatible options for workflow declarations.
-     */
-    get sdkOpts(): SdkHostOpts;
-    get name(): string;
-    get isWorkflow(): boolean;
-    get isTask(): boolean;
-    get methods(): string[];
-    getWorkflowTaskMeta(method: string): WorkflowTaskOpts<any>;
-    getTaskMeta(method: string): TaskOpts;
-}
-/**
- * Create accessor from host constructor.
- */
-export declare function fromCtor(ctor: AnyHostCtor): HostAccessor;
-/**
- * Create accessor from host instance.
- */
-export declare function fromInstance(instance: AnyHost): HostAccessor;
-export {};

package/dist/metadata/decorators/host.decorator.d.cts

@@ -1,19 +0,0 @@
-import type { AnyEventDefinition } from "../../events/index.js";
-import type { CreateBaseWorkflowOpts } from "@hatchet-dev/typescript-sdk";
-/**
- * Properties we enhance beyond SDK types.
- */
-interface EnhancedProperties {
-    name: string;
-    onEvents?: ReadonlyArray<string | AnyEventDefinition>;
-}
-type PassthroughProperties = Omit<CreateBaseWorkflowOpts, "on" | keyof EnhancedProperties>;
-/**
- * Enhanced HostOpts for @Host() decorator.
- */
-export type HostOpts = EnhancedProperties & PassthroughProperties;
-/**
- * Decorator to mark a class as a host (for either a workflow or a task).
- */
-export declare const Host: (opts: HostOpts) => ClassDecorator;
-export {};

package/dist/metadata/decorators/index.d.cts

@@ -1,6 +0,0 @@
-export { Host } from "./host.decorator.js";
-export type { HostOpts } from "./host.decorator.js";
-export { Task } from "./task.decorator.js";
-export type { TaskOpts } from "./task.decorator.js";
-export { WorkflowTask } from "./workflow-task.decorator.js";
-export type { WorkflowTaskOpts } from "./workflow-task.decorator.js";

package/dist/metadata/decorators/task.decorator.d.cts

@@ -1,6 +0,0 @@
-import type { CreateBaseWorkflowOpts, CreateTaskWorkflowOpts } from "@hatchet-dev/typescript-sdk";
-export type TaskOpts = Omit<CreateTaskWorkflowOpts, "fn" | "name" | keyof CreateBaseWorkflowOpts>;
-/**
- * Decorator to mark a method as a Hatchet task.
- */
-export declare const Task: (opts: TaskOpts) => MethodDecorator;

package/dist/metadata/decorators/workflow-task.decorator.d.cts

@@ -1,10 +0,0 @@
-import type { WorkflowCtx } from "../../execution/index.js";
-import type { ContextMethodKeys, WorkflowHostCtor } from "../../references/shared.js";
-import type { CreateWorkflowTaskOpts } from "@hatchet-dev/typescript-sdk";
-export type WorkflowTaskOpts<C extends WorkflowHostCtor<any>> = Omit<CreateWorkflowTaskOpts, "fn" | "parents" | "name"> & {
-    parents?: ContextMethodKeys<InstanceType<C>, WorkflowCtx<any>>[];
-};
-/**
- * Decorator to mark a method as a workflow task.
- */
-export declare function WorkflowTask<C extends WorkflowHostCtor<any>>(opts: WorkflowTaskOpts<C>): MethodDecorator;

package/dist/metadata/index.d.cts

@@ -1,6 +0,0 @@
-export { Host } from "./decorators/host.decorator.js";
-export type { HostOpts } from "./decorators/host.decorator.js";
-export { Task } from "./decorators/task.decorator.js";
-export type { TaskOpts } from "./decorators/task.decorator.js";
-export { WorkflowTask } from "./decorators/workflow-task.decorator.js";
-export type { WorkflowTaskOpts } from "./decorators/workflow-task.decorator.js";

package/dist/metadata/keys.d.cts

@@ -1,3 +0,0 @@
-export declare const METADATA_KEY_HOST_OPTS = "hatchet:host:opts";
-export declare const METADATA_KEY_TASK_OPTS = "hatchet:task:opts";
-export declare const METADATA_KEY_WORKFLOW_TASK_OPTS = "hatchet:workflow:task:opts";

package/dist/metadata/translator.d.cts

@@ -1,10 +0,0 @@
-import type { HostOpts } from "./decorators/index.js";
-import type { CreateBaseWorkflowOpts } from "@hatchet-dev/typescript-sdk";
-/**
- * SDK-compatible host options.
- */
-export type SdkHostOpts = Omit<CreateBaseWorkflowOpts, "on">;
-/**
- * Translates enhanced HostOpts to SDK-compatible SdkHostOpts.
- */
-export declare const translateHostOpts: (opts: HostOpts) => SdkHostOpts;

package/dist/references/helpers.d.cts

@@ -1,27 +0,0 @@
-import type { AnyCallableRef, TaskRef, WorkflowRef } from "./refs.js";
-import type { AnyHostCtor, TaskHostCtor, ValidTaskHost, ValidWorkflowHost, WorkflowHostCtor } from "./shared.js";
-/**
- * Creates a reference to a task within a {@link TaskHost}.
- * The task method is automatically resolved since a TaskHost has exactly one task.
- * Compile-time validation ensures the host has exactly one task method.
- */
-export declare function taskRef<C extends TaskHostCtor<any>>(host: ValidTaskHost<C>): TaskRef<C>;
-/**
- * Creates a reference to a workflow as a {@link WorkflowHost}.
- * Compile-time validation ensures the host has at least one workflow task method.
- */
-export declare function workflowRef<C extends WorkflowHostCtor<any>>(host: ValidWorkflowHost<C>): WorkflowRef<C>;
-/**
- * Gets the HostAccessor from a callable reference.
- */
-export declare function getRefAccessor(ref: AnyCallableRef): {
-    readonly ctor: AnyHostCtor;
-    get metadata(): import("../index.js").HostOpts;
-    get sdkOpts(): import("../metadata/translator.js").SdkHostOpts;
-    get name(): string;
-    get isWorkflow(): boolean;
-    get isTask(): boolean;
-    get methods(): string[];
-    getWorkflowTaskMeta(method: string): import("../index.js").WorkflowTaskOpts<any>;
-    getTaskMeta(method: string): import("../index.js").TaskOpts;
-};

package/dist/references/index.d.cts

@@ -1,3 +0,0 @@
-export type { TaskRef, WorkflowRef, AnyCallableRef, InputOfRef, OutputOfRef, } from "./refs.js";
-export { taskRef, workflowRef } from "./helpers.js";
-export type { TaskInput, TaskOutput, WorkflowInput, WorkflowOutput, WorkflowTasksOutputMap, } from "./shared.js";

package/dist/references/refs.d.cts

@@ -1,27 +0,0 @@
-import type { ContextMethodKeys, TaskHostCtor, TaskInput, TaskOutput, WorkflowHostCtor, WorkflowInput, WorkflowOutput } from "./shared.js";
-/**
- * Reference to a task within a {@link TaskHost}
- */
-export interface TaskRef<C extends TaskHostCtor<any>> {
-    readonly host: C;
-    readonly method: ContextMethodKeys<InstanceType<C>>;
-}
-/**
- * Reference to a workflow as a {@link WorkflowHost}
- */
-export interface WorkflowRef<C extends WorkflowHostCtor<any>> {
-    readonly host: C;
-}
-/**
- * Represents any callable reference.
- * Note that externally only TaskRef and WorkflowRef are supported.
- */
-export type AnyCallableRef = TaskRef<any> | WorkflowRef<any>;
-/**
- * Extracts the input type of the callable reference.
- */
-export type InputOfRef<R extends AnyCallableRef> = R extends TaskRef<infer C> ? TaskInput<C> : R extends WorkflowRef<infer C> ? WorkflowInput<C> : never;
-/**
- * Extracts the output type of the callable reference.
- */
-export type OutputOfRef<R extends AnyCallableRef> = R extends TaskRef<infer C> ? TaskOutput<C> : R extends WorkflowRef<infer C> ? WorkflowOutput<C> : never;

package/dist/references/shared.d.cts

@@ -1,172 +0,0 @@
-import type { TaskHost, WorkflowHost } from "../abstracts/index.js";
-import type { BaseCtx, TaskMarker } from "../execution/context/types.js";
-/**
- * Converts a union to an intersection. Used for detecting if a type is a union.
- */
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
- * Checks if a type is a union (more than one member).
- */
-type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-/**
- * Represents any host instance type.
- */
-export type AnyHost = WorkflowHost<any> | TaskHost<any>;
-/**
- * Represents any host constructor type.
- */
-export type AnyHostCtor = WorkflowHostCtor<any> | TaskHostCtor<any>;
-/**
- * Represents a workflow host constructor type.
- *
- * @internal Used in public signatures but not intended for direct external use.
- * @template I - The input type that the workflow accepts.
- */
-export type WorkflowHostCtor<I> = abstract new (...args: any[]) => WorkflowHost<I>;
-/**
- * Represents a task host constructor type.
- *
- * @internal Used in public signatures but not intended for direct external use.
- * @template I - The input type that the task accepts.
- */
-export type TaskHostCtor<I> = abstract new (...args: any[]) => TaskHost<I>;
-/**
- * Checks if a function signature is a "runnable" task method.
- *
- * A method is considered runnable if its first parameter is a context type
- * that includes the TaskMarker brand. This distinguishes actual task methods
- * (decorated with `@Task()` or `@WorkflowTask()`) from helper methods that
- * use `HelperCtx` which lacks the marker.
- *
- * @template F - The function type to check.
- * @template C - The expected context type (defaults to any BaseCtx).
- * @returns `true` if F is a task method, `false` otherwise.
- */
-export type IsTaskRunnableSignature<F extends (...args: any[]) => any, C extends BaseCtx<any> = any> = F extends (...args: any[]) => any ? Parameters<F> extends [infer CI, ...any[]] ? CI extends {
-    [K in TaskMarker]: true;
-} ? CI extends C ? true : false : false : false : false;
-/**
- * Extracts method keys from a host that are "runnable" task methods.
- *
- * Uses {@link IsTaskRunnableSignature} to filter only methods whose first
- * parameter has the TaskMarker brand (i.e., uses `TaskCtx` or `WorkflowCtx`).
- *
- * For a TaskHost, this should return exactly one key.
- * For a WorkflowHost, this returns all workflow task method keys.
- *
- * @internal Used by WorkflowTaskOpts but not intended for direct external use.
- * @template T - The host instance type.
- * @template C - Optional context type constraint.
- */
-export type ContextMethodKeys<T extends AnyHost, C extends BaseCtx<any> = any> = {
-    [K in keyof T]: T[K] extends (...args: any) => any ? IsTaskRunnableSignature<T[K], C> extends true ? K : never : never;
-}[keyof T];
-/**
- * Extracts the output (return) type of a specific task method.
- *
- * @template T - The host constructor type.
- * @template M - The method key (must be a valid task method key).
- * @returns The awaited return type of the method.
- */
-export type AnyTaskOutput<T extends AnyHostCtor, M extends ContextMethodKeys<InstanceType<T>>> = InstanceType<T>[M] extends (...args: any) => any ? Awaited<ReturnType<InstanceType<T>[M]>> : never;
-/**
- * Represents any task function signature.
- *
- * A task function takes a context as its first parameter and returns
- * a value (sync or async).
- *
- * @template C - The context type.
- * @template O - The output type.
- */
-export type AnyTaskFn<C extends BaseCtx<any>, O> = (ctx: C) => Promise<O> | O;
-/**
- * Extracts the output type from a task function, but only if it's a valid
- * task method (has TaskMarker in its context parameter).
- *
- * Returns `never` for helper methods that use `HelperCtx`.
- * This is used by the `parent()` method in workflows to get type-safe
- * access to parent task outputs.
- *
- * @template T - The task function type.
- */
-export type OutputOfTaskFn<T extends AnyTaskFn<any, any>> = IsTaskRunnableSignature<T> extends true ? Awaited<ReturnType<T>> : never;
-/**
- * Extracts the single task method key from a TaskHost.
- * Since a TaskHost must have exactly one task method, this resolves to that method's key.
- *
- * @template T - The task host constructor type.
- */
-export type TaskMethodKey<T extends TaskHostCtor<any>> = ContextMethodKeys<InstanceType<T>, BaseCtx<any>>;
-/**
- * Extracts the input type from a TaskHost.
- *
- * @template T - The task host constructor type.
- */
-export type TaskInput<T extends TaskHostCtor<any>> = InstanceType<T> extends TaskHost<infer I> ? I : never;
-/**
- * Extracts the output type from the single task method of a TaskHost.
- *
- * @template T - The task host constructor type.
- */
-export type TaskOutput<T extends TaskHostCtor<any>> = AnyTaskOutput<T, TaskMethodKey<T>>;
-/**
- * Extracts the input type from a WorkflowHost constructor.
- *
- * @template T - The workflow host constructor type.
- */
-export type WorkflowInput<T extends WorkflowHostCtor<any>> = InstanceType<T> extends WorkflowHost<infer I> ? I : never;
-/**
- * Maps each workflow task method to its output type.
- *
- * @template C - The workflow host instance type.
- * @example
- * ```ts
- * // For a workflow with step1() returning { a: string } and step2() returning { b: number }
- * type Output = WorkflowTasksOutputMap<MyWorkflow>;
- * // Result: { step1: { a: string }; step2: { b: number } }
- * ```
- */
-export type WorkflowTasksOutputMap<C extends WorkflowHost<any>> = {
-    [K in ContextMethodKeys<C>]: C[K] extends (...a: any[]) => infer R ? Awaited<R> : never;
-};
-/**
- * Extracts the complete output type of a workflow (map of all task outputs).
- *
- * @template T - The workflow host constructor type.
- */
-export type WorkflowOutput<T extends WorkflowHostCtor<any>> = WorkflowTasksOutputMap<InstanceType<T>>;
-/**
- * Error type for invalid TaskHost - shows as a readable string literal in error messages.
- *
- * @internal Type-level error message, not intended for direct external use.
- * @template Reason - The error message to display.
- */
-export type InvalidTaskHost<Reason extends string> = `Error: ${Reason}`;
-/**
- * Error type for invalid WorkflowHost - shows as a readable string literal in error messages.
- *
- * @internal Type-level error message, not intended for direct external use.
- * @template Reason - The error message to display.
- */
-export type InvalidWorkflowHost<Reason extends string> = `Error: ${Reason}`;
-/**
- * Validates that a TaskHost has exactly one task method.
- * Returns the host type if valid, or an error type with a descriptive message.
- *
- * Used by {@link taskRef} to provide compile-time validation.
- *
- * @internal Used in taskRef() signature but not intended for direct external use.
- * @template C - The task host constructor type to validate.
- */
-export type ValidTaskHost<C extends TaskHostCtor<any>> = ContextMethodKeys<InstanceType<C>, BaseCtx<any>> extends infer K ? [K] extends [never] ? InvalidTaskHost<"TaskHost must have exactly one method with TaskCtx parameter"> : IsUnion<K> extends true ? InvalidTaskHost<"TaskHost has multiple task methods - only one is allowed"> : C : never;
-/**
- * Validates that a WorkflowHost has at least one workflow task method.
- * Returns the host type if valid, or an error type with a descriptive message.
- *
- * Used by {@link workflowRef} to provide compile-time validation.
- *
- * @internal Used in workflowRef() signature but not intended for direct external use.
- * @template C - The workflow host constructor type to validate.
- */
-export type ValidWorkflowHost<C extends WorkflowHostCtor<any>> = ContextMethodKeys<InstanceType<C>, BaseCtx<any>> extends infer K ? [K] extends [never] ? InvalidWorkflowHost<"WorkflowHost must have at least one method with WorkflowCtx parameter"> : C : never;
-export {};

package/dist/sdk/hatchet-client.factory.d.cts

@@ -1,5 +0,0 @@
-import type { FactoryProvider } from "@nestjs/common";
-/**
- * Factory provider for the HatchetClient.
- */
-export declare const hatchetClientFactory: FactoryProvider;

package/dist/sdk/index.d.cts

@@ -1 +0,0 @@
-export * from "./hatchet-client.factory.js";

package/dist/sdk/types.d.cts

@@ -1,7 +0,0 @@
-/**
- * Minimal compatible interface for the Hatchet SDK's WorkflowRunRef.
- * Used internally to avoid deep subpath imports from the SDK.
- */
-export interface WorkflowRunRef<T> {
-    get output(): Promise<T>;
-}