@warlock.js/herald 4.0.156 → 4.0.158

package/esm/communicators/communicator.d.ts

@@ -1,100 +0,0 @@
-import type { CommunicatorDriverContract } from "../contracts";
-import type { ChannelContract } from "../contracts/channel.contract";
-import { EventMessage } from "../message-managers/event-message";
-import { EventConsumerClass } from "../message-managers/types";
-import type { ChannelOptions } from "../types";
-/**
- * Options for creating a Communicator
- */
-export interface CommunicatorOptions {
-    /** Unique name for this communicator */
-    name: string;
-    /** The underlying driver */
-    driver: CommunicatorDriverContract;
-    /** Whether this is the default communicator */
-    isDefault?: boolean;
-}
-/**
- * Communicator - wrapper around a driver with metadata
- *
- * Similar to DataSource in @warlock.js/cascade
- *
- * @example
- * ```typescript
- * const communicator = new Communicator({
- *   name: "default",
- *   driver: rabbitMQDriver,
- *   isDefault: true,
- * });
- *
- * // Get a channel
- * const channel = communicator.channel("user.created");
- * ```
- */
-export declare class Communicator {
-    /** Unique name identifying this communicator */
-    readonly name: string;
-    /** The underlying driver */
-    readonly driver: CommunicatorDriverContract;
-    /** Whether this is the default communicator */
-    readonly isDefault: boolean;
-    /**
-     * Create a new Communicator
-     *
-     * @param options - Communicator configuration
-     */
-    constructor(options: CommunicatorOptions);
-    /**
-     * Subscribe the given consumer
-     */
-    subscribe(consumer: EventConsumerClass<any>): () => void;
-    /**
-     * Publish the given event message
-     */
-    publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>): void;
-    /**
-     * Get or create a channel
-     *
-     * @param name - Channel name
-     * @param options - Channel options
-     * @returns Channel instance
-     *
-     * @example
-     * ```typescript
-     * // Simple channel
-     * const channel = communicator.channel("notifications");
-     *
-     * // Typed channel with schema
-     * const orderChannel = communicator.channel<OrderPayload>("orders", {
-     *   schema: OrderSchema,
-     *   durable: true,
-     * });
-     * ```
-     */
-    channel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
-    /**
-     * Check if the communicator is connected
-     */
-    get isConnected(): boolean;
-    /**
-     * Connect the underlying driver
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect the underlying driver
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Start consuming messages
-     */
-    startConsuming(): Promise<void>;
-    /**
-     * Stop consuming messages
-     */
-    stopConsuming(): Promise<void>;
-    /**
-     * Health check
-     */
-    healthCheck(): Promise<import("../types").HealthCheckResult>;
-}
-//# sourceMappingURL=communicator.d.ts.map

package/esm/communicators/communicator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"communicator.d.ts","sourceRoot":"","sources":["../../src/communicators/communicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,MAAM,EAAE,0BAA0B,CAAC;IACnC,+CAA+C;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY;IACvB,gDAAgD;IAChD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,4BAA4B;IAC5B,SAAgB,MAAM,EAAE,0BAA0B,CAAC;IAEnD,+CAA+C;IAC/C,SAAgB,SAAS,EAAE,OAAO,CAAC;IAEnC;;;;OAIG;gBACgB,OAAO,EAAE,mBAAmB;IAM/C;;OAEG;IACI,SAAS,CAAC,QAAQ,EAAE,kBAAkB,CAAC,GAAG,CAAC;IAIlD;;OAEG;IACI,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC;IAI5E;;;;;;;;;;;;;;;;;;OAkBG;IACI,OAAO,CAAC,QAAQ,GAAG,OAAO,EAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GACjC,eAAe,CAAC,QAAQ,CAAC;IAI5B;;OAEG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED;;OAEG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5C;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3C;;OAEG;IACU,WAAW;CAGzB"}

package/esm/communicators/communicator.js

