babylonjs-node-editor/babylon.nodeEditor.module.d.ts

Node Editor

declare module "babylonjs-node-editor/serializationTools" {
import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
import { GlobalState } from "babylonjs-node-editor/globalState";
import { Nullable } from "babylonjs/types";
import { GraphFrame } from "babylonjs-node-editor/nodeGraphSystem/graphFrame";
export class SerializationTools {
    static UpdateLocations(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
    static Serialize(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
    static Deserialize(serializationObject: any, globalState: GlobalState): void;
    static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: NodeMaterial): void;
}

}
declare module "babylonjs-node-editor/portal" {
import * as React from "react";
import { GlobalState } from "babylonjs-node-editor/globalState";
import { PropsWithChildren } from "react";
interface IPortalProps {
    globalState: GlobalState;
}
export class Portal extends React.Component<PropsWithChildren<IPortalProps>> {
    render(): React.ReactPortal;
}
export {};

}
declare module "babylonjs-node-editor/nodeEditor" {
import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
import { Observable } from "babylonjs/Misc/observable";
import { Color4 } from "babylonjs/Maths/math.color";
/**
 * Interface used to specify creation options for the node editor
 */
export interface INodeEditorOptions {
    nodeMaterial: NodeMaterial;
    hostElement?: HTMLElement;
    customSave?: {
        label: string;
        action: (data: string) => Promise<void>;
    };
    customLoadObservable?: Observable<any>;
    backgroundColor?: Color4;
}
/**
 * Class used to create a node editor
 */
export class NodeEditor {
    private static _CurrentState;
    private static _PopupWindow;
    /**
     * Show the node editor
     * @param options defines the options to use to configure the node editor
     */
    static Show(options: INodeEditorOptions): void;
}

}
declare module "babylonjs-node-editor/index" {
export * from "babylonjs-node-editor/nodeEditor";

}
declare module "babylonjs-node-editor/graphEditor" {
import * as React from "react";
import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
import { Nullable } from "babylonjs/types";
import { IInspectorOptions } from "babylonjs/Debug/debugLayer";
import "babylonjs-node-editor/main.scss";
import { GraphNode } from "babylonjs-node-editor/nodeGraphSystem/graphNode";
import { IEditorData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
import { GlobalState } from "babylonjs-node-editor/globalState";
interface IGraphEditorProps {
    globalState: GlobalState;
}
interface IGraphEditorState {
    showPreviewPopUp: boolean;
    message: string;
    isError: boolean;
}
interface IInternalPreviewAreaOptions extends IInspectorOptions {
    popup: boolean;
    original: boolean;
    explorerWidth?: string;
    inspectorWidth?: string;
    embedHostWidth?: string;
}
export class GraphEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
    private _graphCanvasRef;
    private _diagramContainerRef;
    private _graphCanvas;
    private _historyStack;
    private _previewManager;
    private _mouseLocationX;
    private _mouseLocationY;
    private _onWidgetKeyUpPointer;
    private _previewHost;
    private _popUpWindow;
    appendBlock(dataToAppend: NodeMaterialBlock | INodeData, recursion?: boolean): GraphNode;
    addValueNode(type: string): GraphNode;
    prepareHistoryStack(): void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    constructor(props: IGraphEditorProps);
    zoomToFit(): void;
    buildMaterial(): void;
    build(ignoreEditorData?: boolean): void;
    loadGraph(): void;
    showWaitScreen(): void;
    hideWaitScreen(): void;
    reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
    onWheel: (evt: WheelEvent) => void;
    emitNewBlock(blockType: string, targetX: number, targetY: number): GraphNode | undefined;
    dropNewBlock(event: React.DragEvent<HTMLDivElement>): void;
    handlePopUp: () => void;
    handleClosingPopUp: () => void;
    initiatePreviewArea: (canvas?: HTMLCanvasElement) => void;
    createPopUp: () => void;
    createPreviewMeshControlHostAsync: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => Promise<unknown>;
    createPreviewHostAsync: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => Promise<unknown>;
    fixPopUpStyles: (document: Document) => void;

}
export {};

}
declare module "babylonjs-node-editor/globalState" {
import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
import { Observable } from "babylonjs/Misc/observable";
import { LogEntry } from "babylonjs-node-editor/components/log/logComponent";
import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
import { PreviewType } from "babylonjs-node-editor/components/preview/previewType";
import { Color4 } from "babylonjs/Maths/math.color";
import { NodeMaterialModes } from "babylonjs/Materials/Node/Enums/nodeMaterialModes";
import { GraphNode } from "babylonjs-node-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "babylonjs-node-editor/nodeGraphSystem/graphFrame";
import { Nullable } from "babylonjs/types";
import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
import { FilesInput } from "babylonjs/Misc/filesInput";
import { RenderTargetTexture } from "babylonjs/Materials/Textures/renderTargetTexture";
import { NodeMaterialDebugBlock } from "babylonjs/Materials/Node/Blocks/debugBlock";
export class GlobalState {
    hostElement: HTMLElement;
    hostDocument: Document;
    hostWindow: Window;
    stateManager: StateManager;
    onBuiltObservable: Observable<void>;
    onResetRequiredObservable: Observable<boolean>;
    onClearUndoStack: Observable<void>;
    onZoomToFitRequiredObservable: Observable<void>;
    onReOrganizedRequiredObservable: Observable<void>;
    onLogRequiredObservable: Observable<LogEntry>;
    onIsLoadingChanged: Observable<boolean>;
    onLightUpdated: Observable<void>;
    onBackgroundHDRUpdated: Observable<void>;
    onPreviewBackgroundChanged: Observable<void>;
    onBackFaceCullingChanged: Observable<void>;
    onDepthPrePassChanged: Observable<void>;
    onAnimationCommandActivated: Observable<void>;
    onImportFrameObservable: Observable<any>;
    onPopupClosedObservable: Observable<void>;
    onDropEventReceivedObservable: Observable<DragEvent>;
    onGetNodeFromBlock: (block: NodeMaterialBlock) => GraphNode;
    previewType: PreviewType;
    previewFile: File;
    envType: PreviewType;
    envFile: File;
    particleSystemBlendMode: number;
    listOfCustomPreviewFiles: File[];
    rotatePreview: boolean;
    backgroundColor: Color4;
    backFaceCulling: boolean;
    depthPrePass: boolean;
    lockObject: LockObject;
    hemisphericLight: boolean;
    directionalLight0: boolean;
    directionalLight1: boolean;
    backgroundHDR: boolean;
    controlCamera: boolean;
    _mode: NodeMaterialModes;
    _engine: number;
    pointerOverCanvas: boolean;
    filesInput: FilesInput;
    onRefreshPreviewMeshControlComponentRequiredObservable: Observable<void>;
    previewTexture: Nullable<RenderTargetTexture>;
    pickingTexture: Nullable<RenderTargetTexture>;
    onPreviewSceneAfterRenderObservable: Observable<void>;
    onPreviewUpdatedObservable: Observable<NodeMaterial>;
    debugBlocksToRefresh: NodeMaterialDebugBlock[];
    forcedDebugBlock: Nullable<NodeMaterialDebugBlock>;
    /** Gets the mode */
    get mode(): NodeMaterialModes;
    /** Sets the mode */
    set mode(m: NodeMaterialModes);
    /** Gets the engine */
    get engine(): number;
    /** Sets the engine */
    set engine(e: number);
    private _nodeMaterial;
    /**
     * Gets the current node material
     */
    get nodeMaterial(): NodeMaterial;
    /**
     * Sets the current node material
     */
    set nodeMaterial(nodeMaterial: NodeMaterial);
    customSave?: {
        label: string;
        action: (data: string) => Promise<void>;
    };
    constructor();
    storeEditorData(serializationObject: any, frame?: Nullable<GraphFrame>): void;
}

}
declare module "babylonjs-node-editor/blockTools" {
import { DiscardBlock } from "babylonjs/Materials/Node/Blocks/Fragment/discardBlock";
import { BonesBlock } from "babylonjs/Materials/Node/Blocks/Vertex/bonesBlock";
import { InstancesBlock } from "babylonjs/Materials/Node/Blocks/Vertex/instancesBlock";
import { MorphTargetsBlock } from "babylonjs/Materials/Node/Blocks/Vertex/morphTargetsBlock";
import { ImageProcessingBlock } from "babylonjs/Materials/Node/Blocks/Fragment/imageProcessingBlock";
import { ColorMergerBlock } from "babylonjs/Materials/Node/Blocks/colorMergerBlock";
import { VectorMergerBlock } from "babylonjs/Materials/Node/Blocks/vectorMergerBlock";
import { ColorSplitterBlock } from "babylonjs/Materials/Node/Blocks/colorSplitterBlock";
import { VectorSplitterBlock } from "babylonjs/Materials/Node/Blocks/vectorSplitterBlock";
import { RemapBlock } from "babylonjs/Materials/Node/Blocks/remapBlock";
import { TextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/textureBlock";
import { ReflectionTextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock";
import { LightBlock } from "babylonjs/Materials/Node/Blocks/Dual/lightBlock";
import { FogBlock } from "babylonjs/Materials/Node/Blocks/Dual/fogBlock";
import { VertexOutputBlock } from "babylonjs/Materials/Node/Blocks/Vertex/vertexOutputBlock";
import { FragmentOutputBlock } from "babylonjs/Materials/Node/Blocks/Fragment/fragmentOutputBlock";
import { PrePassOutputBlock } from "babylonjs/Materials/Node/Blocks/Fragment/prePassOutputBlock";
import { NormalizeBlock } from "babylonjs/Materials/Node/Blocks/normalizeBlock";
import { AddBlock } from "babylonjs/Materials/Node/Blocks/addBlock";
import { ModBlock } from "babylonjs/Materials/Node/Blocks/modBlock";
import { ScaleBlock } from "babylonjs/Materials/Node/Blocks/scaleBlock";
import { TrigonometryBlock } from "babylonjs/Materials/Node/Blocks/trigonometryBlock";
import { ConditionalBlock } from "babylonjs/Materials/Node/Blocks/conditionalBlock";
import { ClampBlock } from "babylonjs/Materials/Node/Blocks/clampBlock";
import { CrossBlock } from "babylonjs/Materials/Node/Blocks/crossBlock";
import { DotBlock } from "babylonjs/Materials/Node/Blocks/dotBlock";
import { MultiplyBlock } from "babylonjs/Materials/Node/Blocks/multiplyBlock";
import { TransformBlock } from "babylonjs/Materials/Node/Blocks/transformBlock";
import { NodeMaterialBlockConnectionPointTypes } from "babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes";
import { FresnelBlock } from "babylonjs/Materials/Node/Blocks/fresnelBlock";
import { LerpBlock } from "babylonjs/Materials/Node/Blocks/lerpBlock";
import { NLerpBlock } from "babylonjs/Materials/Node/Blocks/nLerpBlock";
import { DivideBlock } from "babylonjs/Materials/Node/Blocks/divideBlock";
import { SubtractBlock } from "babylonjs/Materials/Node/Blocks/subtractBlock";
import { StepBlock } from "babylonjs/Materials/Node/Blocks/stepBlock";
import { SmoothStepBlock } from "babylonjs/Materials/Node/Blocks/smoothStepBlock";
import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock";
import { OneMinusBlock } from "babylonjs/Materials/Node/Blocks/oneMinusBlock";
import { ViewDirectionBlock } from "babylonjs/Materials/Node/Blocks/viewDirectionBlock";
import { LightInformationBlock } from "babylonjs/Materials/Node/Blocks/Vertex/lightInformationBlock";
import { MaxBlock } from "babylonjs/Materials/Node/Blocks/maxBlock";
import { MinBlock } from "babylonjs/Materials/Node/Blocks/minBlock";
import { PerturbNormalBlock } from "babylonjs/Materials/Node/Blocks/Fragment/perturbNormalBlock";
import { TBNBlock } from "babylonjs/Materials/Node/Blocks/Fragment/TBNBlock";
import { LengthBlock } from "babylonjs/Materials/Node/Blocks/lengthBlock";
import { DistanceBlock } from "babylonjs/Materials/Node/Blocks/distanceBlock";
import { FrontFacingBlock } from "babylonjs/Materials/Node/Blocks/Fragment/frontFacingBlock";
import { MeshAttributeExistsBlock } from "babylonjs/Materials/Node/Blocks/meshAttributeExistsBlock";
import { NegateBlock } from "babylonjs/Materials/Node/Blocks/negateBlock";
import { PowBlock } from "babylonjs/Materials/Node/Blocks/powBlock";
import { Scene } from "babylonjs/scene";
import { RandomNumberBlock } from "babylonjs/Materials/Node/Blocks/randomNumberBlock";
import { ReplaceColorBlock } from "babylonjs/Materials/Node/Blocks/replaceColorBlock";
import { PosterizeBlock } from "babylonjs/Materials/Node/Blocks/posterizeBlock";
import { ArcTan2Block } from "babylonjs/Materials/Node/Blocks/arcTan2Block";
import { ReciprocalBlock } from "babylonjs/Materials/Node/Blocks/reciprocalBlock";
import { GradientBlock } from "babylonjs/Materials/Node/Blocks/gradientBlock";
import { WaveBlock } from "babylonjs/Materials/Node/Blocks/waveBlock";
import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
import { WorleyNoise3DBlock } from "babylonjs/Materials/Node/Blocks/worleyNoise3DBlock";
import { SimplexPerlin3DBlock } from "babylonjs/Materials/Node/Blocks/simplexPerlin3DBlock";
import { NormalBlendBlock } from "babylonjs/Materials/Node/Blocks/normalBlendBlock";
import { Rotate2dBlock } from "babylonjs/Materials/Node/Blocks/rotate2dBlock";
import { DerivativeBlock } from "babylonjs/Materials/Node/Blocks/Fragment/derivativeBlock";
import { RefractBlock } from "babylonjs/Materials/Node/Blocks/refractBlock";
import { ReflectBlock } from "babylonjs/Materials/Node/Blocks/reflectBlock";
import { DesaturateBlock } from "babylonjs/Materials/Node/Blocks/desaturateBlock";
import { PBRMetallicRoughnessBlock } from "babylonjs/Materials/Node/Blocks/PBR/pbrMetallicRoughnessBlock";
import { SheenBlock } from "babylonjs/Materials/Node/Blocks/PBR/sheenBlock";
import { AnisotropyBlock } from "babylonjs/Materials/Node/Blocks/PBR/anisotropyBlock";
import { ReflectionBlock } from "babylonjs/Materials/Node/Blocks/PBR/reflectionBlock";
import { ClearCoatBlock } from "babylonjs/Materials/Node/Blocks/PBR/clearCoatBlock";
import { RefractionBlock } from "babylonjs/Materials/Node/Blocks/PBR/refractionBlock";
import { SubSurfaceBlock } from "babylonjs/Materials/Node/Blocks/PBR/subSurfaceBlock";
import { CurrentScreenBlock } from "babylonjs/Materials/Node/Blocks/Dual/currentScreenBlock";
import { ParticleTextureBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleTextureBlock";
import { ParticleRampGradientBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleRampGradientBlock";
import { ParticleBlendMultiplyBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleBlendMultiplyBlock";
import { GaussianSplattingBlock } from "babylonjs/Materials/Node/Blocks/GaussianSplatting/gaussianSplattingBlock";
import { GaussianBlock } from "babylonjs/Materials/Node/Blocks/GaussianSplatting/gaussianBlock";
import { SplatReaderBlock } from "babylonjs/Materials/Node/Blocks/GaussianSplatting/splatReaderBlock";
import { FragCoordBlock } from "babylonjs/Materials/Node/Blocks/Fragment/fragCoordBlock";
import { ScreenSizeBlock } from "babylonjs/Materials/Node/Blocks/Fragment/screenSizeBlock";
import { MatrixBuilderBlock } from "babylonjs/Materials/Node/Blocks/matrixBuilderBlock";
import { SceneDepthBlock } from "babylonjs/Materials/Node/Blocks/Dual/sceneDepthBlock";
import { ImageSourceBlock } from "babylonjs/Materials/Node/Blocks/Dual/imageSourceBlock";
import { CloudBlock } from "babylonjs/Materials/Node/Blocks/cloudBlock";
import { VoronoiNoiseBlock } from "babylonjs/Materials/Node/Blocks/voronoiNoiseBlock";
import { ScreenSpaceBlock } from "babylonjs/Materials/Node/Blocks/Fragment/screenSpaceBlock";
import { HeightToNormalBlock } from "babylonjs/Materials/Node/Blocks/Fragment/heightToNormalBlock";
import { TwirlBlock } from "babylonjs/Materials/Node/Blocks/Fragment/twirlBlock";
import { ElbowBlock } from "babylonjs/Materials/Node/Blocks/elbowBlock";
import { ClipPlanesBlock } from "babylonjs/Materials/Node/Blocks/Dual/clipPlanesBlock";
import { FragDepthBlock } from "babylonjs/Materials/Node/Blocks/Fragment/fragDepthBlock";
import { ShadowMapBlock } from "babylonjs/Materials/Node/Blocks/Fragment/shadowMapBlock";
import { TriPlanarBlock } from "babylonjs/Materials/Node/Blocks/triPlanarBlock";
import { MatrixDeterminantBlock } from "babylonjs/Materials/Node/Blocks/matrixDeterminantBlock";
import { MatrixTransposeBlock } from "babylonjs/Materials/Node/Blocks/matrixTransposeBlock";
import { CurveBlock } from "babylonjs/Materials/Node/Blocks/curveBlock";
import { PrePassTextureBlock } from "babylonjs/Materials/Node/Blocks/Input/prePassTextureBlock";
import { NodeMaterialTeleportInBlock } from "babylonjs/Materials/Node/Blocks/Teleport/teleportInBlock";
import { NodeMaterialTeleportOutBlock } from "babylonjs/Materials/Node/Blocks/Teleport/teleportOutBlock";
import { ColorConverterBlock } from "babylonjs/Materials/Node/Blocks/colorConverterBlock";
import { LoopBlock } from "babylonjs/Materials/Node/Blocks/loopBlock";
import { StorageReadBlock } from "babylonjs/Materials/Node/Blocks/storageReadBlock";
import { StorageWriteBlock } from "babylonjs/Materials/Node/Blocks/storageWriteBlock";
import { MatrixSplitterBlock } from "babylonjs/Materials/Node/Blocks/matrixSplitterBlock";
import { NodeMaterialDebugBlock } from "babylonjs/Materials/Node/Blocks/debugBlock";
import { IridescenceBlock } from "babylonjs/Materials/Node/Blocks/PBR/iridescenceBlock";
import { AmbientOcclusionBlock } from "babylonjs/Materials/Node/Blocks/Fragment/ambientOcclusionBlock";
export class BlockTools {
    static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial): AmbientOcclusionBlock | NodeMaterialDebugBlock | MatrixSplitterBlock | StorageWriteBlock | StorageReadBlock | LoopBlock | ColorConverterBlock | NodeMaterialTeleportInBlock | NodeMaterialTeleportOutBlock | HeightToNormalBlock | ElbowBlock | TwirlBlock | VoronoiNoiseBlock | ScreenSpaceBlock | CloudBlock | MatrixBuilderBlock | DesaturateBlock | RefractBlock | ReflectBlock | DerivativeBlock | Rotate2dBlock | NormalBlendBlock | WorleyNoise3DBlock | SimplexPerlin3DBlock | BonesBlock | InstancesBlock | MorphTargetsBlock | DiscardBlock | PrePassTextureBlock | ImageProcessingBlock | ColorMergerBlock | VectorMergerBlock | ColorSplitterBlock | VectorSplitterBlock | TextureBlock | ReflectionTextureBlock | LightBlock | FogBlock | VertexOutputBlock | FragmentOutputBlock | PrePassOutputBlock | AddBlock | ClampBlock | ScaleBlock | CrossBlock | DotBlock | PowBlock | MultiplyBlock | TransformBlock | TrigonometryBlock | RemapBlock | NormalizeBlock | FresnelBlock | LerpBlock | NLerpBlock | DivideBlock | SubtractBlock | ModBlock | StepBlock | SmoothStepBlock | OneMinusBlock | ReciprocalBlock | ViewDirectionBlock | LightInformationBlock | MaxBlock | MinBlock | LengthBlock | DistanceBlock | NegateBlock | PerturbNormalBlock | TBNBlock | RandomNumberBlock | ReplaceColorBlock | PosterizeBlock | ArcTan2Block | GradientBlock | FrontFacingBlock | MeshAttributeExistsBlock | WaveBlock | InputBlock | PBRMetallicRoughnessBlock | SheenBlock | AnisotropyBlock | ReflectionBlock | ClearCoatBlock | RefractionBlock | SubSurfaceBlock | IridescenceBlock | CurrentScreenBlock | ParticleTextureBlock | ParticleRampGradientBlock | ParticleBlendMultiplyBlock | FragCoordBlock | ScreenSizeBlock | SceneDepthBlock | ConditionalBlock | ImageSourceBlock | ClipPlanesBlock | FragDepthBlock | ShadowMapBlock | TriPlanarBlock | MatrixTransposeBlock | MatrixDeterminantBlock | CurveBlock | GaussianSplattingBlock | GaussianBlock | SplatReaderBlock | null;
    static GetColorFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): string;
    static GetConnectionNodeTypeFromString(type: string): NodeMaterialBlockConnectionPointTypes.Float | NodeMaterialBlockConnectionPointTypes.Vector2 | NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Vector4 | NodeMaterialBlockConnectionPointTypes.Color3 | NodeMaterialBlockConnectionPointTypes.Color4 | NodeMaterialBlockConnectionPointTypes.Matrix | NodeMaterialBlockConnectionPointTypes.AutoDetect;
    static GetStringFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): "" | "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4";
}

}
declare module "babylonjs-node-editor/sharedComponents/textureLineComponent" {
import * as React from "react";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
interface ITextureLineComponentProps {
    texture: BaseTexture;
    width: number;
    height: number;
    globalState?: any;
    hideChannelSelect?: boolean;
}
export interface ITextureLineComponentState {
    displayRed: boolean;
    displayGreen: boolean;
    displayBlue: boolean;
    displayAlpha: boolean;
    face: number;
}
export class TextureLineComponent extends React.Component<ITextureLineComponentProps, ITextureLineComponentState> {
    private _canvasRef;
    constructor(props: ITextureLineComponentProps);
    shouldComponentUpdate(): boolean;
    componentDidMount(): void;
    componentDidUpdate(): void;
    updatePreview(): void;
    static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;

}
export {};

}
declare module "babylonjs-node-editor/sharedComponents/checkBoxLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-node-editor/propertyChangedEvent";
export interface ICheckBoxLineComponentProps {
    label: string;
    target?: any;
    propertyName?: string;
    isSelected?: () => boolean;
    onSelect?: (value: boolean) => void;
    onValueChanged?: () => void;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    disabled?: boolean;
}
export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
    isSelected: boolean;
    isDisabled?: boolean;
}> {
    private static _UniqueIdSeed;
    private _uniqueId;
    private _localChange;
    constructor(props: ICheckBoxLineComponentProps);
    shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
        isSelected: boolean;
        isDisabled: boolean;
    }): boolean;
    onChange(): void;



}

}
declare module "babylonjs-node-editor/legacy/legacy" {
export * from "babylonjs-node-editor/index";

}
declare module "babylonjs-node-editor/graphSystem/registerToTypeLedger" {
export const RegisterTypeLedger: () => void;

}
declare module "babylonjs-node-editor/graphSystem/registerToPropertyLedger" {
export const RegisterToPropertyTabManagers: () => void;

}
declare module "babylonjs-node-editor/graphSystem/registerToDisplayLedger" {
export const RegisterToDisplayManagers: () => void;

}
declare module "babylonjs-node-editor/graphSystem/registerNodePortDesign" {
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
export const RegisterNodePortDesign: (stateManager: StateManager) => void;

}
declare module "babylonjs-node-editor/graphSystem/registerExportData" {
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
export const RegisterExportData: (stateManager: StateManager) => void;

}
declare module "babylonjs-node-editor/graphSystem/registerElbowSupport" {
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
export const RegisterElbowSupport: (stateManager: StateManager) => void;

}
declare module "babylonjs-node-editor/graphSystem/registerDefaultInput" {
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
export const RegisterDefaultInput: (stateManager: StateManager) => void;

}
declare module "babylonjs-node-editor/graphSystem/registerDebugSupport" {
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
export const RegisterDebugSupport: (stateManager: StateManager) => void;

}
declare module "babylonjs-node-editor/graphSystem/connectionPointPortData" {
import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
import { NodeMaterialConnectionPoint } from "babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint";
import { NodeMaterialConnectionPointCompatibilityStates } from "babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint";
import { Nullable } from "babylonjs/types";
import { GraphNode } from "babylonjs-node-editor/nodeGraphSystem/graphNode";
import { INodeContainer } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeContainer";
import { IPortData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/portData";
import { PortDataDirection } from "babylonjs-node-editor/nodeGraphSystem/interfaces/portData";
export class ConnectionPointPortData implements IPortData {
    private _connectedPort;
    private _nodeContainer;
    data: NodeMaterialConnectionPoint;
    get name(): string;
    get internalName(): string;
    get isExposedOnFrame(): boolean;
    set isExposedOnFrame(value: boolean);
    get exposedPortPosition(): number;
    set exposedPortPosition(value: number);
    get isConnected(): boolean;
    get isInactive(): boolean;
    get connectedPort(): Nullable<IPortData>;
    set connectedPort(value: Nullable<IPortData>);
    get direction(): PortDataDirection;
    get ownerData(): NodeMaterialBlock;
    get needDualDirectionValidation(): boolean;
    get hasEndpoints(): boolean;
    get endpoints(): IPortData[];
    constructor(connectionPoint: NodeMaterialConnectionPoint, nodeContainer: INodeContainer);
    updateDisplayName(newName: string): void;
    connectTo(port: IPortData): void;
    canConnectTo(port: IPortData): boolean;
    disconnectFrom(port: IPortData): void;
    checkCompatibilityState(port: IPortData): 0 | NodeMaterialConnectionPointCompatibilityStates.TypeIncompatible | NodeMaterialConnectionPointCompatibilityStates.TargetIncompatible | NodeMaterialConnectionPointCompatibilityStates.HierarchyIssue;
    getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string;
}

}
declare module "babylonjs-node-editor/graphSystem/blockNodeData" {
import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock";
import { INodeContainer } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeContainer";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/portData";
import { NodeMaterialTeleportOutBlock } from "babylonjs/Materials/Node/Blocks/Teleport/teleportOutBlock";
export class BlockNodeData implements INodeData {
    data: NodeMaterialBlock;
    private _inputs;
    private _outputs;
    get uniqueId(): number;
    get name(): string;
    getClassName(): string;
    get isInput(): boolean;
    get inputs(): IPortData[];
    get outputs(): IPortData[];
    get comments(): string;
    set comments(value: string);
    get executionTime(): number;
    getPortByName(name: string): IPortData | null;
    dispose(): void;
    prepareHeaderIcon(iconDiv: HTMLDivElement, img: HTMLImageElement): void;
    get invisibleEndpoints(): NodeMaterialTeleportOutBlock[] | null;
    constructor(data: NodeMaterialBlock, nodeContainer: INodeContainer);
    get canBeActivated(): boolean;
    get isActive(): any;
    setIsActive(value: boolean): void;
}

}
declare module "babylonjs-node-editor/graphSystem/properties/vectorMergerPropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class VectorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);

}

}
declare module "babylonjs-node-editor/graphSystem/properties/texturePropertyTabComponent" {
import * as React from "react";
import { ReflectionTextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock";
import { ReflectionBlock } from "babylonjs/Materials/Node/Blocks/PBR/reflectionBlock";
import { RefractionBlock } from "babylonjs/Materials/Node/Blocks/PBR/refractionBlock";
import { TextureBlock } from "babylonjs/Materials/Node/Blocks/Dual/textureBlock";
import { CurrentScreenBlock } from "babylonjs/Materials/Node/Blocks/Dual/currentScreenBlock";
import { ParticleTextureBlock } from "babylonjs/Materials/Node/Blocks/Particle/particleTextureBlock";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
import { TriPlanarBlock } from "babylonjs/Materials/Node/Blocks/triPlanarBlock";
type ReflectionTexture = ReflectionTextureBlock | ReflectionBlock | RefractionBlock;
type AnyTexture = TextureBlock | ReflectionTexture | CurrentScreenBlock | ParticleTextureBlock | TriPlanarBlock;
export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
    isEmbedded: boolean;
    loadAsCubeTexture: boolean;
    textureIsPrefiltered: boolean;
}> {
    get textureBlock(): AnyTexture;
    constructor(props: IPropertyComponentProps);
    UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
        isEmbedded: boolean;
        loadAsCubeTexture: boolean;
    }): void;
    private _generateRandomForCache;
    updateAfterTextureLoad(): void;
    removeTexture(): void;
    _prepareTexture(): void;
    /**
     * Replaces the texture of the node
     * @param file the file of the texture to use
     */
    replaceTexture(file: File): void;
    replaceTextureWithUrl(url: string): void;

}
export {};

}
declare module "babylonjs-node-editor/graphSystem/properties/teleportOutNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class TeleportOutPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    private _onUpdateRequiredObserver;
    constructor(props: IPropertyComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/nodePortPropertyComponent" {
import * as React from "react";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
import { NodePort } from "babylonjs-node-editor/nodeGraphSystem/nodePort";
export interface IFrameNodePortPropertyTabComponentProps {
    stateManager: StateManager;
    nodePort: NodePort;
}
export class NodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps> {
    constructor(props: IFrameNodePortPropertyTabComponentProps);
    toggleExposeOnFrame(value: boolean): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/lightPropertyTabComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class LightPropertyTabComponent extends React.Component<IPropertyComponentProps> {

}

}
declare module "babylonjs-node-editor/graphSystem/properties/lightInformationPropertyTabComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class LightInformationPropertyTabComponent extends React.Component<IPropertyComponentProps> {

}

}
declare module "babylonjs-node-editor/graphSystem/properties/inputNodePropertyComponent" {
import * as React from "react";
import { GlobalState } from "babylonjs-node-editor/globalState";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class InputPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    private _onValueChangedObserver;
    constructor(props: IPropertyComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;

    setDefaultValue(): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/imageSourcePropertyTabComponent" {
import * as React from "react";
import { ImageSourceBlock } from "babylonjs/Materials/Node/Blocks/Dual/imageSourceBlock";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class ImageSourcePropertyTabComponent extends React.Component<IPropertyComponentProps, {
    isEmbedded: boolean;
}> {
    get imageSourceBlock(): ImageSourceBlock;
    constructor(props: IPropertyComponentProps);
    UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
        isEmbedded: boolean;
        loadAsCubeTexture: boolean;
    }): void;
    private _generateRandomForCache;
    updateAfterTextureLoad(): void;
    removeTexture(): void;
    _prepareTexture(): void;
    /**
     * Replaces the texture of the node
     * @param file the file of the texture to use
     */
    replaceTexture(file: File): void;
    replaceTextureWithUrl(url: string): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/gradientStepComponent" {
import * as React from "react";
import { GradientBlockColorStep } from "babylonjs/Materials/Node/Blocks/gradientBlock";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
interface IGradientStepComponentProps {
    stateManager: StateManager;
    step: GradientBlockColorStep;
    lineIndex: number;
    onDelete: () => void;
    onUpdateStep: () => void;
    onCheckForReOrder: () => void;
    onCopy?: () => void;
}
export class GradientStepComponent extends React.Component<IGradientStepComponentProps, {
    gradient: number;
}> {
    constructor(props: IGradientStepComponentProps);
    updateColor(color: string): void;
    updateStep(gradient: number): void;
    onPointerUp(): void;

}
export {};

}
declare module "babylonjs-node-editor/graphSystem/properties/gradientNodePropertyComponent" {
import * as React from "react";
import { GradientBlockColorStep } from "babylonjs/Materials/Node/Blocks/gradientBlock";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class GradientPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    private _onValueChangedObserver;
    constructor(props: IPropertyComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    forceRebuild(): void;
    deleteStep(step: GradientBlockColorStep): void;
    copyStep(step: GradientBlockColorStep): void;
    addNewStep(): void;
    checkForReOrder(): void;



}

}
declare module "babylonjs-node-editor/graphSystem/properties/genericNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class DefaultPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);

}
/**
 * NOTE This is intentionally a function to avoid another wrapper JSX element around the lineContainerComponent, and will ensure
 * the lineContainerComponent gets properly rendered as a child of the Accordion
 * @param props
 * @returns
 */

