import type { Connection } from '@webkrafters/auto-immutable';
import type { BaseStream, Changes, Data, IStorage, Listener, Prehooks, ProviderProps, RawProviderProps, SelectorMap, ShutdownMonitor, State, Store, StoreInternal, StoreRef, Unsubscribe } from '..';
import AutoImmutable from '@webkrafters/auto-immutable';
import { Phase, ShutdownReason } from '..';
export declare const deps: {
    createStorageKey: () => string;
};
export declare const ACCESS_SYM: unique symbol;
export declare class Channel<T extends State = State, S extends SelectorMap = SelectorMap> implements Store<T, S> {
    private _context;
    private _internalStore;
    private _data;
    private eventMap;
    private _phase;
    private _selectorMap;
    private _unsubClosing;
    private _unsubscribe;
    constructor(context: EagleEyeContext<T>, selectorMap?: S);
    get closed(): boolean;
    get data(): Data<S, T>;
    get phase(): Phase;
    get streaming(): boolean;
    set selectorMap(selectorMap: S);
    addListener(eventType: 'stream-ending', listener: ShutdownMonitor): void;
    addListener(eventType: 'data-changed', listener: () => void): void;
    endStream(): void;
    removeListener(eventType: 'stream-ending', listener: ShutdownMonitor): void;
    removeListener(eventType: 'data-changed', listener: () => void): void;
    resetState(propertyPaths?: string[]): void;
    setState(changes: Changes<T>): void;
    protected subscribe(): void;
    protected unsubscribe(): void;
    private get _renderKeys();
    private _dataSourceListener;
    private _integrateSelectors;
    private _reclaim;
    private _refreshDataRef;
    private _setupInternalStore;
    private _updateData;
    private _updateInternalStore;
}
export declare class EagleEyeContext<T extends State = State> {
    private _cache;
    private _cacheCloseMonitor;
    private _prehooks;
    private _storage;
    private _store;
    private _storeRef;
    private eventMap;
    private inchoateValue;
    private storageKey;
    protected _stream: BaseStream<T>;
    constructor(value?: AutoImmutable<T>, prehooks?: Prehooks<T>, storage?: IStorage<T>);
    constructor(value?: T, prehooks?: Prehooks<T>, storage?: IStorage<T>);
    get cache(): AutoImmutable<T>;
    get closed(): boolean;
    get prehooks(): Prehooks<T>;
    get storage(): IStorage<T>;
    get store(): StoreRef<T>;
    get stream(): BaseStream<T>;
    set prehooks(prehooks: Prehooks<T>);
    set storage(storage: IStorage<T>);
    createInternalStore(access?: Symbol): StoreInternal<T>;
    dispose(): void;
    protected createUpdateEmitterFor(changes: Changes<T>): (netChanges: Readonly<Partial<T>>, changedPathsTokens: Array<Array<string>>) => void;
    protected disconnectInternalStore(connection: Connection<T>): void;
    protected getState(connection: Connection<T>, propertyPaths: Array<string>): Readonly<Partial<T>>;
    protected notifyClosing(reason: ShutdownReason): void;
    protected resetState(connection: Connection<T>, propertyPaths: Array<string>): void;
    protected setState(connection: Connection<T>, changes: Changes<T>): void;
    protected subscribe(eventType: 'closing', listener: ShutdownMonitor): Unsubscribe;
    protected subscribe(eventType: 'data-updated', listener: Listener): Unsubscribe;
    private _createInternalStore;
    private _reclaim;
}
export declare function createEagleEye<T extends State = State>(props?: RawProviderProps<T>): EagleEyeContext<T>;
export declare function createEagleEye<T extends State = State>(props?: ProviderProps<T>): EagleEyeContext<T>;
export declare function mkReadonly(v: any): any;
export declare function set<T>(obj: {}, path: Array<string | number>, value: T): void;
export declare function set<T>(obj: {}, path: string, value: T): void;