@@ -1,105 +0,0 @@
-/**
- * Communicator - wrapper around a driver with metadata
- *
- * Similar to DataSource in @warlock.js/cascade
- *
- * @example
- * ```typescript
- * const communicator = new Communicator({
- *   name: "default",
- *   driver: rabbitMQDriver,
- *   isDefault: true,
- * });
- *
- * // Get a channel
- * const channel = communicator.channel("user.created");
- * ```
- */
-class Communicator {
-    /** Unique name identifying this communicator */
-    name;
-    /** The underlying driver */
-    driver;
-    /** Whether this is the default communicator */
-    isDefault;
-    /**
-     * Create a new Communicator
-     *
-     * @param options - Communicator configuration
-     */
-    constructor(options) {
-        this.name = options.name;
-        this.driver = options.driver;
-        this.isDefault = Boolean(options.isDefault);
-    }
-    /**
-     * Subscribe the given consumer
-     */
-    subscribe(consumer) {
-        return this.driver.subscribe(consumer);
-    }
-    /**
-     * Publish the given event message
-     */
-    publish(event) {
-        this.driver.publish(event);
-    }
-    /**
-     * Get or create a channel
-     *
-     * @param name - Channel name
-     * @param options - Channel options
-     * @returns Channel instance
-     *
-     * @example
-     * ```typescript
-     * // Simple channel
-     * const channel = communicator.channel("notifications");
-     *
-     * // Typed channel with schema
-     * const orderChannel = communicator.channel<OrderPayload>("orders", {
-     *   schema: OrderSchema,
-     *   durable: true,
-     * });
-     * ```
-     */
-    channel(name, options) {
-        return this.driver.channel(name, options);
-    }
-    /**
-     * Check if the communicator is connected
-     */
-    get isConnected() {
-        return this.driver.isConnected;
-    }
-    /**
-     * Connect the underlying driver
-     */
-    async connect() {
-        await this.driver.connect();
-    }
-    /**
-     * Disconnect the underlying driver
-     */
-    async disconnect() {
-        await this.driver.disconnect();
-    }
-    /**
-     * Start consuming messages
-     */
-    async startConsuming() {
-        await this.driver.startConsuming();
-    }
-    /**
-     * Stop consuming messages
-     */
-    async stopConsuming() {
-        await this.driver.stopConsuming();
-    }
-    /**
-     * Health check
-     */
-    async healthCheck() {
-        return this.driver.healthCheck();
-    }
-}export{Communicator};//# sourceMappingURL=communicator.js.map

package/esm/communicators/communicator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"communicator.js","sources":["../../src/communicators/communicator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;AAgBG;MACU,YAAY,CAAA;;AAEP,IAAA,IAAI,CAAS;;AAGb,IAAA,MAAM,CAA6B;;AAGnC,IAAA,SAAS,CAAU;AAEnC;;;;AAIG;AACH,IAAA,WAAA,CAAmB,OAA4B,EAAA;AAC7C,QAAA,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;AACzB,QAAA,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;KAC7C;AAED;;AAEG;AACI,IAAA,SAAS,CAAC,QAAiC,EAAA;QAChD,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;KACxC;AAED;;AAEG;AACI,IAAA,OAAO,CAAiC,KAA6B,EAAA;AAC1E,QAAA,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;KAC5B;AAED;;;;;;;;;;;;;;;;;;AAkBG;IACI,OAAO,CACZ,IAAY,EACZ,OAAkC,EAAA;QAElC,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAW,IAAI,EAAE,OAAO,CAAC,CAAC;KACrD;AAED;;AAEG;AACH,IAAA,IAAW,WAAW,GAAA;AACpB,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;KAChC;AAED;;AAEG;AACI,IAAA,MAAM,OAAO,GAAA;AAClB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;KAC7B;AAED;;AAEG;AACI,IAAA,MAAM,UAAU,GAAA;AACrB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;KAChC;AAED;;AAEG;AACI,IAAA,MAAM,cAAc,GAAA;AACzB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;KACpC;AAED;;AAEG;AACI,IAAA,MAAM,aAAa,GAAA;AACxB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;KACnC;AAED;;AAEG;AACI,IAAA,MAAM,WAAW,GAAA;AACtB,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;KAClC;AACF"}

package/esm/communicators/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./communicator";
-export * from "./communicator-registry";
-//# sourceMappingURL=index.d.ts.map

