node-cqrs 1.0.0-rc.9 → 1.0.0

package/types/in-memory/InMemoryMessageBus.d.ts

@@ -1,42 +0,0 @@
-import { DispatchPipelineBatch, ICommand, IDispatchPipelineProcessor, IEvent, IMessageBus, IMessageHandler, IObservable } from '../interfaces';
-/**
- * Default implementation of the message bus.
- * Keeps all subscriptions and messages in memory.
- */
-export declare class InMemoryMessageBus implements IMessageBus, IDispatchPipelineProcessor {
-    protected handlers: Map<string, Set<IMessageHandler>>;
-    protected uniqueEventHandlers: boolean;
-    protected queueName: string | undefined;
-    protected queues: Map<string, IMessageBus>;
-    constructor({ queueName, uniqueEventHandlers }?: {
-        queueName?: string;
-        uniqueEventHandlers?: boolean;
-    });
-    /**
-     * Subscribe to message type
-     */
-    on(messageType: string, handler: IMessageHandler): void;
-    /**
-     * Get or create a named queue.
-     * Named queues support only one handler per event type.
-     */
-    queue(queueName: string): IObservable;
-    /**
-     * Remove subscription
-     */
-    off(messageType: string, handler: IMessageHandler): void;
-    /**
-     * Send command to exactly 1 command handler
-     */
-    send(command: ICommand): Promise<any>;
-    /**
-     * Publish event to all subscribers (if any)
-     */
-    publish(event: IEvent, meta?: Record<string, any>): Promise<any>;
-    /**
-     * Processes a batch of events and publishes them to the fanout exchange.
-     *
-     * This method is part of the `IDispatchPipelineProcessor` interface.
-     */
-    process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch>;
-}

package/types/in-memory/InMemorySnapshotStorage.d.ts

@@ -1,37 +0,0 @@
-import { DispatchPipelineBatch, IAggregateSnapshotStorage, IContainer, IDispatchPipelineProcessor, IEvent } from '../interfaces';
-/**
- * In-memory storage for aggregate snapshots.
- * Storage content resets on app restart
- */
-export declare class InMemorySnapshotStorage implements IAggregateSnapshotStorage, IDispatchPipelineProcessor {
-    #private;
-    constructor(c?: Partial<Pick<IContainer, 'logger'>>);
-    /**
-     * Get latest aggregate snapshot
-     */
-    getAggregateSnapshot(aggregateId: string): Promise<IEvent | undefined>;
-    /**
-     * Save new aggregate snapshot
-     */
-    saveAggregateSnapshot(snapshotEvent: IEvent): Promise<void>;
-    /**
-     * Delete aggregate snapshot
-     */
-    deleteAggregateSnapshot<TState>(snapshotEvent: IEvent<TState>): Promise<void> | void;
-    /**
-     * Processes a batch of events, saves any snapshot events found, and returns the batch
-     * without the snapshot events.
-     *
-     * This method is part of the `IDispatchPipelineProcessor` interface.
-     */
-    process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch>;
-    /**
-     * Reverts the snapshots associated with the events in the given batch.
-     * It filters the batch for snapshot events and deletes the corresponding aggregate snapshots.
-     *
-     * This method is part of the `IDispatchPipelineProcessor` interface.
-     *
-     * @param batch The batch of events to revert snapshots for.
-     */
-    revert(batch: DispatchPipelineBatch): Promise<void>;
-}

package/types/in-memory/InMemoryView.d.ts

