synapse-storage 3.0.2 → 3.0.4

package/dist/{core/storage/modules/plugin/plugin.interface.d.ts → core.d.ts}

@@ -1,9 +1,12 @@
-import { StorageKeyType } from '../../utils/storage-key';
+import { I as ISelectorModule, a as Selector, b as SelectorOptions, S as SelectorAPI } from './selector.interface-CA5y-kD_.js';
+import { c as StorageKeyType, I as IStorage, h as StorageConfig, f as IEventEmitter, g as ILogger, D as DefaultMiddlewares, e as StorageEvent, i as StorageType, M as Middleware, C as ConfigureMiddlewares, l as StorageKey } from './storage.interface-Dl8SLUd1.js';
+export { B as BatchingMiddlewareOptions, G as GetDefaultMiddleware, k as IndexedDBStorageConfig, L as LocalStorageConfig, j as MemoryStorageConfig, a as MiddlewareAPI, N as NextFunction, S as ShallowCompareMiddlewareOptions, b as StorageAction, d as StorageEvents } from './storage.interface-Dl8SLUd1.js';
+
 /**
  * Контекст выполнения для плагинов
  * Содержит информацию о текущей операции и хранилище
  */
-export interface PluginContext {
+interface PluginContext {
     /** Имя хранилища, к которому применяется плагин */
     storageName: string;
     /** Временная метка выполнения операции (timestamp) */
@@ -15,7 +18,7 @@ export interface PluginContext {
  * Базовый интерфейс для всех плагинов
  * Определяет основные свойства и методы жизненного цикла
  */
-export interface IPlugin {
+interface IPlugin {
     /** Уникальное имя плагина */
     name: string;
     /**
@@ -34,7 +37,7 @@ export interface IPlugin {
  * Интерфейс плагина для хранилища данных
  * Определяет хуки для различных операций хранилища
  */
-export interface IStoragePlugin extends IPlugin {
+interface IStoragePlugin extends IPlugin {
     /**
      * Вызывается перед установкой значения в хранилище
      * Позволяет изменить значение до его сохранения
@@ -102,7 +105,7 @@ export interface IStoragePlugin extends IPlugin {
  * Исполнитель плагинов
  * Отвечает за выполнение хуков плагинов в определенной последовательности
  */
-export interface IPluginExecutor {
+interface IPluginExecutor {
     /**
      * Выполняет хуки onBeforeSet всех зарегистрированных плагинов
      *
@@ -163,7 +166,7 @@ export interface IPluginExecutor {
  * Менеджер плагинов
  * Отвечает за регистрацию, получение и удаление плагинов
  */
-export interface IPluginManager<T extends IPlugin> {
+interface IPluginManager<T extends IPlugin> {
     /**
      * Добавляет плагин в менеджер
      *
@@ -198,4 +201,197 @@ export interface IPluginManager<T extends IPlugin> {
      */
     destroy(): Promise<void>;
 }
-//# sourceMappingURL=plugin.interface.d.ts.map
+
+type PathSelector<T, R> = (state: T) => R;
+declare abstract class BaseStorage<T extends Record<string, any>> implements IStorage<T> {
+    protected readonly config: StorageConfig;
+    protected readonly pluginExecutor?: IPluginExecutor | undefined;
+    protected readonly eventEmitter?: IEventEmitter | undefined;
+    protected readonly logger?: ILogger | undefined;
+    protected static readonly GLOBAL_SUBSCRIPTION_KEY = "*";
+    name: string;
+    private selectorPathCache;
+    private middlewareModule;
+    private initializedMiddlewares;
+    protected subscribers: Map<StorageKeyType, Set<(value: any) => void>>;
+    constructor(config: StorageConfig, pluginExecutor?: IPluginExecutor | undefined, eventEmitter?: IEventEmitter | undefined, logger?: ILogger | undefined);
+    protected initializeMiddlewares(): void;
+    protected getDefaultMiddleware(): DefaultMiddlewares;
+    protected initializeWithMiddlewares(): Promise<void>;
+    abstract initialize(): Promise<this>;
+    protected abstract doGet(key: StorageKeyType): Promise<any>;
+    protected abstract doSet(key: StorageKeyType, value: any): Promise<void>;
+    protected abstract doUpdate(updates: Array<{
+        key: StorageKeyType;
+        value: any;
+    }>): Promise<void>;
+    protected abstract doDelete(key: StorageKeyType): Promise<boolean>;
+    protected abstract doClear(): Promise<void>;
+    protected abstract doKeys(): Promise<string[]>;
+    protected abstract doHas(key: StorageKeyType): Promise<boolean>;
+    protected abstract doDestroy(): Promise<void>;
+    get<R>(key: StorageKeyType): Promise<R | undefined>;
+    set<R>(key: StorageKeyType, value: R): Promise<void>;
+    update(updater: (state: T) => void): Promise<void>;
+    delete(key: StorageKeyType): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    has(key: StorageKeyType): Promise<boolean>;
+    getState(): Promise<T>;
+    subscribeToAll(callback: (event: {
+        type: string;
+        key?: StorageKeyType[] | StorageKeyType;
+        value?: any;
+        changedPaths?: string[];
+    }) => void): VoidFunction;
+    subscribe(key: string, callback: (value: any) => void): VoidFunction;
+    subscribe<R>(pathSelector: PathSelector<T, R>, callback: (value: R) => void): VoidFunction;
+    destroy(): Promise<void>;
+    private subscribeByKey;
+    private createDummyState;
+    private isEqual;
+    /**
+     * Возвращает полный путь, а не только корневой ключ
+     */
+    private extractPath;
+    protected notifySubscribers(key: StorageKeyType, value: any): void;
+    /**
+     * Метод для определения изменившихся путей между двумя объектами
+     */
+    private findChangedPaths;
+    private subscribeBySelector;
+    protected emitEvent(event: StorageEvent): Promise<void>;
+}
+
+interface SharedStateMiddlewareProps {
+    storageType: StorageType;
+    storageName: string;
+}
+declare const broadcastMiddleware: (props: SharedStateMiddlewareProps) => Middleware;
+
+declare class StoragePluginModule implements IPluginManager<IStoragePlugin>, IPluginExecutor {
+    protected readonly parentExecutor?: IPluginExecutor | undefined;
+    protected readonly logger?: ILogger | undefined;
+    protected readonly storageName: string;
+    private plugins;
+    constructor(parentExecutor?: IPluginExecutor | undefined, logger?: ILogger | undefined, storageName?: string);
+    private createContext;
+    add(plugin: IStoragePlugin): Promise<void>;
+    remove(name: string): Promise<void>;
+    get(name: string): IStoragePlugin | undefined;
+    getAll(): IStoragePlugin[];
+    initialize(): Promise<void>;
+    destroy(): Promise<void>;
+    executeBeforeSet<T>(value: T, metadata?: Record<string, any>): Promise<T>;
+    executeAfterSet<T>(key: StorageKeyType, value: T, metadata?: Record<string, any>): Promise<T>;
+    executeBeforeGet(key: StorageKeyType, metadata?: Record<string, any>): Promise<StorageKeyType>;
+    executeAfterGet<T>(key: StorageKeyType, value: T | undefined, metadata?: Record<string, any>): Promise<T | undefined>;
+    executeBeforeDelete(key: StorageKeyType, metadata?: Record<string, any>): Promise<boolean>;
+    executeAfterDelete(key: StorageKeyType, metadata?: Record<string, any>): Promise<void>;
+    executeOnClear(metadata?: Record<string, any>): Promise<void>;
+}
+
+interface IndexedDBConfig {
+    dbName?: string;
+    dbVersion: number;
+}
+declare class IndexedDBStorage<T extends Record<string, any>> extends BaseStorage<T> {
+    private readonly DB_NAME;
+    private readonly STORE_NAME;
+    private readonly DB_VERSION;
+    private dbManager;
+    constructor(config: StorageConfig & {
+        options: IndexedDBConfig;
+    }, pluginExecutor?: IPluginExecutor, eventEmitter?: IEventEmitter, logger?: ILogger);
+    initialize(): Promise<this>;
+    static getCurrentDBVersion(dbName: string): Promise<number>;
+    static createStorages<S extends Record<string, any>>(dbName: string, configs: {
+        [K in keyof S]: {
+            name: string;
+            initialState?: S[K];
+            middlewares?: ConfigureMiddlewares;
+            pluginExecutor?: IPluginExecutor;
+            eventEmitter?: IEventEmitter;
+        };
+    }, logger?: ILogger): Promise<{
+        [K in keyof S]: IndexedDBStorage<S[K]>;
+    }>;
+    private getTransaction;
+    private getObjectStore;
+    protected doGet(key: StorageKeyType): Promise<any>;
+    protected doSet(key: StorageKeyType, value: any): Promise<void>;
+    private putValueInStore;
+    protected doUpdate(updates: Array<{
+        key: string | StorageKey;
+        value: any;
+    }>): Promise<void>;
+    protected doDelete(key: StorageKeyType): Promise<boolean>;
+    protected doClear(): Promise<void>;
+    protected doKeys(): Promise<string[]>;
+    protected doHas(key: StorageKeyType): Promise<boolean>;
+    protected doDestroy(): Promise<void>;
+}
+
+declare class LocalStorage<T extends Record<string, any>> extends BaseStorage<T> {
+    constructor(config: StorageConfig, pluginExecutor?: IPluginExecutor, eventEmitter?: IEventEmitter, logger?: ILogger);
+    initialize(): Promise<this>;
+    protected doGet(key: StorageKeyType): Promise<any>;
+    protected doSet(key: StorageKeyType, value: any): Promise<void>;
+    protected doDelete(key: StorageKeyType): Promise<boolean>;
+    protected doUpdate(updates: Array<{
+        key: StorageKeyType;
+        value: any;
+    }>): Promise<void>;
+    protected doClear(): Promise<void>;
+    protected doKeys(): Promise<string[]>;
+    protected doHas(key: StorageKeyType): Promise<boolean>;
+    private getAllKeys;
+    protected doDestroy(): Promise<void>;
+}
+
+declare class MemoryStorage<T extends Record<string, any>> extends BaseStorage<T> {
+    private storage;
+    constructor(config: StorageConfig, pluginExecutor?: IPluginExecutor, eventEmitter?: IEventEmitter, logger?: ILogger);
+    initialize(): Promise<this>;
+    protected doGet(key: StorageKeyType): Promise<any>;
+    protected doSet(key: StorageKeyType, value: any): Promise<void>;
+    protected doDelete(key: StorageKeyType): Promise<boolean>;
+    protected doUpdate(updates: Array<{
+        key: StorageKeyType;
+        value: any;
+    }>): Promise<void>;
+    protected doClear(): Promise<void>;
+    protected doKeys(): Promise<string[]>;
+    protected doHas(key: StorageKeyType): Promise<boolean>;
+    protected doDestroy(): Promise<void>;
+    private getAllKeys;
+}
+
+declare class SelectorModule<S extends Record<string, any>> implements ISelectorModule<S> {
+    private readonly source;
+    private readonly logger?;
+    storageName: string;
+    private subscriptions;
+    private cachedState?;
+    private localSelectorCache;
+    private batchUpdateInProgress;
+    private pendingUpdates;
+    constructor(source: IStorage<S>, logger?: ILogger | undefined);
+    /**
+     * Генерирует имя для селектора на основе его типа и функции
+     */
+    private generateName;
+    /**
+     * Обрабатывает отложенные обновления, чтобы избежать каскадных уведомлений
+     */
+    private processPendingUpdates;
+    createSelector<T>(selector: Selector<S, T>, options?: SelectorOptions<T>): SelectorAPI<T>;
+    createSelector<Deps extends unknown[], T>(dependencies: {
+        [K in keyof Deps]: SelectorAPI<Deps[K]>;
+    }, resultFn: (...args: Deps) => T, options?: SelectorOptions<T>): SelectorAPI<T>;
+    private createSimpleSelector;
+    private createCombinedSelector;
+    destroy(): void;
+}
+
+export { ConfigureMiddlewares, DefaultMiddlewares, IEventEmitter, ILogger, type IPlugin, type IPluginExecutor, type IPluginManager, ISelectorModule, IStorage, type IStoragePlugin, IndexedDBStorage, LocalStorage, MemoryStorage, Middleware, type PluginContext, SelectorAPI, SelectorModule, StorageConfig, StorageEvent, StorageKeyType, StoragePluginModule, StorageType, broadcastMiddleware };

package/dist/core.js

@@ -0,0 +1 @@
+export{e as IndexedDBStorage,f as LocalStorage,g as MemoryStorage,a as SelectorModule,c as StorageEvents,b as StoragePluginModule,d as broadcastMiddleware}from'./chunk-6RNZVHSR.js';import'./chunk-ZE2EJX2Y.js';

package/dist/dispatcher.module-CdpmkplA.d.cts

@@ -0,0 +1,363 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { I as IStorage } from './storage.interface-Dl8SLUd1.cjs';
+
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПОСЛЕДОВАТЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */
+declare const chunkRequestConsistent: <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs?: number) => Observable<R[]>;
+type ChunkRequestConsistent = typeof chunkRequestConsistent;
+
+/**
+ * Разбиение запроса на порции
+ * Отправляется ПАРАЛЛЕЛЬНО n-запросов и дожидается ответа от каждого
+ * @param fn - функция в которую передается chunk и возвращается функция api
+ * @param arr - массив который нужно поделить
+ * @param size - размер порции
+ * @param delayMs - задержка между запросами в миллисекундах
+ */
+declare const chunkRequestParallel: <T, R>(fn: (chunk: T[]) => Observable<R>, arr: T[], size: number, delayMs?: number) => Observable<R[]>;
+type ChunkRequestParallel = typeof chunkRequestParallel;
+
+/**
+ * Тип действия с типизированным payload
+ */
+interface TypedAction<P> extends Action<P> {
+    type: string;
+    payload: P;
+}
+/**
+ * Тип для внешних состояний
+ */
+type ExternalStates = Record<string, Observable<any>>;
+/**
+ * Тип для базового эффекта без доступа к состоянию
+ */
+type EffectBase<TDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TServices extends Record<string, any> = Record<string, never>> = (action$: Observable<Action>, dispatchers: TDispatchers, services: TServices) => Observable<unknown>;
+/**
+ * Тип для эффекта с доступом к состоянию и конфигурации - это основной тип, который используется по умолчанию
+ */
+type Effect<TState extends Record<string, any> = any, TDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> = (action$: Observable<Action>, state$: Observable<TState>, externalStates: TExternalStates, dispatchers: TDispatchers, services: TServices, config: TConfig) => Observable<unknown>;
+/**
+ * Тип для получения типов действий диспетчера
+ */
+type DispatcherActions<T> = T extends Dispatcher<any, infer A> ? ActionsResult<A> : Record<string, DispatchFunction<any, any>>;
+/**
+ * Конфигурация для валидации в validateMap
+ */
+interface ValidateConfig {
+    conditions: boolean[];
+    skipAction: (() => any) | any | ((() => any) | any)[];
+}
+/**
+ * Утилиты для запросов в validateMap
+ */
+interface ValidateMapRequestUtils {
+    chunkRequest: ChunkRequestParallel;
+    chunkRequestConsistent: ChunkRequestConsistent;
+}
+/**
+ * Оператор для фильтрации действий по типу с сохранением типа payload
+ */
+declare function ofType<T extends DispatchFunction<any, any> | WatcherFunction<any>>(actionFn: T): OperatorFunction<Action, TypedAction<T extends WatcherFunction<infer R> ? R : ExtractResultType<T>>>;
+/**
+ * Оператор для фильтрации действий по нескольким типам с объединением типов payload
+ * @param actionFns Массив функций действий
+ */
+declare function ofTypes<T extends DispatchFunction<any, any>[]>(actionFns: [...T]): OperatorFunction<Action, TypedAction<ExtractResultType<T[number]>>>;
+/**
+ * Оператор для ожидания выполнения всех указанных действий
+ * @param actionFns Массив функций действий
+ */
+declare function ofTypesWaitAll<T extends DispatchFunction<any, any>[]>(actionFns: [...T]): (source$: Observable<Action>) => Observable<{ [K in keyof T]: TypedAction<ExtractResultType<T[K]>>; }>;
+/**
+ * Создает Observable с выбранными данными из состояния
+ * @param state$ Поток состояния
+ * @param selectors Селекторы для выбора частей состояния
+ * @returns Observable с массивом выбранных значений
+ */
+declare function selectorMap<TState, TResults extends any[]>(state$: Observable<TState>, ...selectors: {
+    [K in keyof TResults]: (state: TState) => TResults[K];
+}): Observable<TResults>;
+/**
+ * Создает именованный объект вместо массива
+ * @param state$ Поток состояния
+ * @param selectors Объект с селекторами
+ * @returns Observable с объектом выбранных значений
+ */
+declare function selectorObject<TState, TResult extends Record<string, any>>(state$: Observable<TState>, selectors: {
+    [K in keyof TResult]: (state: TState) => TResult[K];
+}): Observable<TResult>;
+/**
+ * Оператор validateMap для валидации данных и условного вызова API
+ */
+declare function validateMap<T, TResult = any>({ validator, apiCall, }: {
+    validator?: (value: T) => ValidateConfig;
+    apiCall: (value: T, utils: ValidateMapRequestUtils) => Observable<TResult>;
+}): OperatorFunction<T, any>;
+/**
+ * Класс для управления эффектами с поддержкой доступа к состоянию и конфигурации
+ * Основной класс, который следует использовать
+ */
+declare class EffectsModule<TState extends Record<string, any> = any, TDispatchers extends Record<string, Dispatcher<any, any>> = Record<string, never>, TServices extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>> {
+    private storage;
+    private externalStates;
+    private dispatchers;
+    private services;
+    private config;
+    private effects;
+    private subscriptions;
+    private running;
+    private action$;
+    /**
+     * Поток состояния
+     */
+    readonly state$: Observable<TState>;
+    /**
+     * Создает модуль эффектов с доступом к состоянию, внешним состояниям и конфигурации
+     * @param storage Хранилище состояния
+     * @param externalStates Внешние состояния
+     * @param dispatchers Объект с диспетчерами
+     * @param services Объект с сервисами
+     * @param config Глобальная конфигурация для всех эффектов
+     */
+    constructor(storage: IStorage<TState>, externalStates: TExternalStates | undefined, dispatchers: TDispatchers, services?: TServices, config?: TConfig);
+    /**
+     * Подписывается на действия от всех диспетчеров
+     */
+    private subscribeToDispatchers;
+    add(effect: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>): this;
+    /**
+     * Добавляет несколько эффектов
+     * @param effects Эффекты для добавления
+     * @returns Текущий модуль
+     */
+    addEffects(effects: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>[]): this;
+    /**
+     * Запускает все эффекты
+     * @returns Текущий модуль
+     */
+    start(): this;
+    /**
+     * Останавливает все эффекты
+     * @returns Текущий модуль
+     */
+    stop(): this;
+    /**
+     * Подписывается на конкретный эффект
+     * @param effect Эффект для подписки
+     */
+    private subscribeToEffect;
+}
+/**
+ * Вспомогательная функция для создания типизированного эффекта без состояния
+ * @deprecated Используйте createEffect вместо этого
+ */
+declare function createEffectBase<TDispatchers extends Record<string, Dispatcher<any, any>>, TServices extends Record<string, any>>(effect: EffectBase<TDispatchers, TServices>): EffectBase<TDispatchers, TServices>;
+/**
+ * Вспомогательная функция для создания типизированного эффекта с состоянием и конфигурацией
+ */
+declare function createEffect<TState extends Record<string, any>, TDispatchers extends Record<string, Dispatcher<any, any>>, TServices extends Record<string, any>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>>(effect: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>): Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>;
+/**
+ * Объединяет несколько эффектов в один
+ * @param effects Эффекты для объединения
+ * @returns Объединенный эффект
+ */
+declare function combineEffects<TState extends Record<string, any>, TDispatchers extends Record<string, Dispatcher<any, any>>, TServices extends Record<string, any>, TConfig extends Record<string, any> = Record<string, never>, TExternalStates extends ExternalStates = Record<string, never>>(...effects: Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>[]): Effect<TState, TDispatchers, TServices, TConfig, TExternalStates>;
+
+/**
+ * Расширенное API для middleware
+ */
+interface EnhancedMiddlewareAPI<T extends Record<string, any>> {
+    getState: () => Promise<T>;
+    dispatch: (action: Action) => Promise<any>;
+    storage: IStorage<T>;
+    actions$: Observable<Action>;
+    actions: Record<string, DispatchFunction<any, any>>;
+    watchers: Record<string, WatcherFunction<any>>;
+    findActionByType: (actionType: string) => DispatchFunction<any, any> | undefined;
+    findWatcherByType: (actionType: string) => WatcherFunction<any> | undefined;
+}
+/**
+ * Расширенное определение middleware
+ */
+interface EnhancedMiddleware<T extends Record<string, any> = any> {
+    (api: EnhancedMiddlewareAPI<T>): (next: (action: Action) => Promise<any>) => (action: Action) => Promise<any>;
+}
+/**
+ * Базовая структура действия
+ */
+interface Action<T = unknown> {
+    type: string;
+    payload?: T;
+    meta?: Record<string, any>;
+}
+interface ActionExecutionOptions {
+    worker?: Worker;
+    memoize?: (currentArgs: any[], previousArgs: any[], previousResult: any) => boolean;
+}
+/**
+ * Параметры для создания действия
+ */
+interface ActionDefinition<TParams, TResult> {
+    /** Тип действия для идентификации в потоке и эффектах */
+    type: string;
+    /** Функция, выполняющая действие и возвращающая результат (payload) */
+    action: (params: TParams) => Promise<TResult> | TResult;
+    /** Дополнительные метаданные (опционально) */
+    meta?: Record<string, any>;
+}
+/**
+ * Определение типа для watcher'а
+ */
+interface WatcherDefinition<T, R> {
+    type: string;
+    selector: (state: T) => R;
+    meta?: Record<string, any>;
+    shouldTrigger?: (prev: R | undefined, current: R) => boolean;
+}
+/**
+ * Тип для функции watcher
+ */
+interface WatcherFunction<R> {
+    (): Observable<TypedAction<R>>;
+    actionType: string;
+    meta?: Record<string, any>;
+    unsubscribe: VoidFunction;
+}
+/**
+ * Расширенный тип для функции настройки действий с поддержкой дополнительных утилит
+ */
+type ActionsSetupWithUtils<T extends Record<string, unknown>> = (storage: IStorage<T>, utils: {
+    createAction: ActionCreatorFactory;
+    createWatcher: <R>(config: WatcherDefinition<T, R>) => WatcherFunction<R>;
+}) => Record<string, DispatchFunction<any, any> | WatcherFunction<any>>;
+/**
+ * Расширенная функция диспетчеризации
+ */
+interface DispatchFunction<TParams, TResult> {
+    /** Функция для вызова действия с параметрами */
+    (params: TParams): Promise<TResult>;
+    /** Тип действия для использования в эффектах */
+    actionType: string;
+    /** Метаданные действия */
+    meta?: Record<string, any>;
+    /** Внутренний тип для идентификации */
+    _type?: 'dispatch' | 'watchers';
+}
+/**
+ * Тип для фабрики создателей действий
+ */
+type ActionCreatorFactory = <TParams, TResult>(config: ActionDefinition<TParams, TResult>, executionOptions?: ActionExecutionOptions) => DispatchFunction<TParams, TResult>;
+/**
+ * Тип для функции настройки действий
+ */
+type ActionsSetup<T extends Record<string, unknown>> = (create: ActionCreatorFactory, storage: IStorage<T>) => Record<string, DispatchFunction<any, any>>;
+/**
+ * Извлекает тип результата из функции диспетчера
+ */
+type ExtractResultType<T> = T extends DispatchFunction<any, infer R> ? R : never;
+/**
+ * Извлекает типы из функции настройки действий
+ */
+type ActionsResult<F> = F extends (create: ActionCreatorFactory, storage: any, ...args: any[]) => infer R ? R : Record<string, DispatchFunction<any, any>>;
+/**
+ * Типизированный объект действий
+ */
+type DispatchActions<T> = {
+    [K in keyof T]: T[K] extends DispatchFunction<any, any> ? T[K] : never;
+};
+/**
+ * Типизированный объект watchers
+ */
+type WatcherActions<T> = {
+    [K in keyof T]: T[K] extends WatcherFunction<any> ? T[K] : never;
+};
+/**
+ * Параметры для Dispatcher
+ */
+interface DispatcherOptions<T extends Record<string, any>> {
+    storage: IStorage<T>;
+    worker?: Worker;
+    middlewares?: EnhancedMiddleware<T>[];
+}
+/**
+ * Интерфейс для API middleware
+ */
+interface DispatcherMiddlewareAPI<T extends Record<string, any>> {
+    getState: () => Promise<T>;
+    dispatch: (action: Action) => Promise<any>;
+}
+/**
+ * Интерфейс для middleware
+ */
+interface DispatcherMiddleware<T extends Record<string, any> = any> {
+    (api: DispatcherMiddlewareAPI<T>): (next: (action: Action) => Promise<any>) => (action: Action) => Promise<any>;
+}
+/**
+ * Класс Dispatcher для интеграции хранилищ с реактивной системой
+ */
+declare class Dispatcher<T extends Record<string, any>, TActionsFn extends ActionsSetupWithUtils<T> = ActionsSetupWithUtils<T>> {
+    private options;
+    private actions$;
+    readonly actions: Observable<Action>;
+    dispatch: Record<string, DispatchFunction<any, any>>;
+    watchers: Record<string, WatcherFunction<any>>;
+    private storage;
+    private middlewareFunctions;
+    private middlewareAPI;
+    /**
+     * Создает новый экземпляр Dispatcher
+     */
+    constructor(options: DispatcherOptions<T>);
+    /**
+     * Добавляет middleware в цепочку обработки
+     */
+    use(...middlewares: EnhancedMiddleware<T>[]): this;
+    /**
+     * Получает все действия с улучшенной типизацией
+     */
+    getActions(): ActionsResult<TActionsFn>;
+    /**
+     * Получает типизированные действия диспетчера
+     */
+    getTypedDispatch<A extends Record<string, any>>(): DispatchActions<A>;
+    /**
+     * Получает типизированные watcher'ы
+     */
+    getTypedWatchers<A extends Record<string, any>>(): WatcherActions<A>;
+    /**
+     * Находит действие по типу
+     */
+    findActionByType(actionType: string): DispatchFunction<any, any> | undefined;
+    /**
+     * Находит наблюдатель по типу
+     */
+    findWatcherByType(actionType: string): WatcherFunction<any> | undefined;
+    /**
+     * Создает действие
+     */
+    createAction<TParams, TResult>(actionConfig: ActionDefinition<TParams, TResult>, executionOptions?: ActionExecutionOptions): DispatchFunction<TParams, TResult>;
+    /**
+     * Создает watcher для отслеживания изменений в хранилище
+     */
+    createWatcher<R>(config: WatcherDefinition<T, R>): WatcherFunction<R>;
+    /**
+     * Выполняет действие в worker
+     */
+    private executeInWorker;
+}
+/**
+ * Функция для создания типизированного диспетчера
+ */
+declare function createDispatcher<TState extends Record<string, any>, TActions extends ActionsSetupWithUtils<TState>>(options: DispatcherOptions<TState>, actionsSetup: TActions): Dispatcher<TState, TActions> & {
+    dispatch: DispatchActions<ReturnType<TActions>>;
+    watchers: WatcherActions<ReturnType<TActions>>;
+};
+type CreateDispatcherType = ReturnType<typeof createDispatcher>;
+
+export { type Action as A, combineEffects as B, type CreateDispatcherType as C, type DispatchFunction as D, type EnhancedMiddlewareAPI as E, type TypedAction as T, type ValidateConfig as V, type WatcherFunction as W, type EnhancedMiddleware as a, type ActionDefinition as b, type ActionsSetupWithUtils as c, type ActionsSetup as d, type ExtractResultType as e, type ActionsResult as f, type DispatchActions as g, type WatcherActions as h, type DispatcherMiddlewareAPI as i, type DispatcherMiddleware as j, Dispatcher as k, createDispatcher as l, type ExternalStates as m, type EffectBase as n, type Effect as o, type DispatcherActions as p, type ValidateMapRequestUtils as q, ofType as r, ofTypes as s, ofTypesWaitAll as t, selectorMap as u, selectorObject as v, validateMap as w, EffectsModule as x, createEffectBase as y, createEffect as z };