package/esm/communicators/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/communicators/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC"}

package/esm/contracts/channel.contract.d.ts

@@ -1,186 +0,0 @@
-import type { ChannelOptions, ChannelStats, MessageHandler, PublishOptions, RequestOptions, ResponseHandler, SubscribeOptions, Subscription } from "../types";
-/**
- * Channel contract - represents a queue (RabbitMQ) or topic (Kafka)
- *
- * Provides a unified pub/sub interface across different message brokers.
- *
- * @template TPayload - The typed payload for messages on this channel
- *
- * @example
- * ```typescript
- * // Get a typed channel
- * const userChannel = communicators().channel<UserPayload>("user.created");
- *
- * // Publish
- * await userChannel.publish({ userId: 1, email: "test@example.com" });
- *
- * // Subscribe
- * userChannel.subscribe(async (message, ctx) => {
- *   console.log(message.payload.userId);
- *   await ctx.ack();
- * });
- * ```
- */
-export interface ChannelContract<TPayload = unknown> {
-    /**
-     * Channel name/routing key
-     */
-    readonly name: string;
-    /**
-     * Channel options
-     */
-    readonly options: ChannelOptions<TPayload>;
-    /**
-     * Publish a message to this channel
-     *
-     * @param payload - The message payload
-     * @param options - Optional publish options
-     *
-     * @example
-     * ```typescript
-     * await channel.publish({ orderId: 123 });
-     *
-     * // With options
-     * await channel.publish({ orderId: 123 }, {
-     *   priority: 5,
-     *   persistent: true,
-     *   correlationId: "req-123",
-     * });
-     * ```
-     */
-    publish(payload: TPayload, options?: PublishOptions): Promise<void>;
-    /**
-     * Publish multiple messages in a batch
-     *
-     * More efficient than publishing one by one.
-     *
-     * @param messages - Array of payloads to publish
-     * @param options - Optional publish options (applied to all messages)
-     *
-     * @example
-     * ```typescript
-     * await channel.publishBatch([
-     *   { event: "page_view", page: "/home" },
-     *   { event: "page_view", page: "/products" },
-     * ]);
-     * ```
-     */
-    publishBatch(messages: TPayload[], options?: PublishOptions): Promise<void>;
-    /**
-     * Subscribe to messages on this channel
-     *
-     * @param handler - Function to handle incoming messages
-     * @param options - Optional subscribe options
-     * @returns Subscription object for managing the subscription
-     *
-     * @example
-     * ```typescript
-     * const subscription = await channel.subscribe(
-     *   async (message, ctx) => {
-     *     await processOrder(message.payload);
-     *     await ctx.ack();
-     *   },
-     *   {
-     *     prefetch: 10,
-     *     retry: { maxRetries: 3, delay: 1000 },
-     *   }
-     * );
-     *
-     * // Later: unsubscribe
-     * await subscription.unsubscribe();
-     * ```
-     */
-    subscribe(handler: MessageHandler<TPayload>, options?: SubscribeOptions): Promise<Subscription>;
-    /**
-     * Unsubscribe a consumer by its ID
-     *
-     * @param consumerId - The consumer ID to unsubscribe
-     *
-     * @example
-     * ```typescript
-     * await channel.unsubscribeById("consumer-uuid");
-     * ```
-     */
-    unsubscribeById(consumerId: string): Promise<void>;
-    /**
-     * Request-Response pattern (RPC)
-     *
-     * Publishes a message and waits for a response.
-     *
-     * @param payload - The request payload
-     * @param options - Request options including timeout
-     * @returns Promise resolving to the response
-     *
-     * @example
-     * ```typescript
-     * const result = await channel.request<ProcessResult>(
-     *   { imageUrl: "https://..." },
-     *   { timeout: 30000 }
-     * );
-     * console.log(result.processedUrl);
-     * ```
-     */
-    request<TResponse = unknown>(payload: TPayload, options?: RequestOptions): Promise<TResponse>;
-    /**
-     * Register a response handler for RPC pattern
-     *
-     * The return value of the handler becomes the response.
-     *
-     * @param handler - Function to handle requests and return responses
-     * @returns Subscription for managing the responder
-     *
-     * @example
-     * ```typescript
-     * channel.respond(async (message, ctx) => {
-     *   const result = await processImage(message.payload);
-     *   return { processedUrl: result.url };
-     * });
-     * ```
-     */
-    respond<TResponse = unknown>(handler: ResponseHandler<TPayload, TResponse>): Promise<Subscription>;
-    /**
-     * Get channel statistics
-     *
-     * @returns Channel stats including message count and consumer count
-     *
-     * @example
-     * ```typescript
-     * const stats = await channel.stats();
-     * console.log(`Messages: ${stats.messageCount}, Consumers: ${stats.consumerCount}`);
-     * ```
-     */
-    stats(): Promise<ChannelStats>;
-    /**
-     * Purge all messages from the channel
-     *
-     * Use with caution - this deletes all pending messages.
-     *
-     * @returns Number of messages purged
-     *
-     * @example
-     * ```typescript
-     * const purgedCount = await channel.purge();
-     * console.log(`Purged ${purgedCount} messages`);
-     * ```
-     */
-    purge(): Promise<number>;
-    /**
-     * Check if the channel exists
-     *
-     * @returns True if the channel exists on the broker
-     */
-    exists(): Promise<boolean>;
-    /**
-     * Delete the channel
-     *
-     * Use with caution - this removes the queue/topic entirely.
-     */
-    delete(): Promise<void>;
-    /**
-     * Assert/create the channel with its options
-     *
-     * Creates the channel if it doesn't exist, or verifies options match.
-     */
-    assert(): Promise<void>;
-}
-//# sourceMappingURL=channel.contract.d.ts.map

