import { PolyScene } from '../scene/PolyScene';
import { CoreGraphNode } from '../../core/graph/CoreGraphNode';
import { UIData } from './utils/UIData';
import { FlagsController, FlagsControllerD } from './utils/FlagsController';
import { NodeStatesController } from './utils/StatesController';
import { HierarchyParentController } from './utils/hierarchy/ParentController';
import { HierarchyChildrenController, NodeCreateOptions } from './utils/hierarchy/ChildrenController';
import { NodeLifeCycleController } from './utils/LifeCycleController';
import { TypedContainerController } from './utils/ContainerController';
import { NodeCookController, OnCookCompleteHook } from './utils/CookController';
import { NameController } from './utils/NameController';
import { CoreNodeSerializer, NodeSerializerData } from './utils/CoreNodeSerializer';
import { ParamsController } from './utils/params/ParamsController';
import { ParamConstructorMap } from '../params/types/ParamConstructorMap';
import { ParamInitValuesTypeMap } from '../params/types/ParamInitValuesTypeMap';
import { NodeParamsConfig } from './utils/params/ParamsConfig';
import { ParamsValueAccessorType } from './utils/params/ParamsValueAccessor';
import { IOController } from './utils/io/IOController';
import { NodeEvent } from '../poly/NodeEvent';
import { BaseNodeByContextMap, NodeContext } from '../poly/NodeContext';
import { ParamsAccessorType } from './utils/params/ParamsAccessor';
import { ContainableMap } from '../containers/utils/ContainableMap';
import { ParamOptions } from '../params/utils/OptionsController';
import { ParamType } from '../poly/ParamType';
import { DisplayNodeController } from './utils/DisplayNodeController';
import { ParamInitValueSerialized } from '../params/types/ParamInitValueSerialized';
import { ModuleName } from '../poly/registers/modules/Common';
import { BasePersistedConfig } from './utils/BasePersistedConfig';
import { AssemblerName } from '../poly/registers/assemblers/_BaseRegister';
import { PolyNodeController } from './utils/poly/PolyNodeController';
import { CoreGraphNodeId } from '../../core/graph/CoreGraph';
import { PolyDictionary } from '../../types/GlobalTypes';
import { SetInputsOptions } from './utils/io/InputsController';
import { OnNodeRegisterCallback } from '../poly/registers/nodes/NodesRegister';
import { EventDispatcher, BaseEvent, EventListener } from 'three';
import { CoreObjectType, ObjectContent } from '../../core/geometry/ObjectContent';
export interface NodeDeletedEmitData {
    parent_id: CoreGraphNodeId;
}
export interface NodeCreatedEmitData {
    child_node_json: NodeSerializerData;
}
type EmitDataByNodeEventMapGeneric = {
    [key in NodeEvent]: any;
};
export interface EmitDataByNodeEventMap extends EmitDataByNodeEventMapGeneric {
    [NodeEvent.CREATED]: NodeCreatedEmitData;
    [NodeEvent.DELETED]: NodeDeletedEmitData;
    [NodeEvent.ERROR_UPDATED]: undefined;
}
export interface IntegrationData {
    name: string;
    data: PolyDictionary<string>;
}
export interface BaseNodeEvent extends BaseEvent {
    target?: BaseNodeType;
}
export type NodeEventListener = EventListener<BaseNodeEvent, string, EventDispatcher<BaseNodeEvent>>;
export declare const DEFAULT_DATA_TYPE = "default";
/**
 *
 *
 * TypedNode is the base class that all nodes inherit from. This inherits from [CoreGraphNode](/docs/api/CoreGraphNode).
 *
 */
