import { LoggingOptions } from "../Logging.js";
import { LinkedList, LinkedItem } from "../util/LinkedList.js";
import { Priority, Mode } from "../Enums.js";
import { ReactivityOptions } from "../Options.js";
import { RxObject } from "../core/Mvcc.js";
export type Script<E> = (this: E, o: E, basis: () => void) => void;
export type ScriptAsync<E> = (this: E, o: E, basis: () => Promise<void>) => Promise<void>;
export type Handler<E = unknown, R = void> = (o: E) => R;
export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, body?: Script<E>, bodyTask?: ScriptAsync<E>, key?: string, mode?: Mode, unmounted?: boolean, preparation?: Script<E>, preparationTask?: ScriptAsync<E>, mounting?: Script<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, bodyOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, bodyTask?: ScriptAsync<E>, key?: string, mode?: Mode, unmounted?: boolean, preparation?: Script<E>, preparationTask?: ScriptAsync<E>, mounting?: Script<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
export declare function setBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
export declare function launch<T>(func: (...args: any[]) => T, ...args: any[]): T;
export declare abstract class ReactiveTreeNode<E = unknown> extends LinkedItem<ReactiveTreeNode<E>> {
    static readonly shortFrameDuration = 16;
    static readonly longFrameDuration = 300;
    static frameDuration: number;
    static currentBodyPriority: Priority;
    abstract readonly key: string;
    abstract readonly driver: ReactiveTreeNodeDriver<E>;
    abstract readonly declaration: Readonly<ReactiveTreeNodeDecl<E>>;
    abstract readonly level: number;
    abstract readonly owner: ReactiveTreeNode;
    abstract element: E;
    abstract readonly host: ReactiveTreeNode;
    abstract readonly children: LinkedList<ReactiveTreeNode>;
    abstract readonly stamp: number;
    abstract readonly outer: ReactiveTreeNode;
    abstract readonly context: ReactiveTreeNodeContext | undefined;
    abstract priority?: Priority;
    abstract childrenShuffling: boolean;
    abstract strictOrder: boolean;
    abstract getUri(relativeTo?: ReactiveTreeNode<any>): string;
    abstract has(mode: Mode): boolean;
    abstract hasAny(mode: Mode): boolean;
    abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
    static get current(): ReactiveTreeNode;
    static get isFirstBodyBuild(): boolean;
    static rebuildBody(node: ReactiveTreeNode<any>, signalArgs: unknown): void;
    static launchFinalization(node: ReactiveTreeNode<any>): void;
    static launchNestedNodesThenDo(action: (error: unknown) => void): void;
    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
    lookupTreeNodeByUri<E = unknown>(uri: string): ReactiveTreeNode<E> | undefined;
    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
    static getDefaultLoggingOptions(): LoggingOptions | undefined;
    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
}
export type ReactiveTreeNodeDecl<E = unknown> = {
    body?: Script<E>;
    bodyTask?: ScriptAsync<E>;
    key?: string;
    mode?: Mode;
    unmounted?: boolean;
    preparation?: Script<E>;
    preparationTask?: ScriptAsync<E>;
    mounting?: Script<E>;
    finalization?: Script<E>;
    signalArgs?: unknown;
    basis?: ReactiveTreeNodeDecl<E>;
};
export type ReactiveTreeNodeDriver<E = unknown> = {
    readonly name: string;
    readonly isPartition: boolean;
    readonly initialize?: Handler<E>;
    create(node: ReactiveTreeNode<E>): E;
    runPreparation(node: ReactiveTreeNode<E>): void;
    runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
    runMount(node: ReactiveTreeNode<E>): void;
    rebuildBody(node: ReactiveTreeNode<E>): void | Promise<void>;
    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
    provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
};
export type ReactiveTreeNodeContext<T extends Object = Object> = {
    variable: ReactiveTreeVariable<T>;
    value: T;
};
export declare abstract class BaseDriver<E = unknown> implements ReactiveTreeNodeDriver<E> {
    readonly name: string;
    readonly isPartition: boolean;
    readonly initialize?: Handler<E> | undefined;
    constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
    abstract create(node: ReactiveTreeNode<E>): E;
    runPreparation(node: ReactiveTreeNode<E>): void | Promise<void>;
    runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
    runMount(node: ReactiveTreeNode<E>): void;
    rebuildBody(node: ReactiveTreeNode<E>): void | Promise<void>;
    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
    provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
}
export declare class ReactiveTreeVariable<T extends Object = Object> {
    readonly hint: string;
    readonly defaultValue: T | undefined;
    constructor(hint: string, defaultValue?: T);
    set value(value: T);
    get value(): T;
    get valueOrUndefined(): T | undefined;
}
export declare function generateKey(owner?: ReactiveTreeNode$): string;
export declare function getModeUsingBasisChain(declaration?: ReactiveTreeNodeDecl<any>): Mode;
declare class ReactiveTreeNodeContext$<T extends Object = Object> extends RxObject implements ReactiveTreeNodeContext<T> {
    next: ReactiveTreeNodeContext$<object> | undefined;
    variable: ReactiveTreeVariable<T>;
    value: T;
    constructor(variable: ReactiveTreeVariable<T>, value: T);
}
declare class ReactiveTreeNode$<E = unknown> extends ReactiveTreeNode<E> {
    static logging: LoggingOptions | undefined;
    static grandNodeCount: number;
    static disposableNodeCount: number;
    readonly key: string;
    readonly driver: ReactiveTreeNodeDriver<E>;
    declaration: ReactiveTreeNodeDecl<E>;
    readonly level: number;
    readonly owner: ReactiveTreeNode$;
    readonly element: E;
    host: ReactiveTreeNode;
    readonly children: LinkedList<ReactiveTreeNode>;
    stamp: number;
    outer: ReactiveTreeNode$;
    context: ReactiveTreeNodeContext$<any> | undefined;
    numerator: number;
    priority: Priority;
    childrenShuffling: boolean;
    constructor(key: string, driver: ReactiveTreeNodeDriver<E>, declaration: Readonly<ReactiveTreeNodeDecl<E>>, owner: ReactiveTreeNode$ | undefined);
    getUri(relativeTo?: ReactiveTreeNode<any>): string;
    get strictOrder(): boolean;
    set strictOrder(value: boolean);
    get isMoved(): boolean;
    has(mode: Mode): boolean;
    hasAny(mode: Mode): boolean;
    body(_signalArgs: unknown): void;
    configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
    static get node(): ReactiveTreeNode$;
    static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
    static useTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
    static setTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
}
export declare function signalsAreEqual(a1: any, a2: any): boolean;
export {};