import { PolyScene } from '../scene/PolyScene';
import { CoreGraphNode } from '../../core/graph/CoreGraphNode';
import { UIData } from './utils/UIData';
import { FlagsController, FlagsControllerD } from './utils/FlagsController';
import { StatesController } from './utils/StatesController';
import { HierarchyParentController } from './utils/hierarchy/ParentController';
import { HierarchyChildrenController } from './utils/hierarchy/ChildrenController';
import { LifeCycleController } from './utils/LifeCycleController';
import { TypedContainerController } from './utils/ContainerController';
import { NodeCookController } from './utils/CookController';
import { NameController } from './utils/NameController';
import { NodeSerializer, NodeSerializerData } from './utils/Serializer';
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, ParamsInitData } from './utils/io/IOController';
import { NodeEvent } from '../poly/NodeEvent';
import { NodeContext } from '../poly/NodeContext';
import { ParamsAccessorType } from './utils/params/ParamsAccessor';
export interface NodeDeletedEmitData {
    parent_id: CoreGraphNodeId;
}
export interface NodeCreatedEmitData {
    child_node_json: NodeSerializerData;
}
declare 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>;
}
import { ContainableMap } from '../containers/utils/ContainableMap';
import { ParamOptions } from '../params/utils/OptionsController';
import { ParamType } from '../poly/ParamType';
import { DisplayNodeController } from './utils/DisplayNodeController';
import { NodeTypeMap } from '../containers/utils/ContainerMap';
import { ParamInitValueSerialized } from '../params/types/ParamInitValueSerialized';
import { ModuleName } from '../poly/registers/modules/_BaseRegister';
import { BasePersistedConfig } from './utils/PersistedConfig';
import { AssemblerName } from '../poly/registers/assemblers/_BaseRegister';
import { PolyNodeController } from './utils/poly/PolyNodeController';
import { CoreGraphNodeId } from '../../core/graph/CoreGraph';
import { PolyDictionary } from '../../types/GlobalTypes';
export declare class TypedNode<NC extends NodeContext, K extends NodeParamsConfig> extends CoreGraphNode {
    params_init_value_overrides?: ParamsInitData | undefined;
    container_controller: TypedContainerController<NC>;
    private _parent_controller;
    private _ui_data;
    private _states;
    private _lifecycle;
    private _serializer;
    private _cook_controller;
    readonly flags: FlagsController | undefined;
    readonly display_node_controller: DisplayNodeController | undefined;
    readonly persisted_config: BasePersistedConfig | undefined;
    private _params_controller;
    readonly params_config: K | undefined;
    readonly pv: ParamsValueAccessorType<K>;
    readonly p: ParamsAccessorType<K>;
    copy_param_values(node: TypedNode<NC, K>): void;
    private _name_controller;
    get parentController(): HierarchyParentController;
    static displayedInputNames(): string[];
    private _children_controller;
    protected _children_controller_context: NodeContext | undefined;
    get childrenControllerContext(): NodeContext | undefined;
    private _create_children_controller;
    get childrenController(): HierarchyChildrenController | undefined;
    childrenAllowed(): boolean;
    get uiData(): UIData;
    get states(): StatesController;
    get lifecycle(): LifeCycleController;
    get serializer(): NodeSerializer;
    get cookController(): NodeCookController<NC>;
    protected _io: IOController<NC> | undefined;
    get io(): IOController<NC>;
    get nameController(): NameController;
    setName(name: string): void;
    _set_core_name(name: string): void;
    get params(): ParamsController;
    constructor(scene: PolyScene, name?: string, params_init_value_overrides?: ParamsInitData | undefined);
    private _initialized;
    initialize_base_and_node(): void;
    protected initializeBaseNode(): void;
    protected initializeNode(): void;
    static type(): string;
    type(): string;
    static nodeContext(): NodeContext;
    nodeContext(): NodeContext;
    static require_webgl2(): boolean;
    require_webgl2(): boolean;
    setParent(parent: BaseNodeType | null): void;
    parent(): BaseNodeType | null;
    root(): import("./manager/ObjectsManager").ObjectsManagerNode;
    fullPath(relative_to_parent?: BaseNodeType): string;
    create_params(): void;
    addParam<T extends ParamType>(type: T, name: string, default_value: ParamInitValuesTypeMap[T], options?: ParamOptions): ParamConstructorMap[T] | undefined;
    param_default_value(name: string): ParamInitValueSerialized;
    cook(input_contents: any[]): any;
    requestContainer(): Promise<import("../containers/utils/ContainerMap").ContainerMap[NC]>;
    setContainer(content: ContainableMap[NC], message?: string | null): void;
    createNode(node_class: any, params_init_value_overrides?: ParamsInitData): BaseNodeType | undefined;
    create_operation_container(type: string, operation_container_name: string, params_init_value_overrides?: ParamsInitData): import("../../core/operations/container/_Base").BaseOperationContainer | undefined;
    removeNode(node: BaseNodeType): void;
    dispose(): void;
    children(): BaseNodeType[];
    node(path: string): BaseNodeType | null;
    nodeSibbling(name: string): NodeTypeMap[NC] | null;
    nodesByType(type: string): BaseNodeType[];
    setInput(input_index_or_name: number | string, node: NodeTypeMap[NC] | null, output_index_or_name?: number | string): 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;
    toJSON(include_param_components?: boolean): NodeSerializerData;
    requiredModules(): Promise<ModuleName[] | void>;
    usedAssembler(): AssemblerName | void;
    integrationData(): IntegrationData | void;
    readonly polyNodeController: PolyNodeController | undefined;
}
export declare 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 {};