synapse-storage 3.0.11 → 3.0.13

package/dist/storage.interface-2HKvqdAJ.d.ts

@@ -0,0 +1,444 @@
+declare class StorageKey {
+    private readonly value;
+    private readonly isRawKey;
+    constructor(value: string, isRawKey?: boolean);
+    toString(): string;
+    toJSON(): string;
+    valueOf(): string;
+    isUnparseable(): boolean;
+}
+type StorageKeyType = string | StorageKey;
+
+/**
+ * Контекст выполнения для плагинов
+ * Содержит информацию о текущей операции и хранилище
+ */
+interface PluginContext {
+    /** Имя хранилища, к которому применяется плагин */
+    storageName: string;
+    /** Временная метка выполнения операции (timestamp) */
+    timestamp: number;
+    /** Дополнительные метаданные операции (могут быть предоставлены хранилищем или другими плагинами) */
+    metadata?: Record<string, any>;
+}
+/**
+ * Базовый интерфейс для всех плагинов
+ * Определяет основные свойства и методы жизненного цикла
+ */
+interface IPlugin {
+    /** Уникальное имя плагина */
+    name: string;
+    /**
+     * Метод инициализации плагина
+     * Вызывается при добавлении плагина в хранилище или при инициализации хранилища
+     */
+    initialize?(): Promise<void>;
+    /**
+     * Метод уничтожения плагина
+     * Вызывается при удалении плагина из хранилища или при уничтожении хранилища
+     * Используется для освобождения ресурсов и очистки состояния
+     */
+    destroy?(): Promise<void>;
+}
+/**
+ * Интерфейс плагина для хранилища данных
+ * Определяет хуки для различных операций хранилища
+ */
+interface IStoragePlugin extends IPlugin {
+    /**
+     * Вызывается перед установкой значения в хранилище
+     * Позволяет изменить значение до его сохранения
+     *
+     * @param value Значение, которое будет сохранено
+     * @param context Контекст выполнения операции
+     * @returns Модифицированное значение для сохранения
+     */
+    onBeforeSet?<T>(value: T, context: PluginContext): Promise<T>;
+    /**
+     * Вызывается после установки значения в хранилище
+     * Позволяет выполнить дополнительные действия или модифицировать результат
+     *
+     * @param key Ключ, по которому было сохранено значение
+     * @param value Сохраненное значение
+     * @param context Контекст выполнения операции
+     * @returns Финальное значение (может быть модифицировано)
+     */
+    onAfterSet?<T>(key: StorageKeyType, value: T, context: PluginContext): Promise<T>;
+    /**
+     * Вызывается перед получением значения из хранилища
+     * Позволяет модифицировать запрашиваемый ключ
+     *
+     * @param key Ключ, по которому запрашивается значение
+     * @param context Контекст выполнения операции
+     * @returns Возможно модифицированный ключ для запроса
+     */
+    onBeforeGet?(key: StorageKeyType, context: PluginContext): Promise<StorageKeyType>;
+    /**
+     * Вызывается после получения значения из хранилища
+     * Позволяет модифицировать полученное значение
+     *
+     * @param key Ключ, по которому было запрошено значение
+     * @param value Полученное значение (undefined, если значение не найдено)
+     * @param context Контекст выполнения операции
+     * @returns Финальное значение (может быть модифицировано)
+     */
+    onAfterGet?<T>(key: StorageKeyType, value: T | undefined, context: PluginContext): Promise<T | undefined>;
+    /**
+     * Вызывается перед удалением значения из хранилища
+     * Позволяет разрешить или запретить удаление
+     *
+     * @param key Ключ, по которому будет удалено значение
+     * @param context Контекст выполнения операции
+     * @returns Булево значение, разрешающее (true) или запрещающее (false) удаление
+     */
+    onBeforeDelete?(key: StorageKeyType, context: PluginContext): Promise<boolean>;
+    /**
+     * Вызывается после удаления значения из хранилища
+     * Позволяет выполнить дополнительные действия после удаления
+     *
+     * @param key Ключ, по которому было удалено значение
+     * @param context Контекст выполнения операции
+     */
+    onAfterDelete?(key: StorageKeyType, context: PluginContext): Promise<void>;
+    /**
+     * Вызывается перед очисткой хранилища
+     * Позволяет выполнить дополнительные действия перед удалением всех данных
+     *
+     * @param context Контекст выполнения операции
+     */
+    onClear?(context: PluginContext): Promise<void>;
+}
+/**
+ * Исполнитель плагинов
+ * Отвечает за выполнение хуков плагинов в определенной последовательности
+ */
+interface IPluginExecutor {
+    /**
+     * Выполняет хуки onBeforeSet всех зарегистрированных плагинов
+     *
+     * @param value Исходное значение
+     * @param metadata Дополнительные метаданные
+     * @returns Модифицированное значение после прохождения всех плагинов
+     */
+    executeBeforeSet<T>(value: T, metadata?: Record<string, any>): Promise<T>;
+    /**
+     * Выполняет хуки onAfterSet всех зарегистрированных плагинов
+     *
+     * @param key Ключ, по которому было сохранено значение
+     * @param value Сохраненное значение
+     * @param metadata Дополнительные метаданные
+     * @returns Финальное значение после прохождения всех плагинов
+     */
+    executeAfterSet<T>(key: StorageKeyType, value: T, metadata?: Record<string, any>): Promise<T>;
+    /**
+     * Выполняет хуки onBeforeGet всех зарегистрированных плагинов
+     *
+     * @param key Исходный ключ
+     * @param metadata Дополнительные метаданные
+     * @returns Модифицированный ключ после прохождения всех плагинов
+     */
+    executeBeforeGet(key: StorageKeyType, metadata?: Record<string, any>): Promise<StorageKeyType>;
+    /**
+     * Выполняет хуки onAfterGet всех зарегистрированных плагинов
+     *
+     * @param key Ключ, по которому было запрошено значение
+     * @param value Полученное значение
+     * @param metadata Дополнительные метаданные
+     * @returns Финальное значение после прохождения всех плагинов
+     */
+    executeAfterGet<T>(key: StorageKeyType, value: T | undefined, metadata?: Record<string, any>): Promise<T | undefined>;
+    /**
+     * Выполняет хуки onBeforeDelete всех зарегистрированных плагинов
+     *
+     * @param key Ключ, по которому будет удалено значение
+     * @param metadata Дополнительные метаданные
+     * @returns Результат проверки всех плагинов (false если хотя бы один плагин запретил удаление)
+     */
+    executeBeforeDelete(key: StorageKeyType, metadata?: Record<string, any>): Promise<boolean>;
+    /**
+     * Выполняет хуки onAfterDelete всех зарегистрированных плагинов
+     *
+     * @param key Ключ, по которому было удалено значение
+     * @param metadata Дополнительные метаданные
+     */
+    executeAfterDelete(key: StorageKeyType, metadata?: Record<string, any>): Promise<void>;
+    /**
+     * Выполняет хуки onClear всех зарегистрированных плагинов
+     *
+     * @param metadata Дополнительные метаданные
+     */
+    executeOnClear(metadata?: Record<string, any>): Promise<void>;
+}
+/**
+ * Менеджер плагинов
+ * Отвечает за регистрацию, получение и удаление плагинов
+ */
+interface IPluginManager<T extends IPlugin> {
+    /**
+     * Добавляет плагин в менеджер
+     *
+     * @param plugin Экземпляр плагина
+     */
+    add(plugin: T): Promise<void>;
+    /**
+     * Удаляет плагин из менеджера по имени
+     *
+     * @param name Имя плагина
+     */
+    remove(name: string): Promise<void>;
+    /**
+     * Получает плагин по имени
+     *
+     * @param name Имя плагина
+     * @returns Экземпляр плагина или undefined, если плагин не найден
+     */
+    get(name: string): T | undefined;
+    /**
+     * Получает все зарегистрированные плагины
+     *
+     * @returns Массив всех плагинов
+     */
+    getAll(): T[];
+    /**
+     * Инициализирует все зарегистрированные плагины
+     */
+    initialize(): Promise<void>;
+    /**
+     * Уничтожает все зарегистрированные плагины
+     */
+    destroy(): Promise<void>;
+}
+
+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 _initStatus;
+    private statusSubscribers;
+    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);
+    get initStatus(): StorageInitStatus;
+    waitForReady(): Promise<this>;
+    onStatusChange(callback: (status: StorageInitStatus) => void): VoidFunction;
+    private updateInitStatus;
+    initialize(): Promise<this>;
+    protected abstract doInitialize(): Promise<this>;
+    private ensureReady;
+    protected initializeMiddlewares(): void;
+    protected getDefaultMiddleware(): DefaultMiddlewares;
+    protected initializeWithMiddlewares(): Promise<void>;
+    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 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);
+    protected doInitialize(): 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>;
+}
+
+type StorageActionType = 'get' | 'set' | 'delete' | 'clear' | 'init' | 'keys' | 'update';
+type StorageAction = {
+    type: StorageActionType;
+    key?: StorageKeyType;
+    value?: any;
+    metadata?: Record<string, any>;
+    source?: string;
+    timestamp?: number;
+};
+type MiddlewareAPI = {
+    dispatch: (action: StorageAction) => Promise<any>;
+    getState: () => Promise<Record<string, any>>;
+    storage: {
+        doGet: (key: StorageKeyType) => Promise<any>;
+        doSet: (key: StorageKeyType, value: any) => Promise<void>;
+        doUpdate: (updates: Array<{
+            key: StorageKeyType;
+            value: any;
+        }>) => Promise<void>;
+        doDelete: (key: StorageKeyType) => Promise<boolean>;
+        doClear: () => Promise<void>;
+        doKeys: () => Promise<string[]>;
+        notifySubscribers: (key: StorageKeyType, value: any) => void;
+    };
+};
+type NextFunction = (action: StorageAction) => Promise<any>;
+type SetupEventsFunction = (api: MiddlewareAPI) => void;
+type Middleware = {
+    name: string;
+    setup?: SetupEventsFunction;
+    cleanup?: () => Promise<void> | void;
+    reducer: (api: MiddlewareAPI) => (next: NextFunction) => (action: StorageAction) => Promise<any>;
+};
+
+interface BatchingMiddlewareOptions {
+    batchSize?: number;
+    batchDelay?: number;
+}
+
+interface ShallowCompareMiddlewareOptions {
+    segments?: string[];
+    comparator?: <T>(prev: T, next: T) => boolean;
+}
+
+declare enum StorageStatus {
+    IDLE = "idle",// Не инициализировано
+    LOADING = "loading",// В процессе инициализации
+    READY = "ready",// Успешно инициализировано
+    ERROR = "error"
+}
+interface StorageInitStatus {
+    status: StorageStatus;
+    error?: Error;
+}
+interface IStorage<T extends Record<string, any> = any> {
+    name: string;
+    get<R>(key: StorageKeyType): Promise<R | undefined>;
+    getState(): Promise<T>;
+    set<R>(key: StorageKeyType, value: R): Promise<void>;
+    update(updater: (state: T) => void): Promise<void>;
+    has(key: StorageKeyType): Promise<boolean>;
+    delete(key: StorageKeyType): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    destroy(): Promise<void>;
+    subscribeToAll(callback: (event: {
+        type: string;
+        changedPaths?: string[];
+        key?: StorageKeyType[] | StorageKeyType;
+        value?: any;
+    }) => void): VoidFunction;
+    initialize(): Promise<this>;
+    subscribe(key: StorageKeyType, callback: (value: any) => void): VoidFunction;
+    subscribe<R>(pathSelector: (state: T) => R, callback: (value: R) => void): VoidFunction;
+    onStatusChange(callback: (status: StorageInitStatus) => void): VoidFunction;
+    waitForReady(): Promise<this>;
+}
+declare enum StorageEvents {
+    STORAGE_UPDATE = "storage:update",
+    STORAGE_DELETE = "storage:delete",
+    STORAGE_PATCH = "storage:patch",
+    STORAGE_SELECT = "storage:select",
+    STORAGE_CLEAR = "storage:clear",
+    STORAGE_DESTROY = "storage:destroy"
+}
+interface StorageEvent<T = any> {
+    type: string;
+    payload?: T;
+    metadata?: Record<string, any>;
+}
+interface IEventEmitter {
+    emit(event: StorageEvent): Promise<void>;
+}
+interface ILogger {
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+interface DefaultMiddlewares {
+    batching: (options?: BatchingMiddlewareOptions) => Middleware;
+    shallowCompare: (options?: ShallowCompareMiddlewareOptions) => Middleware;
+}
+type GetDefaultMiddleware = () => DefaultMiddlewares;
+type ConfigureMiddlewares = (getDefaultMiddleware: GetDefaultMiddleware) => Middleware[];
+interface StorageConfig {
+    name: string;
+    initialState?: Record<string, any>;
+    middlewares?: ConfigureMiddlewares;
+}
+type StorageType = 'memory' | 'localStorage' | 'indexedDB';
+interface MemoryStorageConfig extends StorageConfig {
+    type: 'memory';
+}
+interface LocalStorageConfig extends StorageConfig {
+    type: 'localStorage';
+}
+interface IndexedDBStorageConfig extends StorageConfig {
+    type: 'indexedDB';
+    options: IndexedDBConfig;
+}
+
+export { type BatchingMiddlewareOptions as B, type ConfigureMiddlewares as C, type DefaultMiddlewares as D, type GetDefaultMiddleware as G, IndexedDBStorage as I, type LocalStorageConfig as L, type Middleware as M, type NextFunction as N, type PluginContext as P, type ShallowCompareMiddlewareOptions as S, type MiddlewareAPI as a, type StorageAction as b, type StorageKeyType as c, type IPlugin as d, type IStoragePlugin as e, type IPluginExecutor as f, type IPluginManager as g, StorageStatus as h, type StorageInitStatus as i, type IStorage as j, StorageEvents as k, type StorageEvent as l, type IEventEmitter as m, type ILogger as n, type StorageConfig as o, type StorageType as p, type MemoryStorageConfig as q, type IndexedDBStorageConfig as r, BaseStorage as s };

package/dist/utils.d.ts

@@ -1,92 +1,95 @@
-import { Observable } from 'rxjs';
-import { I as ISelectorModule } from './selector.interface-CA5y-kD_.js';
-import { I as IStorage } from './storage.interface-Dl8SLUd1.js';
-import { m as ExternalStates, o as Effect } from './dispatcher.module-jd8U_ZEs.js';
+import { a as SynapseStoreWithDispatcher } from './createSynapse-CzeX0ONj.js';
+export { A as AnySynapseStore, S as SynapseStoreBasic, b as SynapseStoreWithEffects, c as createSynapse } from './createSynapse-CzeX0ONj.js';
+import { j as IStorage } from './storage.interface-2HKvqdAJ.js';
+import { D as DispatchFunction, f as DispatchActions } from './dispatcher.module-DjMloBXe.js';
+import 'rxjs';
+import './selector.interface-CA5y-kD_.js';
 
-type ExtractDispatchType<T> = T extends {
-    dispatch: infer D;
-} ? D : never;
-type StorageCreatorFunction<T extends Record<string, any>> = () => Promise<IStorage<T>>;
-/**
- * Базовая конфигурация хранилища
- */
-type BaseSynapseConfig<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = ({
-    storage: IStorage<TStore>;
-    createStorageFn?: undefined;
-} | {
-    storage?: undefined;
-    createStorageFn: StorageCreatorFunction<TStore>;
-}) & {
-    externalSelectors?: TExternalSelectors;
-    createSelectorsFn?: (selectorModule: ISelectorModule<TStore>, externalSelectors: TExternalSelectors) => TSelectors;
-};
-/**
- * Конфигурация с dispatcher и effects
- */
-type CreateSynapseConfigWithEffects<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TApi extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
-    createDispatcherFn: (storage: IStorage<TStore>) => TDispatcher;
-    createEffectConfig: (dispatcher: TDispatcher) => {
-        dispatchers: Record<string, any>;
-        api?: TApi;
-        config?: TConfig;
-        externalStates?: ExternalStates;
+interface EventBusEvent {
+    id: string;
+    event: string;
+    data: any;
+    metadata: {
+        ttl?: number | null;
+        priority?: 'low' | 'normal' | 'high';
+        [key: string]: any;
     };
-    effects?: Effect<TStore, any, TApi, TConfig, any>[];
-};
-/**
- * Конфигурация только с dispatcher
- */
-type CreateSynapseConfigWithDispatcher<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
-    createDispatcherFn: (storage: IStorage<TStore>) => TDispatcher;
-    createEffectConfig?: never;
-    effects?: never;
-};
-/**
- * Конфигурация без dispatcher
- */
-type CreateSynapseConfigBasic<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>> = BaseSynapseConfig<TStore, TSelectors, TExternalSelectors> & {
-    createDispatcherFn?: never;
-    createEffectConfig?: never;
-    effects?: never;
-};
-/**
- * Результат с dispatcher и effects
- */
-interface SynapseStoreWithEffects<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions> {
-    storage: TStorage;
-    selectors: TSelectors;
-    actions: TActions;
-    state$: Observable<TStore>;
-    dispatcher: any;
-    destroy: () => Promise<void>;
+    timestamp: number;
 }
-/**
- * Результат только с dispatcher
- */
-interface SynapseStoreWithDispatcher<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors, TActions> {
-    storage: TStorage;
-    selectors: TSelectors;
-    actions: TActions;
-    dispatcher: any;
-    destroy: () => Promise<void>;
+interface EventBusState {
+    events: Record<string, EventBusEvent>;
+    subscriptions: Record<string, any>;
 }
-/**
- * Результат без dispatcher
- */
-interface SynapseStoreBasic<TStore extends Record<string, any>, TStorage extends IStorage<TStore>, TSelectors> {
-    storage: TStorage;
-    selectors: TSelectors;
-    destroy: () => Promise<void>;
+interface EventBusConfig {
+    name?: string;
+    autoCleanup?: boolean;
+    maxEvents?: number;
 }
 /**
- * Union-тип для всех возможных результатов createSynapse
- */
-type AnySynapseStore<TStore extends Record<string, any> = any, TStorage extends IStorage<TStore> = IStorage<any>, TSelectors = any, TActions = any> = SynapseStoreWithEffects<TStore, TStorage, TSelectors, TActions> | SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, TActions> | SynapseStoreBasic<TStore, TStorage, TSelectors>;
-/**
- * Перегрузки функции createSynapse
+ * Создает EventBus для связи между модулями
+ *
+ * @example
+ * ```typescript
+ * // Создание EventBus
+ * const eventBus = await createEventBus({
+ *   name: 'app-events',
+ *   autoCleanup: true,
+ *   maxEvents: 500
+ * })
+ *
+ * // Использование в Synapse
+ * const mySynapse = await createSynapse({
+ *   dependencies: [eventBus],
+ *   createEffectConfig: (dispatcher) => ({
+ *     dispatchers: {
+ *       dispatcher,
+ *       eventBus: eventBus.dispatcher
+ *     }
+ *   }),
+ *   effects: [
+ *     createEffect((action$, _, __, { eventBus }) => {
+ *       // Публикация события
+ *       eventBus.dispatch.publish({
+ *         event: 'USER_UPDATED',
+ *         data: { userId: 123 }
+ *       })
+ *
+ *       // Подписка на события
+ *       eventBus.dispatch.subscribe({
+ *         eventPattern: 'CORE_*',
+ *         handler: (data, event) => console.log('Received:', event.event, data)
+ *       })
+ *     })
+ *   ]
+ * })
+ * ```
  */
-declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TApi extends Record<string, any> = Record<string, never>, TConfig extends Record<string, any> = Record<string, never>, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigWithEffects<TStore, TSelectors, TDispatcher, TApi, TConfig, TExternalSelectors>): Promise<SynapseStoreWithEffects<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>;
-declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TDispatcher = any, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigWithDispatcher<TStore, TSelectors, TDispatcher, TExternalSelectors>): Promise<SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>;
-declare function createSynapse<TStore extends Record<string, any>, TSelectors = any, TExternalSelectors extends Record<string, any> = Record<string, any>, TStorage extends IStorage<TStore> = IStorage<TStore>>(config: CreateSynapseConfigBasic<TStore, TSelectors, TExternalSelectors>): Promise<SynapseStoreBasic<TStore, TStorage, TSelectors>>;
+declare const createEventBus: (config?: EventBusConfig) => Promise<SynapseStoreWithDispatcher<EventBusState, IStorage<EventBusState>, any, Record<string, DispatchFunction<any, any>> & DispatchActions<{
+    publish: DispatchFunction<{
+        event: string;
+        data: any;
+        metadata?: Record<string, any>;
+    }, {
+        eventId: string;
+        event: string;
+        data: any;
+    }>;
+    subscribe: DispatchFunction<{
+        eventPattern: string;
+        handler: (data: any, event: EventBusEvent) => void | Promise<void>;
+        options?: Record<string, any>;
+    }, {
+        subscriptionId: string;
+        unsubscribe: VoidFunction;
+    }>;
+    getEventHistory: DispatchFunction<{
+        eventType: string;
+        limit?: number;
+    }, EventBusEvent[]>;
+    clearEvents: DispatchFunction<{
+        olderThan?: number;
+    } | undefined, void>;
+    getActiveSubscriptions: DispatchFunction<any, any[]>;
+}>>>;
 
-export { type AnySynapseStore, type SynapseStoreBasic, type SynapseStoreWithDispatcher, type SynapseStoreWithEffects, createSynapse };
+export { type EventBusConfig, type EventBusEvent, type EventBusState, SynapseStoreWithDispatcher, createEventBus };