import { type Atom, type Action, type Ctx, type Rec, type Fn } from '@reatom/core';
type State<T> = T extends Atom<infer Value> ? Value : T;
export declare const LL_PREV: unique symbol;
export declare const LL_NEXT: unique symbol;
/** Linked List is reusing the model reference to simplify the reference sharing and using it as a key of LL methods.
 * Btw, symbols works fine with serialization and will not add a garbage to an output.
 */
export type LLNode<T extends Rec = Rec> = T & {
    [LL_PREV]: null | LLNode<T>;
    [LL_NEXT]: null | LLNode<T>;
};
type LLChanges<Node extends LLNode> = {
    kind: 'create';
    node: Node;
} | {
    kind: 'remove';
    node: Node;
} | {
    kind: 'swap';
    a: Node;
    b: Node;
} | {
    kind: 'move';
    node: Node;
    after: null | Node;
} | {
    kind: 'clear';
};
export interface LinkedList<Node extends LLNode = LLNode> {
    head: null | Node;
    tail: null | Node;
    size: number;
    version: number;
    changes: Array<LLChanges<Node>>;
}
export interface LinkedListLikeAtom<T extends LinkedList = LinkedList> extends Atom<T> {
    __reatomLinkedList: true;
    array: Atom<Array<T extends LinkedList<infer LLNode> ? LLNode : never>>;
}
export interface LinkedListAtom<Params extends any[] = any[], Node extends Rec = Rec, Key extends keyof Node = never> extends LinkedListLikeAtom<LinkedList<LLNode<Node>>> {
    batch: Action<[cb: Fn]>;
    create: Action<Params, LLNode<Node>>;
    remove: Action<[LLNode<Node>], boolean>;
    swap: Action<[a: LLNode<Node>, b: LLNode<Node>], void>;
    move: Action<[node: LLNode<Node>, after: null | LLNode<Node>], void>;
    clear: Action<[], void>;
    find: (ctx: Ctx, cb: (node: LLNode<Node>) => boolean) => null | LLNode<Node>;
    /** This lazy map is useful for working with serializable identifier,
     * but it is not recommended to use it for large (thousands elements) lists */
    map: Key extends never ? never : Atom<Map<State<Node[Key]>, LLNode<Node>>>;
    initiate: {
        (initState: Array<Node>): LinkedList<LLNode<Node>>;
        (ctx: Ctx, initSnapshot: Array<Params>): LinkedList<LLNode<Node>>;
    };
    reatomMap: <T extends Rec>(cb: (ctx: Ctx, node: LLNode<Node>) => T, options?: string | {
        name?: string;
        onCreate?: (ctx: Ctx, node: LLNode<T>) => void;
        onRemove?: (ctx: Ctx, node: LLNode<T>, origin: LLNode<Node>) => void;
        onSwap?: (ctx: Ctx, payload: {
            a: LLNode<T>;
            b: LLNode<T>;
        }) => void;
        onMove?: (ctx: Ctx, node: LLNode<T>) => void;
        onClear?: (ctx: Ctx, lastState: LinkedListDerivedState<LLNode<Node>, LLNode<T>>) => void;
    }) => LinkedListDerivedAtom<LLNode<Node>, LLNode<T>>;
}
export interface LinkedListDerivedState<Node extends LLNode, T extends LLNode> extends LinkedList<T> {
    map: WeakMap<Node, T>;
}
export interface LinkedListDerivedAtom<Node extends LLNode, T extends LLNode> extends LinkedListLikeAtom<LinkedListDerivedState<Node, T>> {
}
export declare function reatomLinkedList<Node extends Rec, Params extends any[] = [Node], Key extends keyof Node = never>(initState: Array<Node>, name?: string): LinkedListAtom<Params, Node, Key>;
export declare function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(initState: ((ctx: Ctx, ...params: Params) => Node), name?: string): LinkedListAtom<Params, Node, Key>;
export declare function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(initState: {
    create: (ctx: Ctx, ...params: Params) => Node;
    initState?: Array<Node>;
    key?: Key;
}, name?: string): LinkedListAtom<Params, Node, Key>;
export declare function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(initState: {
    create?: (ctx: Ctx, ...params: Params) => Node;
    initState: Array<Node>;
    key?: Key;
}, name?: string): LinkedListAtom<Params, Node, Key>;
export declare function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(initSnapshot: {
    create: (ctx: Ctx, ...params: Params) => Node;
    initSnapshot?: Array<Params>;
    key?: Key;
}, name?: string): LinkedListAtom<Params, Node, Key>;
export declare const isLinkedListAtom: (thing: any) => thing is LinkedListLikeAtom;
export {};
//# sourceMappingURL=reatomLinkedList.d.ts.map