/** @noSelfInFile */
import { FunctionComponent as FunctionalComponentType } from "./Component";
import { Children, NodeProps, VNode } from "./element";
import { Context } from "./createContext";
/**
 * A fleshed out vdom, with pointers to instantiated components or frames.
 */
export interface Instance<T, P> {
    vnode: VNode<P>;
    childInstances: Instance<T, unknown>[];
    component?: ClassComponent<P> | undefined;
    hostFrame?: T;
}
export declare function render<T, P>(vnode: VNode<P>, container: T): void;
export declare function reconcile<T, InstanceProps>(parentFrame: T | undefined, instance: Instance<T, InstanceProps> | null, vnode: null, contexts?: Contexts): null;
export declare function reconcile<T, VNodeProps, InstanceProps>(parentFrame: T | undefined, instance: Instance<T, InstanceProps> | null, vnode: VNode<VNodeProps>, contexts?: Contexts): Instance<T, VNodeProps>;
export declare const scheduleUpdate: <T>(instance: Instance<T, unknown>) => void;
export declare type Contexts = {
    [contextId: number]: InstanceType<Context<unknown>["Provider"]> | undefined;
};
export declare abstract class ClassComponent<P, S = unknown, T = unknown> {
    props: NodeProps<P>;
    static context?: Context<any>;
    state: S;
    contexts: Contexts;
    componentWillUnmount?: () => void;
    componentDidCatch?: (error: unknown) => void;
    constructor(props: NodeProps<P>);
    setState(partialState: Partial<S>): void;
    set instance(instance: Instance<T, P>);
    get instance(): Instance<T, P>;
    abstract render(props: NodeProps<P>, contexts: Contexts): Children;
}
export declare type ComponentClass<P = unknown, S = unknown, T = unknown, E = unknown> = {
    new (props: NodeProps<P>): ClassComponent<P, S, T> & E;
    context?: Context<unknown>;
};
export declare const flushUpdates: () => void;
export declare const test: {
    functionalComponentClasses: WeakMap<FunctionalComponentType<any>, ComponentClass<any, unknown, unknown, unknown>>;
};