@@ -1,53 +0,0 @@
-import { IViewLocker, Identifier, IObjectStorage } from '../interfaces';
-/**
- * In-memory Projection View, which suspends get()'s until it is ready
- */
-export declare class InMemoryView<TRecord> implements IViewLocker, IObjectStorage<TRecord> {
-    #private;
-    static factory<TView>(): TView;
-    protected _map: Map<Identifier, TRecord>;
-    /** Whether the view is restored */
-    get ready(): boolean;
-    /** Number of records in the View */
-    get size(): number;
-    constructor();
-    /** Lock the view to prevent concurrent modifications */
-    lock(): Promise<boolean>;
-    /** Release the lock */
-    unlock(): Promise<void>;
-    /** Create a Promise which will resolve to a first emitted event of a given type */
-    once(eventType: 'ready'): Promise<any>;
-    /**
-     * Check if view contains a record with a given key.
-     * This is the only synchronous method, so make sure to check the `ready` flag, if necessary
-     *
-     * @deprecated Use `async get()` instead
-     */
-    has(key: Identifier): boolean;
-    /** Get record with a given key; await until the view is restored */
-    get(key: Identifier, options?: {
-        nowait?: boolean;
-    }): Promise<TRecord | undefined>;
-    /**
-     * Get record with a given key synchronously
-     */
-    getSync(key: Identifier): TRecord | undefined;
-    /** Get all records matching an optional filter */
-    getAll(filter?: (r: TRecord | undefined, i: Identifier) => boolean): Promise<Array<[Identifier, TRecord | undefined]>>;
-    /** Create record with a given key and value */
-    create(key: Identifier, value?: TRecord): Promise<void>;
-    /** Update existing view record */
-    update(key: Identifier, update: (r: TRecord) => TRecord): Promise<void>;
-    /** Update existing view record or create new */
-    updateEnforcingNew(key: Identifier, update: (r?: TRecord) => TRecord): Promise<void>;
-    /** Update all records that match filter criteria */
-    updateAll(filter: (r: TRecord) => boolean, update: (r: TRecord) => TRecord): Promise<void>;
-    /** Update existing record */
-    private _update;
-    /** Delete record */
-    delete(key: Identifier): Promise<void>;
-    /** Delete all records that match filter criteria */
-    deleteAll(filter: (r?: TRecord) => boolean): Promise<void>;
-    /** Get view summary as string */
-    toString(): string;
-}

package/types/in-memory/index.d.ts

@@ -1,5 +0,0 @@
-export * from './InMemoryEventStorage';
-export * from './InMemoryLock';
-export * from './InMemoryMessageBus';
-export * from './InMemorySnapshotStorage';
-export * from './InMemoryView';

package/types/in-memory/utils/index.d.ts

@@ -1 +0,0 @@
-export * from './nextCycle';

package/types/index.d.ts

@@ -1,14 +0,0 @@
-export { CqrsContainerBuilder as ContainerBuilder } from './CqrsContainerBuilder';
-export * from './CommandBus';
-export * from './EventStore';
-export * from './AbstractAggregate';
-export * from './AggregateCommandHandler';
-export * from './AbstractSaga';
-export * from './SagaEventHandler';
-export * from './AbstractProjection';
-export * from './EventDispatcher';
-export * from './EventValidationProcessor';
-export * from './in-memory';
-export * as Event from './Event';
-export { getMessageHandlerNames, subscribe } from './utils';
-export * from './interfaces';

package/types/interfaces/IAggregate.d.ts

@@ -1,35 +0,0 @@
-import { ICommand } from './ICommand';
-import { Identifier } from './Identifier';
-import { IEvent } from './IEvent';
-import { IEventSet } from './IEventSet';
-/**
- * Minimum aggregate interface, as it's used by default `AggregateCommandHandler`
- */
-export interface IAggregate {
-    /** Unique aggregate identifier */
-    readonly id: Identifier;
-    /** Main entry point for aggregate commands */
-    handle(command: ICommand): void | Promise<void>;
-    /** List of events emitted by Aggregate as a result of handling command(s) */
-    readonly changes: IEventSet;
-    /** An indicator if aggregate snapshot should be taken */
-    readonly shouldTakeSnapshot?: boolean;
-    /** Take an aggregate state snapshot and add it to the changes queue */
-    takeSnapshot(): void;
-}
-export interface IMutableAggregateState {
-    mutate(event: IEvent): void;
-}
-export type IAggregateConstructorParams<TState extends IMutableAggregateState | object | void> = {
-    /** Unique aggregate identifier */
-    id: Identifier;
-    /** Aggregate events, logged after latest snapshot */
-    events?: IEventSet;
-    /** Aggregate state instance */
-    state?: TState;
-};
-export interface IAggregateConstructor<TState extends IMutableAggregateState | object | void> {
-    readonly handles: string[];
-    new (options: IAggregateConstructorParams<TState>): IAggregate;
-}
-export type IAggregateFactory<TState extends IMutableAggregateState | object | void> = (options: IAggregateConstructorParams<TState>) => IAggregate;

package/types/interfaces/IAggregateSnapshotStorage.d.ts

@@ -1,7 +0,0 @@
-import { Identifier } from './Identifier';
-import { IEvent } from './IEvent';
-export interface IAggregateSnapshotStorage {
-    getAggregateSnapshot<TState>(aggregateId: Identifier): Promise<IEvent<TState> | undefined> | IEvent<TState> | undefined;
-    saveAggregateSnapshot<TState>(snapshotEvent: IEvent<TState>): Promise<void> | void;
-    deleteAggregateSnapshot<TState>(snapshotEvent: IEvent<TState>): Promise<void> | void;
-}

