evg_observable 2.14.61 → 2.15.1

package/src/outLib/Types.d.ts

@@ -1,164 +1,726 @@
 import { PipeSwitchCase } from "./Pipe";
 import { FilterSwitchCase } from "./FilterCollection";
+/**
+ * Defines a callback function type that can be invoked with an optional value of type `T`.
+ * The function can perform any operation and optionally return a value of any type.
+ *
+ * @template T - The type of the parameter that the callback function may receive.
+ * @param {T} [value] - An optional parameter of type `T` passed to the callback function.
+ * @returns {any} - The return type of the callback function is not specified and can be of any type.
+ */
 export type ICallback<T> = (value?: T) => any;
+/**
+ * Represents a callback function to handle error scenarios.
+ *
+ * This type defines a function signature that accepts error-related data
+ * and a descriptive error message as parameters and performs an operation.
+ *
+ * @callback IErrorCallback
+ * @param {any} errorData - The data or object representing the error.
+ * @param {any} errorMessage - A descriptive message providing details about the error.
+ */
 export type IErrorCallback = (errorData: any, errorMessage: any) => void;
+/**
+ * Represents a contract for subscribing to a data stream or event source.
+ *
+ * @template T The type of data or events being subscribed to.
+ *
+ * @property subscribe Provides the mechanism to register a listener for handling incoming data or events,
+ *   and optionally handles errors.
+ *   - `listener` is the callback that processes the data or events.
+ *   - `errorHandler` is an optional callback for handling errors during the subscription.
+ *   - Returns an object implementing `ISubscriptionLike` to manage the subscription, or `undefined` if no subscription is created.
+ */
 export type ISubscribe<T> = {
     subscribe(listener: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
 };
+/**
+ * Represents a listener interface that extends the functionality of `ICallback`.
+ * This type is designed to handle events, callbacks, or notifications with a specific type `T`.
+ *
+ * Generic:
+ * @template T - The type of data that the listener will handle.
+ */
 export type IListener<T> = ICallback<T>;
+/**
+ * IDestroy represents an interface for objects that can be destroyed to release resources.
+ * It provides a method to perform the destroy operation and a property to indicate if the object is already destroyed.
+ *
+ * Members:
+ * - destroy(): A method to perform cleanup and release resources associated with the object.
+ * - isDestroyed: A boolean property that reflects whether the object has been destroyed.
+ */
 export type IDestroy = {
     destroy(): void;
     isDestroyed: boolean;
 };
+/**
+ * Represents an order with a specific numerical value.
+ * Defines a structure to hold the order information as a numeric value.
+ */
 export type IOrder = {
     order: number;
 };
+/**
+ * Represents a generic switch interface.
+ *
+ * @template T The type of the value to be used in the switch operation.
+ *
+ * @property {Function} switch - Defines the method for initiating a switch operation.
+ * Returns a `PipeSwitchCase<T>` representing the next step in the switching process.
+ */
 export type ISwitch<T> = {
     switch(): PipeSwitchCase<T>;
 };
+/**
+ * Represents an interface for an ordered switch mechanism that evaluates
+ * conditions in a specific sequence and invokes the corresponding logic.
+ *
+ * This interface is generic and designed to operate with a specific type `T`.
+ *
+ * @template T The type of data expected by the implementation.
+ * @property switch A method intended to handle the ordered evaluation of cases
+ *                  and return an instance of `PipeSwitchCase<T>`.
+ */
 export type IOrderedSwitch<T> = {
     switch(): PipeSwitchCase<T>;
 };
+/**
+ * Represents an interface defining a contract for a one-time settable subscription mechanism.
+ *
+ * @template T - The type of the data or value associated with the subscription.
+ *
+ * @property setOnce - A method that ensures the associated subscription can only be set or triggered once.
+ * @returns {ISubscribe<T>} - An instance of ISubscribe with the generic type T.
+ */
 export type IOnce<T> = {
     setOnce(): ISubscribe<T>;
 };
+/**
+ * Represents an interface that ensures an ordered item can be set only once.
+ *
+ * @template T - The type of item to be handled by the implementation.
+ */
 export type IOrderedOnce<T> = {
     setOnce(): IOrderedSubscribe<T>;
 };
+/**
+ * Interface representing an observable value that can be updated by emitting a new value.
+ *
+ * ISetObservableValue provides a `next` method that allows sending new values to be observed by subscribers.
+ */
 export type ISetObservableValue = {
     next(value: any): void;
 };
+/**
+ * Represents a subscription-like object which provides a mechanism to release resources or
+ * cancelable operations when they are no longer needed.
+ *
+ * This type defines a structure that requires an `unsubscribe` method, allowing consumers
+ * to implement custom behavior or cleanup logic when the subscription is no longer active.
+ */
 export type ISubscriptionLike = {
     unsubscribe(): void;
 };
+/**
+ * Represents a composite interface that combines multiple functionalities for handling events, transformations, and subscriptions in a generic way.
+ *
+ * @template T The type of the data or events processed by the setup.
+ * @typedef {object} ISetup<T>
+ * @property {IUnsubscribeByPositive<T>} Implements unsubscribe functionality based on positive filters or criteria.
+ * @property {IEmitByPositive<T>} Implements emission functionality for events based on positive conditions.
+ * @property {IOnce<T>} Provides mechanisms for handling one-time subscriptions.
+ * @property {ISwitch<T>} Interface for enabling switch-like behavior for managing state or event streams.
+ * @property {ITransform<T>} Allows for the transformation of data or events before they are processed or re-emitted.
+ * @property {ISerialisation} Includes methods for serializing and deserializing data structures.
+ * @property {ISubscribe<T>} Implements standard subscription management functionalities.
+ */
 export type ISetup<T> = IUnsubscribeByPositive<T> & IEmitByPositive<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISerialisation & ISubscribe<T>;
+/**
+ * Represents an ordered setup configuration that combines multiple ordered operations
+ * related to subscribing, emitting, transforming, serializing, and other functionalities.
+ * This type extends various ordered operation interfaces to provide a comprehensive
+ * structure for managing ordered processing of type T data.
+ *
+ * It includes the following features:
+ * - Unsubscription handling in an ordered manner.
+ * - Event emission management with positive ordering.
+ * - One-time execution of operations.
+ * - Switching between different ordered setups.
+ * - Transformation of data in an ordered way.
+ * - Serialization and deserialization capabilities.
+ * - Subscription management adhering to order.
+ *
+ * @template T The type of the data to be handled by the ordered setup.
+ */
 export type IOrderedSetup<T> = IOrderedUnsubscribeByPositive<T> & IOrderedEmitByPositive<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSerialisation & IOrderedSubscribe<T>;
+/**
+ * Represents a composite type that combines several interfaces to define
+ * the behavior and properties of a subscription object with extended
+ * features.
+ *
+ * @template T The type of data being interacted with in the subscription object.
+ *
+ * @extends ISubscriptionLike Represents the basic structure for subscription-like objects.
+ * @extends IPause Provides the ability to pause and resume functionality.
+ * @extends IOrder Adds capabilities for managing ordered processing or priority.
+ * @extends ISend<T> Includes sending data functionality with type T.
+ * @extends ISetup<T> Incorporates setup or initialization procedures with type T.
+ */
 export type ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
+/**
+ * Represents a counter interface for subscriptions.
+ * An ISubscribeCounter instance provides methods to query the size
+ * of the collection or group being managed.
+ */
 export type ISubscribeCounter = {
     size(): number;
 };
+/**
+ * Interface representing a subscriber that can hold a value and has a subscription mechanism.
+ * Combines the functionalities of value retrieval and subscription handling.
+ *
+ * @template T - The type of the value that the subscriber holds.
+ *
+ * @property {boolean} isEnable - Indicates whether the subscriber is currently enabled.
+ *
+ * @method getValue
+ * Retrieves the current value held by the subscriber.
+ * @returns {T | undefined} The current value of type T if available, or undefined if not set.
+ *
+ * @extends ISubscribe
+ */
 export type ISubscriber<T> = {
     getValue(): T | undefined;
     isEnable: boolean;
 } & ISubscribe<T>;
+/**
+ * An interface representing an Observer with extended functionalities for managing subscriptions,
+ * controlling observability, and interacting with subscriber-related behavior.
+ *
+ * @template T - The type of the observed value.
+ *
+ * @extends ISetObservableValue
+ * @extends ISubscriber<T>
+ * @extends IDestroy
+ * @extends ISubscribeCounter
+ * @extends IObservablePipe<T>
+ *
+ * @property {function(ISubscriptionLike): void} unSubscribe - Removes a specific subscriber from the observer.
+ * @property {function(): void} unsubscribeAll - Removes all subscribers from the observer.
+ * @property {function(): void} disable - Temporarily disables the observer, preventing it from notifying subscribers.
+ * @property {function(): void} enable - Re-enables the observer, allowing it to notify subscribers.
+ */
 export type IObserver<T> = ISetObservableValue & ISubscriber<T> & IDestroy & ISubscribeCounter & IObservablePipe<T> & {
     unSubscribe(subscriber: ISubscriptionLike): void;
     unsubscribeAll(): void;
     disable(): void;
     enable(): void;
 };
+/**
+ * Represents a generic stream interface for processing arrays of type T.
+ *
+ * This interface defines a method to input and handle data streams.
+ *
+ * @template T The type of the data elements to be streamed.
+ * @typedef {Object} IStream
+ * @property {(value: T[]) => void} stream A method to handle an array of elements of type T.
+ */
 export type IStream<T> = {
     stream(value: T[]): void;
 };
+/**
+ * Represents an interface for pausing and resuming operations.
+ *
+ * The IPause interface provides methods to pause and resume a process or operation.
+ * It can be used as a structure for implementing functionality where halting and continuing an activity is required.
+ *
+ * Method Summary:
+ * - `pause`: Invokes a pause in the operation.
+ * - `resume`: Resumes the operation from a paused state.
+ */
 export type IPause = {
     pause(): void;
     resume(): void;
 };
+/**
+ * Represents an observable pipe, which provides a mechanism to transform or manipulate a stream of data.
+ *
+ * This type defines the structure for an object with a `pipe` method. The `pipe` method is intended
+ * to configure or sequence certain operations on data of type `T` and return an optional setup structure.
+ *
+ * @template T - The type of data the observable pipe operates on.
+ * @property {Function} pipe - A method that executes the defined setup or transformation process.
+ *                              Returns an `ISetup<T>` instance or `undefined` if no setup is performed.
+ */
 export type IObservablePipe<T> = {
     pipe(): ISetup<T> | undefined;
 };
+/**
+ * Represents an interface for an ordered observable pipe.
+ *
+ * @template T - The type of the value being processed through the pipe.
+ *
+ * @property {Function} pipe - A method that processes the observable stream and returns a setup.
+ *                             The setup may be undefined if no valid output is generated.
+ * @returns {ISetup<T> | undefined} - Returns an instance of ISetup of type T if the processing succeeds,
+ *                                     otherwise undefined.
+ */
 export type IOrderedObservablePipe<T> = {
     pipe(): ISetup<T> | undefined;
 };
+/**
+ * Interface ISend represents a contract for sending a value of a generic type.
+ *
+ * This interface declares a single method, `send`, which is responsible
+ * for handling the transmission or processing of the provided value.
+ *
+ * @template T - The type of the value that can be sent using this interface.
+ */
 export type ISend<T> = {
     send(value: T): void;
 };
+/**
+ * Represents an interface that provides a method for unsubscribing actions based on a
+ * specified negative condition defined by a callback function.
+ *
+ * @template T - The type parameter that the interface will operate with.
+ *
+ * @property unsubscribeByNegative - A method to unsubscribe based on the evaluation
+ *                                    of a condition provided through a callback.
+ *
+ * @param condition - A callback function that determines the criteria for unsubscribing.
+ *                    The callback may evaluate a condition on the type `T`.
+ * @returns An object of type `ISetup<T>` which represents the setup or state after
+ *          the unsubscribe operation.
+ */
 export type IUnsubscribeByNegative<T> = {
     unsubscribeByNegative(condition: ICallback<T>): ISetup<T>;
 };
+/**
+ * Represents an interface that provides a mechanism to unsubscribe using a negative condition.
+ *
+ * @template T The type of data handled by the callback function.
+ *
+ * @typedef {Object} IOrderedUnsubscribeByNegative
+ * @property {function(condition: ICallback<T>): IOrderedSetup<T>} unsubscribeByNegative
+ *           A method that allows unsubscribing based on a provided negative condition.
+ *           The condition is determined through the given callback function.
+ */
 export type IOrderedUnsubscribeByNegative<T> = {
     unsubscribeByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
+/**
+ * Represents a generic type that allows for unsubscribing based on a given condition.
+ *
+ * This type is designed to provide an interface for managing subscriptions
+ * that can be terminated by evaluating a condition specified by the user.
+ *
+ * @template T - The type of the value being processed or observed in the context
+ * of the unsubscribe operation.
+ *
+ * @property {function} unsubscribeBy - A method to unsubscribe based on a specified condition.
+ * This condition is defined as a callback function that determines whether the unsubscribe action
+ * should be performed.
+ *
+ * @param {ICallback<T>} condition - A callback function that evaluates the condition for unsubscribing.
+ * The callback should return a value indicating whether the specified condition has been met.
+ *
+ * @returns {ISetup<T>} - Returns an instance of ISetup to allow further configuration or management
+ * following the unsubscribe operation.
+ */
 export type IUnsubscribeByPositive<T> = {
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
 };
+/**
+ * Represents an interface for managing ordered unsubscription using a provided condition.
+ *
+ * @template T - The type parameter representing the data model or entity being handled.
+ *
+ * @typedef {Object} IOrderedUnsubscribeByPositive
+ * @property {(condition: ICallback<T>) => ISetup<T>} unsubscribeBy - Method to unsubscribe items based on a specific condition.
+ *   Accepts a callback function that determines the criteria for unsubscription and returns the setup object associated with the operation.
+ */
 export type IOrderedUnsubscribeByPositive<T> = {
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
 };
+/**
+ * Represents a type for an object that allows emitting events based on a negative condition.
+ *
+ * @template T The type of the value that will be passed to the callback and setup methods.
+ *
+ * @property {function(condition: ICallback<T>): ISetup<T>} emitByNegative - A method that triggers a setup process
+ *                                                                          if a specified condition evaluates to a negative result.
+ */
 export type IEmitByNegative<T> = {
     emitByNegative(condition: ICallback<T>): ISetup<T>;
 };
+/**
+ * Represents an interface for handling ordered emissions based on a negative condition.
+ *
+ * @template T - The type of the value being processed.
+ *
+ * @typedef {Object} IOrderedEmitByNegative
+ *
+ * @property {function(condition: ICallback<T>): IOrderedSetup<T>} emitByNegative -
+ * A method that determines ordered emissions of elements based on a provided
+ * condition that evaluates to a negative criteria.
+ *
+ * @callback ICallback<T>
+ * A callback function used to define the negative condition for emission.
+ *
+ * @returns {IOrderedSetup<T>}
+ * Returns an instance of IOrderedSetup<T>, facilitating further configuration
+ * of the ordered emission process based on the negative condition.
+ */
 export type IOrderedEmitByNegative<T> = {
     emitByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
+/**
+ * Represents a type that facilitates the refinement of conditions or rules and manages setting up these refinements.
+ *
+ * @template T - The type of data or element that the methods operate on.
+ *
+ * @typedef {Object} IEmitByPositive
+ *
+ * @property {function(condition: ICallback<T>): ISetup<T>} refine - Refines a specific condition by taking an input callback and setting it up.
+ * @property {function(conditions: ICallback<T>[]): ISetup<T>} pushRefiners - Pushes an array of callback conditions to further refine the setup process.
+ */
 export type IEmitByPositive<T> = {
     refine(condition: ICallback<T>): ISetup<T>;
     pushRefiners(conditions: ICallback<T>[]): ISetup<T>;
 };
+/**
+ * Represents a transformation interface that defines a chainable method to apply transformations to a value
+ * using a provided callback function and returning a setup structure for further transformations.
+ *
+ * @template T - The type of the input value that the transformation operates on.
+ *
+ * @typedef {Object} ITransform
+ *
+ * @property {function} then - Method that takes a callback function and returns a setup structure for further transformations.
+ * @param {ICallback<T>} condition - The transformation logic applied to the input.
+ * @returns {ISetup<K>} A setup structure for additional transformations.
+ */
 export type ITransform<T> = {
     then<K>(condition: ICallback<T>): ISetup<K>;
 };
+/**
+ * ISerialisation interface defines the structure for objects responsible for
+ * handling the serialization and deserialization of data.
+ *
+ * This interface provides methods to serialize data into a specific format
+ * and to deserialize data back into a desired type.
+ *
+ * The generic method `deserialize` allows flexibility in defining the type
+ * of data to be returned upon deserialization.
+ */
 export type ISerialisation = {
     serialize(): ISetup<string>;
     deserialize<K>(): ISetup<K>;
 };
+/**
+ * A type that represents an ordered operation which processes and refines
+ * elements for a positive outcome. This is achieved through the use of
+ * conditional callbacks and the ability to chain multiple refinement conditions.
+ *
+ * @template T - The type of the element being processed.
+ *
+ * @property {Function} refine - Refines the current state based on a provided condition.
+ * This function accepts a single callback condition which determines the refinement logic
+ * and returns an updated setup instance.
+ *
+ * @property {Function} pushRefiners - Allows the addition of multiple refinement conditions
+ * to the current state. Accepts an array of callback conditions and returns an updated setup instance.
+ */
 export type IOrderedEmitByPositive<T> = {
     refine(condition: ICallback<any>): ISetup<T>;
     pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
 };
+/**
+ * Represents an interface for an ordered transformation sequence applied to a data type `T`.
+ *
+ * @template T - The type of the data to be transformed.
+ */
 export type IOrderedTransform<T> = {
     then<K>(condition: ICallback<T>): ISetup<K>;
 };
+/**
+ * Represents an interface for ordered serialization and deserialization operations.
+ * Useful for implementing structured serialization mechanisms that maintain a specific order.
+ *
+ * @interface
+ * @typedef {Object} IOrderedSerialisation
+ *
+ * @property {function(): ISetup<string>} serialize - Serializes an object or value into a string in a structured and ordered format.
+ * @property {function(): ISetup<K>} deserialize - Deserializes a structured and ordered string back into an object or value of type `K`.
+ */
 export type IOrderedSerialisation = {
     serialize(): ISetup<string>;
     deserialize<K>(): ISetup<K>;
 };
+/**
+ * Defines a structure for an object that provides a mechanism to emit a match based on a given condition.
+ *
+ * @template T The type parameter representing the expected return type of the setup process.
+ */
 export type IEmitMatchCondition<T> = {
     emitMatch(condition: ICallback<any>): ISetup<T>;
 };
+/**
+ * Represents a condition for emitting a match in a specific order.
+ * The match condition is defined by the provided callback and
+ * can be used to set up ordered operations.
+ *
+ * @template T - The type of data associated with the ordered setup.
+ *
+ * @property {function(condition: ICallback<any>): IOrderedSetup<T>} emitMatch
+ * - A method to define a condition for emitting a match. It accepts a callback and returns an ordered setup configuration.
+ */
 export type IOrderedEmitMatchCondition<T> = {
     emitMatch(condition: ICallback<any>): IOrderedSetup<T>;
 };
+/**
+ * ICollector is an interface that combines IDestroy and ISubscribeCounter interfaces,
+ * providing additional functionality for managing subscriptions.
+ * This interface allows for collecting, unsubscribing, and batch unsubscription of subscription-like objects.
+ *
+ * The primary purpose of ICollector is to manage subscription lifecycles efficiently and ensure
+ * that subscriptions are correctly unsubscribed when no longer needed.
+ *
+ * Methods:
+ * - collect(...subscriptionLikeList): Adds one or more subscription-like objects to be managed by the collector.
+ * - unsubscribe(subscriptionLike): Unsubscribes a single subscription-like object that the collector is managing.
+ * - unsubscribeAll(): Unsubscribes all subscription-like objects managed by the collector.
+ */
 export type ICollector = IDestroy & ISubscribeCounter & {
     collect(...subscriptionLikeList: ISubscriptionLike[]): void;
     unsubscribe(subscriptionLike: ISubscriptionLike): void;
     unsubscribeAll(): void;
 };
+/**
+ * IOrderedObservable is a type definition that represents an object with the ability
+ * to determine whether elements are sorted in a specific order.
+ *
+ * This type contains a single method, `sortByOrder`, which is used to perform a determination
+ * or operation associated with the ordering of elements.
+ *
+ * @typedef {Object} IOrderedObservable
+ * @property {Function} sortByOrder - A method that checks or enforces the ordering of elements.
+ * Returns a boolean representing whether the ordering is correct or applicable.
+ */
 export type IOrderedObservable = {
     sortByOrder(): boolean;
 };
+/**
+ * Represents a type that combines the behavior of an observer, an ordered observable, and an ordered observable pipe.
+ * This interface is generic and accepts a type parameter `T`, which specifies the data type it operates on.
+ *
+ * The `IOrdered` interface is composed of:
+ * - `IObserver<T>`: Handles observation logic for receiving values of type `T`.
+ * - `IOrderedObservable`: Encapsulates logic for ordered observables.
+ * - `IOrderedObservablePipe<T>`: Defines transformation and handling of ordered observable data of type `T`.
+ *
+ * Use this interface when working with structures that need ordered observation and transformation capabilities.
+ */
 export type IOrdered<T> = IObserver<T> & IOrderedObservable & IOrderedObservablePipe<T>;
+/**
+ * A type that combines the features of `ISubscriptionLike` and `IOrder`.
+ * Represents a subscription-like object that also implements ordering properties or methods.
+ *
+ * This type is typically used in scenarios where an object needs to maintain
+ * subscription behavior alongside ordered data or operations.
+ *
+ * It inherits all the characteristics and requirements of both `ISubscriptionLike` and `IOrder`.
+ */
 export type IOrderedSubscriptionLike = (ISubscriptionLike & IOrder);
+/**
+ * Represents an interface for an ordered subscription mechanism.
+ *
+ * @template T The type of data that the subscription will handle.
+ *
+ * @typedef {Object} IOrderedSubscribe
+ * @property {function(IListener<T>, IErrorCallback=): IOrderedSubscriptionLike} subscribe
+ *  Subscribes to the updates with a listener callback and an optional error handler.
+ *  Returns a subscription-like object for managing the subscription.
+ *
+ * @callback IListener
+ *  Defines a listener callback function that is notified with updates of type T.
+ *
+ * @callback IErrorCallback
+ *  Defines an optional error handler that is called whenever an error occurs in the subscription mechanism.
+ *
+ * @typedef {Object} IOrderedSubscriptionLike
+ *  Represents an object that provides methods to manage the lifecycle of the subscription.
+ */
 export type IOrderedSubscribe<T> = {
     subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
 };
+/**
+ * Represents a container for a chain of elements.
+ *
+ * This interface defines a structure that holds an array of elements.
+ * It is used to manage and interact with a sequential chain of items.
+ *
+ * Properties:
+ * - chain: An array representing the chain, where each element can be of any type.
+ */
 export type IChainContainer = {
     chain: any[];
 };
+/**
+ * Represents the payload structure used within a pipe system.
+ *
+ * This type defines the fields necessary for managing the flow and control
+ * within a pipe operation, including breaking, unsubscribing, availability
+ * status, and the actual payload to be processed or transmitted.
+ *
+ * Properties:
+ * - isBreak: A boolean indicating if the pipe operation should terminate.
+ * - isUnsubscribe: A boolean indicating if the operation should include an unsubscribing action.
+ * - isAvailable: A boolean specifying whether the payload is available for processing.
+ * - payload: A flexible property designed to hold any data intended to be carried through the pipe.
+ */
 export type IPipePayload = {
     isBreak: boolean;
     isUnsubscribe: boolean;
     isAvailable: boolean;
     payload: any;
 };
+/**
+ * Represents a callback function interface for handling chain-related operations.
+ * This function is typically invoked with a payload to perform specific operations
+ * in a chain or pipeline.
+ *
+ * @callback IChainCallback
+ * @param {IPipePayload} data - The payload passed to the callback function
+ *                              containing the necessary data for processing.
+ */
 export type IChainCallback = (data: IPipePayload) => void;
+/**
+ * Represents a pipeline case that extends the functionality of subscribing
+ * to a stream of data with additional case-checking operations.
+ *
+ * @template T - The type of data being processed in the pipeline.
+ * @extends ISubscribe<T>
+ */
 export type IPipeCase<T> = ISubscribe<T> & {
     case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
     pushCases(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
 };
+/**
+ * Represents a combined subscriber that can either be a listener or a setter for observable values.
+ *
+ * This type is a union of `IListener<T>` and `ISetObservableValue`, providing flexibility to handle subscriptions
+ * with different behaviors. It allows implementing components to react to changes in data or directly set observable values.
+ *
+ * @template T - The type of the value to be handled by the subscriber.
+ */
 export type ICombinedSubscriber<T> = IListener<T> | ISetObservableValue;
+/**
+ * Represents a type definition for a group of subscriptions.
+ *
+ * This type can be either a single `ICombinedSubscriber` instance or an array of `ICombinedSubscriber` instances.
+ *
+ * @template T The type of data that the subscriber(s) will handle.
+ */
 export type ISubscribeGroup<T> = ICombinedSubscriber<T> | ICombinedSubscriber<T>[];
+/**
+ * Represents an interface for adding a filter to a specific setup or configuration.
+ *
+ * @template T - The type that the filter setup operates on.
+ */
 export type IAddFilter<T> = {
     addFilter(): IFilterSetup<T>;
 };
+/**
+ * Represents a setup for filtering that combines the functionality of IFilter and IFilterSwitch interfaces.
+ * This type is parameterized with a generic type T, which determines the type of data it operates on.
+ *
+ * It encompasses the capabilities provided by the IFilter and IFilterSwitch types, allowing for more
+ * robust and flexible filter setups. This is particularly useful in scenarios where both filtering
+ * logic and the ability to switch between filter states are required.
+ *
+ * @template T The type of the items to be filtered by the setup.
+ */
 export type IFilterSetup<T> = IFilter<T> & IFilterSwitch<T>;
+/**
+ * Represents a generic filtering interface that applies conditions to a data set.
+ *
+ * @template T The type of data this filter will operate on.
+ *
+ * @typedef {Object} IFilter
+ *
+ * @property {function(condition: ICallback<any>): IFilterSetup<T>} filter
+ * Applies a single filtering condition to the data set.
+ *
+ * @property {function(conditions: ICallback<any>[]): IFilterSetup<T>} pushFilters
+ * Applies multiple filtering conditions to the data set in bulk.
+ */
 export type IFilter<T> = {
     filter(condition: ICallback<any>): IFilterSetup<T>;
     pushFilters(conditions: ICallback<any>[]): IFilterSetup<T>;
 };
+/**
+ * Interface representing a filter switch mechanism.
+ *
+ * This interface defines a method for managing cases within a filter switch
+ * process, allowing the user to determine a specific behavior based on a given
+ * context or condition mapped to the type parameter `T`.
+ *
+ * @template T Type of the context or condition used by the filter switch.
+ */
 export type IFilterSwitch<T> = {
     switch(): FilterSwitchCase<T>;
 };
+/**
+ * Represents a filtering construct that allows chaining of conditional cases.
+ * Utilized to sequentially apply multiple conditions for filtering items.
+ *
+ * @template T - The type of the elements to be filtered.
+ */
 export type IFilterCase<T> = {
     case(condition: ICallback<any>): IFilterCase<T>;
     pushCases(conditions: ICallback<any>[]): IFilterCase<T>;
 };
+/**
+ * Represents the structure of a filter payload that includes the state of a break, availability, and additional payload.
+ *
+ * @typedef {Object} IFilterPayload
+ * @property {boolean} isBreak Indicates whether the current state represents a break.
+ * @property {boolean} isAvailable Indicates whether the current state is available.
+ * @property {any} payload Holds additional data associated with the filter payload.
+ */
 export type IFilterPayload = {
     isBreak: boolean;
     isAvailable: boolean;
     payload: any;
 };
+/**
+ * Represents a callback function that is invoked during a filter chain operation.
+ *
+ * The IFilterChainCallback is intended to process or manipulate the provided
+ * filter payload and perform necessary actions as part of the filter chain execution.
+ *
+ * The callback function receives a single argument, which is the filter payload data,
+ * allowing it to perform operations relevant to the filtering process.
+ *
+ * @callback IFilterChainCallback
+ * @param {IFilterPayload} data - The payload data to be processed by the callback during the filter chain execution.
+ */
 export type IFilterChainCallback = (data: IFilterPayload) => void;
+/**
+ * Represents the response format for a filtering operation.
+ *
+ * This type defines the standard structure for the response data when
+ * performing a filter operation. It indicates the success status and
+ * contains the corresponding payload of data.
+ *
+ * Properties:
+ * - `isOK`: A boolean indicating whether the filtering operation was successful.
+ * - `payload`: The data retrieved or processed during the filtering operation;
+ *   this can be of any type.
+ */
 export type IFilterResponse = {
     isOK: boolean;
     payload: any;