@blac/core 2.0.0-rc-13 → 2.0.0-rc-16

package/dist/index.d.ts

@@ -1,1078 +0,0 @@
-import { BlacPlugin as BlacPlugin_2 } from '../core/types';
-import { BlocPlugin as BlocPlugin_2 } from '../core/types';
-import { ErrorContext as ErrorContext_2 } from '../core/types';
-import { PluginMetrics as PluginMetrics_2 } from '../core/types';
-import { PluginRegistry as PluginRegistry_2 } from '../core/types';
-
-export declare interface AdapterOptions<B extends BlocBase<any>> {
-    id?: string;
-    dependencies?: (bloc: B) => unknown[];
-    props?: any;
-    onMount?: (bloc: B) => void;
-    onUnmount?: (bloc: B) => void;
-}
-
-/**
- * Main Blac class that manages the state management system.
- * Can work with singleton pattern or dependency injection.
- * Handles bloc lifecycle, and instance tracking.
- *
- * Key responsibilities:
- * - Managing bloc instances (creation, disposal, lookup)
- * - Handling isolated and non-isolated blocs
- * - Providing logging and debugging capabilities
- */
-export declare class Blac {
-    static get instance(): Blac;
-    /** Timestamp when the instance was created */
-    createdAt: number;
-    static get getAllBlocs(): <B extends BlocConstructor<any>>(blocClass: B, options?: {
-        searchIsolated?: boolean;
-    }) => InstanceType<B>[];
-    /** Private static configuration */
-    private static _config;
-    /** Get current configuration */
-    static get config(): Readonly<BlacConfig>;
-    /**
-     * Set or update Blac configuration
-     * @param config - Partial configuration to merge with existing config
-     * @throws Error if configuration is invalid
-     */
-    static setConfig(config: Partial<BlacConfig>): void;
-    /** Map storing all registered bloc instances by their class name and ID */
-    blocInstanceMap: Map<string, BlocBase<unknown>>;
-    /** Map storing isolated bloc instances grouped by their constructor */
-    isolatedBlocMap: Map<BlocConstructor<any>, BlocBase<unknown>[]>;
-    /** Map for O(1) lookup of isolated blocs by UID */
-    isolatedBlocIndex: Map<string, BlocBase<unknown>>;
-    /** Map tracking UIDs to prevent memory leaks */
-    uidRegistry: Map<string, BlocBase<unknown>>;
-    /** Set of keep-alive blocs for controlled cleanup */
-    keepAliveBlocs: Set<BlocBase<unknown>>;
-    /** Flag to control whether changes should be posted to document */
-    postChangesToDocument: boolean;
-    /** System plugin registry */
-    readonly plugins: SystemPluginRegistry;
-    /**
-     * Creates a new Blac instance.
-     * @param options - Configuration options including singleton control
-     */
-    constructor(options?: {
-        __unsafe_ignore_singleton?: boolean;
-    });
-    /** Flag to enable/disable logging */
-    static enableLog: boolean;
-    static logLevel: 'warn' | 'log';
-    static logSpy: ((...args: unknown[]) => void) | null;
-    /**
-     * Logs messages to console when logging is enabled
-     * @param args - Arguments to log
-     */
-    log: (...args: unknown[]) => void;
-    static get log(): (...args: unknown[]) => void;
-    /**
-     * Gets the current Blac instance
-     * @returns The Blac instance
-     */
-    static getInstance(): Blac;
-    /**
-     * Logs a warning message
-     * @param message - Warning message
-     * @param args - Additional arguments
-     */
-    warn: (message: string, ...args: unknown[]) => void;
-    static get warn(): (message: string, ...args: unknown[]) => void;
-    /**
-     * Logs an error message
-     * @param message - Error message
-     * @param args - Additional arguments
-     */
-    error: (message: string, ...args: unknown[]) => void;
-    static get error(): (message: string, ...args: unknown[]) => void;
-    /**
-     * Resets the Blac instance to a new one, disposing non-keepAlive blocs
-     * from the old instance.
-     */
-    resetInstance: () => void;
-    static resetInstance: () => void;
-    /**
-     * Disposes of a bloc instance by removing it from the appropriate registry
-     * @param bloc - The bloc instance to dispose
-     */
-    disposeBloc: (bloc: BlocBase<unknown>) => void;
-    static get disposeBloc(): (bloc: BlocBase<unknown>) => void;
-    /**
-     * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
-     * @param blocClassName - The name of the bloc class
-     * @param id - The instance ID
-     * @returns A unique key string in the format "className:id"
-     */
-    createBlocInstanceMapKey(blocClassName: string, id: BlocInstanceId): string;
-    /**
-     * Unregister a bloc instance from the main registry
-     * @param bloc - The bloc instance to unregister
-     */
-    unregisterBlocInstance(bloc: BlocBase<unknown>): void;
-    /**
-     * Registers a bloc instance in the main registry
-     * @param bloc - The bloc instance to register
-     */
-    registerBlocInstance(bloc: BlocBase<unknown>): void;
-    /**
-     * Finds a registered bloc instance by its class and ID
-     * @param blocClass - The bloc class to search for
-     * @param id - The instance ID
-     * @returns The found bloc instance or undefined if not found
-     */
-    findRegisteredBlocInstance<B extends BlocConstructor<any>>(blocClass: B, id: BlocInstanceId): InstanceType<B> | undefined;
-    /**
-     * Registers an isolated bloc instance in the isolated registry
-     * @param bloc - The isolated bloc instance to register
-     */
-    registerIsolatedBlocInstance(bloc: BlocBase<unknown>): void;
-    /**
-     * Unregister an isolated bloc instance from the isolated registry
-     * @param bloc - The isolated bloc instance to unregister
-     */
-    unregisterIsolatedBlocInstance(bloc: BlocBase<unknown>): void;
-    /**
-     * Finds an isolated bloc instance by its class and ID (O(n) lookup)
-     */
-    findIsolatedBlocInstance<B extends BlocConstructor<any>>(blocClass: B, id: BlocInstanceId): InstanceType<B> | undefined;
-    /**
-     * Finds an isolated bloc instance by UID (O(1) lookup)
-     */
-    findIsolatedBlocInstanceByUid<B extends BlocBase<unknown>>(uid: string): B | undefined;
-    /**
-     * Creates a new bloc instance and registers it in the appropriate registry
-     * @param blocClass - The bloc class to instantiate
-     * @param id - The instance ID
-     * @param props - Properties to pass to the bloc constructor
-     * @param instanceRef - Optional reference string for the instance
-     * @returns The newly created bloc instance
-     */
-    createNewBlocInstance<B extends BlocConstructor<BlocBase<any>>>(blocClass: B, id: BlocInstanceId, options?: GetBlocOptions<InstanceType<B>>): InstanceType<B>;
-    activateBloc: (bloc: BlocBase<unknown>) => void;
-    static get activateBloc(): (bloc: BlocBase<unknown>) => void;
-    /**
-     * Gets or creates a bloc instance based on the provided class and options.
-     * If a bloc with the given ID exists, it will be returned. Otherwise, a new instance will be created.
-     *
-     * @param blocClass - The bloc class to get or create
-     * @param options - Options including:
-     *   - id: The instance ID (defaults to class name if not provided)
-     *   - props: Properties to pass to the bloc constructor
-     *   - instanceRef: Optional reference string for the instance
-     * @returns The bloc instance
-     */
-    getBloc: <B extends BlocConstructor<BlocBase<any>>>(blocClass: B, options?: GetBlocOptions<InstanceType<B>>) => InstanceType<B>;
-    static get getBloc(): <B extends BlocConstructor<BlocBase<any>>>(blocClass: B, options?: GetBlocOptions<InstanceType<B>>) => InstanceType<B>;
-    /**
-     * Gets a bloc instance or throws an error if it doesn't exist
-     * @param blocClass - The bloc class to get
-     * @param options - Options including:
-     *   - id: The instance ID (defaults to class name if not provided)
-     *   - props: Properties to pass to the bloc constructor
-     *   - instanceRef: Optional reference string for the instance
-     */
-    getBlocOrThrow: <B extends BlocConstructor<any>>(blocClass: B, options?: {
-        id?: BlocInstanceId;
-        props?: InferPropsFromGeneric<B>;
-        instanceRef?: string;
-    }) => InstanceType<B>;
-    static get getBlocOrThrow(): <B extends BlocConstructor<any>>(blocClass: B, options?: {
-        id?: BlocInstanceId;
-        props?: InferPropsFromGeneric<B> | undefined;
-        instanceRef?: string;
-    }) => InstanceType<B>;
-    /**
-     * Gets all instances of a specific bloc class
-     * @param blocClass - The bloc class to search for
-     * @param options - Options including:
-     *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
-     * @returns Array of matching bloc instances
-     */
-    getAllBlocs: <B extends BlocConstructor<any>>(blocClass: B, options?: {
-        searchIsolated?: boolean;
-    }) => InstanceType<B>[];
-    /**
-     * Disposes all keep-alive blocs of a specific type
-     * @param blocClass - The bloc class to dispose
-     */
-    disposeKeepAliveBlocs: <B extends BlocConstructor<any>>(blocClass?: B) => void;
-    static get disposeKeepAliveBlocs(): <B extends BlocConstructor<any>>(blocClass?: B | undefined) => void;
-    /**
-     * Disposes all blocs matching a pattern
-     * @param predicate - Function to test each bloc for disposal
-     */
-    disposeBlocs: (predicate: (bloc: BlocBase<unknown>) => boolean) => void;
-    static get disposeBlocs(): (predicate: (bloc: BlocBase<unknown>) => boolean) => void;
-    /**
-     * Gets memory usage statistics for debugging
-     */
-    getMemoryStats: () => {
-        totalBlocs: number;
-        registeredBlocs: number;
-        isolatedBlocs: number;
-        keepAliveBlocs: number;
-        isolatedBlocTypes: number;
-    };
-    static get getMemoryStats(): () => {
-        totalBlocs: number;
-        registeredBlocs: number;
-        isolatedBlocs: number;
-        keepAliveBlocs: number;
-        isolatedBlocTypes: number;
-    };
-    /**
-     * Validates consumer references and cleans up orphaned consumers
-     */
-    validateConsumers: () => void;
-    static get validateConsumers(): () => void;
-    /**
-     * Bootstrap the Blac instance and all plugins
-     */
-    bootstrap(): void;
-    /**
-     * Shutdown the Blac instance and all plugins
-     */
-    shutdown(): void;
-}
-
-/**
- * BlacAdapter orchestrates the connection between Bloc instances and React components.
- * It manages dependency tracking, lifecycle hooks, and proxy creation.
- */
-export declare class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
-    readonly id: string;
-    readonly blocConstructor: B;
-    readonly componentRef: {
-        current: object;
-    };
-    blocInstance: InstanceType<B>;
-    private consumerTracker;
-    private static propsOwners;
-    private lastProps?;
-    unmountTime: number;
-    mountTime: number;
-    private dependencyValues?;
-    private isUsingDependencies;
-    private hasMounted;
-    private mountCount;
-    options?: AdapterOptions<InstanceType<B>>;
-    constructor(instanceProps: {
-        componentRef: {
-            current: object;
-        };
-        blocConstructor: B;
-    }, options?: typeof BlacAdapter.options);
-    trackAccess(consumerRef: object, type: 'state' | 'class', path: string, value?: any): void;
-    getConsumerDependencies(consumerRef: object): DependencyArray | null;
-    shouldNotifyConsumer(consumerRef: object, changedPaths: Set<string>): boolean;
-    updateLastNotified(consumerRef: object): void;
-    resetConsumerTracking(): void;
-    createStateProxy: <T extends object>(props: {
-        target: T;
-    }) => T;
-    createClassProxy: <T extends object>(props: {
-        target: T;
-    }) => T;
-    updateBlocInstance(): InstanceType<B>;
-    createSubscription: (options: {
-        onChange: () => void;
-    }) => () => void;
-    mount: () => void;
-    unmount: () => void;
-    getProxyState: (state: BlocState<InstanceType<B>>) => BlocState<InstanceType<B>>;
-    getProxyBlocInstance: () => InstanceType<B>;
-    get calledOnMount(): boolean;
-    updateProps(props: any): void;
-    private hasDependencyValuesChanged;
-}
-
-/**
- * Configuration options for the Blac instance
- */
-export declare interface BlacConfig {
-    /** Whether to expose the Blac instance globally */
-    exposeBlacInstance?: boolean;
-    /**
-     * Whether to enable proxy dependency tracking for automatic re-render optimization.
-     * When false, state changes always cause re-renders unless dependencies are manually specified.
-     * Default: true
-     */
-    proxyDependencyTracking?: boolean;
-}
-
-/**
- * Interface for Blac instance management
- */
-export declare interface BlacInstanceManager {
-    getInstance(): Blac;
-    setInstance(instance: Blac): void;
-    resetInstance(): void;
-}
-
-/**
- * A class that manages observers for a Bloc's state changes
- * @template S - The type of state being observed
- */
-export declare class BlacObservable<S = unknown> {
-    /** The Bloc instance this observable is associated with */
-    bloc: BlocBase<S>;
-    /**
-     * Creates a new BlacObservable instance
-     * @param bloc - The Bloc instance to observe
-     */
-    constructor(bloc: BlocBase<S>);
-    private _observers;
-    /**
-     * Gets the number of active observers
-     * @returns The number of observers currently subscribed
-     */
-    get size(): number;
-    /**
-     * Gets the set of all observers
-     * @returns The Set of all BlacObserver instances
-     */
-    get observers(): Set<BlacObserver<S>>;
-    /**
-     * Subscribes an observer to state changes
-     * @param observer - The observer to subscribe
-     * @returns A function that can be called to unsubscribe the observer
-     */
-    subscribe(observer: BlacObserver<S>): () => void;
-    /**
-     * Unsubscribes an observer from state changes
-     * @param observer - The observer to unsubscribe
-     */
-    unsubscribe(observer: BlacObserver<S>): void;
-    /**
-     * Notifies all observers of a state change
-     * @param newState - The new state value
-     * @param oldState - The previous state value
-     * @param action - Optional action that triggered the state change
-     */
-    notify(newState: S, oldState: S, action?: unknown): void;
-    /**
-     * Clears the observer set
-     */
-    clear(): void;
-}
-
-/**
- * Represents an observer that can subscribe to state changes in a Bloc
- * @template S - The type of state being observed
- */
-export declare type BlacObserver<S> = {
-    /** Function to be called when state changes */
-    fn: (newState: S, oldState: S, action?: unknown) => void | Promise<void>;
-    /** Optional function to determine if the observer should be notified of state changes */
-    dependencyArray?: BlocHookDependencyArrayFn<S>;
-    /** Dispose function for the observer */
-    dispose?: () => void;
-    /** Cached state values used for dependency comparison */
-    lastState?: unknown[];
-    /** Unique identifier for the observer */
-    id: string;
-};
-
-/**
- * System-wide plugin that observes all blocs
- */
-export declare interface BlacPlugin extends Plugin_2 {
-    beforeBootstrap?(): void;
-    afterBootstrap?(): void;
-    beforeShutdown?(): void;
-    afterShutdown?(): void;
-    onBlocCreated?(bloc: BlocBase<any>): void;
-    onBlocDisposed?(bloc: BlocBase<any>): void;
-    onStateChanged?(bloc: BlocBase<any>, previousState: any, currentState: any): void;
-    onEventAdded?(bloc: Bloc<any, any>, event: any): void;
-    onError?(error: Error, bloc: BlocBase<unknown>, context: ErrorContext): void;
-}
-
-export declare abstract class Bloc<S, // State type
-A extends BlocEventConstraint = BlocEventConstraint, // Base Action/Event type with proper constraints
-P = unknown> extends BlocBase<S, P> {
-    readonly eventHandlers: Map<new (...args: any[]) => A, (event: A, emit: (newState: S) => void) => void | Promise<void>>;
-    /* Excluded from this release type: _eventQueue */
-    /* Excluded from this release type: _isProcessingEvent */
-    /**
-     * Registers an event handler for a specific event type.
-     * This method is typically called in the constructor of a derived Bloc class.
-     * @param eventConstructor The constructor of the event to handle (e.g., LoadDataEvent).
-     * @param handler A function that processes the event and can emit new states.
-     *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
-     */
-    protected on<E extends A>(eventConstructor: new (...args: any[]) => E, handler: (event: E, emit: (newState: S) => void) => void | Promise<void>): void;
-    /**
-     * Dispatches an action/event to the Bloc.
-     * Events are queued and processed sequentially to prevent race conditions.
-     * @param action The action/event instance to be processed.
-     */
-    add: (action: A) => Promise<void>;
-    /* Excluded from this release type: _processEventQueue */
-    /* Excluded from this release type: _processEvent */
-}
-
-/**
- * Base class for both Blocs and Cubits that provides core state management functionality.
- * Handles state transitions, observer notifications, lifecycle management, and addon integration.
- *
- * @abstract This class should be extended, not instantiated directly
- * @template S The type of state managed by this Bloc
- * @template P The type of props that can be passed during instance creation (optional)
- */
-export declare abstract class BlocBase<S, P = unknown> {
-    uid: string;
-    /**
-     * When true, every consumer will receive its own unique instance of this Bloc.
-     * Use this when state should not be shared between components.
-     * @default false
-     */
-    static isolated: boolean;
-    get isIsolated(): boolean;
-    /**
-     * When true, the Bloc instance persists even when there are no active consumers.
-     * Useful for maintaining state between component unmount/remount cycles.
-     * @default false
-     */
-    static keepAlive: boolean;
-    get isKeepAlive(): boolean;
-    /**
-     * Defines how dependencies are selected from the state for efficient updates.
-     * When provided, observers will only be notified when selected dependencies change.
-     */
-    defaultDependencySelector: DependencySelector<S> | undefined;
-    /* Excluded from this release type: _isolated */
-    /* Excluded from this release type: _observer */
-    /**
-     * The unique identifier for this Bloc instance.
-     * Defaults to the class name, but can be customized.
-     */
-    _id: BlocInstanceId;
-    /* Excluded from this release type: _instanceRef */
-    /* Excluded from this release type: _keepAlive */
-    /**
-     * @readonly
-     * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
-     */
-    readonly _createdAt: number;
-    /* Excluded from this release type: _disposalState */
-    /* Excluded from this release type: _disposalRequestTime */
-    /* Excluded from this release type: _state */
-    /* Excluded from this release type: _oldState */
-    /**
-     * Props passed during Bloc instance creation.
-     * Can be used to configure or parameterize the Bloc's behavior.
-     */
-    props: P | null;
-    /* Excluded from this release type: _batchingLock */
-    /* Excluded from this release type: _pendingUpdates */
-    /* Excluded from this release type: _consumerRefs */
-    /**
-     * Plugin registry for this bloc instance
-     */
-    protected _plugins: BlocPluginRegistry<S, any>;
-    /* Excluded from this release type: _validateConsumers */
-    /**
-     * Creates a new BlocBase instance with the given initial state.
-     * Sets up the observer, registers with the Blac manager, and initializes addons.
-     *
-     * @param initialState The initial state value for this Bloc
-     */
-    constructor(initialState: S);
-    /**
-     * Returns the current state of the Bloc.
-     * Use this getter to access the state in a read-only manner.
-     * Returns the state even during transitional lifecycle states for React compatibility.
-     */
-    get state(): S;
-    /**
-     * Returns whether this Bloc instance has been disposed.
-     * @returns true if the bloc is in DISPOSED state
-     */
-    get isDisposed(): boolean;
-    /* Excluded from this release type: _name */
-    /* Excluded from this release type: _updateId */
-    /* Excluded from this release type: _atomicStateTransition */
-    /* Excluded from this release type: _dispose */
-    /* Excluded from this release type: onDispose */
-    /* Excluded from this release type: _consumers */
-    /* Excluded from this release type: _addConsumer */
-    /* Excluded from this release type: _removeConsumer */
-    /* Excluded from this release type: _disposalHandler */
-    /* Excluded from this release type: _setDisposalHandler */
-    /* Excluded from this release type: _scheduleDisposal */
-    lastUpdate: number;
-    /* Excluded from this release type: _batchingEnabled */
-    /* Excluded from this release type: _pushState */
-    /* Excluded from this release type: _notifyObservers */
-    /**
-     * Enables batching for multiple state updates
-     * @param batchFn Function to execute with batching enabled
-     */
-    batch: <T>(batchFn: () => T) => T;
-    /**
-     * Add a plugin to this bloc instance
-     */
-    addPlugin(plugin: BlocPlugin<S, any>): void;
-    /**
-     * Remove a plugin from this bloc instance
-     */
-    removePlugin(pluginName: string): boolean;
-    /**
-     * Get a plugin by name
-     */
-    getPlugin(pluginName: string): BlocPlugin<S, any> | undefined;
-    /**
-     * Get all plugins
-     */
-    getPlugins(): ReadonlyArray<BlocPlugin<S, any>>;
-    /* Excluded from this release type: _activatePlugins */
-}
-
-/**
- * Represents the abstract base types for Bloc and Cubit
- */
-export declare type BlocBaseAbstract = typeof Bloc<any, any, any> | typeof Cubit<any, any>;
-
-/**
- * Represents a constructor type for a Bloc that takes no parameters
- * @template B - The type of the Bloc instance
- */
-export declare type BlocClassNoParams<B> = new (args: never[]) => B;
-
-/**
- * Represents a constructor type for a Bloc that can take any parameters
- * @template B - The type of the Bloc instance
- */
-export declare type BlocConstructor<B> = (new (...args: any) => B) & {
-    isolated?: boolean;
-    keepAlive?: boolean;
-};
-
-/**
- * Extracts the constructor parameters type from a BlocBase
- * @template B - The BlocBase type to extract the constructor parameters from
- */
-export declare type BlocConstructorParameters<B extends BlocBase<any>> = BlocConstructor<B> extends new (...args: infer P) => B ? P : never;
-
-/**
- * Error boundary interface for Bloc error handling
- */
-export declare interface BlocErrorBoundary<S, A extends BlocEventConstraint> {
-    onError: (error: Error, event: A, currentState: S, bloc: {
-        name: string;
-        id: string;
-    }) => void | Promise<void>;
-    shouldRethrow?: (error: Error, event: A) => boolean;
-}
-
-/**
- * Enhanced constraint for Bloc events - must be objects with proper constructor
- */
-export declare type BlocEventConstraint = object;
-
-/**
- * Function type for determining dependencies that trigger re-renders
- * Similar to React's useEffect dependency array - if any dependency changes, a re-render is triggered
- * @template S The state type
- * @template I The bloc instance type
- * @param currentState The current state
- * @param previousState The previous state (undefined on first call)
- * @param instance The bloc instance
- * @returns Array of dependencies - if any dependency changes, a re-render is triggered
- */
-export declare type BlocHookDependencyArrayFn<S, I = any> = (currentState: S, previousState: S | undefined, instance: I) => unknown[];
-
-export declare type BlocInstanceId = string | number | undefined;
-
-/**
- * Enum representing the lifecycle states of a Bloc instance
- * Used for atomic state transitions to prevent race conditions
- */
-export declare enum BlocLifecycleState {
-    ACTIVE = "active",
-    DISPOSAL_REQUESTED = "disposal_requested",
-    DISPOSING = "disposing",
-    DISPOSED = "disposed"
-}
-
-/**
- * Bloc-specific plugin that can transform behavior
- */
-export declare interface BlocPlugin<TState = any, TEvent = never> extends Plugin_2 {
-    transformState?(previousState: TState, nextState: TState): TState;
-    transformEvent?(event: TEvent): TEvent | null;
-    onAttach?(bloc: BlocBase<TState, any>): void;
-    onDetach?(): void;
-    onStateChange?(previousState: TState, currentState: TState): void;
-    onEvent?(event: TEvent): void;
-    onError?(error: Error, context: ErrorContext): void;
-}
-
-/**
- * Registry for bloc-specific plugins
- */
-export declare class BlocPluginRegistry<TState, TEvent = never> implements PluginRegistry_2<BlocPlugin_2<TState, TEvent>> {
-    private plugins;
-    private executionOrder;
-    private attached;
-    /**
-     * Add a bloc plugin
-     */
-    add(plugin: BlocPlugin_2<TState, TEvent>): void;
-    /**
-     * Remove a bloc plugin
-     */
-    remove(pluginName: string): boolean;
-    /**
-     * Get a plugin by name
-     */
-    get(pluginName: string): BlocPlugin_2<TState, TEvent> | undefined;
-    /**
-     * Get all plugins in execution order
-     */
-    getAll(): ReadonlyArray<BlocPlugin_2<TState, TEvent>>;
-    /**
-     * Clear all plugins
-     */
-    clear(): void;
-    /**
-     * Attach all plugins to a bloc
-     */
-    attach(bloc: any): void;
-    /**
-     * Transform state through all plugins
-     */
-    transformState(previousState: TState, nextState: TState): TState;
-    /**
-     * Transform event through all plugins
-     */
-    transformEvent(event: TEvent): TEvent | null;
-    /**
-     * Notify plugins of state change
-     */
-    notifyStateChange(previousState: TState, currentState: TState): void;
-    /**
-     * Notify plugins of event
-     */
-    notifyEvent(event: TEvent): void;
-    /**
-     * Notify plugins of error
-     */
-    notifyError(error: Error, context: ErrorContext_2): void;
-    private validateCapabilities;
-    private canReadState;
-    private canTransformState;
-    private canInterceptEvents;
-}
-
-/**
- * Extracts the state type from either a Bloc or Cubit
- * @template T - The Bloc or Cubit type to extract the state from
- */
-export declare type BlocState<T> = T extends BlocBase<infer S> ? S : never;
-
-/**
- * Test utilities for Blac state management
- */
-export declare class BlocTest {
-    private static originalInstance;
-    /**
-     * Sets up a clean test environment
-     */
-    static setUp(): void;
-    /**
-     * Tears down the test environment and restores original state
-     */
-    static tearDown(): void;
-    /**
-     * Creates a test bloc with automatic cleanup
-     */
-    static createBloc<T extends BlocBase<any>>(BlocClass: new (...args: any[]) => T, ...args: any[]): T;
-    /**
-     * Waits for a bloc to emit a specific state
-     */
-    static waitForState<T extends BlocBase<S>, S>(bloc: T, predicate: (state: S) => boolean, timeout?: number): Promise<S>;
-    /**
-     * Expects a bloc to emit specific states in order
-     */
-    static expectStates<T extends BlocBase<S>, S>(bloc: T, expectedStates: S[], timeout?: number): Promise<void>;
-}
-
-export declare interface ConsumerInfo {
-    id: string;
-    lastNotified: number;
-    hasRendered: boolean;
-    stateAccesses: Set<string>;
-    classAccesses: Set<string>;
-    stateValues: Map<string, TrackedValue>;
-    classValues: Map<string, TrackedValue>;
-    accessCount: number;
-    lastAccessTime: number;
-    firstAccessTime: number;
-}
-
-/**
- * ConsumerTracker manages both consumer registration and dependency tracking.
- * It uses a WeakMap for automatic garbage collection when consumers are no longer referenced.
- */
-export declare class ConsumerTracker {
-    private consumers;
-    private registrationCount;
-    private activeConsumers;
-    register(consumerRef: object, consumerId: string): void;
-    unregister(consumerRef: object): void;
-    trackAccess(consumerRef: object, type: 'state' | 'class', path: string, value?: any): void;
-    resetTracking(consumerRef: object): void;
-    getDependencies(consumerRef: object): DependencyArray | null;
-    hasValuesChanged(consumerRef: object, newState: any, newBlocInstance: any): boolean;
-    shouldNotifyConsumer(consumerRef: object, changedPaths: Set<string>): boolean;
-    updateLastNotified(consumerRef: object): void;
-    getConsumerInfo(consumerRef: object): ConsumerInfo | undefined;
-    setHasRendered(consumerRef: object, hasRendered: boolean): void;
-    hasConsumer(consumerRef: object): boolean;
-    getStats(): {
-        totalRegistrations: number;
-        activeConsumers: number;
-    };
-    private getValueAtPath;
-}
-
-declare interface ConsumerTracker_2 {
-    trackAccess: (consumerRef: object, type: 'state' | 'class', path: string, value?: any) => void;
-}
-
-/**
- * A Cubit is a simpler version of a Bloc that doesn't handle events.
- * It manages state and provides methods to update it.
- * @template S - The type of state this Cubit manages
- * @template P - The type of parameters (optional, defaults to null)
- */
-export declare abstract class Cubit<S, P = null> extends BlocBase<S, P> {
-    /* Excluded from this release type: _updateProps */
-    /**
-     * Optional override for props handling
-     */
-    protected onPropsChanged?(oldProps: P | undefined, newProps: P): void;
-    /**
-     * Updates the current state and notifies all observers of the change.
-     * If the new state is identical to the current state (using Object.is),
-     * no update will occur.
-     * @param state - The new state to set
-     */
-    emit(state: S): void;
-    /**
-     * Partially updates the current state by merging it with the provided state patch.
-     * This method is only applicable when the state is an object type.
-     *
-     * @param statePatch - A partial state object containing only the properties to update
-     * @param ignoreChangeCheck - If true, skips checking if the state has actually changed
-     * @throws {TypeError} If the state is not an object type
-     */
-    patch(statePatch: S extends object ? Partial<S> : S, ignoreChangeCheck?: boolean): void;
-}
-
-export declare interface DependencyArray {
-    statePaths: string[];
-    classPaths: string[];
-}
-
-declare type DependencySelector<S> = (currentState: S, previousState: S | undefined, instance: any) => unknown[];
-
-/**
- * Error context provided to error handlers
- */
-export declare interface ErrorContext {
-    readonly phase: 'initialization' | 'state-change' | 'event-processing' | 'disposal';
-    readonly operation: string;
-    readonly metadata?: Record<string, unknown>;
-}
-
-/**
- * Cross-platform UUID v4 generator that works in all environments including React Native/Hermes
- * Falls back to crypto.randomUUID() when available, otherwise uses Math.random()
- */
-/**
- * Generates a UUID v4 string compatible with all JavaScript environments
- * @returns A UUID v4 string in the format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
- */
-export declare function generateUUID(): string;
-
-export declare interface GetBlocOptions<B extends BlocBase<unknown>> {
-    id?: string;
-    selector?: BlocHookDependencyArrayFn<BlocState<B>>;
-    props?: InferPropsFromGeneric<B>;
-    onMount?: (bloc: B) => void;
-    instanceRef?: string;
-    throwIfNotFound?: boolean;
-    /** Force creation of a new instance for isolated blocs, bypassing instance lookup */
-    forceNewInstance?: boolean;
-}
-
-/**
- * Extracts the props type from either a Bloc or Cubit
- * @template T - The Bloc or Cubit type to extract the props from
- */
-export declare type InferPropsFromGeneric<T> = T extends Bloc<any, any, infer P> ? P : T extends Cubit<any, infer P> ? P : never;
-
-/**
- * Memory leak detector for tests
- */
-export declare class MemoryLeakDetector {
-    private initialStats;
-    constructor();
-    /**
-     * Check for memory leaks and return a report
-     */
-    checkForLeaks(): {
-        hasLeaks: boolean;
-        report: string;
-        stats: ReturnType<typeof Blac.getMemoryStats>;
-    };
-}
-
-/**
- * Mock Bloc for testing
- */
-export declare class MockBloc<S, A extends BlocEventConstraint = BlocEventConstraint> extends Bloc<S, A> {
-    private mockHandlers;
-    constructor(initialState: S);
-    /**
-     * Mock an event handler for testing
-     */
-    mockEventHandler<E extends A>(eventConstructor: new (...args: any[]) => E, handler: (event: E, emit: (newState: S) => void) => void | Promise<void>): void;
-    /**
-     * Get the number of registered handlers
-     */
-    getHandlerCount(): number;
-    /**
-     * Check if a handler is registered for an event type
-     */
-    hasHandler(eventConstructor: new (...args: any[]) => A): boolean;
-}
-
-/**
- * Mock Cubit for testing
- */
-export declare class MockCubit<S> extends Cubit<S> {
-    private stateHistory;
-    constructor(initialState: S);
-    /**
-     * Override emit to track state history
-     */
-    emit(newState: S): void;
-    /**
-     * Get the history of all states
-     */
-    getStateHistory(): S[];
-    /**
-     * Clear state history
-     */
-    clearStateHistory(): void;
-}
-
-/**
- * Base interface for all plugins
- */
-declare interface Plugin_2 {
-    readonly name: string;
-    readonly version: string;
-    readonly capabilities?: PluginCapabilities;
-}
-export { Plugin_2 as Plugin }
-
-/**
- * Plugin capabilities for security model
- */
-export declare interface PluginCapabilities {
-    readonly readState: boolean;
-    readonly transformState: boolean;
-    readonly interceptEvents: boolean;
-    readonly persistData: boolean;
-    readonly accessMetadata: boolean;
-}
-
-/**
- * Plugin execution context for performance monitoring
- */
-export declare interface PluginExecutionContext {
-    readonly pluginName: string;
-    readonly hookName: string;
-    readonly startTime: number;
-    readonly blocName?: string;
-    readonly blocId?: string;
-}
-
-/**
- * Plugin metrics for monitoring
- */
-export declare interface PluginMetrics {
-    readonly executionTime: number;
-    readonly executionCount: number;
-    readonly errorCount: number;
-    readonly lastError?: Error;
-    readonly lastExecutionTime?: number;
-}
-
-/**
- * Plugin registry interface
- */
-export declare interface PluginRegistry<T extends Plugin_2> {
-    add(plugin: T): void;
-    remove(pluginName: string): boolean;
-    get(pluginName: string): T | undefined;
-    getAll(): ReadonlyArray<T>;
-    clear(): void;
-}
-
-export declare class PropsUpdated<P = any> {
-    readonly props: P;
-    constructor(props: P);
-}
-
-export declare class ProxyFactory {
-    static createStateProxy<T extends object>(options: {
-        target: T;
-        consumerRef: object;
-        consumerTracker: ConsumerTracker_2;
-        path?: string;
-    }): T;
-    static createClassProxy<T extends object>(options: {
-        target: T;
-        consumerRef: object;
-        consumerTracker: ConsumerTracker_2;
-    }): T;
-    static getProxyState<B extends BlocBase<any>>(options: {
-        state: BlocState<B>;
-        consumerRef: object;
-        consumerTracker: ConsumerTracker_2;
-    }): BlocState<B>;
-    static getProxyBlocInstance<B extends BlocBase<any>>(options: {
-        blocInstance: B;
-        consumerRef: object;
-        consumerTracker: ConsumerTracker_2;
-    }): B;
-    static getStats(): {
-        totalProxies: number;
-        cacheEfficiency: string;
-        lifetime: string;
-        proxiesPerSecond: string;
-        stateProxiesCreated: number;
-        classProxiesCreated: number;
-        cacheHits: number;
-        cacheMisses: number;
-        propertyAccesses: number;
-        nestedProxiesCreated: number;
-        totalProxiesCreated: number;
-        createdAt: number;
-    };
-    static resetStats(): void;
-}
-
-/**
- * Sets a custom instance manager (useful for testing or advanced patterns)
- */
-export declare function setBlacInstanceManager(manager: BlacInstanceManager): void;
-
-/**
- * Performs a shallow equality comparison between two values.
- * For objects, it checks if all top-level properties are equal using Object.is.
- * @param a First value to compare
- * @param b Second value to compare
- * @returns true if values are shallowly equal, false otherwise
- */
-export declare function shallowEqual(a: any, b: any): boolean;
-
-/**
- * Result of an atomic state transition operation
- */
-export declare interface StateTransitionResult {
-    success: boolean;
-    currentState: BlocLifecycleState;
-    previousState: BlocLifecycleState;
-}
-
-/**
- * Registry for system-wide plugins
- */
-export declare class SystemPluginRegistry implements PluginRegistry_2<BlacPlugin_2> {
-    private plugins;
-    private metrics;
-    private executionOrder;
-    /**
-     * Add a system plugin
-     */
-    add(plugin: BlacPlugin_2): void;
-    /**
-     * Remove a system plugin
-     */
-    remove(pluginName: string): boolean;
-    /**
-     * Get a plugin by name
-     */
-    get(pluginName: string): BlacPlugin_2 | undefined;
-    /**
-     * Get all plugins in execution order
-     */
-    getAll(): ReadonlyArray<BlacPlugin_2>;
-    /**
-     * Clear all plugins
-     */
-    clear(): void;
-    /**
-     * Execute a hook on all plugins
-     */
-    executeHook(hookName: keyof BlacPlugin_2, args: unknown[], errorHandler?: (error: Error, plugin: BlacPlugin_2) => void): void;
-    /**
-     * Bootstrap all plugins
-     */
-    bootstrap(): void;
-    /**
-     * Shutdown all plugins
-     */
-    shutdown(): void;
-    /**
-     * Notify plugins of bloc creation
-     */
-    notifyBlocCreated(bloc: BlocBase<any>): void;
-    /**
-     * Notify plugins of bloc disposal
-     */
-    notifyBlocDisposed(bloc: BlocBase<any>): void;
-    /**
-     * Notify plugins of state change
-     */
-    notifyStateChanged(bloc: BlocBase<any>, previousState: any, currentState: any): void;
-    /**
-     * Notify plugins of event addition
-     */
-    notifyEventAdded(bloc: Bloc<any, any>, event: any): void;
-    /**
-     * Notify plugins of errors
-     */
-    notifyError(error: Error, bloc: BlocBase<unknown>, context: ErrorContext_2): void;
-    /**
-     * Get metrics for a plugin
-     */
-    getMetrics(pluginName: string): Map<string, PluginMetrics_2> | undefined;
-    private initializeMetrics;
-    private recordSuccess;
-    private recordError;
-}
-
-export declare interface TrackedValue {
-    value: any;
-    lastAccessTime: number;
-}
-
-/**
- * Extracts the state type from a BlocBase instance
- * @template B - The BlocBase type to extract the state from
- */
-export declare type ValueType<B extends BlocBase<any>> = B extends BlocBase<infer U> ? U : never;
-
-export { }