/**
 * NOTE This is intentionally a function to avoid another wrapper JSX element around the lineContainerComponent, and will ensure
 * the lineContainerComponent gets properly rendered as a child of the Accordion
 * @param props
 * @returns
 */


}
declare module "babylonjs-node-editor/graphSystem/properties/framePropertyComponent" {
import * as React from "react";
import { GlobalState } from "babylonjs-node-editor/globalState";
import { GraphFrame } from "babylonjs-node-editor/nodeGraphSystem/graphFrame";
export interface IFramePropertyTabComponentProps {
    globalState: GlobalState;
    frame: GraphFrame;
}
export class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
    private _onFrameExpandStateChangedObserver;
    constructor(props: IFramePropertyTabComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/frameNodePortPropertyComponent" {
import * as React from "react";
import { GlobalState } from "babylonjs-node-editor/globalState";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
import { GraphFrame } from "babylonjs-node-editor/nodeGraphSystem/graphFrame";
import { FrameNodePort } from "babylonjs-node-editor/nodeGraphSystem/frameNodePort";
export interface IFrameNodePortPropertyTabComponentProps {
    stateManager: StateManager;
    globalState: GlobalState;
    frameNodePort: FrameNodePort;
    frame: GraphFrame;
}
export class FrameNodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps, {
    port: FrameNodePort;
}> {
    private _onFramePortPositionChangedObserver;
    private _onSelectionChangedObserver;
    constructor(props: IFrameNodePortPropertyTabComponentProps);
    componentWillUnmount(): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/debugNodePropertyTabComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class DebugNodePropertyTabComponent extends React.Component<IPropertyComponentProps> {
    refreshAll(): void;

}

}
declare module "babylonjs-node-editor/graphSystem/properties/colorMergerPropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "babylonjs-node-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class ColorMergerPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);

}

}
declare module "babylonjs-node-editor/graphSystem/display/trigonometryDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class TrigonometryDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/textureDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class TextureDisplayManager implements IDisplayManager {
    private _previewCanvas;
    private _previewImage;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/teleportOutDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