export declare class TypedNode<NC extends NodeContext, K extends NodeParamsConfig> extends CoreGraphNode {
    createOptions?: NodeCreateOptions | undefined;
    containerController: TypedContainerController<NC>;
    private _parentController;
    private _uiData;
    private _states;
    private _lifecycle;
    private _serializer;
    private _cookController;
    readonly flags: FlagsController | undefined;
    readonly displayNodeController: DisplayNodeController | undefined;
    readonly persisted_config: BasePersistedConfig | undefined;
    private _paramsController;
    readonly paramsConfig: K | undefined;
    readonly pv: ParamsValueAccessorType<K>;
    readonly p: ParamsAccessorType<K>;
    copy_param_values(node: TypedNode<NC, K>): void;
    dataType(): string;
    private _nameController;
    get parentController(): HierarchyParentController;
    static displayedInputNames(): string[] | undefined;
    displayedInputNames(): string[] | undefined;
    private _childrenController;
    protected _childrenControllerContext: NodeContext | undefined;
    childrenControllerContext(): NodeContext | undefined;
    private _create_childrenController;
    get childrenController(): HierarchyChildrenController | undefined;
    childrenAllowed(): boolean;
    sceneReadonly(): boolean;
    get uiData(): UIData;
    get states(): NodeStatesController<NC>;
    get lifecycle(): NodeLifeCycleController;
    get serializer(): CoreNodeSerializer | undefined;
    get cookController(): NodeCookController<NC>;
    protected _io: IOController<NC> | undefined;
    get io(): IOController<NC>;
    get nameController(): NameController;
    /**
     * sets the name of a node. Note that if a sibling node already has that name, it will be updated to be unique.
     *
     */
    setName(name: string): void;
    _setCoreName(name: string): void;
    get params(): ParamsController;
    constructor(scene: PolyScene, nodeName?: string, createOptions?: NodeCreateOptions | undefined);
    private _initialized;
    initializeBaseAndNode(): void;
    protected initializeBaseNode(): void;
    protected initializeNode(): void;
    static type(): string;
    static onRegister: OnNodeRegisterCallback | undefined;
    /**
     * returns the type of the node.
     *
     */
    type(): string;
    static context(): NodeContext;
    /**
     * returns the context.
     *
     */
    context(): NodeContext;
    static requireWebGL2(): boolean;
    requireWebGL2(): boolean;
    setParent(parent: BaseNodeType | null): void;
    /**
     * returns the parent.
     *
     */
    parent(): BaseNodeType | null;
    insideALockedParent(): boolean;
    lockedOrInsideALockedParent(): boolean;
    selfOrLockedParent(): BaseNodeType | null;
    lockedParent(): BaseNodeType | null;
    firstAncestorWithContext<N extends NodeContext>(context: N): BaseNodeByContextMap[N] | null;
    root(): import("./manager/Root").RootManagerNode;
    /**
     * returns the path.
     *
     */
    path(relative_to_parent?: BaseNodeType): string;
    createParams(): void;
    addParam<T extends ParamType>(type: T, name: string, default_value: ParamInitValuesTypeMap[T], options?: ParamOptions): ParamConstructorMap[T] | undefined;
    paramDefaultValue(name: string): ParamInitValueSerialized;
    cook(inputContents: any[]): any;
    /**
     * registers a callback that will be run every time the node finishes cooking.
     *
     */
    onCookEnd(callbackName: string, callback: OnCookCompleteHook): void;
    /**
     * returns a promise that will be resolved when the node finishes cooking.
     *
     */
    compute(): Promise<import("../containers/utils/ContainerMap").ContainerMap[NC]>;
    _setContainer(content: ContainableMap[NC]): void;
    /**
     * create a node.
     *
     */
    createNode(nodeClass: any, options?: NodeCreateOptions): BaseNodeType | undefined;
    createOperationContainer(type: string, operation_container_name: string, options?: NodeCreateOptions): import("../operations/container/_Base").BaseOperationContainer<any> | undefined;
    /**
     * removes a child node
     *
     */
    removeNode(node: BaseNodeType): void;
    dispose(): void;
    /**
     * returns the list of children
     *
     */
    children(): Readonly<BaseNodeType[]>;
    /**
     * returns a child node
     *
     */
    node(path: string): BaseNodeType | null;
    /**
     * returns a sibling node
     *
     */
    nodeSibling(name: string): BaseNodeByContextMap[NC] | null;
    /**
     * returns the children matching the type
     *
     */
    nodesByType(type: string): BaseNodeType[];
    /**
     * sets a node as input
     *
     */
    setInput(inputIndexOrName: number | string, node: BaseNodeByContextMap[NC] | null, outputIndexOrName?: number | string, options?: SetInputsOptions): void;
    emit(event_name: NodeEvent.CREATED, data: EmitDataByNodeEventMap[NodeEvent.CREATED]): void;
    emit(event_name: NodeEvent.DELETED, data: EmitDataByNodeEventMap[NodeEvent.DELETED]): void;
    emit(event_name: NodeEvent.NAME_UPDATED): void;
    emit(event_name: NodeEvent.OVERRIDE_CLONABLE_STATE_UPDATE): void;
    emit(event_name: NodeEvent.NAMED_INPUTS_UPDATED): void;
    emit(event_name: NodeEvent.NAMED_OUTPUTS_UPDATED): void;
    emit(event_name: NodeEvent.INPUTS_UPDATED): void;
    emit(event_name: NodeEvent.PARAMS_UPDATED): void;
    emit(event_name: NodeEvent.UI_DATA_POSITION_UPDATED): void;
    emit(event_name: NodeEvent.UI_DATA_COMMENT_UPDATED): void;
    emit(event_name: NodeEvent.ERROR_UPDATED): void;
    emit(event_name: NodeEvent.FLAG_BYPASS_UPDATED): void;
    emit(event_name: NodeEvent.FLAG_DISPLAY_UPDATED): void;
    emit(event_name: NodeEvent.FLAG_OPTIMIZE_UPDATED): void;
    emit(event_name: NodeEvent.SELECTION_UPDATED): void;
    emit(event_name: NodeEvent.POLY_NODE_LOCK_STATE_UPDATED): void;
    private __eventsDispatcher;
    private _eventsDispatcher;
    dispatchEvent(event: BaseEvent<string>): void;
    addEventListener(type: string, listener: NodeEventListener): void;
    removeEventListener(type: string, listener: NodeEventListener): void;
    toJSON(includeParamComponents?: boolean): NodeSerializerData | undefined;
    requiredModules(): ModuleName[] | void;
    usedAssembler(): AssemblerName | void;
    integrationData(): IntegrationData | void;
    readonly polyNodeController: PolyNodeController | undefined;
    processError(e: unknown): unknown;
    updateObjectOnAdd(object: ObjectContent<CoreObjectType>, parent: ObjectContent<CoreObjectType>): void;
    updateObjectOnRemove(object: ObjectContent<CoreObjectType>, parent: ObjectContent<CoreObjectType>): void;
}
export type BaseNodeType = TypedNode<any, any>;
export declare class BaseNodeClass extends TypedNode<any, any> {
}
export declare class BaseNodeClassWithDisplayFlag extends TypedNode<any, any> {
    readonly flags: FlagsControllerD;
}
export {};