import type { Atom, WritableAtom } from './atom';
declare type AnyAtom = Atom<unknown>;
declare type OnUnmount = () => void;
declare type NonPromise<T> = T extends Promise<infer V> ? V : T;
declare const IS_EQUAL_PROMISE: unique symbol;
declare const INTERRUPT_PROMISE: unique symbol;
declare type InterruptablePromise = Promise<void> & {
    [IS_EQUAL_PROMISE]: (p: Promise<void>) => boolean;
    [INTERRUPT_PROMISE]: () => void;
};
declare type Revision = number;
declare type InvalidatedRevision = number;
declare type ReadDependencies = Map<AnyAtom, Revision>;
export declare type AtomState<Value = unknown> = {
    e?: Error;
    p?: InterruptablePromise;
    c?: () => void;
    w?: Promise<void>;
    v?: NonPromise<Value>;
    r: Revision;
    i?: InvalidatedRevision;
    d: ReadDependencies;
};
declare type AtomStateMap = WeakMap<AnyAtom, AtomState>;
declare type Listeners = Set<() => void>;
declare type Dependents = Set<AnyAtom>;
declare type Mounted = {
    l: Listeners;
    d: Dependents;
    u: OnUnmount | void;
};
declare type MountedMap = WeakMap<AnyAtom, Mounted>;
declare type StateListener = (updatedAtom: AnyAtom, isNewAtom: boolean) => void;
declare type StateVersion = number;
declare type PendingAtoms = Set<AnyAtom>;
export declare type State = {
    l?: StateListener;
    v: StateVersion;
    a: AtomStateMap;
    m: MountedMap;
    p: PendingAtoms;
};
export declare const createState: (initialValues?: Iterable<readonly [AnyAtom, unknown]> | undefined, stateListener?: StateListener | undefined) => State;
export declare const readAtom: <Value>(state: State, readingAtom: Atom<Value>) => AtomState<Value>;
export declare const writeAtom: <Value, Update>(state: State, writingAtom: WritableAtom<Value, Update>, update: Update) => void | Promise<void>;
export declare const subscribeAtom: (state: State, atom: AnyAtom, callback: () => void) => () => void;
export declare const restoreAtoms: (state: State, values: Iterable<readonly [AnyAtom, unknown]>) => void;
export {};