export declare type VNodeTag = string | ComponentConstructor | ComponentFunction | null;
export interface VNode<T extends VNodeTag = VNodeTag> {
    dom: IntactDom | null;
    type: Types;
    tag: T;
    childrenType: ChildrenTypes;
    props?: Readonly<VNodeProps<T>> | null;
    children?: VNodeChildren<T> | null;
    className?: string | null;
    key: Key | null;
    ref: VNodeRef<T> | null;
    isValidated?: boolean;
    transition: TransitionHooks | null;
    position: TransitionPosition | null;
    newPosition: TransitionPosition | null;
    hooks: Hooks | null;
}
export interface VNodeElement extends VNode<string> {
}
export interface VNodeTextElement extends VNode<null> {
    dom: Text | Comment | null;
}
export interface VNodeComponentClass<T extends ComponentClass = ComponentClass> extends VNode<ComponentConstructor<T>> {
}
export interface VNodeComponentFunction<T extends ComponentFunction = ComponentFunction> extends VNode<T> {
}
export interface TransitionHooks {
    beforeEnter(el: TransitionElement): void;
    enter(el: TransitionElement): void;
    leave(el: TransitionElement, remove: () => void): void;
    show: boolean;
}
export interface TransitionElement extends HTMLElement {
    _enterCb?: PendingCallback;
    _leaveCb?: PendingCallback;
    _moveCb?: (e?: TransitionEvent) => void;
    $TC?: Record<string, boolean>;
    $TD?: string;
    $ID?: number;
}
export interface TransitionPosition {
    top: number;
    left: number;
}
export declare type PendingCallback = (cancelled?: boolean) => void;
export declare type VNodeProps<T extends VNodeTag> = T extends string ? Props<{
    [key in string]: any;
}, Element> : T extends null ? Props<{}, Element> : T extends ComponentConstructor<infer C> ? C extends ComponentClass<infer P> ? Props<P, C> : never : T extends ComponentFunction<infer P, infer R> ? Props<P, R> : never;
export declare type VNodeChildren<T extends VNodeTag> = T extends ComponentConstructor<infer C> ? C : T extends ComponentFunction ? VNode : T extends null ? string | number : NormalizedChildren;
export declare type VNodeRef<T extends VNodeTag> = T extends ComponentConstructor<infer C> ? Ref<C> : T extends ComponentFunction<infer P, infer R> ? Ref<R> : Ref<Element>;
export declare type IntactDom = Element | Text | Comment;
export declare const enum Types {
    Text = 1,
    CommonElement = 2,
    ComponentUnknown = 4,
    ComponentClass = 8,
    ComponentFunction = 16,
    HtmlComment = 32,
    InputElement = 64,
    SelectElement = 128,
    TextareaElement = 256,
    SvgElement = 512,
    UnescapeText = 1024,
    Void = 2048,
    Fragment = 4096,
    InUse = 8192,
    Normalized = 16384,
    PrefixedKey = 32768,
    Component = 28,
    ComponentKnown = 24,
    FormElement = 448,
    TextElement = 2081,
    Element = 962,
    HtmlElement = 3043,
    InUseOrNormalized = 24576,
    ClearInUse = -8193
}
export declare const enum ChildrenTypes {
    UnknownChildren = 0,
    HasInvalidChildren = 1,
    HasVNodeChildren = 2,
    HasNonKeyedChildren = 4,
    HasKeyedChildren = 8,
    HasTextChildren = 16,
    MultipleChildren = 12
}
export declare type NormalizedChildren = VNode<any> | VNode<any>[] | null | undefined | string | number;
export declare type Children = NormalizedChildren | NormalizedChildren[] | boolean | Children[];
export declare type Key = string | number;
export interface RefObject<T> {
    value: T | null;
    readonly __is_ref: boolean;
}
export interface NonNullableRefObject<T> extends RefObject<T> {
    value: T;
}
export declare type RefFunction<T> = {
    bivarianceHack(i: T | null): any;
}["bivarianceHack"];
export declare type Ref<T> = RefFunction<T> | RefObject<T>;
export declare type Block<T> = (this: T, parent: () => Children, ...args: any[]) => Children;
export declare type Blocks<T = any> = Record<string, Block<T>>;
export declare type Props<P extends {}, T extends Element | ComponentClass = Element | ComponentClass> = {
    children?: Children;
    ref?: Ref<T>;
    key?: Key;
    className?: string;
    $blocks?: Blocks;
} & P;
export interface ComponentConstructor<T extends ComponentClass = ComponentClass> {
    new (props: T extends ComponentClass<infer P> ? P : null, $vNode: VNodeComponentClass, $SVG: boolean, $mountedQueue: Function[], $senior: ComponentClass | null): T;
    displayName?: string;
    typeDefs?: TypeDefs<T extends ComponentClass<infer P> ? P : {}>;
}
export interface ComponentClass<P = any> {
    $props: Props<P, ComponentClass<P>>;
    $inited: boolean;
    $SVG: boolean;
    $vNode: VNodeComponentClass<ComponentClass<P>> | null;
    $lastInput: VNode | null;
    $mountedQueue: Function[] | null;
    $senior: ComponentClass | null;
    $init(props: Props<P, ComponentClass<P>> | null): void;
    $render(lastVNode: VNodeComponentClass | null, vNode: VNodeComponentClass, parentDom: Element, anchor: IntactDom | null, mountedQueue: Function[]): void;
    $update(lastVNode: VNodeComponentClass, vNode: VNodeComponentClass, parentDom: Element, anchor: IntactDom | null, mountedQueue: Function[], force: boolean): void;
    $unmount(vNode: VNodeComponentClass, nextVNode: VNodeComponentClass | null): void;
}
export interface ComponentFunction<P = any, R extends Element | ComponentClass = Element | ComponentClass> {
    (props: Props<P, R>): Children;
    displayName?: string;
    typeDefs?: TypeDefs<P>;
}
export declare type Component = ComponentConstructor | ComponentFunction;
export interface LinkedEvent<T, E extends Event = Event> {
    data: T;
    event: (data: T, event: E) => void;
}
export declare type IntactEventListener = EventListener | LinkedEvent<any> | null;
export interface IntactElement extends Element {
    [key: string]: any;
    $EV?: Record<string, IntactEventListener>;
    $V?: VNode | null;
    $M?: string | null;
    $TV?: any;
    $FV?: any;
    $VA?: any;
}
export declare type Reference = {
    value: boolean;
};
export declare type TypePrimitive = Function | string | number | null | undefined;
export declare type TypeObject = {
    type?: TypePrimitive | readonly TypePrimitive[];
    validator?: Function;
    required?: boolean | Function;
};
export declare type TypeDefs<T> = {
    [key in keyof T]?: TypePrimitive | readonly TypePrimitive[] | TypeObject;
};
export declare type Hooks = {
    beforeInsert: ((vNode: VNode, parent: ComponentClass | null) => void) | null;
};