package/esm/contracts/channel.contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/channel.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,eAAe,CAAC,QAAQ,GAAG,OAAO;IACjD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SAAS,CAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAEhG;;;;;;;;;OASG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAE9F;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,SAAS,GAAG,OAAO,EACzB,OAAO,EAAE,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,GAC5C,OAAO,CAAC,YAAY,CAAC,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAE/B;;;;;;;;;;;;OAYG;IACH,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3B;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB"}

package/esm/contracts/communicator-driver.contract.d.ts

@@ -1,196 +0,0 @@
-import { type EventMessage } from "../message-managers/event-message";
-import { EventConsumerClass } from "../message-managers/types";
-import type { ChannelOptions, CommunicatorDriverType, CommunicatorEvent, CommunicatorEventListener, HealthCheckResult } from "../types";
-import type { ChannelContract } from "./channel.contract";
-/**
- * Communicator Driver Contract
- *
- * Base contract for all message bus drivers (RabbitMQ, Kafka, etc.)
- * Similar to DriverContract in @warlock.js/cascade
- *
- * @example
- * ```typescript
- * // Driver implementation
- * class RabbitMQDriver implements CommunicatorDriverContract {
- *   readonly name = "rabbitmq";
- *   // ...
- * }
- * ```
- */
-export interface CommunicatorDriverContract {
-    /**
-     * Driver name identifier
-     *
-     * @example "rabbitmq", "kafka", "redis-streams"
-     */
-    readonly name: CommunicatorDriverType;
-    /**
-     * Whether currently connected to the message broker
-     */
-    readonly isConnected: boolean;
-    /**
-     * Establish connection to the message broker
-     *
-     * @throws Error if connection fails
-     *
-     * @example
-     * ```typescript
-     * await driver.connect();
-     * console.log("Connected to RabbitMQ");
-     * ```
-     */
-    connect(): Promise<void>;
-    /**
-     * Close connection gracefully
-     *
-     * Ensures all pending operations complete before disconnecting.
-     *
-     * @example
-     * ```typescript
-     * await driver.disconnect();
-     * ```
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Register event listeners for driver lifecycle events
-     *
-     * @param event - Event name to listen for
-     * @param listener - Callback function
-     *
-     * @example
-     * ```typescript
-     * driver.on("connected", () => {
-     *   console.log("Connected to broker");
-     * });
-     *
-     * driver.on("disconnected", () => {
-     *   console.log("Disconnected from broker");
-     * });
-     *
-     * driver.on("error", (error) => {
-     *   console.error("Driver error:", error);
-     * });
-     *
-     * driver.on("reconnecting", (attempt) => {
-     *   console.log(`Reconnection attempt ${attempt}`);
-     * });
-     * ```
-     */
-    on(event: CommunicatorEvent, listener: CommunicatorEventListener): void;
-    /**
-     * Remove an event listener
-     *
-     * @param event - Event name
-     * @param listener - Callback to remove
-     */
-    off(event: CommunicatorEvent, listener: CommunicatorEventListener): void;
-    /**
-     * Subscribe the given consumer class to the driver
-     *
-     * @param consumer - Consumer class to subscribe
-     * @returns Unsubscribe function
-     * @example
-     * ```typescript
-     * driver.subscribe(UserUpdatedConsumer);
-     * ```
-     */
-    subscribe(consumer: EventConsumerClass): () => void;
-    /**
-     * Unsubscribe the given consumer class from the driver
-     *
-     * @param consumer - Consumer class to unsubscribe
-     *
-     * @example
-     * ```typescript
-     * driver.unsubscribe(UserUpdatedConsumer);
-     * ```
-     */
-    unsubscribe(consumer: EventConsumerClass): void;
-    /**
-     * Publish the given event message
-     */
-    publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>): void;
-    /**
-     * Get or create a channel
-     *
-     * Channels are lazy-created and cached for reuse.
-     *
-     * @param name - Channel/queue/topic name
-     * @param options - Channel configuration
-     * @returns Channel instance
-     *
-     * @example
-     * ```typescript
-     * // Simple channel
-     * const channel = driver.channel("user.created");
-     *
-     * // With options
-     * const orderChannel = driver.channel("orders", {
-     *   durable: true,
-     *   deadLetter: { channel: "orders.failed" },
-     * });
-     *
-     * // Typed channel
-     * const typedChannel = driver.channel<OrderPayload>("orders", {
-     *   schema: OrderSchema,
-     * });
-     * ```
-     */
-    channel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
-    /**
-     * Start consuming messages from all subscribed channels
-     *
-     * Call this after setting up all subscriptions to begin processing.
-     *
-     * @example
-     * ```typescript
-     * // Set up subscriptions
-     * channel1.subscribe(handler1);
-     * channel2.subscribe(handler2);
-     *
-     * // Start consuming
-     * await driver.startConsuming();
-     * ```
-     */
-    startConsuming(): Promise<void>;
-    /**
-     * Stop consuming messages gracefully
-     *
-     * Waits for currently processing messages to complete.
-     *
-     * @example
-     * ```typescript
-     * await driver.stopConsuming();
-     * ```
-     */
-    stopConsuming(): Promise<void>;
-    /**
-     * Perform a health check on the connection
-     *
-     * @returns Health check result with status and optional latency
-     *
-     * @example
-     * ```typescript
-     * const health = await driver.healthCheck();
-     * if (health.healthy) {
-     *   console.log(`Healthy, latency: ${health.latency}ms`);
-     * } else {
-     *   console.error(`Unhealthy: ${health.error}`);
-     * }
-     * ```
-     */
-    healthCheck(): Promise<HealthCheckResult>;
-    /**
-     * Get list of all channels managed by this driver
-     *
-     * @returns Array of channel names
-     */
-    getChannelNames(): string[];
-    /**
-     * Close and remove a specific channel
-     *
-     * @param name - Channel name to close
-     */
-    closeChannel(name: string): Promise<void>;
-}
-//# sourceMappingURL=communicator-driver.contract.d.ts.map