package/types/interfaces/ICommand.d.ts

@@ -1,2 +0,0 @@
-import { IMessage } from './IMessage';
-export type ICommand<TPayload = any> = IMessage<TPayload>;

package/types/interfaces/ICommandBus.d.ts

@@ -1,14 +0,0 @@
-import { ICommand } from './ICommand';
-import { IEventSet } from './IEventSet';
-import { IObservable } from './IObservable';
-import { IObserver } from './IObserver';
-export interface ICommandBus extends IObservable {
-    send(commandType: string, aggregateId: string | undefined, options: {
-        payload?: object;
-        context?: object;
-    }): Promise<IEventSet>;
-    sendRaw(command: ICommand): Promise<IEventSet>;
-}
-export interface ICommandHandler extends IObserver {
-    subscribe(commandBus: ICommandBus): void;
-}

package/types/interfaces/IContainer.d.ts

@@ -1,23 +0,0 @@
-import { Container } from 'di0';
-import { ICommandBus } from './ICommandBus';
-import { IEventDispatcher } from './IEventDispatcher';
-import { IEventStore } from './IEventStore';
-import { IEventBus } from './IEventBus';
-import { IDispatchPipelineProcessor } from './IDispatchPipelineProcessor';
-import { IEventStorageReader, IEventStorageWriter } from './IEventStorage';
-import { IAggregateSnapshotStorage } from './IAggregateSnapshotStorage';
-import { IIdentifierProvider } from './IIdentifierProvider';
-import { IExtendableLogger, ILogger } from './ILogger';
-export interface IContainer extends Container {
-    eventBus: IEventBus;
-    eventStore: IEventStore;
-    eventStorageReader: IEventStorageReader;
-    eventStorageWriter?: IEventStorageWriter;
-    identifierProvider?: IIdentifierProvider;
-    snapshotStorage?: IAggregateSnapshotStorage;
-    commandBus: ICommandBus;
-    eventDispatcher: IEventDispatcher;
-    eventDispatchPipeline?: IDispatchPipelineProcessor[];
-    logger?: ILogger | IExtendableLogger;
-    process?: NodeJS.Process;
-}

package/types/interfaces/IDispatchPipelineProcessor.d.ts

@@ -1,25 +0,0 @@
-import { IEvent } from './IEvent';
-/**
- * Represents a wrapper for an event that can optionally contain additional metadata.
- * Used to extend event processing with context-specific data required by processors.
- */
-export type DispatchPipelineEnvelope = {
-    /**
-     * Origin of the event. Can be used to distinguish between events coming from different sources.
-     */
-    origin?: 'external' | 'internal';
-    event?: IEvent;
-};
-/**
- * A batch of event envelopes. Can contain custom envelope types extending EventEnvelope.
- */
-export type DispatchPipelineBatch<T extends DispatchPipelineEnvelope = DispatchPipelineEnvelope> = Readonly<Array<T>>;
-/**
- * Defines a processor that operates on a batch of event envelopes.
- * Allows transformations, side-effects, or filtering of events during dispatch.
- */
-export interface IDispatchPipelineProcessor<T extends DispatchPipelineEnvelope = {}> {
-    process(batch: DispatchPipelineBatch<T>): Promise<DispatchPipelineBatch<T>>;
-    revert?(batch: DispatchPipelineBatch<T>): Promise<void>;
-}
-export declare const isDispatchPipelineProcessor: (obj: unknown) => obj is IDispatchPipelineProcessor;

package/types/interfaces/IEvent.d.ts

@@ -1,6 +0,0 @@
-import { IMessage } from './IMessage';
-export type IEvent<TPayload = any> = IMessage<TPayload> & {
-    /** Unique event identifier */
-    id?: string;
-};
-export declare const isEvent: (event: unknown) => event is IEvent;

package/types/interfaces/IEventBus.d.ts

@@ -1,6 +0,0 @@
-import { IEvent } from './IEvent';
-import { IObservable } from './IObservable';
-export interface IEventBus extends IObservable {
-    publish(event: IEvent, meta?: Record<string, any>): Promise<any>;
-}
-export declare const isIEventBus: (obj: unknown) => boolean;

package/types/interfaces/IEventDispatcher.d.ts

