@signaltree/events 7.3.1

package/src/core/validation.d.ts

@@ -0,0 +1,619 @@
+import { z, ZodError, ZodObject, ZodRawShape } from 'zod';
+import { BaseEvent } from './types';
+/**
+ * Event validation using Zod schemas
+ *
+ * Provides:
+ * - Base schemas for common event fields
+ * - Factory function to create event schemas
+ * - Runtime validation with detailed errors
+ */
+/**
+ * Schema for event actor
+ */
+export declare const EventActorSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "user" | "system" | "admin" | "webhook";
+    name?: string | undefined;
+}, {
+    id: string;
+    type: "user" | "system" | "admin" | "webhook";
+    name?: string | undefined;
+}>;
+/**
+ * Schema for event version
+ */
+export declare const EventVersionSchema: z.ZodObject<{
+    major: z.ZodNumber;
+    minor: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    major: number;
+    minor: number;
+}, {
+    major: number;
+    minor: number;
+}>;
+/**
+ * Schema for event metadata
+ */
+export declare const EventMetadataSchema: z.ZodObject<{
+    source: z.ZodString;
+    environment: z.ZodString;
+    ip: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodString;
+    environment: z.ZodString;
+    ip: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodString;
+    environment: z.ZodString;
+    ip: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Schema for aggregate info
+ */
+export declare const AggregateSchema: z.ZodOptional<z.ZodObject<{
+    type: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: string;
+}, {
+    id: string;
+    type: string;
+}>>;
+/**
+ * Base event schema without data field
+ */
+export declare const BaseEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: string;
+    version: {
+        major: number;
+        minor: number;
+    };
+    timestamp: string;
+    correlationId: string;
+    actor: {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    };
+    metadata: {
+        source: string;
+        environment: string;
+        ip?: string | undefined;
+        userAgent?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    causationId?: string | undefined;
+    priority?: "critical" | "high" | "normal" | "low" | "bulk" | undefined;
+    aggregate?: {
+        id: string;
+        type: string;
+    } | undefined;
+}, {
+    id: string;
+    type: string;
+    version: {
+        major: number;
+        minor: number;
+    };
+    timestamp: string;
+    correlationId: string;
+    actor: {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    };
+    metadata: {
+        source: string;
+        environment: string;
+        ip?: string | undefined;
+        userAgent?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    causationId?: string | undefined;
+    priority?: "critical" | "high" | "normal" | "low" | "bulk" | undefined;
+    aggregate?: {
+        id: string;
+        type: string;
+    } | undefined;
+}>;
+/**
+ * Create a typed event schema with Zod validation
+ *
+ * @param eventType - The event type string (e.g., 'TradeProposalCreated')
+ * @param dataSchema - Zod schema for the event's data field
+ * @returns Complete event schema
+ *
+ * @example
+ * ```typescript
+ * const TradeProposalCreatedSchema = createEventSchema('TradeProposalCreated', {
+ *   tradeId: z.string().uuid(),
+ *   initiatorId: z.string().uuid(),
+ *   recipientId: z.string().uuid(),
+ *   vehicleOfferedId: z.string().uuid(),
+ *   terms: z.object({
+ *     cashDifference: z.number().optional(),
+ *   }),
+ * });
+ *
+ * type TradeProposalCreated = z.infer<typeof TradeProposalCreatedSchema>;
+ * ```
+ */
+export declare function createEventSchema<TType extends string, TDataShape extends ZodRawShape>(eventType: TType, dataSchema: TDataShape): z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+} & {
+    type: z.ZodLiteral<TType>;
+    data: z.ZodObject<TDataShape, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TDataShape>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<TDataShape> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+} & {
+    type: z.ZodLiteral<TType>;
+    data: z.ZodObject<TDataShape, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TDataShape>, any> extends infer T_3 ? { [k in keyof T_3]: T_3[k]; } : never, z.baseObjectInputType<TDataShape> extends infer T_4 ? { [k_1 in keyof T_4]: T_4[k_1]; } : never>;
+}>, any> extends infer T_2 ? { [k_2 in keyof T_2]: T_2[k_2]; } : never, z.baseObjectInputType<{
+    id: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+} & {
+    type: z.ZodLiteral<TType>;
+    data: z.ZodObject<TDataShape, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<TDataShape>, any> extends infer T_6 ? { [k in keyof T_6]: T_6[k]; } : never, z.baseObjectInputType<TDataShape> extends infer T_7 ? { [k_1 in keyof T_7]: T_7[k_1]; } : never>;
+}> extends infer T_5 ? { [k_3 in keyof T_5]: T_5[k_3]; } : never>;
+/**
+ * Create event schema from existing Zod object
+ */
+export declare function createEventSchemaFromZod<TType extends string, TData extends ZodObject<ZodRawShape>>(eventType: TType, dataSchema: TData): z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+} & {
+    type: z.ZodLiteral<TType>;
+    data: TData;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+} & {
+    type: z.ZodLiteral<TType>;
+    data: TData;
+}>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+    id: z.ZodString;
+    version: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        major: number;
+        minor: number;
+    }, {
+        major: number;
+        minor: number;
+    }>;
+    timestamp: z.ZodString;
+    correlationId: z.ZodString;
+    causationId: z.ZodOptional<z.ZodString>;
+    actor: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["user", "system", "admin", "webhook"]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }, {
+        id: string;
+        type: "user" | "system" | "admin" | "webhook";
+        name?: string | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+        environment: z.ZodString;
+        ip: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "normal", "low", "bulk"]>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: string;
+    }, {
+        id: string;
+        type: string;
+    }>>;
+} & {
+    type: z.ZodLiteral<TType>;
+    data: TData;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+/**
+ * Custom error class for event validation failures
+ */
+export declare class EventValidationError extends Error {
+    readonly zodError: ZodError;
+    readonly event: unknown;
+    constructor(message: string, zodError: ZodError, event: unknown);
+    /**
+     * Get formatted error messages
+     */
+    get issues(): string[];
+}
+/**
+ * Validate an event against a schema, throwing on failure
+ *
+ * @param schema - Zod schema to validate against
+ * @param event - Event to validate
+ * @returns Validated and typed event
+ * @throws EventValidationError if validation fails
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const validEvent = validateEvent(TradeProposalCreatedSchema, rawEvent);
+ *   // validEvent is typed as TradeProposalCreated
+ * } catch (error) {
+ *   if (error instanceof EventValidationError) {
+ *     console.error('Validation failed:', error.issues);
+ *   }
+ * }
+ * ```
+ */
+export declare function validateEvent<T extends z.ZodTypeAny>(schema: T, event: unknown): z.infer<T>;
+/**
+ * Check if an event is valid without throwing
+ *
+ * @param schema - Zod schema to validate against
+ * @param event - Event to check
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidEvent<T extends z.ZodTypeAny>(schema: T, event: unknown): event is z.infer<T>;
+/**
+ * Parse an event, returning result with success/error
+ *
+ * @param schema - Zod schema to parse with
+ * @param event - Event to parse
+ * @returns SafeParseResult with data or error
+ */
+export declare function parseEvent<T extends z.ZodTypeAny>(schema: T, event: unknown): z.SafeParseReturnType<unknown, z.infer<T>>;
+/**
+ * Validate base event structure (without specific data validation)
+ */
+export declare function validateBaseEvent(event: unknown): BaseEvent;
+/**
+ * Check if value looks like a base event (duck typing)
+ */
+export declare function isBaseEventLike(value: unknown): value is BaseEvent;

package/src/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @signaltree/events
+ *
+ * Event-driven architecture infrastructure for SignalTree applications.
+ * Provides a complete event bus system with validation, subscribers, and real-time sync.
+ *
+ * ## Subpaths
+ *
+ * - `@signaltree/events` - Core types, schemas, validation (framework-agnostic)
+ * - `@signaltree/events/nestjs` - NestJS integration (EventBusModule, BaseSubscriber)
+ * - `@signaltree/events/angular` - Angular integration (WebSocketService)
+ * - `@signaltree/events/testing` - Test utilities (MockEventBus, event factories)
+ *
+ * @example
+ * ```typescript
+ * // Define your app events
+ * import { BaseEvent, createEventSchema, EventPriority } from '@signaltree/events';
+ * import { z } from 'zod';
+ *
+ * // Define event schema with Zod for runtime validation
+ * export const TradeProposalCreatedSchema = createEventSchema('TradeProposalCreated', {
+ *   tradeId: z.string().uuid(),
+ *   initiatorId: z.string().uuid(),
+ *   recipientId: z.string().uuid(),
+ *   vehicleOfferedId: z.string().uuid(),
+ * });
+ *
+ * export type TradeProposalCreated = z.infer<typeof TradeProposalCreatedSchema>;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // NestJS: Set up event bus
+ * import { EventBusModule } from '@signaltree/events/nestjs';
+ *
+ * @Module({
+ *   imports: [
+ *     EventBusModule.forRoot({
+ *       redis: { host: 'localhost', port: 6379 },
+ *       queues: ['critical', 'high', 'normal', 'low', 'bulk'],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @packageDocumentation
+ */
+export type { BaseEvent, EventMetadata, EventActor, EventPriority, EventVersion, } from './core/types';
+export { EVENT_PRIORITIES, DEFAULT_EVENT_VERSION } from './core/types';
+export { createEventSchema, BaseEventSchema, EventMetadataSchema, EventActorSchema, EventVersionSchema, validateEvent, isValidEvent, parseEvent, EventValidationError, } from './core/validation';
+export { EventRegistry, createEventRegistry, type RegisteredEvent, type EventRegistryConfig, type EventCatalog, type EventCatalogEntry, } from './core/registry';
+export { createEvent, createEventFactory, generateEventId, generateCorrelationId, type EventFactory, type EventFactoryConfig, type CreateEventOptions, } from './core/factory';
+export { classifyError, isRetryableError, createErrorClassifier, defaultErrorClassifier, DEFAULT_RETRY_CONFIGS, type ErrorClassification, type RetryConfig, type ClassificationResult, type ErrorClassifier, type ErrorClassifierConfig, } from './core/error-classification';
+export { InMemoryIdempotencyStore, createInMemoryIdempotencyStore, generateIdempotencyKey, generateCorrelationKey, type IdempotencyStore, type IdempotencyCheckResult, type IdempotencyCheckOptions, type ProcessedEventRecord, type InMemoryIdempotencyStoreConfig, } from './core/idempotency';
+export { z } from 'zod';