@abinnovision/nestjs-hatchet 0.8.0-beta.4 → 0.8.0-beta.5

package/README.md

@@ -176,11 +176,11 @@ await client.emit(UserCreatedEvent, {
 
 ### Client
 
-| Method                             | Description           |
-| ---------------------------------- | --------------------- |
-| `client.run(ref, input, opts?)`    | Execute task/workflow |
-| `client.emit(event, payload)`      | Emit single event     |
-| `client.emitBulk(event, payloads)` | Emit multiple events  |
+| Method                                    | Description                                    |
+| ----------------------------------------- | ---------------------------------------------- |
+| `client.run(ref, input, opts?)`           | Execute task/workflow                          |
+| `client.emit(event, payload \| payloads)` | Emit one or many events                        |
+| `client.emitBulk(event, payloads)`        | Emit multiple events (deprecated — use `emit`) |
 
 ### Context Types
 
@@ -212,7 +212,7 @@ const result = await runRef.output; // Await when needed
 ### Bulk Event Emission
 
 ```typescript
-await client.emitBulk(OrderEvent, [
+await client.emit(OrderEvent, [
   { orderId: "1", total: 100 },
   { orderId: "2", total: 200 },
 ]);

package/dist/abstracts/hosts.d.cts

@@ -0,0 +1,70 @@
+import { InputType } from "@hatchet-dev/typescript-sdk";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/abstracts/hosts.d.ts
+/**
+ * Interface for classes that provide a schema for their input.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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;
+  };
+};
+//#endregion
+export { InputSchemaProvider, TaskHost, WorkflowHost, taskHost, workflowHost };

package/dist/abstracts/hosts.d.mts

@@ -0,0 +1,70 @@
+import { InputType } from "@hatchet-dev/typescript-sdk";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/abstracts/hosts.d.ts
+/**
+ * Interface for classes that provide a schema for their input.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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;
+  };
+};
+//#endregion
+export { InputSchemaProvider, TaskHost, WorkflowHost, taskHost, workflowHost };

package/dist/abstracts/index.d.cts

@@ -0,0 +1 @@
+import { InputSchemaProvider, TaskHost, WorkflowHost, taskHost, workflowHost } from "./hosts.cjs";

package/dist/abstracts/index.d.mts

@@ -0,0 +1 @@
+import { InputSchemaProvider, TaskHost, WorkflowHost, taskHost, workflowHost } from "./hosts.mjs";

package/dist/client/client.cjs

@@ -26,18 +26,45 @@ var Client = class {
 		return this.client;
 	}
 	/**
-	* Emit a single event.
+	* Emit one or many events of the same type.
+	*
+	* Pass a single payload to emit one event, or an array of payloads to emit
+	* many at once. The return type adjusts accordingly: a single {@link Event}
+	* for a single input, or an array of {@link Event} for an array of inputs.
 	*
 	* @param event The event definition to emit.
-	* @param input The event payload (must match the event's schema).
+	* @param input A single event payload, or an array of payloads (each must
+	*   match the event's schema).
 	* @param options Optional emit configuration.
-	* @returns The emitted event.
+	* @returns The emitted event, or an array of emitted events.
 	*
 	* @example
 	* ```typescript
+	* // Single event
 	* await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
 	* ```
+	*
+	* @example
+	* ```typescript
+	* // Multiple events
+	* await client.emit(OrderPlacedEvent, [
+	*   { orderId: "1", userId: "123", total: 100 },
+	*   { orderId: "2", userId: "456", total: 200 },
+	* ]);
+	* ```
 	*/ async emit(event, input, options) {
+		if (Array.isArray(input)) {
+			if (input.length === 0) return [];
+			return (await this.client.events.bulkPush(event.name, input.map((single) => ({
+				payload: {
+					...single,
+					[require_event_definition.EVENT_MARKER]: event.name
+				},
+				...options?.additionalMetadata !== void 0 && { additionalMetadata: options.additionalMetadata },
+				...options?.priority !== void 0 && { priority: options.priority },
+				...options?.scope !== void 0 && { scope: options.scope }
+			})), options)).events;
+		}
 		return await this.client.events.push(event.name, {
 			...input,
 			[require_event_definition.EVENT_MARKER]: event.name
@@ -46,29 +73,15 @@ var Client = class {
 	/**
 	* Emit multiple events of the same type.
 	*
+	* @deprecated Use {@link Client.emit} with an array of inputs instead. This
+	*   alias forwards to `emit` and will be removed in a future major version.
+	*
 	* @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 },
-	* ]);
-	* ```
 	*/ async emitBulk(event, inputs, options) {
-		if (inputs.length === 0) return [];
-		return (await this.client.events.bulkPush(event.name, inputs.map((input) => ({
-			payload: {
-				...input,
-				[require_event_definition.EVENT_MARKER]: event.name
-			},
-			...options?.additionalMetadata !== void 0 && { additionalMetadata: options.additionalMetadata },
-			...options?.priority !== void 0 && { priority: options.priority },
-			...options?.scope !== void 0 && { scope: options.scope }
-		})), options)).events;
+		return await this.emit(event, inputs, options);
 	}
 };
 Client = _ts_decorate([

package/dist/client/client.d.cts

@@ -0,0 +1,70 @@
+import { AnyEventDefinition, EventInput } from "../events/event-definition.cjs";
+import { HostRunFn } from "../execution/host-run/function-type.cjs";
+import { HatchetClient } from "@hatchet-dev/typescript-sdk";
+
+//#region src/client/client.d.ts
+type EventClient = HatchetClient["events"];
+type EventEmitOptions = Parameters<EventClient["push"]>[2];
+type Event = Awaited<ReturnType<EventClient["push"]>>;
+/**
+ * Input accepted by {@link Client.emit} — a single event payload or an array of them.
+ */
+type EventEmitInput<E extends AnyEventDefinition> = EventInput<E> | EventInput<E>[];
+/**
+ * Return type of {@link Client.emit}: an array of events when an array of inputs is
+ * provided, otherwise a single event.
+ */
+type EventEmitReturn<E extends AnyEventDefinition, I extends EventEmitInput<E>> = I extends EventInput<E>[] ? Event[] : Event;
+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 one or many events of the same type.
+   *
+   * Pass a single payload to emit one event, or an array of payloads to emit
+   * many at once. The return type adjusts accordingly: a single {@link Event}
+   * for a single input, or an array of {@link Event} for an array of inputs.
+   *
+   * @param event The event definition to emit.
+   * @param input A single event payload, or an array of payloads (each must
+   *   match the event's schema).
+   * @param options Optional emit configuration.
+   * @returns The emitted event, or an array of emitted events.
+   *
+   * @example
+   * ```typescript
+   * // Single event
+   * await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Multiple events
+   * await client.emit(OrderPlacedEvent, [
+   *   { orderId: "1", userId: "123", total: 100 },
+   *   { orderId: "2", userId: "456", total: 200 },
+   * ]);
+   * ```
+   */
+  emit<E extends AnyEventDefinition, I extends EventEmitInput<E>>(event: E, input: I, options?: EventEmitOptions): Promise<EventEmitReturn<E, I>>;
+  /**
+   * Emit multiple events of the same type.
+   *
+   * @deprecated Use {@link Client.emit} with an array of inputs instead. This
+   *   alias forwards to `emit` and will be removed in a future major version.
+   *
+   * @param event The event definition to emit.
+   * @param inputs Array of event payloads.
+   * @param options Optional emit configuration.
+   * @returns Array of emitted events.
+   */
+  emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EventEmitOptions): Promise<Event[]>;
+}
+//#endregion
+export { Client };

package/dist/client/client.d.mts

@@ -0,0 +1,70 @@
+import { AnyEventDefinition, EventInput } from "../events/event-definition.mjs";
+import { HostRunFn } from "../execution/host-run/function-type.mjs";
+import { HatchetClient } from "@hatchet-dev/typescript-sdk";
+
+//#region src/client/client.d.ts
+type EventClient = HatchetClient["events"];
+type EventEmitOptions = Parameters<EventClient["push"]>[2];
+type Event = Awaited<ReturnType<EventClient["push"]>>;
+/**
+ * Input accepted by {@link Client.emit} — a single event payload or an array of them.
+ */
+type EventEmitInput<E extends AnyEventDefinition> = EventInput<E> | EventInput<E>[];
+/**
+ * Return type of {@link Client.emit}: an array of events when an array of inputs is
+ * provided, otherwise a single event.
+ */
+type EventEmitReturn<E extends AnyEventDefinition, I extends EventEmitInput<E>> = I extends EventInput<E>[] ? Event[] : Event;
+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 one or many events of the same type.
+   *
+   * Pass a single payload to emit one event, or an array of payloads to emit
+   * many at once. The return type adjusts accordingly: a single {@link Event}
+   * for a single input, or an array of {@link Event} for an array of inputs.
+   *
+   * @param event The event definition to emit.
+   * @param input A single event payload, or an array of payloads (each must
+   *   match the event's schema).
+   * @param options Optional emit configuration.
+   * @returns The emitted event, or an array of emitted events.
+   *
+   * @example
+   * ```typescript
+   * // Single event
+   * await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Multiple events
+   * await client.emit(OrderPlacedEvent, [
+   *   { orderId: "1", userId: "123", total: 100 },
+   *   { orderId: "2", userId: "456", total: 200 },
+   * ]);
+   * ```
+   */
+  emit<E extends AnyEventDefinition, I extends EventEmitInput<E>>(event: E, input: I, options?: EventEmitOptions): Promise<EventEmitReturn<E, I>>;
+  /**
+   * Emit multiple events of the same type.
+   *
+   * @deprecated Use {@link Client.emit} with an array of inputs instead. This
+   *   alias forwards to `emit` and will be removed in a future major version.
+   *
+   * @param event The event definition to emit.
+   * @param inputs Array of event payloads.
+   * @param options Optional emit configuration.
+   * @returns Array of emitted events.
+   */
+  emitBulk<E extends AnyEventDefinition>(event: E, inputs: EventInput<E>[], options?: EventEmitOptions): Promise<Event[]>;
+}
+//#endregion
+export { Client };

package/dist/client/client.mjs

@@ -26,18 +26,45 @@ var Client = class {
 		return this.client;
 	}
 	/**
-	* Emit a single event.
+	* Emit one or many events of the same type.
+	*
+	* Pass a single payload to emit one event, or an array of payloads to emit
+	* many at once. The return type adjusts accordingly: a single {@link Event}
+	* for a single input, or an array of {@link Event} for an array of inputs.
 	*
 	* @param event The event definition to emit.
-	* @param input The event payload (must match the event's schema).
+	* @param input A single event payload, or an array of payloads (each must
+	*   match the event's schema).
 	* @param options Optional emit configuration.
-	* @returns The emitted event.
+	* @returns The emitted event, or an array of emitted events.
 	*
 	* @example
 	* ```typescript
+	* // Single event
 	* await client.emit(UserCreatedEvent, { userId: "123", email: "user@example.com" });
 	* ```
+	*
+	* @example
+	* ```typescript
+	* // Multiple events
+	* await client.emit(OrderPlacedEvent, [
+	*   { orderId: "1", userId: "123", total: 100 },
+	*   { orderId: "2", userId: "456", total: 200 },
+	* ]);
+	* ```
 	*/ async emit(event, input, options) {
+		if (Array.isArray(input)) {
+			if (input.length === 0) return [];
+			return (await this.client.events.bulkPush(event.name, input.map((single) => ({
+				payload: {
+					...single,
+					[EVENT_MARKER]: event.name
+				},
+				...options?.additionalMetadata !== void 0 && { additionalMetadata: options.additionalMetadata },
+				...options?.priority !== void 0 && { priority: options.priority },
+				...options?.scope !== void 0 && { scope: options.scope }
+			})), options)).events;
+		}
 		return await this.client.events.push(event.name, {
 			...input,
 			[EVENT_MARKER]: event.name
@@ -46,29 +73,15 @@ var Client = class {
 	/**
 	* Emit multiple events of the same type.
 	*
+	* @deprecated Use {@link Client.emit} with an array of inputs instead. This
+	*   alias forwards to `emit` and will be removed in a future major version.
+	*
 	* @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 },
-	* ]);
-	* ```
 	*/ async emitBulk(event, inputs, options) {
-		if (inputs.length === 0) return [];
-		return (await this.client.events.bulkPush(event.name, inputs.map((input) => ({
-			payload: {
-				...input,
-				[EVENT_MARKER]: event.name
-			},
-			...options?.additionalMetadata !== void 0 && { additionalMetadata: options.additionalMetadata },
-			...options?.priority !== void 0 && { priority: options.priority },
-			...options?.scope !== void 0 && { scope: options.scope }
-		})), options)).events;
+		return await this.emit(event, inputs, options);
 	}
 };
 Client = _ts_decorate([

package/dist/client/index.d.cts

@@ -0,0 +1 @@
+import { Client } from "./client.cjs";

package/dist/client/index.d.mts

@@ -0,0 +1 @@
+import { Client } from "./client.mjs";

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

@@ -0,0 +1,92 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/events/event-definition.d.ts
+/**
+ * Marker embedded in event payload to identify an event type.
+ * Used by isCtx() type guard to determine which event triggered the workflow.
+ */
+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.
+ */
+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: casts the context input to this event's schema output type
+   * without requiring the event marker to be present.
+   *
+   * Use this for externally sourced events that arrive without the marker
+   * injected by Client.emit(). Schema validation still runs and throws if
+   * the payload is malformed.
+   *
+   * @param ctx The context to check (TaskCtx, WorkflowCtx, HelperCtx, or SDK Context).
+   * @returns True if the context input is a non-null object that passes schema validation.
+   * @throws {EventPayloadMalformedException} If the payload fails schema validation.
+   */
+  cast<C extends {
+    input: unknown;
+  }>(ctx: C): ctx is C & {
+    input: StandardSchemaV1.InferOutput<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 {EventPayloadMalformedException} 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.
+ */
+type AnyEventDefinition = EventDefinition<string, StandardSchemaV1>;
+/**
+ * Extracts the input type from an event definition.
+ */
+type EventInput<E extends AnyEventDefinition> = E["__types"]["input"];
+/**
+ * Extracts the output type from an event definition.
+ */
+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(),
+ * }));
+ * ```
+ */
+declare const defineEvent: <TName extends string, TSchema extends StandardSchemaV1>(name: TName, schema: TSchema) => EventDefinition<TName, TSchema>;
+//#endregion
+export { AnyEventDefinition, EventDefinition, EventInput, EventOutput, defineEvent };

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

@@ -0,0 +1,92 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/events/event-definition.d.ts
+/**
+ * Marker embedded in event payload to identify an event type.
+ * Used by isCtx() type guard to determine which event triggered the workflow.
+ */
+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.
+ */
+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: casts the context input to this event's schema output type
+   * without requiring the event marker to be present.
+   *
+   * Use this for externally sourced events that arrive without the marker
+   * injected by Client.emit(). Schema validation still runs and throws if
+   * the payload is malformed.
+   *
+   * @param ctx The context to check (TaskCtx, WorkflowCtx, HelperCtx, or SDK Context).
+   * @returns True if the context input is a non-null object that passes schema validation.
+   * @throws {EventPayloadMalformedException} If the payload fails schema validation.
+   */
+  cast<C extends {
+    input: unknown;
+  }>(ctx: C): ctx is C & {
+    input: StandardSchemaV1.InferOutput<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 {EventPayloadMalformedException} 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.
+ */
+type AnyEventDefinition = EventDefinition<string, StandardSchemaV1>;
+/**
+ * Extracts the input type from an event definition.
+ */
+type EventInput<E extends AnyEventDefinition> = E["__types"]["input"];
+/**
+ * Extracts the output type from an event definition.
+ */
+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(),
+ * }));
+ * ```
+ */
+declare const defineEvent: <TName extends string, TSchema extends StandardSchemaV1>(name: TName, schema: TSchema) => EventDefinition<TName, TSchema>;
+//#endregion
+export { AnyEventDefinition, EventDefinition, EventInput, EventOutput, defineEvent };

package/dist/events/index.d.cts

@@ -0,0 +1 @@
+import { AnyEventDefinition, EventDefinition, EventInput, EventOutput, defineEvent } from "./event-definition.cjs";

package/dist/events/index.d.mts

@@ -0,0 +1 @@
+import { AnyEventDefinition, EventDefinition, EventInput, EventOutput, defineEvent } from "./event-definition.mjs";