@@ -1,6 +0,0 @@
-import { IEventSet } from './IEventSet';
-import { IEventBus } from './IEventBus';
-export interface IEventDispatcher {
-    readonly eventBus: IEventBus;
-    dispatch(events: IEventSet, meta?: Record<string, any>): Promise<IEventSet>;
-}

package/types/interfaces/IEventLocker.d.ts

@@ -1,24 +0,0 @@
-import { IEvent } from './IEvent';
-/**
- * Interface for tracking event processing state to prevent concurrent processing
- * by multiple processes.
- */
-export interface IEventLocker {
-    /**
-     * Retrieves the last projected event,
-     * allowing the projection state to be restored from subsequent events.
-     */
-    getLastEvent(): Promise<IEvent | undefined> | IEvent | undefined;
-    /**
-     * Marks an event as projecting to prevent it from being processed
-     * by another projection instance using the same storage.
-     *
-     * @returns `false` if the event is already being processed or has been processed.
-     */
-    tryMarkAsProjecting(event: IEvent): Promise<boolean> | boolean;
-    /**
-     * Marks an event as projected.
-     */
-    markAsProjected(event: IEvent): Promise<void> | void;
-}
-export declare const isEventLocker: (view: unknown) => view is IEventLocker;

package/types/interfaces/IEventReceptor.d.ts

@@ -1,5 +0,0 @@
-import { IEventStore } from './IEventStore';
-import { IObserver } from './IObserver';
-export interface IEventReceptor extends IObserver {
-    subscribe(eventStore: IEventStore): void;
-}

package/types/interfaces/IEventSet.d.ts

@@ -1,3 +0,0 @@
-import { IEvent } from './IEvent';
-export type IEventSet = ReadonlyArray<Readonly<IEvent>>;
-export declare const isEventSet: (arr: unknown) => arr is IEventSet;

package/types/interfaces/IEventStorage.d.ts

@@ -1,36 +0,0 @@
-import { Identifier } from './Identifier';
-import { IEvent } from './IEvent';
-import { IEventSet } from './IEventSet';
-import { IEventStream } from './IEventStream';
-export type EventQueryAfter = {
-    /** Get events emitted after this specific event */
-    afterEvent?: IEvent;
-};
-export type EventQueryBefore = {
-    /** Get events emitted before this specific event */
-    beforeEvent?: IEvent;
-};
-export interface IEventStorageReader {
-    /**
-     * Retrieves events of specified types that were emitted after a given event.
-     */
-    getEventsByTypes(eventTypes: Readonly<string[]>, options?: EventQueryAfter): IEventStream;
-    /**
-     * Retrieves all events (and optionally a snapshot) associated with a specific aggregate.
-     */
-    getAggregateEvents(aggregateId: Identifier, options?: {
-        snapshot?: IEvent;
-    }): IEventStream;
-    /**
-     * Retrieves events associated with a saga, with optional filtering by version or timestamp.
-     */
-    getSagaEvents(sagaId: Identifier, options: EventQueryBefore): IEventStream;
-}
-export interface IEventStorageWriter {
-    /**
-     * Persists a set of events to the event store.
-     * Returns the persisted event set (potentially enriched or normalized).
-     */
-    commitEvents(events: IEventSet): Promise<IEventSet>;
-}
-export declare const isIEventStorageReader: (storage: unknown) => storage is IEventStorageReader;

package/types/interfaces/IEventStore.d.ts

@@ -1,9 +0,0 @@
-import { IEventDispatcher } from './IEventDispatcher';
-import { IEvent } from './IEvent';
-import { IEventStorageReader } from './IEventStorage';
-import { IIdentifierProvider } from './IIdentifierProvider';
-import { IMessageHandler, IObservable } from './IObservable';
-export interface IEventStore extends IObservable, IEventDispatcher, IEventStorageReader, IIdentifierProvider {
-    registerSagaStarters(startsWith: string[] | undefined): void;
-    once(messageTypes: string | string[], handler?: IMessageHandler, filter?: (e: IEvent) => boolean): Promise<IEvent>;
-}

package/types/interfaces/IEventStream.d.ts

@@ -1,2 +0,0 @@
-import { IEvent } from './IEvent';
-export type IEventStream = AsyncIterableIterator<Readonly<IEvent>>;

package/types/interfaces/IIdentifierProvider.d.ts

