type Listener<T> = (state: T, prev: T) => void;
type Selector<T, U> = (state: T) => U;
type EqualityFn<T> = (a: T, b: T) => boolean;
type SetState<T> = (partial: T | Partial<T> | ((s: T) => T | Partial<T>), replace?: boolean) => void;
type ModelHook<T> = {
    (): T;
    <U>(sel: Selector<T, U>, eq?: EqualityFn<U>): U;
};
type StorageEngine = {
    getItem(key: string): string | null | Promise<string | null>;
    setItem(key: string, value: string): void | Promise<void>;
    removeItem(key: string): void | Promise<void>;
};
interface PersistOptions<T> {
    key: string;
    storage?: StorageEngine;
    debounce?: number;
    beforePersist?(state: T): any;
    beforeRecover?(value: any): T | Partial<T>;
}
interface CreateModelOptions<T> {
    persist?: string | PersistOptions<T>;
    logger?: {
        warn(...a: any[]): void;
        error(...a: any[]): void;
    };
    strict?: {
        forbidSetStateAfterDestroy?: boolean;
    };
}
interface SubscribeWithSelectorOptions<U> {
    equalityFn?(a: U, b: U): boolean;
    fireImmediately?: boolean;
}
interface Subscribe<T> {
    (listener: Listener<T>): () => void;
    <U>(sel: Selector<T, U>, fn: (s: U, p: U) => void, opts?: SubscribeWithSelectorOptions<U>): () => void;
}
interface ModelData<T> {
    getState(): T;
    setState: SetState<T>;
    subscribe: Subscribe<T>;
    destroy(): void;
    reset(): void;
    state: T;
}
type Model<T> = ModelHook<T> & {
    getState: ModelHook<T>;
    useState: ModelHook<T>;
    use: ModelHook<T>;
    setState: SetState<T>;
    destroy(): void;
    reset(): void;
    data: ModelData<T>;
};
declare function shallow<T>(a: T, b: T): boolean;
declare function debounce<T extends (...a: any[]) => any>(fn: T, ms: number): {
    (...a: Parameters<T>): void;
    flush(): void;
    cancel(): void;
};
declare const createStore: <T>(init: T) => {
    getState: () => T;
    getInitialState: () => T;
    setState(partial: T | Partial<T> | ((s: T) => T | Partial<T>), replace?: boolean): void;
    subscribe(l: Listener<T>): () => void;
    destroy(): void;
};
declare function createModel<T>(initialState: T | (() => T), options?: CreateModelOptions<T>): Model<T>;

export { type CreateModelOptions, type Model, type ModelData, type PersistOptions, type StorageEngine, type SubscribeWithSelectorOptions, createModel, createStore, debounce, shallow };