import type { CoreObjectEvents, InputEvent, InputEventKey, InputEvents, MaskLike, WebGLRenderer } from '../../core';
import type { SceneTree } from './SceneTree';
import type { Viewport } from './Viewport';
import type { Window } from './Window';
import { CoreObject } from '../../core';
import { Children } from './Children';
import { Meta } from './Meta';
export interface NodeEvents extends CoreObjectEvents, InputEvents {
    treeEnter: [tree: SceneTree];
    treeEntered: [tree: SceneTree];
    treePostEnter: [tree: SceneTree];
    treeExit: [oldTree: SceneTree];
    treeExiting: [oldTree: SceneTree];
    treeExited: [oldTree: SceneTree];
    childExitingTree: [node: Node];
    childEnteredTree: [node: Node];
    ready: [];
    parented: [parent: Node];
    unparented: [oldParent: Node];
    processing: [delta?: number];
    process: [delta?: number];
    processed: [delta?: number];
    addChild: [child: Node, newIndex: number];
    removeChild: [child: Node, oldIndex: number];
}
export interface Node {
    on: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
    once: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
    off: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
    emit: <K extends keyof NodeEvents & string>(event: K, ...args: NodeEvents[K]) => this;
}
export type ProcessMode = 'inherit' | 'always' | 'disabled';
export type ProcessSortMode = 'default' | 'parent-before';
export type RenderMode = 'inherit' | 'always' | 'disabled';
export type InputMode = 'inherit' | 'always' | 'disabled';
export type InternalMode = 'default' | 'front' | 'back';
export interface NodeProperties {
    id: string;
    name: string;
    processMode: ProcessMode;
    processSortMode: ProcessSortMode;
    renderMode: RenderMode;
    internalMode: InternalMode;
    meta: Record<string, any>;
}
export interface SerializedNode {
    [key: string]: any;
    is?: string;
    children?: SerializedNode[];
    meta?: {
        [key: string]: any;
        inCanvasIs?: string;
    };
}
export declare class Node extends CoreObject {
    static parse(value: SerializedNode | SerializedNode[], defaultInCanvasIs?: string): any;
    readonly is: string;
    id: string;
    name: string;
    processMode: ProcessMode;
    processSortMode: ProcessSortMode;
    renderMode: RenderMode;
    inputMode: InputMode;
    internalMode: InternalMode;
    protected _mask?: MaskLike;
    protected _meta: Meta;
    get meta(): Meta;
    set meta(value: Record<string, any>);
    needsRender: boolean;
    protected _processable: boolean;
    get processable(): boolean;
    protected _renderable: boolean;
    get renderable(): boolean;
    protected _readyed: boolean;
    constructor(properties?: Partial<NodeProperties>, nodes?: Node[]);
    protected _defaultName(): string;
    setProperties(properties?: Record<string, any>): this;
    /** Name */
    getName(): string;
    setName(value: string): this;
    /** Tree */
    protected _tree?: SceneTree;
    get tree(): SceneTree | undefined;
    set tree(tree: SceneTree | undefined);
    getTree(): SceneTree | undefined;
    getViewport(): Viewport | undefined;
    getWindow(): Window | undefined;
    isInsideTree(): boolean;
    setTree(tree: SceneTree | undefined): this;
    /** Parent */
    protected _parent?: Node;
    get parent(): Node | undefined;
    set parent(parent: Node | undefined);
    hasParent(): boolean;
    getParent<T extends Node = Node>(): T | undefined;
    setParent<T extends Node = Node>(parent: T | undefined): this;
    /** Children */
    protected _children: Children<Node>;
    get children(): Node[];
    set children(value: Node[]);
    getChildren(internalMode?: InternalMode | true): Node[];
    getChild<T extends Node = Node>(index?: number): T | undefined;
    get siblingIndex(): number;
    set siblingIndex(toIndex: number);
    get previousSibling(): Node | undefined;
    get nextSibling(): Node | undefined;
    get firstSibling(): Node | undefined;
    get lastSibling(): Node | undefined;
    canInput(): boolean;
    private _onTreeEnter;
    private _onTreeExit;
    private _onParented;
    private _onUnparented;
    private _onReady;
    _onProcess(delta?: number): void;
    requestRender(): void;
    updateProcessable(): void;
    updateRenderable(): void;
    protected _updateProperty(key: string, newValue: any, oldValue: any): void;
    render(renderer: WebGLRenderer, next?: () => void): void;
    input(event: InputEvent, key: InputEventKey): void;
    getIndex(): number;
    getNode<T extends Node>(path: string): T | undefined;
    removeNode(path: string): void;
    addSibling(sibling: Node): this;
    prepend<T extends Node>(nodes: T[]): void;
    prepend<T extends Node>(...nodes: T[]): void;
    append<T extends Node | SerializedNode>(nodes: T[]): void;
    append<T extends Node | SerializedNode>(...nodes: T[]): void;
    before<T extends Node>(nodes: T[]): void;
    before<T extends Node>(...nodes: T[]): void;
    after<T extends Node>(nodes: T[]): void;
    after<T extends Node>(...nodes: T[]): void;
    insertBefore<T extends Node>(node: T, child: Node): T;
    appendChild<T extends Node>(node: T, internalMode?: InternalMode): T;
    moveChild(node: Node, toIndex: number, internalMode?: InternalMode): this;
    removeChild<T extends Node>(child: T): T;
    removeChildren(internalMode?: InternalMode | true): void;
    remove(): void;
    findOne<T extends Node = Node>(callbackfn: (value: Node) => boolean): T | undefined;
    findAll<T extends Node = Node>(callbackfn: (value: Node) => boolean): T[];
    findAncestor<T extends Node = Node>(callbackfn: (value: Node) => boolean): T | undefined;
    /** override */
    protected _ready(): void;
    protected _treeEnter(tree: SceneTree): void;
    protected _treeExit(oldTree: SceneTree): void;
    protected _parented(parent: Node): void;
    protected _unparented(oldParent: Node): void;
    protected _process(delta: number): void;
    protected _input(event: InputEvent, key: InputEventKey): void;
    protected _render(renderer: WebGLRenderer): void;
    destroy(): void;
    clone(): this;
    toJSON(): Record<string, any>;
}