package/esm/contracts/communicator-driver.contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"communicator-driver.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/communicator-driver.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,yBAAyB,EACzB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAE9B;;;;;;;;;;OAUG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;;;;;;;OASG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAExE;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI,CAAC;IAEpD;;;;;;;;;OASG;IACH,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAEhD;;OAEG;IACH,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IAE7E;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,QAAQ,GAAG,OAAO,EACxB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GACjC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAE7B;;;;;;;;;;;;;;OAcG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;;;;;;;OASG;IACH,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;OAcG;IACH,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE1C;;;;OAIG;IACH,eAAe,IAAI,MAAM,EAAE,CAAC;IAE5B;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}

package/esm/contracts/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./channel.contract";
-export * from "./communicator-driver.contract";
-//# sourceMappingURL=index.d.ts.map

package/esm/contracts/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gCAAgC,CAAC"}

package/esm/decorators/consumable.d.ts

@@ -1,13 +0,0 @@
-import { type EventConsumerClass } from "../message-managers/types";
-export type ConsumableOptions = {
-    communicator?: string;
-};
-export declare const pendingSubscribers: Set<{
-    Consumer: EventConsumerClass;
-    options?: ConsumableOptions;
-}>;
-/**
- * Register the consumer to the communicator
- */
-export declare function Consumable(options?: ConsumableOptions): (target: EventConsumerClass) => void;
-//# sourceMappingURL=consumable.d.ts.map

