@artstesh/postboy 3.4.0 → 3.4.2

package/lib/index.d.mts

@@ -1,701 +1,705 @@
 import { Subject, Observable } from 'rxjs';
 
-/**
- * Represents metadata associated with a Postboy message.
- *
- * This interface can be used to store optional metadata that provides
- * additional context or tracking information for a message. It supports
- * flexible extension by allowing additional properties through an index signature.
- *
- * Properties:
- * - `correlationId` (optional): A unique identifier used to correlate
- *   related messages or operations across systems.
- * - `causationId` (optional): The identifier of the preceding message
- *   or event that caused the current message to be produced.
- * - `source` (optional): The origin or source of the message, such as
- *   a particular service or system.
- * - `tags` (optional): An array of tags or labels that can be attached
- *   to the message for categorization, filtering, or logging purposes.
- * - `[key: string]` (optional): Additional custom properties can be
- *   added to capture specific metadata not covered by the predefined fields.
- */
-interface PostboyMessageMetadata {
-    correlationId?: string;
-    causationId?: string;
-    tags?: Set<string>;
-    [key: string]: any;
-}
-
-declare abstract class PostboyMessage {
-    metadata: PostboyMessageMetadata;
-    get id(): string;
-    setMetadata(metadata: Partial<PostboyMessageMetadata>): this;
-}
-
-/**
- * An inheritor should have a static ID field
- */
-declare abstract class PostboyGenericMessage extends PostboyMessage {
-}
-declare function checkId(message: new (...args: any[]) => any): string;
-
-declare abstract class PostboyExecutor<T> extends PostboyMessage {
-    protected readonly _postboyResultType?: T;
-}
-
-/**
- * An abstract class extending PostboyGenericMessage that provides mechanisms for managing
- * asynchronous data communication using RxJS observables. It is designed to work with
- * callback-based operations that emit a result of type T.
- *
- * @template T - The type of the data emitted by the observables in this class.
- *
- * @extends PostboyGenericMessage
- *
- * @property {Observable<T>} result - An observable that emits the result of the operation
- * and completes once the operation is finished.
- *
- * @method next - Emits the next value for the result observable.
- * @param {T} value - The value to be emitted by the result observable.
- *
- * @method finish - Emits the final value for the result observable and completes it.
- * @param {T} value - The final value for the observable emission.
- */
-declare abstract class PostboyCallbackMessage<T> extends PostboyGenericMessage {
-    protected result$: Subject<T>;
-    result: Observable<T>;
-    /**
-     * Emits the provided value.
-     *
-     * @template T - The type of the value to emit.
-     * @param {T} value - The value to emit through the `result$` observable.
-     * @returns {void}
-     */
-    next: (value: T) => void;
-    /**
-     * Marks the operation as complete by emitting the provided value and then completing the result stream.
-     *
-     * @param {T} value - The value to emit prior to completing the result stream.
-     * @return {void} This method does not return a value.
-     */
-    finish(value: T): void;
-    /**
-     * Completes the current observable result stream.
-     * This method marks the result observable as complete, ensuring no further values
-     * or events will be emitted from it.
-     *
-     * @return {void} No value is returned from this method.
-     */
-    complete(): void;
-}
-
-interface IPostboyDependingService {
-    up(): void;
-    down?: () => void;
-}
-
-/**
- * Abstract class representing a handler for executing a Postboy task.
- *
- * This class is intended to manage the execution flow of a PostboyExecutor instance.
- * Subclasses must implement the `handle` method, which executes a given PostboyExecutor
- * and returns a result of type R.
- *
- * @template R The type of the result returned by the `handle` method.
- * @template E The type of the executor extending the PostboyExecutor.
- */
-declare abstract class PostboyExecutionHandler<R, E extends PostboyExecutor<R>> {
-    /**
-     * Abstract method to handle the specified executor and return a result.
-     *
-     * @param {E} executor - The executor that will be processed by the method.
-     * @return {R} The result obtained after handling the executor.
-     */
-    abstract handle(executor: E): R;
-}
-
-type MessageType<T extends PostboyGenericMessage> = new (...args: any[]) => T;
-declare abstract class PostboyAbstractRegistrator {
-    protected postboy: PostboyService;
-    get namespace(): string;
-    private ids;
-    private services;
-    private readonly _namespace;
-    constructor(postboy: PostboyService, namespace?: string | null);
-    /**
-     * Registers a list of services to be used by the application.
-     *
-     * @param {IPostboyDependingService[]} services - An array of services to register.
-     * @return {void} This method does not return a value.
-     */
-    registerServices(services: IPostboyDependingService[]): void;
-    /**
-     * Initiates the 'up' process for the current instance and all associated services.
-     *
-     * @return {void} Does not return a value.
-     */
-    up(): void;
-    protected abstract _up(): void;
-    down(): void;
-    /**
-     * Records a type and its corresponding Subject<T> into the Postboy system and updates the internal identifiers.
-     *
-     * @param {MessageType<T>} type - A constructor for the generic message type T.
-     * @param {Subject<T>} sub - The subject associated with the generic message type.
-     * @return {this} Returns the current instance for method chaining.
-     */
-    record<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>): PostboyAbstractRegistrator;
-    /**
-     * Records a message type with a specific subject and applies a transformation pipe to the subject.
-     *
-     * @param {MessageType<T>} type - The constructor of the message type to record, which extends PostboyGenericMessage.
-     * @param {Subject<T>} sub - The Subject instance to associate with the message type.
-     * @param {(s: Subject<T>) => Observable<T>} pipe - A function that takes the subject as input and returns an Observable with transformations applied.
-     * @return {this} The current instance of the class for chaining.
-     */
-    recordWithPipe<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>, pipe: (s: Subject<T>) => Observable<T>): PostboyAbstractRegistrator;
-    /**
-     * Records an executor associated with a specific type and execution logic.
-     *
-     * @param type The class constructor of the executor type to be recorded, which extends PostboyExecutor.
-     * @param exec A callback function that executes the logic using an instance of the specified executor type.
-     * @return void
-     */
-    recordExecutor<E extends PostboyExecutor<T>, T>(type: new (...args: any[]) => E, exec: (e: E) => T): PostboyAbstractRegistrator;
-    /**
-     * Records a handler for a specific executor type.
-     *
-     * @param executor The constructor of the executor type, which extends `PostboyExecutor`.
-     * @param handler The execution handler associated with the given executor type.
-     * @return void
-     */
-    recordHandler<E extends PostboyExecutor<R>, R>(executor: new (...args: any[]) => E, handler: PostboyExecutionHandler<R, E>): PostboyAbstractRegistrator;
-    /**
-     * A utility function that facilitates the recording and replaying of messages
-     * using a ReplaySubject. This function is designed to handle messages of a
-     * specific type and allows specifying a buffer size to determine how many
-     * of the most recent messages should be replayed.
-     *
-     * @template T Extends the PostboyGenericMessage type, representing the type of message
-     * to be recorded and replayed.
-     * @param {MessageType<T>} type The constructor of the message type to be recorded and replayed.
-     * @param {number} [bufferSize=1] The number of recent messages to retain in the ReplaySubject's buffer.
-     * Defaults to 1 if not specified.
-     * @returns The result of invoking the `record` method with the given message type and configured ReplaySubject.
-     */
-    recordReplay<T extends PostboyGenericMessage>(type: MessageType<T>, bufferSize?: number): PostboyAbstractRegistrator;
-    /**
-     * Represents a method that records a specific behavior associated with a message type.
-     * It creates a `BehaviorSubject` initialized with the provided initial message
-     * and associates it with the given message type using the `record` method.
-     *
-     * @template T - A type parameter extending `PostboyGenericMessage` that defines the message structure.
-     * @param {MessageType<T>} type - The constructor function of the message type to be recorded.
-     * @param {T} initial - The initial value of the message that will be set in the `BehaviorSubject`.
-     * @returns {void} - This function does not return a value; instead, it modifies the internal state.
-     */
-    recordBehavior<T extends PostboyGenericMessage>(type: MessageType<T>, initial: T): PostboyAbstractRegistrator;
-    /**
-     * A function that creates and returns a new generic message recorder for a specific message type.
-     *
-     * @template T - A type parameter extending from `PostboyGenericMessage`.
-     * @param {MessageType<T>} type - The constructor for the message type being recorded.
-     * @returns {Subject<T>} A new instance of `Subject<T>` bound to the specified message type.
-     */
-    recordSubject<T extends PostboyGenericMessage>(type: MessageType<T>): this;
-}
-
-interface PostboyMiddleware {
-    handle(message: PostboyMessage): void;
-}
-
-/**
- * A service class that manages middleware functions for processing PostboyMessage objects.
- * It provides methods to add, remove, and execute middlewares in sequence.
- */
-declare class PostboyMiddlewareService {
-    protected middlewares: PostboyMiddleware[];
-    /**
-     * Adds a middleware function to the collection of middlewares.
-     *
-     * @param {PostboyMiddleware} middleware - The middleware function to be added.
-     * @return {void}
-     */
-    addMiddleware(middleware: PostboyMiddleware): void;
-    /**
-     * Removes a middleware from the list of registered middlewares.
-     *
-     * @param {PostboyMiddleware} middleware - The middleware instance to be removed.
-     * @return {void} No return value.
-     */
-    removeMiddleware(middleware: PostboyMiddleware): void;
-    /**
-     * Manages the processing of a PostboyMessage by sequentially applying all middlewares.
-     *
-     * @param {PostboyMessage} msg - The message object to be processed by the middlewares.
-     * @return {void} - This method does not return any value.
-     */
-    manage(msg: PostboyMessage): void;
-    /**
-     * Disposes of the current object by clearing its middlewares array.
-     *
-     * @return {void} This method does not return a value.
-     */
-    dispose(): void;
-}
-
-/**
- * A class that manages a reactive subscription using a provided Subject and transformation pipe.
- * Offers methods to interact with the subscription, such as emitting data, completing the subscription,
- * and accessing the transformed observable.
- *
- * @template T The type of data managed by the subscription.
- */
-declare class PostboySubscription<T> {
-    private subscription;
-    private readonly _subscription;
-    /**
-     * Constructs an instance of the class with a given subscription and a transformation pipe.
-     *
-     * @param {Subject<T>} subscription - The source Subject that will be transformed.
-     * @param {(s: Subject<T>) => Observable<T>} pipe - A function that applies a transformation to the subscription.
-     */
-    constructor(subscription: Subject<T>, pipe?: (s: Subject<T>) => Observable<T>);
-    /**
-     * Returns an observable subscription.
-     *
-     * @return {Observable<T>} An observable instance of type T.
-     */
-    sub(): Observable<T>;
-    /**
-     * Triggers an event by emitting the provided data to all subscribers.
-     *
-     * @param {T} data - The data to emit to the subscribers.
-     * @return {void} - Does not return any value.
-     */
-    fire(data: T): void;
-    /**
-     * Completes the subscription, signaling that no further values will be sent.
-     * This is typically used to finalize or clean up resources.
-     * @return {void} This method does not return any value.
-     */
-    finish(): void;
-}
-
-/**
- * The PostboyMessageStore is a utility class for managing message subscriptions and executors.
- * It provides functionality to register, retrieve, and unregister subscription-based messages and executors.
- */
-declare class PostboyMessageStore {
-    protected messages: Map<string, PostboySubscription<any>>;
-    protected executors: Map<string, (e: PostboyExecutor<any>) => any>;
-    protected callbacks: Map<string, (() => void)[]>;
-    registerMessage(id: string, sub: PostboySubscription<any>): void;
-    registerExecutor(id: string, executor: (e: PostboyExecutor<any>) => any): void;
-    callbackFired(message: PostboyCallbackMessage<any>): void;
-    getMessage(id: string, name: string): PostboySubscription<any>;
-    getExecutor<T>(id: string): (e: PostboyExecutor<T>) => T;
-    unregister(id: string): void;
-    dispose(): void;
-}
-
-/**
- * Represents a store for managing namespaces in the Postboy system.
- * Provides functionality to add, eliminate, and dispose namespaces.
- */
-declare class PostboyNamespaceStore {
-    private spaces;
-    /**
-     * Adds a new space or retrieves an existing one if it already exists.
-     *
-     * @param {string} space - The name of the space to add or retrieve.
-     * @param {PostboyService} postboy - The PostboyService instance used to create a namespace registrator.
-     * @return {PostboyAbstractRegistrator} The registrator associated with the specified space.
-     */
-    addSpace(space: string, postboy: PostboyService): PostboyAbstractRegistrator;
-    /**
-     * Removes a specified space from the spaces collection if it exists.
-     * If the space exists, it will be deleted after invoking its down method.
-     *
-     * @param {string} space - The name of the space to be removed.
-     * @return {void} This method does not return a value.
-     */
-    eliminateSpace(space: string): void;
-    /**
-     * Disposes of the current instance by performing cleanup operations.
-     * Iterates through all spaces, performs a "down" operation on each,
-     * and then clears the collection of spaces.
-     *
-     * @return {void} No return value.
-     */
-    dispose(): void;
-}
-
-declare class PostboyDependencyResolver {
-    /**
-     * Retrieves an instance of the PostboyMiddlewareService.
-     *
-     * This function initializes and returns a new instance of the
-     * PostboyMiddlewareService, which can be used to configure and manage
-     * middleware for a specific module or application.
-     *
-     * @returns {PostboyMiddlewareService} A new instance of PostboyMiddlewareService.
-     */
-    getMiddlewareService: () => PostboyMiddlewareService;
-    /**
-     * A function that instantiates and returns a new instance of PostboyMessageStore.
-     *
-     * This function serves as a factory method for creating instances
-     * of the PostboyMessageStore class.
-     *
-     * @returns {PostboyMessageStore} A new instance of the PostboyMessageStore class.
-     */
-    getMessageStore: () => PostboyMessageStore;
-    /**
-     * Creates and initializes a new instance of PostboyNamespaceStore using the provided PostboyService instance.
-     *
-     * @function getNamespaceStore
-     * @returns {PostboyNamespaceStore} A new instance of PostboyNamespaceStore associated with the given PostboyService.
-     */
-    getNamespaceStore: () => PostboyNamespaceStore;
-}
-
-declare class PostboyService {
-    protected locked: Set<string>;
-    private middleware;
-    private store;
-    private namespaceStore;
-    private dependencyResolver;
-    constructor(resolver?: PostboyDependencyResolver);
-    private registerInfrastructureMessages;
-    /**
-     * Locks a specific message type to prevent further modifications or actions.
-     *
-     * @deprecated The method should be replaced with firing {@link LockMessage} message.
-     * @param {MessageType<T>} type - The message type to be locked. It must extend from the `PostboyGenericMessage`.
-     * @return {void} This method does not return a value.
-     */
-    lock<T extends PostboyGenericMessage>(type: MessageType<T>): void;
-    /**
-     * Unlocks a previously locked message type by removing its ID from the locked set.
-     *
-     * @deprecated The method should be replaced with firing {@link UnlockMessage} message.
-     * @param {MessageType<T>} type - The message type to unlock, which is a generic type extending PostboyGenericMessage.
-     * @return {void} This method does not return any value.
-     */
-    unlock<T extends PostboyGenericMessage>(type: MessageType<T>): void;
-    /**
-     * Adds a middleware to the middleware stack.
-     *
-     * @deprecated The method should be replaced with firing {@link AddMiddleware} message.
-     * @param {PostboyMiddleware} middleware - The middleware instance to be added.
-     * @return {void}
-     */
-    addMiddleware(middleware: PostboyMiddleware): void;
-    /**
-     * Removes a middleware from the current middleware stack.
-     *
-     * @deprecated The method should be replaced with firing {@link RemoveMiddleware} message.
-     * @param {PostboyMiddleware} middleware - The middleware instance to be removed.
-     * @return {void} No return value.
-     */
-    removeMiddleware(middleware: PostboyMiddleware): void;
-    /**
-     * Unregisters a message identified by the given ID from the store.
-     *
-     * @deprecated The method should be replaced with firing {@link DisconnectMessage} message.
-     * @param {string} id - The unique identifier of the item to unregister.
-     * @return {void} No value is returned.
-     */
-    unregister(id: string): void;
-    /**
-     * Fires a registered event and passes the message to its subscribers.
-     *
-     * @param {PostboyGenericMessage} message - The message object containing the event data.
-     * @return {void} This method does not return a value.
-     * @throws {Error} Throws an error if no registered event is found for the provided message ID.
-     */
-    fire(message: PostboyGenericMessage): void;
-    /**
-     * Triggers a callback function associated with a given message.
-     *
-     * @param {PostboyCallbackMessage<T>} message - The message object used to trigger the callback.
-     * It contains details about the event and result subscription.
-     * @param {(e: T) => void} [action] - Optional callback function to execute when the result of the message is emitted.
-     * @return {void} This method does not return any value.
-     */
-    fireCallback<T>(message: PostboyCallbackMessage<T>, action?: (e: T) => void): Observable<T>;
-    /**
-     * Executes the provided executor function and returns its result.
-     *
-     * @param {PostboyExecutor<T>} executor The executor to be executed, which includes its identifier and logic.
-     * @return {T} The resulting output from the executed executor function.
-     * @throws {Error} If the specified executor is not registered.
-     */
-    exec<T>(executor: PostboyExecutor<T>): T;
-    /**
-     * Subscribes to a specific message type and returns an observable of that type.
-     *
-     * @param type The constructor function of the type that extends PostboyGenericMessage.
-     * @return An Observable of the specified generic message type.
-     */
-    sub<T extends PostboyGenericMessage>(type: MessageType<T>): Observable<T>;
-    /**
-     * Subscribes to a specific message type and automatically unsubscribes after receiving the first message.
-     *
-     * @param type The type of message to subscribe to.
-     * @return An observable that emits the first message of the specified type and then completes.
-     */
-    once<T extends PostboyGenericMessage>(type: MessageType<T>): Observable<T>;
-    /**
-     * Registers a given message type and its associated subject subscription with the system.
-     *
-     * @deprecated The method should be replaced with firing {@link ConnectMessage} message.
-     * @param type The constructor function of the message type that extends the PostboyGenericMessage.
-     * @param sub The Subject instance for the provided message type, used for managing subscriptions.
-     * @return {void} No return value.
-     */
-    record<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>): void;
-    /**
-     * Registers a generic message type with a Subject and a transformation pipe.
-     *
-     * @deprecated The method should be replaced with firing {@link ConnectMessage} message.
-     * @param {MessageType<T>} type - The constructor of the message type being registered.
-     * @param {Subject<T>} sub - The Subject instance used to handle incoming messages of the specified type.
-     * @param {(s: Subject<T>) => Observable<T>} pipe - A function that applies a transformation or processing logic to the Subject and returns an Observable.
-     * @return {void} No return value.
-     */
-    recordWithPipe<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>, pipe: (s: Subject<T>) => Observable<T>): void;
-    /**
-     * Registers an executor for a specified message type.
-     *
-     * @deprecated The method should be replaced with firing {@link ConnectExecutor} message.
-     * @param {MessageType<E>} type - The message type for which the executor is being registered.
-     * @param {(e: E) => T} exec - The executor function that will handle messages of the specified type.
-     * @return {void} This method does not return any value.
-     */
-    recordExecutor<E extends PostboyExecutor<T>, T>(type: MessageType<E>, exec: (e: E) => T): void;
-    /**
-     * Registers a handler for a specific executor type.
-     *
-     * @deprecated The method should be replaced with firing {@link ConnectHandler} message.
-     * @param executor The constructor of the executor class that extends `PostboyExecutor<R>`.
-     * @param handler An instance of `PostboyExecutionHandler<R, E>` that defines the logic for handling the executor.
-     * @return void
-     */
-    recordHandler<E extends PostboyExecutor<R>, R>(executor: new (...args: any[]) => E, handler: PostboyExecutionHandler<R, E>): void;
-    /**
-     * Adds a namespace to the namespace store.
-     *
-     * @deprecated The method should be replaced with firing {@link AddNamespace} message.
-     * @param {string} space - The name of the namespace to be added.
-     * @return {PostboyAbstractRegistrator} The instance of the namespace after adding the specified namespace.
-     */
-    addNamespace(space: string): PostboyAbstractRegistrator;
-    /**
-     * Removes the specified namespace from the namespace store.
-     *
-     * @deprecated The method should be replaced with firing {@link EliminateNamespace} message.
-     * @param {string} space - The name of the namespace to be removed.
-     * @return {void} This method does not return a value.
-     */
-    eliminateNamespace(space: string): void;
-    /**
-     * Disposes of resources and cleans up any internal components or stores associated with the instance.
-     * This method ensures that all resources are properly released to avoid memory leaks.
-     *
-     * @return {void} This method does not return a value.
-     */
-    dispose(): void;
-}
-
-/**
- * Represents a {@link PostboyMiddleware} addition operation for Postboy.
- * This class extends the functionality of the PostboyExecutor to add middleware to the processing chain.
- *
- * The middleware to be added is provided during instantiation.
- */
-declare class AddMiddleware extends PostboyExecutor<void> {
-    middleware: PostboyMiddleware;
-    static readonly ID = "0a8cfe0a-6193-4082-8440-d0793367b21d";
-    /**
-     * Initializes a new instance of the class with the specified middleware.
-     *
-     * @param {PostboyMiddleware} middleware - The {@link PostboyMiddleware} to be used for processing.
-     */
-    constructor(middleware: PostboyMiddleware);
-}
-
-/**
- * Represents a class responsible for removing {@link PostboyMiddleware} in execution flow.
- * This class extends PostboyExecutor and operates with a void return type.
- */
-declare class RemoveMiddleware extends PostboyExecutor<void> {
-    middleware: PostboyMiddleware;
-    static readonly ID = "c25c708c-53c9-498d-a28b-936fbaf68b91";
-    /**
-     * Constructs an instance of the class with the specified middleware.
-     *
-     * @param {PostboyMiddleware} middleware - The {@link PostboyMiddleware} instance to be removed.
-     */
-    constructor(middleware: PostboyMiddleware);
-}
-
-/**
- * Locks a specific message type to prevent firing of them.
- *
- * This class is used to handle operations associated with locking mechanisms
- * for a specified message type.
- *
- * @template T - A type that extends {@link PostboyGenericMessage}.
- */
-declare class LockMessage<T extends PostboyGenericMessage> extends PostboyExecutor<void> {
-    type: MessageType<T>;
-    static readonly ID = "477df3e2-1f99-4476-9a3b-afd1fa426436";
-    /**
-     * Constructs an instance of the class with the specified message type.
-     *
-     * @param {MessageType<T>} type - The type of the message to be used for the instance.
-     */
-    constructor(type: MessageType<T>);
-}
-
-/**
- * A specialized executor that handles the unlocking process for messages of a specified type.
- * Unlocks a previously locked message, making it available for processing again.
- *
- * @template T - The type parameter extending {@link PostboyGenericMessage}, representing the message type handled by the executor.
- * @extends {PostboyExecutor<void>}
- */
-declare class UnlockMessage<T extends PostboyGenericMessage> extends PostboyExecutor<void> {
-    type: MessageType<T>;
-    static readonly ID = "d71d25e3-90ac-4009-b972-9e6c6b05611e";
-    /**
-     * Creates an instance of the class with the specified message type.
-     *
-     * @param {MessageType<T>} type - The message type for this instance.
-     */
-    constructor(type: MessageType<T>);
-}
-
-/**
- * AddNamespace is a class that extends the PostboyExecutor with a specific implementation
- * for adding namespaces to a PostboyService instance.
- *
- * This class is identified uniquely by its static ID property for tracking and referencing purposes.
- */
-declare class AddNamespace extends PostboyExecutor<PostboyAbstractRegistrator> {
-    space: string;
-    static readonly ID = "6d1a6f7d-6b6e-4c4d-8af8-9cc9a32e850c";
-    /**
-     * Creates an instance of the class with the specified space identifier.
-     *
-     * @param {string} space - The identifier for the space.
-     */
-    constructor(space: string);
-}
-
-/**
- * Represents an executor that eliminates a specific namespace.
- * This class extends the PostboyExecutor with a void return type.
- */
-declare class EliminateNamespace extends PostboyExecutor<void> {
-    space: string;
-    static readonly ID = "03bb03bb-53e0-4b74-9aad-64d5c54a8972";
-    /**
-     * Creates an instance of the class with the specified space value.
-     *
-     * @param {string} space - The string value representing the space configuration.
-     */
-    constructor(space: string);
-}
-
-/**
- * Represents a connection handler that extends the PostboyExecutor class.
- *
- * This class encapsulates logic associated with executing a handler in a structured way.
- * It is generic and operates on the provided executor and handler types.
- *
- * Type Parameters:
- *   E - Represents an extension of the PostboyExecutor class with a specific type parameter R.
- *   R - Represents the type of the result that the executor is expected to operate on.
- */
-declare class ConnectHandler<E extends PostboyExecutor<R>, R> extends PostboyExecutor<void> {
-    executor: new (...args: any[]) => E;
-    handler: PostboyExecutionHandler<R, E>;
-    static readonly ID = "bf618cea-6f32-417c-9548-8eafe937378b";
-    /**
-     * Constructs an instance of the class.
-     *
-     * @param {new (...args: any[]) => E} executor - A constructor function for the executor object.
-     * @param {PostboyExecutionHandler<R, E>} handler - A handler that processes the execution logic.
-     */
-    constructor(executor: new (...args: any[]) => E, handler: PostboyExecutionHandler<R, E>);
-}
-
-/**
- * Registers an executor that connects to a specific type of message handler.
- * This class extends the functionality of `PostboyExecutor` and is designed to manage
- * the execution of a handler defined by a specific message type and an execution function.
- *
- * @template E The type of the executor extending {@link PostboyExecutor}.
- * @template T The return type of the execution function.
- *
- * @extends {PostboyExecutor<void>}
- */
-declare class ConnectExecutor<E extends PostboyExecutor<T>, T> extends PostboyExecutor<void> {
-    type: MessageType<E>;
-    exec: (e: E) => T;
-    static readonly ID = "cb80e8ad-b68c-4b2d-8c44-617ea6017cb3";
-    /**
-     * Constructs an instance of the class with the specified type and execution function.
-     *
-     * @param {MessageType<E>} type - The type of the message.
-     * @param {(e: E) => T} exec - The function to be executed with the input of type E that returns a value of type T.
-     */
-    constructor(type: MessageType<E>, exec: (e: E) => T);
-}
-
-/**
- * Represents a message signaling a disconnection event. This class is used
- * within the framework to manage and process disconnection notifications.
- * Extends the {@link PostboyExecutor} base class.
- *
- * @extends {PostboyExecutor<void>}
- */
-declare class DisconnectMessage extends PostboyExecutor<void> {
-    messageId: string;
-    static readonly ID = "94579e43-5bc9-4517-bcda-b595bcda1ae7";
-    /**
-     * Creates an instance of the class with the specified message identifier.
-     *
-     * @param {string} messageId - The unique identifier for the message.
-     */
-    constructor(messageId: string);
-}
-
-/**
- * Represents a message that facilitates connection functionality
- * within the application's messaging system.
- *
- * @template T - A type that extends {@link PostboyGenericMessage}, representing
- * the structure of the message being handled.
- *
- * @extends PostboyExecutor<void>
- */
-declare class ConnectMessage<T extends PostboyGenericMessage> extends PostboyExecutor<void> {
-    type: MessageType<T>;
-    sub: Subject<T>;
-    pipe?: ((s: Subject<T>) => Observable<T>) | undefined;
-    static readonly ID = "aa03a192-bdc7-402d-9f2f-bf3748229ea2";
-    /**
-     * Constructs a new instance of the class.
-     *
-     * @param {MessageType<T>} type - The type of the message.
-     * @param {Subject<T>} sub - The subject to be used for message handling.
-     * @param {(s: Subject<T>) => Observable<T>} [pipe] - An optional function to transform the subject.
-     */
-    constructor(type: MessageType<T>, sub: Subject<T>, pipe?: ((s: Subject<T>) => Observable<T>) | undefined);
-}
-
-export { AddMiddleware, AddNamespace, ConnectExecutor, ConnectHandler, ConnectMessage, DisconnectMessage, EliminateNamespace, type IPostboyDependingService, LockMessage, type MessageType, PostboyAbstractRegistrator, PostboyCallbackMessage, PostboyExecutionHandler, PostboyExecutor, PostboyGenericMessage, PostboyMessage, PostboyMessageStore, type PostboyMiddleware, PostboyMiddlewareService, PostboyService, RemoveMiddleware, UnlockMessage, checkId };
+/**
+ * Represents metadata associated with a Postboy message.
+ *
+ * This interface can be used to store optional metadata that provides
+ * additional context or tracking information for a message. It supports
+ * flexible extension by allowing additional properties through an index signature.
+ *
+ * Properties:
+ * - `correlationId` (optional): A unique identifier used to correlate
+ *   related messages or operations across systems.
+ * - `causationId` (optional): The identifier of the preceding message
+ *   or event that caused the current message to be produced.
+ * - `source` (optional): The origin or source of the message, such as
+ *   a particular service or system.
+ * - `tags` (optional): An array of tags or labels that can be attached
+ *   to the message for categorization, filtering, or logging purposes.
+ * - `[key: string]` (optional): Additional custom properties can be
+ *   added to capture specific metadata not covered by the predefined fields.
+ */
+interface PostboyMessageMetadata {
+    correlationId?: string;
+    causationId?: string;
+    tags?: Set<string>;
+    [key: string]: any;
+}
+
+declare abstract class PostboyMessage {
+    metadata: PostboyMessageMetadata;
+    get id(): string;
+    setMetadata(metadata: Partial<PostboyMessageMetadata>): this;
+}
+
+/**
+ * An inheritor should have a static ID field
+ */
+declare abstract class PostboyGenericMessage extends PostboyMessage {
+}
+
+declare abstract class PostboyExecutor<T> extends PostboyMessage {
+    protected readonly _postboyResultType?: T;
+}
+
+/**
+ * An abstract class extending PostboyGenericMessage that provides mechanisms for managing
+ * asynchronous data communication using RxJS observables. It is designed to work with
+ * callback-based operations that emit a result of type T.
+ *
+ * @template T - The type of the data emitted by the observables in this class.
+ *
+ * @extends PostboyGenericMessage
+ *
+ * @property {Observable<T>} result - An observable that emits the result of the operation
+ * and completes once the operation is finished.
+ *
+ * @method next - Emits the next value for the result observable.
+ * @param {T} value - The value to be emitted by the result observable.
+ *
+ * @method finish - Emits the final value for the result observable and completes it.
+ * @param {T} value - The final value for the observable emission.
+ */
+declare abstract class PostboyCallbackMessage<T> extends PostboyGenericMessage {
+    protected result$: Subject<T>;
+    result: Observable<T>;
+    /**
+     * Emits the provided value.
+     *
+     * @template T - The type of the value to emit.
+     * @param {T} value - The value to emit through the `result$` observable.
+     * @returns {void}
+     */
+    next: (value: T) => void;
+    /**
+     * Marks the operation as complete by emitting the provided value and then completing the result stream.
+     *
+     * @param {T} value - The value to emit prior to completing the result stream.
+     * @return {void} This method does not return a value.
+     */
+    finish(value: T): void;
+    /**
+     * Completes the current observable result stream.
+     * This method marks the result observable as complete, ensuring no further values
+     * or events will be emitted from it.
+     *
+     * @return {void} No value is returned from this method.
+     */
+    complete(): void;
+}
+
+interface IPostboyDependingService {
+    up(): void;
+    down?: () => void;
+}
+
+/**
+ * Abstract class representing a handler for executing a Postboy task.
+ *
+ * This class is intended to manage the execution flow of a PostboyExecutor instance.
+ * Subclasses must implement the `handle` method, which executes a given PostboyExecutor
+ * and returns a result of type R.
+ *
+ * @template R The type of the result returned by the `handle` method.
+ * @template E The type of the executor extending the PostboyExecutor.
+ */
+declare abstract class PostboyExecutionHandler<R, E extends PostboyExecutor<R>> {
+    /**
+     * Abstract method to handle the specified executor and return a result.
+     *
+     * @param {E} executor - The executor that will be processed by the method.
+     * @return {R} The result obtained after handling the executor.
+     */
+    abstract handle(executor: E): R;
+}
+
+type MessageType<T extends PostboyGenericMessage> = new (...args: any[]) => T;
+declare abstract class PostboyAbstractRegistrator {
+    protected postboy: PostboyService;
+    get namespace(): string;
+    private ids;
+    private services;
+    private readonly _namespace;
+    constructor(postboy: PostboyService, namespace?: string | null);
+    /**
+     * Registers a list of services to be used by the application.
+     *
+     * @param {IPostboyDependingService[]} services - An array of services to register.
+     * @return {void} This method does not return a value.
+     */
+    registerServices(services: IPostboyDependingService[]): void;
+    /**
+     * Initiates the 'up' process for the current instance and all associated services.
+     *
+     * @return {void} Does not return a value.
+     */
+    up(): void;
+    protected abstract _up(): void;
+    down(): void;
+    /**
+     * Records a type and its corresponding Subject<T> into the Postboy system and updates the internal identifiers.
+     *
+     * @param {MessageType<T>} type - A constructor for the generic message type T.
+     * @param {Subject<T>} sub - The subject associated with the generic message type.
+     * @return {this} Returns the current instance for method chaining.
+     */
+    record<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>): PostboyAbstractRegistrator;
+    /**
+     * Records a message type with a specific subject and applies a transformation pipe to the subject.
+     *
+     * @param {MessageType<T>} type - The constructor of the message type to record, which extends PostboyGenericMessage.
+     * @param {Subject<T>} sub - The Subject instance to associate with the message type.
+     * @param {(s: Subject<T>) => Observable<T>} pipe - A function that takes the subject as input and returns an Observable with transformations applied.
+     * @return {this} The current instance of the class for chaining.
+     */
+    recordWithPipe<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>, pipe: (s: Subject<T>) => Observable<T>): PostboyAbstractRegistrator;
+    /**
+     * Records an executor associated with a specific type and execution logic.
+     *
+     * @param type The class constructor of the executor type to be recorded, which extends PostboyExecutor.
+     * @param exec A callback function that executes the logic using an instance of the specified executor type.
+     * @return void
+     */
+    recordExecutor<E extends PostboyExecutor<T>, T>(type: new (...args: any[]) => E, exec: (e: E) => T): PostboyAbstractRegistrator;
+    /**
+     * Records a handler for a specific executor type.
+     *
+     * @param executor The constructor of the executor type, which extends `PostboyExecutor`.
+     * @param handler The execution handler associated with the given executor type.
+     * @return void
+     */
+    recordHandler<E extends PostboyExecutor<R>, R>(executor: new (...args: any[]) => E, handler: PostboyExecutionHandler<R, E>): PostboyAbstractRegistrator;
+    /**
+     * A utility function that facilitates the recording and replaying of messages
+     * using a ReplaySubject. This function is designed to handle messages of a
+     * specific type and allows specifying a buffer size to determine how many
+     * of the most recent messages should be replayed.
+     *
+     * @template T Extends the PostboyGenericMessage type, representing the type of message
+     * to be recorded and replayed.
+     * @param {MessageType<T>} type The constructor of the message type to be recorded and replayed.
+     * @param {number} [bufferSize=1] The number of recent messages to retain in the ReplaySubject's buffer.
+     * Defaults to 1 if not specified.
+     * @returns The result of invoking the `record` method with the given message type and configured ReplaySubject.
+     */
+    recordReplay<T extends PostboyGenericMessage>(type: MessageType<T>, bufferSize?: number): PostboyAbstractRegistrator;
+    /**
+     * Represents a method that records a specific behavior associated with a message type.
+     * It creates a `BehaviorSubject` initialized with the provided initial message
+     * and associates it with the given message type using the `record` method.
+     *
+     * @template T - A type parameter extending `PostboyGenericMessage` that defines the message structure.
+     * @param {MessageType<T>} type - The constructor function of the message type to be recorded.
+     * @param {T} initial - The initial value of the message that will be set in the `BehaviorSubject`.
+     * @returns {void} - This function does not return a value; instead, it modifies the internal state.
+     */
+    recordBehavior<T extends PostboyGenericMessage>(type: MessageType<T>, initial: T): PostboyAbstractRegistrator;
+    /**
+     * A function that creates and returns a new generic message recorder for a specific message type.
+     *
+     * @template T - A type parameter extending from `PostboyGenericMessage`.
+     * @param {MessageType<T>} type - The constructor for the message type being recorded.
+     * @returns {Subject<T>} A new instance of `Subject<T>` bound to the specified message type.
+     */
+    recordSubject<T extends PostboyGenericMessage>(type: MessageType<T>): this;
+}
+
+declare enum MiddlewareStage {
+    Publish = 1,
+    Callback = 2,
+    Execute = 3
+}
+
+interface PipelineContext<T extends PostboyMessage = PostboyMessage> {
+    stage: MiddlewareStage;
+    message: T;
+}
+
+declare enum MiddlewareDecisionType {
+    Continue = 1,
+    Interrupt = 2
+}
+
+interface MiddlewareDecision {
+    type: MiddlewareDecisionType;
+}
+
+interface CancelDetails {
+    stage: MiddlewareStage;
+    reason?: string;
+    middleware?: string;
+    messageId?: string;
+    namespace?: string;
+}
+
+declare class CancelError extends Error {
+    readonly details: CancelDetails;
+    constructor(details: CancelDetails);
+}
+
+type PipelineResult = {
+    cancelled: boolean;
+    cancelledBy?: string;
+    reason?: string;
+};
+
+interface PostboyMessageContext {
+    correlationId: string;
+    currentMessageId: string;
+    parentMessageId?: string;
+    depth: number;
+    startedAt: Date;
+    tags?: Set<string>;
+}
+
+/**
+ * A class that manages a reactive subscription using a provided Subject and transformation pipe.
+ * Offers methods to interact with the subscription, such as emitting data, completing the subscription,
+ * and accessing the transformed observable.
+ *
+ * @template T The type of data managed by the subscription.
+ */
+declare class PostboySubscription<T> {
+    private subscription;
+    private readonly _subscription;
+    /**
+     * Constructs an instance of the class with a given subscription and a transformation pipe.
+     *
+     * @param {Subject<T>} subscription - The source Subject that will be transformed.
+     * @param {(s: Subject<T>) => Observable<T>} pipe - A function that applies a transformation to the subscription.
+     */
+    constructor(subscription: Subject<T>, pipe?: (s: Subject<T>) => Observable<T>);
+    /**
+     * Returns an observable subscription.
+     *
+     * @return {Observable<T>} An observable instance of type T.
+     */
+    sub(): Observable<T>;
+    /**
+     * Triggers an event by emitting the provided data to all subscribers.
+     *
+     * @param {T} data - The data to emit to the subscribers.
+     * @return {void} - Does not return any value.
+     */
+    fire(data: T): void;
+    /**
+     * Completes the subscription, signaling that no further values will be sent.
+     * This is typically used to finalize or clean up resources.
+     * @return {void} This method does not return any value.
+     */
+    finish(): void;
+}
+
+/**
+ * Abstract base class for defining middleware in a pipeline.
+ * Middleware acts on various stages of pipeline execution, allowing operations
+ * to be intercepted, modified, or monitored.
+ */
+declare abstract class PostboyMiddleware {
+    readonly name: string;
+    /**
+     * Creates an instance of a class, optionally assigning a name.
+     *
+     * @param {string} [name] - An optional name to be assigned. If not provided, defaults to the class name.
+     */
+    constructor(name?: string);
+    /**
+     * Optional filter to skip middleware for unrelated messages/stages.
+     */
+    canHandle(_context: PipelineContext): boolean;
+    /**
+     * Called before the stage is executed.
+     * Return Interrupt to cancel the operation.
+     */
+    before(_context: PipelineContext): MiddlewareDecision;
+    /**
+     * Called after the stage has finished successfully.
+     * `result` is typically set for execute-stage.
+     */
+    after(_context: PipelineContext, _result?: unknown): void;
+    /**
+     * Optional cleanup hook.
+     */
+    dispose(): void;
+}
+
+declare class PostboyMiddlewareService {
+    protected middlewares: PostboyMiddleware[];
+    addMiddleware(middleware: PostboyMiddleware): void;
+    removeMiddleware(middleware: PostboyMiddleware): void;
+    dispose(): void;
+    before<T extends PostboyMessage>(stage: MiddlewareStage, message: T): void;
+    after<T extends PostboyMessage, R = unknown>(stage: MiddlewareStage, message: T, result?: R): void;
+    beforePublish(message: PostboyMessage): void;
+    afterPublish(message: PostboyMessage): void;
+    beforeCallback(message: PostboyMessage): void;
+    afterCallback(message: PostboyMessage, result?: unknown): void;
+    beforeExecute<T>(message: PostboyExecutor<T>): void;
+    afterExecute<T>(message: PostboyExecutor<T>, result: T): void;
+    private buildContext;
+    private throwIfCancelled;
+}
+
+/**
+ * The PostboyMessageStore is a utility class for managing message subscriptions and executors.
+ * It provides functionality to register, retrieve, and unregister subscription-based messages and executors.
+ */
+declare class PostboyMessageStore {
+    protected messages: Map<string, PostboySubscription<any>>;
+    protected executors: Map<string, (e: PostboyExecutor<any>) => any>;
+    protected callbacks: Map<string, (() => void)[]>;
+    registerMessage(id: string, sub: PostboySubscription<any>): void;
+    registerExecutor(id: string, executor: (e: PostboyExecutor<any>) => any): void;
+    callbackFired(message: PostboyCallbackMessage<any>): void;
+    getMessage(id: string, name: string): PostboySubscription<any>;
+    getExecutor<T>(id: string): (e: PostboyExecutor<T>) => T;
+    unregister(id: string): void;
+    dispose(): void;
+}
+
+/**
+ * Represents a store for managing namespaces in the Postboy system.
+ * Provides functionality to add, eliminate, and dispose namespaces.
+ */
+declare class PostboyNamespaceStore {
+    private spaces;
+    /**
+     * Adds a new space or retrieves an existing one if it already exists.
+     *
+     * @param {string} space - The name of the space to add or retrieve.
+     * @param {PostboyService} postboy - The PostboyService instance used to create a namespace registrator.
+     * @return {PostboyAbstractRegistrator} The registrator associated with the specified space.
+     */
+    addSpace(space: string, postboy: PostboyService): PostboyAbstractRegistrator;
+    /**
+     * Removes a specified space from the spaces collection if it exists.
+     * If the space exists, it will be deleted after invoking its down method.
+     *
+     * @param {string} space - The name of the space to be removed.
+     * @return {void} This method does not return a value.
+     */
+    eliminateSpace(space: string): void;
+    /**
+     * Disposes of the current instance by performing cleanup operations.
+     * Iterates through all spaces, performs a "down" operation on each,
+     * and then clears the collection of spaces.
+     *
+     * @return {void} No return value.
+     */
+    dispose(): void;
+}
+
+declare class PostboyDependencyResolver {
+    /**
+     * Retrieves an instance of the PostboyMiddlewareService.
+     *
+     * This function initializes and returns a new instance of the
+     * PostboyMiddlewareService, which can be used to configure and manage
+     * middleware for a specific module or application.
+     *
+     * @returns {PostboyMiddlewareService} A new instance of PostboyMiddlewareService.
+     */
+    getMiddlewareService: () => PostboyMiddlewareService;
+    /**
+     * A function that instantiates and returns a new instance of PostboyMessageStore.
+     *
+     * This function serves as a factory method for creating instances
+     * of the PostboyMessageStore class.
+     *
+     * @returns {PostboyMessageStore} A new instance of the PostboyMessageStore class.
+     */
+    getMessageStore: () => PostboyMessageStore;
+    /**
+     * Creates and initializes a new instance of PostboyNamespaceStore using the provided PostboyService instance.
+     *
+     * @function getNamespaceStore
+     * @returns {PostboyNamespaceStore} A new instance of PostboyNamespaceStore associated with the given PostboyService.
+     */
+    getNamespaceStore: () => PostboyNamespaceStore;
+}
+
+declare class PostboyService {
+    protected locked: Set<string>;
+    private middleware;
+    private store;
+    private namespaceStore;
+    private dependencyResolver;
+    constructor(resolver?: PostboyDependencyResolver);
+    private registerInfrastructureMessages;
+    /**
+     * Fires a registered event and passes the message to its subscribers.
+     *
+     * @param {PostboyGenericMessage} message - The message object containing the event data.
+     * @return {void} This method does not return a value.
+     * @throws {Error} Throws an error if no registered event is found for the provided message ID.
+     */
+    fire(message: PostboyGenericMessage): void;
+    /**
+     * Triggers a callback function associated with a given message.
+     *
+     * @param {PostboyCallbackMessage<T>} message - The message object used to trigger the callback.
+     * It contains details about the event and result subscription.
+     * @param {(e: T) => void} [action] - Optional callback function to execute when the result of the message is emitted.
+     * @return {void} This method does not return any value.
+     */
+    fireCallback<T>(message: PostboyCallbackMessage<T>, action?: (e: T) => void): Observable<T>;
+    /**
+     * Executes the provided executor function and returns its result.
+     *
+     * @param {PostboyExecutor<T>} executor The executor to be executed, which includes its identifier and logic.
+     * @return {T} The resulting output from the executed executor function.
+     * @throws {Error} If the specified executor is not registered.
+     */
+    exec<T>(executor: PostboyExecutor<T>): T;
+    /**
+     * Subscribes to a specific message type and returns an observable of that type.
+     *
+     * @param type The constructor function of the type that extends PostboyGenericMessage.
+     * @return An Observable of the specified generic message type.
+     */
+    sub<T extends PostboyGenericMessage>(type: MessageType<T>): Observable<T>;
+    /**
+     * Subscribes to a specific message type and automatically unsubscribes after receiving the first message.
+     *
+     * @param type The type of message to subscribe to.
+     * @return An observable that emits the first message of the specified type and then completes.
+     */
+    once<T extends PostboyGenericMessage>(type: MessageType<T>): Observable<T>;
+    /**
+     * Registers a given message type and its associated subject subscription with the system.
+     *
+     * @deprecated The method should be replaced with firing {@link ConnectMessage} message.
+     * @param type The constructor function of the message type that extends the PostboyGenericMessage.
+     * @param sub The Subject instance for the provided message type, used for managing subscriptions.
+     * @return {void} No return value.
+     */
+    record<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>): void;
+    /**
+     * Registers a generic message type with a Subject and a transformation pipe.
+     *
+     * @deprecated The method should be replaced with firing {@link ConnectMessage} message.
+     * @param {MessageType<T>} type - The constructor of the message type being registered.
+     * @param {Subject<T>} sub - The Subject instance used to handle incoming messages of the specified type.
+     * @param {(s: Subject<T>) => Observable<T>} pipe - A function that applies a transformation or processing logic to the Subject and returns an Observable.
+     * @return {void} No return value.
+     */
+    recordWithPipe<T extends PostboyGenericMessage>(type: MessageType<T>, sub: Subject<T>, pipe: (s: Subject<T>) => Observable<T>): void;
+    /**
+     * Registers an executor for a specified message type.
+     *
+     * @deprecated The method should be replaced with firing {@link ConnectExecutor} message.
+     * @param {MessageType<E>} type - The message type for which the executor is being registered.
+     * @param {(e: E) => T} exec - The executor function that will handle messages of the specified type.
+     * @return {void} This method does not return any value.
+     */
+    recordExecutor<E extends PostboyExecutor<T>, T>(type: MessageType<E>, exec: (e: E) => T): void;
+    /**
+     * Registers a handler for a specific executor type.
+     *
+     * @deprecated The method should be replaced with firing {@link ConnectHandler} message.
+     * @param executor The constructor of the executor class that extends `PostboyExecutor<R>`.
+     * @param handler An instance of `PostboyExecutionHandler<R, E>` that defines the logic for handling the executor.
+     * @return void
+     */
+    recordHandler<E extends PostboyExecutor<R>, R>(executor: new (...args: any[]) => E, handler: PostboyExecutionHandler<R, E>): void;
+    /**
+     * Disposes of resources and cleans up any internal components or stores associated with the instance.
+     * This method ensures that all resources are properly released to avoid memory leaks.
+     *
+     * @return {void} This method does not return a value.
+     */
+    dispose(): void;
+}
+
+/**
+ * Represents a {@link PostboyMiddleware} addition operation for Postboy.
+ * This class extends the functionality of the PostboyExecutor to add middleware to the processing chain.
+ *
+ * The middleware to be added is provided during instantiation.
+ */
+declare class AddMiddleware extends PostboyExecutor<void> {
+    middleware: PostboyMiddleware;
+    static readonly ID = "0a8cfe0a-6193-4082-8440-d0793367b21d";
+    /**
+     * Initializes a new instance of the class with the specified middleware.
+     *
+     * @param {PostboyMiddleware} middleware - The {@link PostboyMiddleware} to be used for processing.
+     */
+    constructor(middleware: PostboyMiddleware);
+}
+
+/**
+ * Represents a class responsible for removing {@link PostboyMiddleware} in execution flow.
+ * This class extends PostboyExecutor and operates with a void return type.
+ */
+declare class RemoveMiddleware extends PostboyExecutor<void> {
+    middleware: PostboyMiddleware;
+    static readonly ID = "c25c708c-53c9-498d-a28b-936fbaf68b91";
+    /**
+     * Constructs an instance of the class with the specified middleware.
+     *
+     * @param {PostboyMiddleware} middleware - The {@link PostboyMiddleware} instance to be removed.
+     */
+    constructor(middleware: PostboyMiddleware);
+}
+
+/**
+ * Locks a specific message type to prevent firing of them.
+ *
+ * @deprecated Use {@link PostboyMiddleware}
+ * This class is used to handle operations associated with locking mechanisms
+ * for a specified message type.
+ *
+ * @template T - A type that extends {@link PostboyGenericMessage}.
+ */
+declare class LockMessage<T extends PostboyGenericMessage> extends PostboyExecutor<void> {
+    type: MessageType<T>;
+    static readonly ID = "477df3e2-1f99-4476-9a3b-afd1fa426436";
+    /**
+     * Constructs an instance of the class with the specified message type.
+     *
+     * @param {MessageType<T>} type - The type of the message to be used for the instance.
+     */
+    constructor(type: MessageType<T>);
+}
+
+/**
+ * A specialized executor that handles the unlocking process for messages of a specified type.
+ * Unlocks a previously locked message, making it available for processing again.
+ *
+ * @deprecated Use {@link PostboyMiddleware}
+ * @template T - The type parameter extending {@link PostboyGenericMessage}, representing the message type handled by the executor.
+ * @extends {PostboyExecutor<void>}
+ */
+declare class UnlockMessage<T extends PostboyGenericMessage> extends PostboyExecutor<void> {
+    type: MessageType<T>;
+    static readonly ID = "d71d25e3-90ac-4009-b972-9e6c6b05611e";
+    /**
+     * Creates an instance of the class with the specified message type.
+     *
+     * @param {MessageType<T>} type - The message type for this instance.
+     */
+    constructor(type: MessageType<T>);
+}
+
+/**
+ * AddNamespace is a class that extends the PostboyExecutor with a specific implementation
+ * for adding namespaces to a PostboyService instance.
+ *
+ * This class is identified uniquely by its static ID property for tracking and referencing purposes.
+ */
+declare class AddNamespace extends PostboyExecutor<PostboyAbstractRegistrator> {
+    space: string;
+    static readonly ID = "6d1a6f7d-6b6e-4c4d-8af8-9cc9a32e850c";
+    /**
+     * Creates an instance of the class with the specified space identifier.
+     *
+     * @param {string} space - The identifier for the space.
+     */
+    constructor(space: string);
+}
+
+/**
+ * Represents an executor that eliminates a specific namespace.
+ * This class extends the PostboyExecutor with a void return type.
+ */
+declare class EliminateNamespace extends PostboyExecutor<void> {
+    space: string;
+    static readonly ID = "03bb03bb-53e0-4b74-9aad-64d5c54a8972";
+    /**
+     * Creates an instance of the class with the specified space value.
+     *
+     * @param {string} space - The string value representing the space configuration.
+     */
+    constructor(space: string);
+}
+
+/**
+ * Represents a connection handler that extends the PostboyExecutor class.
+ *
+ * This class encapsulates logic associated with executing a handler in a structured way.
+ * It is generic and operates on the provided executor and handler types.
+ *
+ * Type Parameters:
+ *   E - Represents an extension of the PostboyExecutor class with a specific type parameter R.
+ *   R - Represents the type of the result that the executor is expected to operate on.
+ */
+declare class ConnectHandler<E extends PostboyExecutor<R>, R> extends PostboyExecutor<void> {
+    executor: new (...args: any[]) => E;
+    handler: PostboyExecutionHandler<R, E>;
+    static readonly ID = "bf618cea-6f32-417c-9548-8eafe937378b";
+    /**
+     * Constructs an instance of the class.
+     *
+     * @param {new (...args: any[]) => E} executor - A constructor function for the executor object.
+     * @param {PostboyExecutionHandler<R, E>} handler - A handler that processes the execution logic.
+     */
+    constructor(executor: new (...args: any[]) => E, handler: PostboyExecutionHandler<R, E>);
+}
+
+/**
+ * Registers an executor that connects to a specific type of message handler.
+ * This class extends the functionality of `PostboyExecutor` and is designed to manage
+ * the execution of a handler defined by a specific message type and an execution function.
+ *
+ * @template E The type of the executor extending {@link PostboyExecutor}.
+ * @template T The return type of the execution function.
+ *
+ * @extends {PostboyExecutor<void>}
+ */
+declare class ConnectExecutor<E extends PostboyExecutor<T>, T> extends PostboyExecutor<void> {
+    type: MessageType<E>;
+    exec: (e: E) => T;
+    static readonly ID = "cb80e8ad-b68c-4b2d-8c44-617ea6017cb3";
+    /**
+     * Constructs an instance of the class with the specified type and execution function.
+     *
+     * @param {MessageType<E>} type - The type of the message.
+     * @param {(e: E) => T} exec - The function to be executed with the input of type E that returns a value of type T.
+     */
+    constructor(type: MessageType<E>, exec: (e: E) => T);
+}
+
+/**
+ * Represents a message signaling a disconnection event. This class is used
+ * within the framework to manage and process disconnection notifications.
+ * Extends the {@link PostboyExecutor} base class.
+ *
+ * @extends {PostboyExecutor<void>}
+ */
+declare class DisconnectMessage extends PostboyExecutor<void> {
+    messageId: string;
+    static readonly ID = "94579e43-5bc9-4517-bcda-b595bcda1ae7";
+    /**
+     * Creates an instance of the class with the specified message identifier.
+     *
+     * @param {string} messageId - The unique identifier for the message.
+     */
+    constructor(messageId: string);
+}
+
+/**
+ * Represents a message that facilitates connection functionality
+ * within the application's messaging system.
+ *
+ * @template T - A type that extends {@link PostboyGenericMessage}, representing
+ * the structure of the message being handled.
+ *
+ * @extends PostboyExecutor<void>
+ */
+declare class ConnectMessage<T extends PostboyGenericMessage> extends PostboyExecutor<void> {
+    type: MessageType<T>;
+    sub: Subject<T>;
+    pipe?: ((s: Subject<T>) => Observable<T>) | undefined;
+    static readonly ID = "aa03a192-bdc7-402d-9f2f-bf3748229ea2";
+    /**
+     * Constructs a new instance of the class.
+     *
+     * @param {MessageType<T>} type - The type of the message.
+     * @param {Subject<T>} sub - The subject to be used for message handling.
+     * @param {(s: Subject<T>) => Observable<T>} [pipe] - An optional function to transform the subject.
+     */
+    constructor(type: MessageType<T>, sub: Subject<T>, pipe?: ((s: Subject<T>) => Observable<T>) | undefined);
+}
+
+export { AddMiddleware, AddNamespace, type CancelDetails, CancelError, ConnectExecutor, ConnectHandler, ConnectMessage, DisconnectMessage, EliminateNamespace, type IPostboyDependingService, LockMessage, type MessageType, type MiddlewareDecision, MiddlewareDecisionType, MiddlewareStage, type PipelineContext, type PipelineResult, PostboyAbstractRegistrator, PostboyCallbackMessage, PostboyExecutionHandler, PostboyExecutor, PostboyGenericMessage, PostboyMessage, type PostboyMessageContext, type PostboyMessageMetadata, PostboyMessageStore, PostboyMiddleware, PostboyMiddlewareService, PostboyNamespaceStore, PostboyService, PostboySubscription, RemoveMiddleware, UnlockMessage };