@@ -1,10 +0,0 @@
-import { Identifier } from './Identifier';
-export interface IIdentifierProvider {
-    /**
-     * Generates and returns a new unique identifier suitable for aggregates, sagas, and events.
-     *
-     * @returns A promise resolving to an identifier or an identifier itself.
-     */
-    getNewId(): Identifier | Promise<Identifier>;
-}
-export declare const isIdentifierProvider: (obj: any) => obj is IIdentifierProvider;

package/types/interfaces/IMessage.d.ts

@@ -1,12 +0,0 @@
-import { Identifier } from './Identifier';
-export interface IMessage<TPayload = any> {
-    /** Event or command type */
-    type: string;
-    aggregateId?: Identifier;
-    aggregateVersion?: number;
-    sagaId?: Identifier;
-    sagaVersion?: number;
-    payload?: TPayload;
-    context?: any;
-}
-export declare const isMessage: (obj: unknown) => obj is IMessage;

package/types/interfaces/IMessageBus.d.ts

@@ -1,7 +0,0 @@
-import { ICommand } from './ICommand';
-import { IEvent } from './IEvent';
-import { IObservable } from './IObservable';
-export interface IMessageBus extends IObservable {
-    send(command: ICommand): Promise<any>;
-    publish(event: IEvent, meta?: Record<string, any>): Promise<any>;
-}

package/types/interfaces/IObjectStorage.d.ts

@@ -1,8 +0,0 @@
-import { Identifier } from './Identifier';
-export interface IObjectStorage<TRecord> {
-    get(id: Identifier): Promise<TRecord | undefined> | TRecord | undefined;
-    create(id: Identifier, r: TRecord): Promise<any> | any;
-    update(id: Identifier, cb: (r: TRecord) => TRecord): Promise<any> | any;
-    updateEnforcingNew(id: Identifier, cb: (r?: TRecord) => TRecord): Promise<any> | any;
-    delete(id: Identifier): Promise<any> | any;
-}

package/types/interfaces/IObservable.d.ts

@@ -1,19 +0,0 @@
-import { IMessage } from './IMessage';
-export interface IMessageHandler {
-    (message: IMessage, meta?: Record<string, any>): any | Promise<any>;
-}
-export interface IObservable {
-    /**
-     * Setup a listener for a specific event type
-     */
-    on(type: string, handler: IMessageHandler): void;
-    /**
-     * Remove previously installed listener
-     */
-    off(type: string, handler: IMessageHandler): void;
-    /**
-     * Get or create a named queue, which delivers events to a single handler only
-     */
-    queue?(name: string): IObservable;
-}
-export declare const isIObservable: (obj: unknown) => obj is IObservable;

package/types/interfaces/IObserver.d.ts

@@ -1,4 +0,0 @@
-import { IObservable } from './IObservable';
-export interface IObserver {
-    subscribe(observable: IObservable): void;
-}

package/types/interfaces/IProjection.d.ts

@@ -1,17 +0,0 @@
-import { IEvent } from './IEvent';
-import { IEventStore } from './IEventStore';
-import { IObserver } from './IObserver';
-export interface IProjection<TView> extends IObserver {
-    readonly view: TView;
-    subscribe(eventStore: IEventStore): Promise<void>;
-    project(event: IEvent): Promise<void>;
-}
-export interface IProjectionConstructor {
-    new (c?: any): IProjection<any>;
-    readonly handles?: string[];
-}
-export interface IViewFactory<TView> {
-    (options: {
-        schemaVersion: string;
-    }): TView;
-}

package/types/interfaces/ISaga.d.ts

@@ -1,30 +0,0 @@
-import { ICommand } from './ICommand';
-import { Identifier } from './Identifier';
-import { IEvent } from './IEvent';
-import { IEventSet } from './IEventSet';
-export interface ISaga {
-    /** Unique Saga ID */
-    readonly id: Identifier;
-    /** List of commands emitted by Saga */
-    readonly uncommittedMessages: ICommand[];
-    /** Main entry point for Saga events */
-    apply(event: IEvent): void | Promise<void>;
-    /** Reset emitted commands when they are not longer needed */
-    resetUncommittedMessages(): void;
-    onError?(error: Error, options: {
-        event: IEvent;
-        command: ICommand;
-    }): void;
-}
-export type ISagaConstructorParams = {
-    id: Identifier;
-    events?: IEventSet;
-};
-export type ISagaFactory = (options: ISagaConstructorParams) => ISaga;
-export interface ISagaConstructor {
-    new (options: ISagaConstructorParams): ISaga;
-    /** List of event types that trigger new saga start */
-    readonly startsWith: string[];
-    /** List of events being handled by Saga */
-    readonly handles: string[];
-}