package/esm/decorators/consumable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consumable.d.ts","sourceRoot":"","sources":["../../src/decorators/consumable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,kBAAkB;cACnB,kBAAkB;cAClB,iBAAiB;EACzB,CAAC;AAEL;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,YAC3B,kBAAkB,UAkB5C"}

package/esm/decorators/consumable.js

@@ -1,33 +0,0 @@
-import {communicatorRegistry}from'../communicators/communicator-registry.js';const pendingSubscribers = new Set();
-/**
- * Register the consumer to the communicator
- */
-function Consumable(options) {
-    return function (target) {
-        const communicatorDriver = options?.communicator;
-        try {
-            const currentCommunicator = communicatorRegistry.get(communicatorDriver);
-            // if communicator is connected, subscribe the consumer
-            if (currentCommunicator?.isConnected) {
-                currentCommunicator.subscribe(target);
-            }
-            else {
-                pendingSubscribers.add({ Consumer: target, options });
-            }
-        }
-        catch {
-            // mostly it will be an error that communicator is not registered yet
-            // then add it to the pending subscribers
-            pendingSubscribers.add({ Consumer: target, options });
-        }
-    };
-}
-// Register pending consumers on communicator's connection is done
-communicatorRegistry.on("connected", (communicator) => {
-    for (const { Consumer, options } of pendingSubscribers) {
-        if (options?.communicator && communicator.name !== options.communicator) {
-            continue;
-        }
-        communicator.subscribe(Consumer);
-    }
-});export{Consumable,pendingSubscribers};//# sourceMappingURL=consumable.js.map

package/esm/decorators/consumable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"consumable.js","sources":["../../src/decorators/consumable.ts"],"sourcesContent":[null],"names":[],"mappings":"6EAOa,MAAA,kBAAkB,GAAG,IAAI,GAAG,GAGpC;AAEL;;AAEG;AACG,SAAU,UAAU,CAAC,OAA2B,EAAA;AACpD,IAAA,OAAO,UAAU,MAA0B,EAAA;AACzC,QAAA,MAAM,kBAAkB,GAAG,OAAO,EAAE,YAAY,CAAC;QAEjD,IAAI;YACF,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;;YAGzE,IAAI,mBAAmB,EAAE,WAAW,EAAE;AACpC,gBAAA,mBAAmB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AACvC,aAAA;AAAM,iBAAA;gBACL,kBAAkB,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AACvD,aAAA;AACF,SAAA;QAAC,MAAM;;;YAGN,kBAAkB,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AACvD,SAAA;AACH,KAAC,CAAC;AACJ,CAAC;AAED;AACA,oBAAoB,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,KAAI;IACpD,KAAK,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,kBAAkB,EAAE;QACtD,IAAI,OAAO,EAAE,YAAY,IAAI,YAAY,CAAC,IAAI,KAAK,OAAO,CAAC,YAAY,EAAE;YACvE,SAAS;AACV,SAAA;AAED,QAAA,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AAClC,KAAA;AACH,CAAC,CAAC"}

package/esm/decorators/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./consumable";
-//# sourceMappingURL=index.d.ts.map

package/esm/decorators/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}