import Logger from './logger.js';
import CombinedStorage, { type TStoreStateEntry } from './storages/combined-storage.js';
import StoreStatus from './store-status.js';
import type { IConstructableStore, IGroupedStores, IManagerOptions, IManagerParams, IPersistOptions, IStoreParams, IStorePersisted, TAnyStore, TInitStore, TStoreDefinition, TStores } from './types.js';
/**
 * Mobx stores manager
 */
declare class Manager {
    /**
     * Manger instance
     */
    protected static instance: Manager;
    /**
     * Created stores
     */
    protected readonly stores: Map<string, TInitStore>;
    /**
     * Relations between stores
     */
    protected readonly storesRelations: Map<string, {
        ids: Set<string>;
        parentId: string | null;
        componentName?: string;
    }>;
    /**
     * Save persisted stores identities
     */
    protected static readonly persistedStores: Set<string>;
    /**
     * Initial stores state (local storage, custom etc.)
     */
    protected readonly initState: Record<string, Record<string, unknown>>;
    /**
     * Storage for persisted stores
     */
    readonly storage?: CombinedStorage;
    /**
     * Additional store's constructor params
     */
    protected readonly storesParams: IManagerParams['storesParams'];
    /**
     * Manager options
     */
    readonly options: IManagerOptions;
    /**
     * Persisted stores waiting to be saved: store => state getter
     * @see schedulePersist
     */
    protected readonly persistQueue: Map<IStorePersisted, (() => Record<string, any> | undefined) | undefined>;
    /**
     * Scheduled persist flush
     */
    protected persistTimer?: ReturnType<typeof setTimeout>;
    /**
     * Storage writes in progress
     */
    protected readonly persistWrites: Set<Promise<boolean>>;
    /**
     * Remove page lifecycle listeners
     */
    protected removePageListeners?: () => void;
    /**
     * Suspense stores relations
     * @see withStores
     */
    protected suspenseRelations: Map<string, Set<string>>;
    /**
     * Mobx manager logger
     */
    protected readonly logger: Logger;
    /**
     * Detect server side: stores live until the manager is destroyed, no timers are armed
     */
    isServer: boolean;
    /**
     * @constructor
     */
    constructor({ initState, storesParams, storage, options, logger }?: IManagerParams);
    /**
     * Init store manager
     */
    init(): Promise<Manager>;
    /**
     * Get manager instance
     */
    static get(): Manager;
    /**
     * Get all stores
     */
    getStores(): Manager['stores'];
    /**
     * Get stores relations
     */
    getStoresRelations(): Manager['storesRelations'];
    /**
     * Get suspense relations with stores
     */
    getSuspenseRelations(): Manager['suspenseRelations'];
    /**
     * Get persisted stores ids
     */
    static getPersistedStoresIds(): Set<string>;
    /**
     * Push initial state dynamically
     * E.g. when stream html
     */
    pushInitState: (storesState?: Record<string, unknown>) => void;
    /**
     * Get store identity
     */
    protected getStoreId<T extends TAnyStore>(store: IConstructableStore<T> | TInitStore, params?: IStoreParams): string;
    /**
     * Get exist store
     */
    getStore<T>(store: IConstructableStore<T>, params?: IStoreParams): T | undefined;
    /**
     * Lookup store
     */
    protected lookupStore(id: string, params: IStoreParams): TInitStore<TAnyStore> | undefined;
    /**
     * Get bigger context from two
     */
    protected getBiggerContext(ctx1?: string, ctx2?: string): string | undefined;
    /**
     * Create new store instance
     */
    protected createStore<T>(store: IConstructableStore<T>, params: Omit<Required<IStoreParams>, 'key'>): T;
    /**
     * Create stores for component
     *
     * NOTE: use only inside withStores wrapper
     */
    createStores(map: [string, TStoreDefinition][], parentId: string, contextId: string, suspenseId: string, componentName: string, componentProps?: Record<string, any>): IGroupedStores;
    /**
     * Create empty relation context
     */
    protected createRelationContext(contextId: string, parentId?: string, componentName?: string): void;
    /**
     * Delete relation context id
     */
    protected removeRelationContext(contextId: string): void;
    /**
     * Append callback to store destroy lifecycle
     */
    protected appendDestroyCallback(store: TStores[string], callback?: () => void): void;
    /**
     * Prepare store before usage
     */
    protected prepareStore(store: TStores[string]): void;
    /**
     * Remove store
     */
    protected removeStore(store: TStores[string]): void;
    /**
     * Mount stores to component
     *
     * NOTE: use only inside withStores wrapper
     */
    mountStores(contextId: string, { globalStores, relativeStores }: Partial<IGroupedStores>): () => void;
    /**
     * Destroy manager stores and detach internal relations
     */
    destroy(): void;
    /**
     * Change the stores status to touched
     */
    touchedStores(stores: TStores): void;
    /**
     * Change store status
     */
    protected setStoreStatus(store: TStores[string], status: StoreStatus): void;
    /**
     * Get store state
     */
    getStoreState(store: TAnyStore, withNotExported?: boolean): Record<string, any>;
    /**
     * Get store's state
     */
    toJSON(ids?: string[], isIncludeExported?: boolean): Record<string, any>;
    /**
     * Get store state saved by persist: only attributes of storages
     */
    getPersistState(store: IStorePersisted): Record<string, any>;
    /**
     * Save persisted store state to provided storage right now
     */
    savePersistedStore(store: IStorePersisted): Promise<boolean>;
    /**
     * Schedule saving persisted store state.
     * Changes are collected and saved at most once per options.persistDelay.
     * @param store
     * @param getState - returns collected store state, by default: getPersistState
     */
    schedulePersist(store: IStorePersisted, getState?: () => Record<string, any> | undefined): void;
    /**
     * Save scheduled persisted stores right now.
     * E.g. call it when a mobile app goes to background.
     * Resolves when all storage writes are finished: true - saved, false - failed or disabled.
     */
    flushPersist(): Promise<boolean>;
    /**
     * Persist is disabled (e.g. at runtime): nothing to save,
     * but collecting the state keeps store changes listener subscribed
     */
    protected skipPersist(getState?: () => unknown): void;
    /**
     * Write stores state to storage
     */
    protected writePersisted(storage: CombinedStorage, entries: TStoreStateEntry[]): Promise<boolean>;
    /**
     * Save scheduled changes when the page is hidden or unloaded
     */
    protected listenPageHide(): void;
    /**
     * Get observable store props (fields)
     */
    static getObservableProps(store: TAnyStore, withNotExported?: boolean): Record<string, any>;
    /**
     * Persist store
     */
    static persistStore<TSt>(store: IConstructableStore<TSt>, id: string, options?: IPersistOptions): IConstructableStore<TSt>;
}
export default Manager;