@babylonjs/node-geometry-editor/dist/babylon.nodeGeometryEditor.module.d.ts

Node Geometry Editor es6

declare module "@babylonjs/node-geometry-editor/serializationTools" {
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { Nullable } from "@babylonjs/core/types";
import { GraphFrame } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphFrame";
import { NodeGeometry } from "@babylonjs/core/Meshes/Node/nodeGeometry";
export class SerializationTools {
    static UpdateLocations(geometry: NodeGeometry, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
    static Serialize(geometry: NodeGeometry, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
    static Deserialize(serializationObject: any, globalState: GlobalState): void;
    static AddFrameToGeometry(serializationObject: any, globalState: GlobalState, currentGeometry: NodeGeometry): void;
}

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

}
declare module "@babylonjs/node-geometry-editor/nodeGeometryEditor" {
import { NodeGeometry } from "@babylonjs/core/Meshes/Node/nodeGeometry";
import { Observable } from "@babylonjs/core/Misc/observable";
import { Color4 } from "@babylonjs/core/Maths/math.color";
import { Scene } from "@babylonjs/core/scene";
import { Mesh } from "@babylonjs/core/Meshes/mesh";
/**
 * Interface used to specify creation options for the node editor
 */
export interface INodeEditorOptions {
    nodeGeometry: NodeGeometry;
    hostScene?: Scene;
    hostMesh?: Mesh;
    hostElement?: HTMLElement;
    customSave?: {
        label: string;
        action: (data: string) => Promise<void>;
    };
    customLoadObservable?: Observable<any>;
    backgroundColor?: Color4;
}
/**
 * Class used to create a node editor
 */
export class NodeGeometryEditor {
    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-geometry-editor/index" {
export * from "@babylonjs/node-geometry-editor/nodeGeometryEditor";

}
declare module "@babylonjs/node-geometry-editor/graphEditor" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { Nullable } from "@babylonjs/core/types";
import { IInspectorOptions } from "@babylonjs/core/Debug/debugLayer";
import "@babylonjs/node-geometry-editor/main.scss";
import { GraphNode } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphNode";
import { IEditorData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
import { NodeGeometryBlock } from "@babylonjs/core/Meshes/Node/nodeGeometryBlock";
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: NodeGeometryBlock | INodeData, recursion?: boolean): GraphNode;
    addValueNode(type: string): GraphNode;
    prepareHistoryStack(): void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    constructor(props: IGraphEditorProps);
    zoomToFit(): void;
    buildGeometry(): 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;
    createPreviewMeshControlHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
    createPreviewHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
    fixPopUpStyles: (document: Document) => void;

}
export {};

}
declare module "@babylonjs/node-geometry-editor/globalState" {
import { NodeGeometry } from "@babylonjs/core/Meshes/Node/nodeGeometry";
import { Observable } from "@babylonjs/core/Misc/observable";
import { LogEntry } from "@babylonjs/node-geometry-editor/components/log/logComponent";
import { Color4 } from "@babylonjs/core/Maths/math.color";
import { GraphNode } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphFrame";
import { Nullable } from "@babylonjs/core/types";
import { LockObject } from "@babylonjs/node-geometry-editor/tabs/propertyGrids/lockObject";
import { StateManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/stateManager";
import { NodeGeometryBlock } from "@babylonjs/core/Meshes/Node/nodeGeometryBlock";
import { PreviewMode } from "@babylonjs/node-geometry-editor/components/preview/previewMode";
export class GlobalState {
    private _previewMode;
    nodeGeometry: NodeGeometry;
    hostElement: HTMLElement;
    hostDocument: Document;
    hostWindow: Window;
    stateManager: StateManager;
    onBuiltObservable: Observable<void>;
    onResetRequiredObservable: Observable<boolean>;
    onClearUndoStack: Observable<void>;
    onZoomToFitRequiredObservable: Observable<void>;
    onReOrganizedRequiredObservable: Observable<void>;
    onPreviewModeChanged: Observable<void>;
    onLogRequiredObservable: Observable<LogEntry>;
    onIsLoadingChanged: Observable<boolean>;
    onPreviewBackgroundChanged: Observable<void>;
    onFrame: Observable<void>;
    onAxis: Observable<void>;
    onAnimationCommandActivated: Observable<void>;
    onImportFrameObservable: Observable<any>;
    onPopupClosedObservable: Observable<void>;
    onGetNodeFromBlock: (block: NodeGeometryBlock) => GraphNode;
    listOfCustomPreviewFiles: File[];
    rotatePreview: boolean;
    backgroundColor: Color4;
    lockObject: LockObject;
    pointerOverCanvas: boolean;
    onRefreshPreviewMeshControlComponentRequiredObservable: Observable<void>;
    onExportToGLBRequired: Observable<void>;
    customSave?: {
        label: string;
        action: (data: string) => Promise<void>;
    };
    resyncHandler?: () => void;
    get previewMode(): PreviewMode;
    set previewMode(value: PreviewMode);
    constructor();
    storeEditorData(serializationObject: any, frame?: Nullable<GraphFrame>): void;
}

}
declare module "@babylonjs/node-geometry-editor/blockTools" {
import { NodeGeometryBlockConnectionPointTypes } from "@babylonjs/core/Meshes/Node/Enums/nodeGeometryConnectionPointTypes";
import { SetPositionsBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/setPositionsBlock";
import { SetNormalsBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/setNormalsBlock";
import { SetColorsBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/setColorsBlock";
import { SetTangentsBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/setTangentsBlock";
import { SetUVsBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/setUVsBlock";
import { ComputeNormalsBlock } from "@babylonjs/core/Meshes/Node/Blocks/computeNormalsBlock";
import { RandomBlock } from "@babylonjs/core/Meshes/Node/Blocks/randomBlock";
import { NoiseBlock } from "@babylonjs/core/Meshes/Node/Blocks/noiseBlock";
import { GeometryOutputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryOutputBlock";
import { BoxBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/boxBlock";
import { PlaneBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/planeBlock";
import { SphereBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/sphereBlock";
import { CylinderBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/cylinderBlock";
import { CapsuleBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/capsuleBlock";
import { IcoSphereBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/icoSphereBlock";
import { RotationXBlock } from "@babylonjs/core/Meshes/Node/Blocks/Matrices/rotationXBlock";
import { RotationYBlock } from "@babylonjs/core/Meshes/Node/Blocks/Matrices/rotationYBlock";
import { RotationZBlock } from "@babylonjs/core/Meshes/Node/Blocks/Matrices/rotationZBlock";
import { ScalingBlock } from "@babylonjs/core/Meshes/Node/Blocks/Matrices/scalingBlock";
import { AlignBlock } from "@babylonjs/core/Meshes/Node/Blocks/Matrices/alignBlock";
import { TranslationBlock } from "@babylonjs/core/Meshes/Node/Blocks/Matrices/translationBlock";
import { MeshBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/meshBlock";
import { GridBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/gridBlock";
import { TorusBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/torusBlock";
import { DiscBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/discBlock";
import { NullBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/nullBlock";
import { MergeGeometryBlock } from "@babylonjs/core/Meshes/Node/Blocks/mergeGeometryBlock";
import { VectorConverterBlock } from "@babylonjs/core/Meshes/Node/Blocks/vectorConverterBlock";
import { NormalizeVectorBlock } from "@babylonjs/core/Meshes/Node/Blocks/normalizeVectorBlock";
import { GeometryTransformBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryTransformBlock";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
import { MathBlock } from "@babylonjs/core/Meshes/Node/Blocks/mathBlock";
import { GeometryTrigonometryBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryTrigonometryBlock";
import { GeometryElbowBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryElbowBlock";
import { SetMaterialIDBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/setMaterialIDBlock";
import { InstantiateOnVerticesBlock } from "@babylonjs/core/Meshes/Node/Blocks/Instances/instantiateOnVerticesBlock";
import { InstantiateOnFacesBlock } from "@babylonjs/core/Meshes/Node/Blocks/Instances/instantiateOnFacesBlock";
import { InstantiateOnVolumeBlock } from "@babylonjs/core/Meshes/Node/Blocks/Instances/instantiateOnVolumeBlock";
import { InstantiateBlock } from "@babylonjs/core/Meshes/Node/Blocks/Instances/instantiateBlock";
import { DebugBlock } from "@babylonjs/core/Meshes/Node/Blocks/debugBlock";
import { TeleportInBlock } from "@babylonjs/core/Meshes/Node/Blocks/Teleport/teleportInBlock";
import { TeleportOutBlock } from "@babylonjs/core/Meshes/Node/Blocks/Teleport/teleportOutBlock";
import { MapRangeBlock } from "@babylonjs/core/Meshes/Node/Blocks/mapRangeBlock";
import { GeometryOptimizeBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryOptimizeBlock";
import { IntFloatConverterBlock } from "@babylonjs/core/Meshes/Node/Blocks/intFloatConverterBlock";
import { ConditionBlock } from "@babylonjs/core/Meshes/Node/Blocks/conditionBlock";
import { InstantiateLinearBlock } from "@babylonjs/core/Meshes/Node/Blocks/Instances/instantiateLinearBlock";
import { InstantiateRadialBlock } from "@babylonjs/core/Meshes/Node/Blocks/Instances/instantiateRadialBlock";
import { GeometryCollectionBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryCollectionBlock";
import { GeometryInfoBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInfoBlock";
import { MappingBlock } from "@babylonjs/core/Meshes/Node/Blocks/mappingBlock";
import { MatrixComposeBlock } from "@babylonjs/core/Meshes/Node/Blocks/matrixComposeBlock";
import { GeometryTextureBlock } from "@babylonjs/core/Meshes/Node/Blocks/Textures/geometryTextureBlock";
import { GeometryTextureFetchBlock } from "@babylonjs/core/Meshes/Node/Blocks/Textures/geometryTextureFetchBlock";
import { BoundingBlock } from "@babylonjs/core/Meshes/Node/Blocks/boundingBlock";
import { BooleanGeometryBlock } from "@babylonjs/core/Meshes/Node/Blocks/booleanGeometryBlock";
import { GeometryArcTan2Block } from "@babylonjs/core/Meshes/Node/Blocks/geometryArcTan2Block";
import { GeometryLerpBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryLerpBlock";
import { GeometryNLerpBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryNLerpBlock";
import { GeometrySmoothStepBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometrySmoothStepBlock";
import { GeometryStepBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryStepBlock";
import { GeometryModBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryModBlock";
import { GeometryPowBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryPowBlock";
import { GeometryClampBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryClampBlock";
import { GeometryCrossBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryCrossBlock";
import { GeometryCurveBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryCurveBlock";
import { GeometryDesaturateBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryDesaturateBlock";
import { GeometryPosterizeBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryPosterizeBlock";
import { GeometryDistanceBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryDistanceBlock";
import { GeometryDotBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryDotBlock";
import { GeometryReplaceColorBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryReplaceColorBlock";
import { GeometryRotate2dBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryRotate2dBlock";
import { GeometryLengthBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryLengthBlock";
import { GeometryInterceptorBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInterceptorBlock";
import { LatticeBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/latticeBlock";
import { AggregatorBlock } from "@babylonjs/core/Meshes/Node/Blocks/Set/aggregatorBlock";
import { CleanGeometryBlock } from "@babylonjs/core/Meshes/Node/Blocks/cleanGeometryBlock";
import { PointListBlock } from "@babylonjs/core/Meshes/Node/Blocks/Sources/pointListBlock";
import { SubdivideBlock } from "@babylonjs/core/Meshes/Node/Blocks/subdivideBlock";
import { GeometryEaseBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryEaseBlock";
/**
 * Static class for BlockTools
 */
export class BlockTools {
    static GetBlockFromString(data: string): GeometryEaseBlock | SubdivideBlock | PointListBlock | CleanGeometryBlock | AggregatorBlock | LatticeBlock | GeometryInterceptorBlock | GeometryRotate2dBlock | GeometryLengthBlock | GeometryDistanceBlock | GeometryDotBlock | GeometryPosterizeBlock | GeometryReplaceColorBlock | GeometryDesaturateBlock | GeometryCurveBlock | GeometryCrossBlock | GeometryClampBlock | BooleanGeometryBlock | GeometryTextureFetchBlock | GeometryTextureBlock | BoundingBlock | MatrixComposeBlock | GeometryInfoBlock | GeometryCollectionBlock | GeometryOptimizeBlock | NullBlock | TeleportInBlock | TeleportOutBlock | DebugBlock | IntFloatConverterBlock | ConditionBlock | GeometryLerpBlock | GeometryNLerpBlock | GeometrySmoothStepBlock | GeometryStepBlock | MappingBlock | SetMaterialIDBlock | InstantiateOnVolumeBlock | InstantiateOnFacesBlock | InstantiateOnVerticesBlock | InstantiateBlock | MapRangeBlock | NormalizeVectorBlock | MeshBlock | VectorConverterBlock | TranslationBlock | ScalingBlock | AlignBlock | RotationXBlock | RotationYBlock | RotationZBlock | ComputeNormalsBlock | SetPositionsBlock | SetNormalsBlock | SetColorsBlock | SetTangentsBlock | SetUVsBlock | NoiseBlock | RandomBlock | GeometryOutputBlock | GridBlock | DiscBlock | IcoSphereBlock | BoxBlock | TorusBlock | SphereBlock | CylinderBlock | CapsuleBlock | PlaneBlock | GeometryElbowBlock | MergeGeometryBlock | GeometryTransformBlock | GeometryModBlock | GeometryPowBlock | GeometryInputBlock | MathBlock | GeometryTrigonometryBlock | GeometryArcTan2Block | InstantiateLinearBlock | InstantiateRadialBlock | null;
    static GetColorFromConnectionNodeType(type: NodeGeometryBlockConnectionPointTypes): string;
    static GetConnectionNodeTypeFromString(type: string): NodeGeometryBlockConnectionPointTypes.Int | NodeGeometryBlockConnectionPointTypes.Float | NodeGeometryBlockConnectionPointTypes.Vector2 | NodeGeometryBlockConnectionPointTypes.Vector3 | NodeGeometryBlockConnectionPointTypes.Vector4 | NodeGeometryBlockConnectionPointTypes.Matrix | NodeGeometryBlockConnectionPointTypes.AutoDetect;
    static GetStringFromConnectionNodeType(type: NodeGeometryBlockConnectionPointTypes): "" | "Int" | "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix";
}

}
declare module "@babylonjs/node-geometry-editor/sharedComponents/textureLineComponent" {
import * as React from "react";
import { BaseTexture } from "@babylonjs/core/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-geometry-editor/sharedComponents/checkBoxLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/node-geometry-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-geometry-editor/legacy/legacy" {
export * from "@babylonjs/node-geometry-editor/index";

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

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

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

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

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

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

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

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

}
declare module "@babylonjs/node-geometry-editor/graphSystem/connectionPointPortData" {
import { NodeGeometryBlock } from "@babylonjs/core/Meshes/Node/nodeGeometryBlock";
import { type NodeGeometryConnectionPoint, NodeGeometryConnectionPointCompatibilityStates } from "@babylonjs/core/Meshes/Node/nodeGeometryBlockConnectionPoint";
import { Nullable } from "@babylonjs/core/types";
import { GraphNode } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphNode";
import { INodeContainer } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeContainer";
import { IPortData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/portData";
import { PortDataDirection, PortDirectValueTypes } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/portData";
export class ConnectionPointPortData implements IPortData {
    private _connectedPort;
    private _nodeContainer;
    data: NodeGeometryConnectionPoint;
    get name(): string;
    get internalName(): string;
    get isExposedOnFrame(): boolean;
    set isExposedOnFrame(value: boolean);
    get exposedPortPosition(): number;
    set exposedPortPosition(value: number);
    get isConnected(): boolean;
    get connectedPort(): Nullable<IPortData>;
    set connectedPort(value: Nullable<IPortData>);
    get directValueDefinition(): {
        source: NodeGeometryConnectionPoint;
        propertyName: string;
        valueMin: any;
        valueMax: any;
        valueType: PortDirectValueTypes;
    } | undefined;
    get direction(): PortDataDirection;
    get ownerData(): NodeGeometryBlock;
    get needDualDirectionValidation(): boolean;
    get hasEndpoints(): boolean;
    get endpoints(): IPortData[];
    constructor(connectionPoint: NodeGeometryConnectionPoint, nodeContainer: INodeContainer);
    updateDisplayName(newName: string): void;
    connectTo(port: IPortData): void;
    canConnectTo(port: IPortData): boolean;
    disconnectFrom(port: IPortData): void;
    checkCompatibilityState(port: IPortData): 0 | NodeGeometryConnectionPointCompatibilityStates.TypeIncompatible | NodeGeometryConnectionPointCompatibilityStates.HierarchyIssue;
    getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string;
}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/blockNodeData" {
import { INodeContainer } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeContainer";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/portData";
import { NodeGeometryBlock } from "@babylonjs/core/Meshes/Node/nodeGeometryBlock";
import { TeleportOutBlock } from "@babylonjs/core/Meshes/Node/Blocks/Teleport/teleportOutBlock";
export class BlockNodeData implements INodeData {
    data: NodeGeometryBlock;
    private _inputs;
    private _outputs;
    private _onBuildObserver;
    /**
     * Gets or sets a callback used to call node visual refresh
     */
    refreshCallback?: () => void;
    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;
    isConnectedToOutput(): boolean;
    dispose(): void;
    prepareHeaderIcon(iconDiv: HTMLDivElement, img: HTMLImageElement): void;
    get invisibleEndpoints(): TeleportOutBlock[] | null;
    constructor(data: NodeGeometryBlock, nodeContainer: INodeContainer);
}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/properties/textureNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);
    loadTextureData(file: File): Promise<void>;
    removeData(): void;

}

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

}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/properties/pointListNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class PointListPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);
    addPoint(): void;
    removePoint(index: number): void;

}

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

}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/properties/nodePortPropertyComponent" {
import * as React from "react";
import { StateManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/stateManager";
import { NodePort } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/properties/meshNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class MeshPropertyTabComponent extends React.Component<IPropertyComponentProps, {
    isLoading: boolean;
}> {
    constructor(props: IPropertyComponentProps);
    loadMesh(file: File): Promise<void>;
    removeData(): void;

}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/properties/inputNodePropertyComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { IPropertyComponentProps } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/properties/genericNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/propertyComponentProps";
import { NodeGeometryConnectionPoint } from "@babylonjs/core/Meshes/Node/nodeGeometryBlockConnectionPoint";
export class GenericPropertyComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);

}
export class GeneralPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);
    processUpdate(): void;


}
export class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);

}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/properties/framePropertyComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { GraphFrame } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/properties/frameNodePortPropertyComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { StateManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/stateManager";
import { GraphFrame } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphFrame";
import { FrameNodePort } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/properties/debugNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class DebugPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    private _onUpdateRequiredObserver;
    constructor(props: IPropertyComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;

}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/display/textureDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/display/teleportOutDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
import { Nullable } from "@babylonjs/core/types";
import { StateManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/stateManager";
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-geometry-editor/graphSystem/display/teleportInDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
import { Nullable } from "@babylonjs/core/types";
import { StateManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/stateManager";
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-geometry-editor/graphSystem/display/sourceDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
export class SourceDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "@babylonjs/node-geometry-editor/graphSystem/display/outputDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/display/inputDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
import { NodeGeometryBlockConnectionPointTypes } from "@babylonjs/core/Meshes/Node/Enums/nodeGeometryConnectionPointTypes";
import { Nullable } from "@babylonjs/core/types";
import { StateManager } from "@babylonjs/node-geometry-editor/nodeGraphSystem/stateManager";
export class InputDisplayManager implements IDisplayManager {
    private _hasHighlights;
    getHeaderClass(nodeData: INodeData): string;
    getHeaderText(nodeData: INodeData): string;
    shouldDisplayPortLabels(): boolean;
    static GetBaseType(type: NodeGeometryBlockConnectionPointTypes): 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-geometry-editor/graphSystem/display/elbowDisplayManager" {
import { IDisplayManager, VisualContentDescription } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-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-geometry-editor/graphSystem/display/debugDisplayManager" {
import { IDisplayManager, VisualContentDescription } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-geometry-editor/nodeGraphSystem/interfaces/nodeData";
export class DebugDisplayManager 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-geometry-editor/components/propertyTab/propertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { Nullable } from "@babylonjs/core/types";
import "@babylonjs/node-geometry-editor/components/propertyTab/propertyTab.scss";
import { GraphNode } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "@babylonjs/node-geometry-editor/nodeGraphSystem/graphFrame";
import { NodePort } from "@babylonjs/node-geometry-editor/nodeGraphSystem/nodePort";
import { FrameNodePort } from "@babylonjs/node-geometry-editor/nodeGraphSystem/frameNodePort";
import { LockObject } from "@babylonjs/node-geometry-editor/tabs/propertyGrids/lockObject";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
interface IPropertyTabComponentProps {
    globalState: GlobalState;
    lockObject: LockObject;
}
interface IPropertyTabComponentState {
    currentNode: Nullable<GraphNode>;
    currentFrame: Nullable<GraphFrame>;
    currentFrameNodePort: Nullable<FrameNodePort>;
    currentNodePort: Nullable<NodePort>;
    uploadInProgress: boolean;
}
export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
    private _onBuiltObserver;
    constructor(props: IPropertyTabComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    processInputBlockUpdate(): void;

    load(file: File): void;
    loadFrame(file: File): void;
    save(): void;
    customSave(): void;
    saveToSnippetServer(): void;
    loadFromSnippet(): void;
    exportAsGLB(): void;

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/propertyTab/inputsPropertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import "@babylonjs/node-geometry-editor/components/propertyTab/propertyTab.scss";
import { LockObject } from "@babylonjs/node-geometry-editor/tabs/propertyGrids/lockObject";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
interface IInputsPropertyTabComponentProps {
    globalState: GlobalState;
    inputs: GeometryInputBlock[];
    lockObject: LockObject;
}
export class InputsPropertyTabComponent extends React.Component<IInputsPropertyTabComponentProps> {
    constructor(props: IInputsPropertyTabComponentProps);
    processInputBlockUpdate(): void;


}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/propertyTab/properties/vector4PropertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { LockObject } from "@babylonjs/node-geometry-editor/tabs/propertyGrids/lockObject";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
interface IVector4PropertyTabComponentProps {
    globalState: GlobalState;
    inputBlock: GeometryInputBlock;
    lockObject: LockObject;
}
export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/propertyTab/properties/vector3PropertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { LockObject } from "@babylonjs/node-geometry-editor/tabs/propertyGrids/lockObject";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
interface IVector3PropertyTabComponentProps {
    globalState: GlobalState;
    inputBlock: GeometryInputBlock;
    lockObject: LockObject;
}
export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/propertyTab/properties/vector2PropertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { LockObject } from "@babylonjs/node-geometry-editor/tabs/propertyGrids/lockObject";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
interface IVector2PropertyTabComponentProps {
    globalState: GlobalState;
    inputBlock: GeometryInputBlock;
    lockObject: LockObject;
}
export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/propertyTab/properties/floatPropertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import { GeometryInputBlock } from "@babylonjs/core/Meshes/Node/Blocks/geometryInputBlock";
interface IFloatPropertyTabComponentProps {
    globalState: GlobalState;
    inputBlock: GeometryInputBlock;
}
export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/preview/previewMode" {
export enum PreviewMode {
    Normal = 0,
    MatCap = 1,
    Wireframe = 2,
    VertexColor = 3,
    Textured = 4,
    Normals = 5
}

}
declare module "@babylonjs/node-geometry-editor/components/preview/previewMeshControlComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
interface IPreviewMeshControlComponent {
    globalState: GlobalState;
    togglePreviewAreaComponent: () => void;
}
interface IPreviewMeshControlComponentState {
    center: boolean;
}
export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent, IPreviewMeshControlComponentState> {
    private _colorInputRef;
    private _onResetRequiredObserver;
    private _onRefreshPreviewMeshControlComponentRequiredObserver;
    constructor(props: IPreviewMeshControlComponent);
    componentWillUnmount(): void;
    onPopUp(): void;
    changeAnimation(): void;
    changeBackground(value: string): void;
    changeBackgroundClick(): void;
    frame(): void;
    axis(): void;

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/preview/previewManager" {
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import "@babylonjs/core/Rendering/depthRendererSceneComponent";
export class PreviewManager {
    private _nodeGeometry;
    private _onBuildObserver;
    private _onFrameObserver;
    private _onAxisObserver;
    private _onExportToGLBObserver;
    private _onAnimationCommandActivatedObserver;
    private _onUpdateRequiredObserver;
    private _onPreviewBackgroundChangedObserver;
    private _onPreviewChangedObserver;
    private _engine;
    private _scene;
    private _mesh;
    private _camera;
    private _light;
    private _globalState;
    private _matTexture;
    private _matCap;
    private _matStd;
    private _matNME;
    private _matVertexColor;
    private _matNormals;
    private _axis;
    private _toDelete;
    constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
    private _updateStandardMaterial;
    private _handleAnimations;
    private _frameCamera;
    private _prepareScene;
    private _refreshPreviewMesh;
    private _setMaterial;
    private _updatePreview;
    dispose(): void;
}

}
declare module "@babylonjs/node-geometry-editor/components/preview/previewAreaComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
interface IPreviewAreaComponentProps {
    globalState: GlobalState;
}
export class PreviewAreaComponent extends React.Component<IPreviewAreaComponentProps, {
    isLoading: boolean;
}> {
    private _onIsLoadingChangedObserver;
    private _onResetRequiredObserver;
    constructor(props: IPreviewAreaComponentProps);
    componentWillUnmount(): void;
    _onPointerOverCanvas: () => void;
    _onPointerOutCanvas: () => void;
    changeWireframe(): void;
    changeVertexColor(): void;
    changeMatCap(): void;
    changeTexture(): void;
    changeNormals(): void;

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/nodeList/nodeListComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import "@babylonjs/node-geometry-editor/components/nodeList/nodeList.scss";
interface INodeListComponentProps {
    globalState: GlobalState;
}
export class NodeListComponent extends React.Component<INodeListComponentProps, {
    filter: string;
}> {
    private _onResetRequiredObserver;
    private static _Tooltips;
    private _customFrameList;
    constructor(props: INodeListComponentProps);
    componentWillUnmount(): void;
    filterContent(filter: string): void;
    loadCustomFrame(file: File): void;
    removeItem(value: string): void;

}
export {};

}
declare module "@babylonjs/node-geometry-editor/components/log/logComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-geometry-editor/globalState";
import "@babylonjs/node-geometry-editor/components/log/log.scss";
interface ILogComponentProps {
    globalState: GlobalState;
}
export class LogEntry {
    message: string;
    isError: boolean;
    time: Date;
    constructor(message: string, isError: boolean);
}
export class LogComponent extends React.Component<ILogComponentProps, {
    logs: LogEntry[];
}> {
    private _logConsoleRef;
    constructor(props: ILogComponentProps);
    componentDidMount(): void;
    componentDidUpdate(): void;

}
export {};

}
declare module "@babylonjs/node-geometry-editor/styleHelper" {
/**
 * Copy all styles from a document to another document or shadow root
 * @param source document to copy styles from
 * @param target document or shadow root to copy styles to
 */
export function CopyStyles(source: Document, target: DocumentOrShadowRoot): void;
/**
 * Merges classNames by array of strings or conditions
 * @param classNames Array of className strings or truthy conditions
 * @returns A concatenated string, suitable for the className attribute
 */
export function MergeClassNames(classNames: ClassNameCondition[]): string;
/**
 * className (replicating React type) or a tuple with the second member being any truthy value ["className", true]
 */
type ClassNameCondition = string | undefined | [string, any];
export {};

}
declare module "@babylonjs/node-geometry-editor/stringTools" {
export class StringTools {
    private static _SaveAs;
    private static _Click;
    /**
     * Download a string into a file that will be saved locally by the browser
     * @param document
     * @param content defines the string to download locally as a file
     * @param filename
     */
    static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
}

}
declare module "@babylonjs/node-geometry-editor/propertyChangedEvent" {
export class PropertyChangedEvent {
    object: any;
    property: string;
    value: any;
    initialValue: any;
    allowNullValue?: boolean;
}

}
declare module "@babylonjs/node-geometry-editor/popupHelper" {
/**
 * Create a popup window
 * @param title default title for the popup
 * @param options options for the popup
 * @returns the parent control of the popup
 */
export function CreatePopup(title: string, options: Partial<{
    onParentControlCreateCallback?: (parentControl: HTMLDivElement) => void;
    onWindowCreateCallback?: (newWindow: Window) => void;
    width?: number;
    height?: number;
}>): HTMLDivElement | null;

}
declare module "@babylonjs/node-geometry-editor/historyStack" {
import { IDisposable } from "@babylonjs/core/scene";
/**
 * Class handling undo / redo