import { Nullable } from "babylonjs/types";
export class TeleportOutDisplayManager implements IDisplayManager {
    private _hasHighlights;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
    onSelectionChanged(nodeData: INodeData, selectedData: Nullable<INodeData>, manager: StateManager): void;
    onDispose(nodeData: INodeData, manager: StateManager): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/teleportInDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
import { Nullable } from "babylonjs/types";
export class TeleportInDisplayManager implements IDisplayManager {
    private _hasHighlights;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
    onSelectionChanged(nodeData: INodeData, selectedData: Nullable<INodeData>, manager: StateManager): void;
    onDispose(nodeData: INodeData, manager: StateManager): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/remapDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class RemapDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    private _extractInputValue;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/pbrDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class PBRDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/outputDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class OutputDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/meshAttributeExistsDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class MeshAttributeExistsDisplayManager implements IDisplayManager {
    getHeaderClass(nodeData: INodeData): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/loopDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class LoopDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/inputDisplayManager" {
import { NodeMaterialBlockConnectionPointTypes } from "babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes";
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class InputDisplayManager implements IDisplayManager {
    getHeaderClass(nodeData: INodeData): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    static GetBaseType(type: NodeMaterialBlockConnectionPointTypes): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/imageSourceDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class ImageSourceDisplayManager implements IDisplayManager {
    private _previewCanvas;
    private _previewImage;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/gradientDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class GradientDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/elbowDisplayManager" {
import { IDisplayManager, VisualContentDescription } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class ElbowDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(_nodeData: INodeData, _contentArea: HTMLDivElement): void;
    updateFullVisualContent(data: INodeData, visualContent: VisualContentDescription): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/discardDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class DiscardDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/depthSourceDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class DepthSourceDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/debugDisplayManager" {
import { IDisplayManager, VisualContentDescription } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
import { Nullable } from "babylonjs/types";
import { StateManager } from "babylonjs-node-editor/nodeGraphSystem/stateManager";
export class DebugDisplayManager implements IDisplayManager {
    private _previewCanvas;
    private _previewImage;
    private _onPreviewSceneAfterRenderObserver;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    onSelectionChanged?(data: INodeData, selectedData: Nullable<INodeData>, manager: StateManager): void;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
    updateFullVisualContent(data: INodeData, visualContent: VisualContentDescription): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/curveDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "babylonjs-node-editor/nodeGraphSystem/interfaces/nodeData";
export class CurveDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "babylonjs-node-editor/graphSystem/display/conditionalDisplayManager" {
import { IDisplayManager } from "babylonjs-node-editor/nodeGraphSystem/int