package/types/interfaces/Identifier.d.ts

@@ -1 +0,0 @@
-export type Identifier = string | number;

package/types/interfaces/index.d.ts

@@ -1,26 +0,0 @@
-export * from './IAggregate';
-export * from './IAggregateSnapshotStorage';
-export * from './ICommand';
-export * from './ICommandBus';
-export * from './IContainer';
-export * from './Identifier';
-export * from './IDispatchPipelineProcessor';
-export * from './IEvent';
-export * from './IEventBus';
-export * from './IEventDispatcher';
-export * from './IEventLocker';
-export * from './IEventReceptor';
-export * from './IEventSet';
-export * from './IEventStorage';
-export * from './IEventStore';
-export * from './IEventStream';
-export * from './IIdentifierProvider';
-export * from './ILogger';
-export * from './IMessage';
-export * from './IMessageBus';
-export * from './IObjectStorage';
-export * from './IObservable';
-export * from './IObserver';
-export * from './IProjection';
-export * from './ISaga';
-export * from './IViewLocker';

package/types/interfaces/isObject.d.ts

@@ -1 +0,0 @@
-export declare const isObject: (obj: unknown) => obj is {};

package/types/rabbitmq/IContainer.d.ts

@@ -1,14 +0,0 @@
-import { IEventBus } from '../interfaces';
-import { RabbitMqEventInjector } from './RabbitMqEventInjector';
-import { RabbitMqGateway } from './RabbitMqGateway';
-declare module '../interfaces/IContainer' {
-    interface IContainer {
-        rabbitMqGateway?: RabbitMqGateway;
-        rabbitMqEventInjector?: RabbitMqEventInjector;
-        rabbitMqEventBus?: RabbitMqEventInjector;
-        /**
-         * Optional external event bus for publishing events to an external system.
-         */
-        externalEventBus?: IEventBus;
-    }
-}

package/types/rabbitmq/RabbitMqEventBus.d.ts

@@ -1,41 +0,0 @@
-import { IEvent, IEventBus, IDispatchPipelineProcessor, IMessageHandler, IObservable, DispatchPipelineBatch } from '../interfaces';
-import { RabbitMqGateway } from './RabbitMqGateway';
-export declare class RabbitMqEventBus implements IEventBus, IDispatchPipelineProcessor {
-    #private;
-    static get allEventsWildcard(): '*';
-    constructor(o: {
-        rabbitMqGateway: RabbitMqGateway;
-        exchange?: string;
-        queueName?: string;
-    });
-    /**
-     * Publishes an event to the fanout exchange.
-     * The event will be delivered to all subscribers, except this instance's own consumer.
-     */
-    publish(event: IEvent): Promise<void>;
-    /**
-     * Registers a message handler for a specific event type.
-     *
-     * @param eventType The event type to listen for.
-     * @param handler The function to handle incoming messages of the specified type.
-     */
-    on(eventType: string, handler: IMessageHandler): Promise<void>;
-    /**
-     * Removes a previously registered message handler for a specific event type.
-     */
-    off(eventType: string, handler: IMessageHandler): void;
-    /**
-     * Returns a new instance of RabbitMqGateway that uses a durable queue with the given name.
-     * This ensures that all messages published to the fanout exchange are also delivered to this queue.
-     *
-     * @param name The name of the durable queue.
-     * @returns A new RabbitMqGateway instance configured to use the specified queue.
-     */
-    queue(name: string): IObservable;
-    /**
-     * Processes a batch of events and publishes them to the fanout exchange.
-     *
-     * This method is part of the `IDispatchPipelineProcessor` interface.
-     */
-    process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch>;
-}

package/types/rabbitmq/RabbitMqEventInjector.d.ts

@@ -1,13 +0,0 @@
-import { IContainer } from '../interfaces/IContainer';
-/**
- * Injects events received from a RabbitMQ exchange into the local event dispatcher.
- *
- * It subscribes to a specified fanout exchange on RabbitMQ and dispatches
- * any received messages as events using the provided event dispatcher.
- */
-export declare class RabbitMqEventInjector {
-    #private;
-    constructor(container: Partial<Pick<IContainer, 'eventDispatcher' | 'rabbitMqGateway' | 'logger'>>);
-    start(exchange?: string): Promise<void>;
-    stop(exchange?: string): Promise<void>;
-}