@babylonjs/node-particle-editor 8.11.1 → 8.12.1

package/dist/babylon.nodeParticleEditor.module.d.ts

@@ -0,0 +1,4893 @@
+
+declare module "@babylonjs/node-particle-editor/serializationTools" {
+import { NodeParticleSystemSet } from "@babylonjs/core/Particles/Node/nodeParticleSystemSet";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { Nullable } from "@babylonjs/core/types";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+export class SerializationTools {
+    static UpdateLocations(particleSet: NodeParticleSystemSet, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
+    static Serialize(particleSet: NodeParticleSystemSet, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
+    static Deserialize(serializationObject: any, globalState: GlobalState): void;
+    static AddFrameToParticleSystemSet(serializationObject: any, globalState: GlobalState, currentSystemSet: NodeParticleSystemSet): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/portal" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-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-particle-editor/nodeParticleEditor" {
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { Scene } from "@babylonjs/core/scene";
+import { NodeParticleSystemSet } from "@babylonjs/core/Particles/Node/nodeParticleSystemSet";
+/**
+ * Interface used to specify creation options for the node editor
+ */
+export interface INodeEditorOptions {
+    nodeParticleSet: NodeParticleSystemSet;
+    hostScene: Scene;
+    hostElement?: HTMLElement;
+    customSave?: {
+        label: string;
+        action: (data: string) => Promise<void>;
+    };
+    customLoadObservable?: Observable<any>;
+    backgroundColor?: Color4;
+}
+/**
+ * Class used to create a node editor
+ */
+export class NodeParticleEditor {
+    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-particle-editor/index" {
+export * from "@babylonjs/node-particle-editor/nodeParticleEditor";
+
+}
+declare module "@babylonjs/node-particle-editor/graphEditor" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { Nullable } from "@babylonjs/core/types";
+import { IInspectorOptions } from "@babylonjs/core/Debug/debugLayer";
+import "@babylonjs/node-particle-editor/main.scss";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { IEditorData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { NodeParticleBlock } from "@babylonjs/core/Particles/Node/nodeParticleBlock";
+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: NodeParticleBlock | INodeData, recursion?: boolean): GraphNode;
+    addValueNode(type: string): GraphNode;
+    prepareHistoryStack(): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    constructor(props: IGraphEditorProps);
+    zoomToFit(): void;
+    buildParticleSystemSet(): 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-particle-editor/globalState" {
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { LogEntry } from "@babylonjs/node-particle-editor/components/log/logComponent";
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { Nullable } from "@babylonjs/core/types";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { NodeParticleSystemSet } from "@babylonjs/core/Particles/Node/nodeParticleSystemSet";
+import { NodeParticleBlock } from "@babylonjs/core/Particles/Node/nodeParticleBlock";
+import { Scene } from "@babylonjs/core/scene";
+export class GlobalState {
+    nodeParticleSet: NodeParticleSystemSet;
+    hostScene: Scene;
+    hostElement: HTMLElement;
+    hostDocument: Document;
+    hostWindow: Window;
+    stateManager: StateManager;
+    onBuildRequiredObservable: Observable<void>;
+    onResetRequiredObservable: Observable<boolean>;
+    onClearUndoStack: Observable<void>;
+    onZoomToFitRequiredObservable: Observable<void>;
+    onReOrganizedRequiredObservable: Observable<void>;
+    onLogRequiredObservable: Observable<LogEntry>;
+    onIsLoadingChanged: Observable<boolean>;
+    onPreviewBackgroundChanged: Observable<void>;
+    onImportFrameObservable: Observable<any>;
+    onPopupClosedObservable: Observable<void>;
+    onGetNodeFromBlock: (block: NodeParticleBlock) => GraphNode;
+    listOfCustomPreviewFiles: File[];
+    rotatePreview: boolean;
+    backgroundColor: Color4;
+    lockObject: LockObject;
+    pointerOverCanvas: boolean;
+    onRefreshPreviewMeshControlComponentRequiredObservable: Observable<void>;
+    onExportToGLBRequired: Observable<void>;
+    updateState: (left: string, right: string) => void;
+    customSave?: {
+        label: string;
+        action: (data: string) => Promise<void>;
+    };
+    constructor();
+    storeEditorData(serializationObject: any, frame?: Nullable<GraphFrame>): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/blockTools" {
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+import { ParticleTextureSourceBlock } from "@babylonjs/core/Particles/Node/Blocks/particleSourceTextureBlock";
+import { RandomRangeBlock } from "@babylonjs/core/Particles/Node/Blocks/randomRangeBlock";
+import { UpdateDirectionBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateDirectionBlock";
+import { UpdatePositionBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updatePositionBlock";
+import { SystemBlock } from "@babylonjs/core/Particles/Node/Blocks/systemBlock";
+import { NodeParticleBlockConnectionPointTypes } from "@babylonjs/core/Particles/Node/Enums/nodeParticleBlockConnectionPointTypes";
+import { ParticleMathBlock } from "@babylonjs/core/Particles/Node/Blocks/particleMathBlock";
+import { UpdateColorBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateColorBlock";
+import { ParticleLerpBlock } from "@babylonjs/core/Particles/Node/Blocks/particleLerpBlock";
+import { UpdateScaleBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateScaleBlock";
+import { ParticleGradientValueBlock } from "@babylonjs/core/Particles/Node/Blocks/particleGradientValueBlock";
+import { ParticleGradientBlock } from "@babylonjs/core/Particles/Node/Blocks/particleGradientBlock";
+import { ParticleConverterBlock } from "@babylonjs/core/Particles/Node/Blocks/particleConverterBlock";
+import { ParticleTrigonometryBlock } from "@babylonjs/core/Particles/Node/Blocks/particleTrigonometryBlock";
+import { ParticleRandomBlock } from "@babylonjs/core/Particles/Node/Blocks/particleRandomBlock";
+import { ParticleDebugBlock } from "@babylonjs/core/Particles/Node/Blocks/particleDebugBlock";
+import { ParticleElbowBlock } from "@babylonjs/core/Particles/Node/Blocks/particleElbowBlock";
+import { ParticleTeleportInBlock } from "@babylonjs/core/Particles/Node/Blocks/Teleport/particleTeleportInBlock";
+import { ParticleTeleportOutBlock } from "@babylonjs/core/Particles/Node/Blocks/Teleport/particleTeleportOutBlock";
+import { UpdateAngleBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateAngleBlock";
+import { BasicPositionUpdateBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/basicPositionUpdateBlock";
+import { ParticleTriggerBlock } from "@babylonjs/core/Particles/Node/Blocks/Triggers/particleTriggerBlock";
+import { SetupSpriteSheetBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/setupSpriteSheetBlock";
+import { BasicSpriteUpdateBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/basicSpriteUpdateBlock";
+import { UpdateSpriteCellIndexBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateSpriteCellIndexBlock";
+import { UpdateFlowMapBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateFlowMapBlock";
+import { ParticleConditionBlock } from "@babylonjs/core/Particles/Node/Blocks/Conditions/particleConditionBlock";
+import { CreateParticleBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/createParticleBlock";
+import { BoxShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/boxShapeBlock";
+import { SphereShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/sphereShapeBlock";
+import { PointShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/pointShapeBlock";
+import { CustomShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/customShapeBlock";
+import { CylinderShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/cylinderShapeBlock";
+/**
+ * Static class for BlockTools
+ */
+export class BlockTools {
+    static GetBlockFromString(data: string): CreateParticleBlock | ParticleConditionBlock | UpdateSpriteCellIndexBlock | BasicSpriteUpdateBlock | SetupSpriteSheetBlock | ParticleTriggerBlock | BasicPositionUpdateBlock | ParticleTeleportInBlock | ParticleTeleportOutBlock | ParticleElbowBlock | ParticleDebugBlock | ParticleConverterBlock | ParticleGradientBlock | ParticleGradientValueBlock | ParticleLerpBlock | UpdatePositionBlock | UpdateDirectionBlock | UpdateColorBlock | UpdateScaleBlock | UpdateAngleBlock | UpdateFlowMapBlock | SystemBlock | ParticleTextureSourceBlock | BoxShapeBlock | SphereShapeBlock | PointShapeBlock | CustomShapeBlock | CylinderShapeBlock | RandomRangeBlock | ParticleInputBlock | ParticleMathBlock | ParticleTrigonometryBlock | ParticleRandomBlock | null;
+    static GetColorFromConnectionNodeType(type: NodeParticleBlockConnectionPointTypes): string;
+    static GetConnectionNodeTypeFromString(type: string): NodeParticleBlockConnectionPointTypes.Int | NodeParticleBlockConnectionPointTypes.Float | NodeParticleBlockConnectionPointTypes.Vector2 | NodeParticleBlockConnectionPointTypes.Vector3 | NodeParticleBlockConnectionPointTypes.Matrix | NodeParticleBlockConnectionPointTypes.Color4 | NodeParticleBlockConnectionPointTypes.AutoDetect;
+    static GetStringFromConnectionNodeType(type: NodeParticleBlockConnectionPointTypes): "" | "Int" | "Float" | "Vector2" | "Vector3" | "Color4" | "Matrix";
+}
+
+}
+declare module "@babylonjs/node-particle-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-particle-editor/sharedComponents/checkBoxLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-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-particle-editor/legacy/legacy" {
+export * from "@babylonjs/node-particle-editor/index";
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerToTypeLedger" {
+export const RegisterTypeLedger: () => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerToPropertyLedger" {
+export const RegisterToPropertyTabManagers: () => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerToDisplayLedger" {
+export const RegisterToDisplayManagers: () => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerNodePortDesign" {
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+export const RegisterNodePortDesign: (stateManager: StateManager) => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerExportData" {
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+export const RegisterExportData: (stateManager: StateManager) => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerElbowSupport" {
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+export const RegisterElbowSupport: (stateManager: StateManager) => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerDefaultInput" {
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+export const RegisterDefaultInput: (stateManager: StateManager) => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/registerDebugSupport" {
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+export const RegisterDebugSupport: (stateManager: StateManager) => void;
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/connectionPointPortData" {
+import { NodeParticleBlock } from "@babylonjs/core/Particles/Node/nodeParticleBlock";
+import { NodeParticleConnectionPointCompatibilityStates, type NodeParticleConnectionPoint } from "@babylonjs/core/Particles/Node/nodeParticleBlockConnectionPoint";
+import { Nullable } from "@babylonjs/core/types";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { INodeContainer } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeContainer";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { PortDataDirection, PortDirectValueTypes } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+export class ConnectionPointPortData implements IPortData {
+    private _connectedPort;
+    private _nodeContainer;
+    data: NodeParticleConnectionPoint;
+    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: NodeParticleConnectionPoint;
+        propertyName: string;
+        valueMin: any;
+        valueMax: any;
+        valueType: PortDirectValueTypes;
+    } | undefined;
+    get direction(): PortDataDirection;
+    get ownerData(): NodeParticleBlock;
+    get needDualDirectionValidation(): boolean;
+    get hasEndpoints(): boolean;
+    get endpoints(): IPortData[];
+    constructor(connectionPoint: NodeParticleConnectionPoint, nodeContainer: INodeContainer);
+    updateDisplayName(newName: string): void;
+    connectTo(port: IPortData): void;
+    canConnectTo(port: IPortData): boolean;
+    disconnectFrom(port: IPortData): void;
+    checkCompatibilityState(port: IPortData): 0 | NodeParticleConnectionPointCompatibilityStates.TypeIncompatible | NodeParticleConnectionPointCompatibilityStates.HierarchyIssue;
+    getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/blockNodeData" {
+import { INodeContainer } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeContainer";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { NodeParticleBlock } from "@babylonjs/core/Particles/Node/nodeParticleBlock";
+import { ParticleTeleportOutBlock } from "@babylonjs/core/Particles/Node/Blocks/Teleport/particleTeleportOutBlock";
+export class BlockNodeData implements INodeData {
+    data: NodeParticleBlock;
+    private _inputs;
+    private _outputs;
+    private _onBuildObserver;
+    private _onInputChangeObserver;
+    /**
+     * Gets or sets a callback used to call node visual refresh
+     */
+    refreshCallback?: () => void;
+    onInputCountChanged?: () => 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(): ParticleTeleportOutBlock[] | null;
+    constructor(data: NodeParticleBlock, nodeContainer: INodeContainer);
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/properties/textureSourceNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps";
+export class TextureSourcePropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    constructor(props: IPropertyComponentProps);
+    _prepareImgToLoadAsync(url: string): Promise<string>;
+    loadTextureFromFileAsync(imageFile: File): Promise<string>;
+    loadTextureData(file: File): Promise<void>;
+    removeData(): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/properties/teleportOutNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps";
+export class TeleportOutPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    private _onUpdateRequiredObserver;
+    constructor(props: IPropertyComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/properties/nodePortPropertyComponent" {
+import * as React from "react";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { NodePort } from "@babylonjs/node-particle-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-particle-editor/graphSystem/properties/inputNodePropertyComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { IPropertyComponentProps } from "@babylonjs/node-particle-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-particle-editor/graphSystem/properties/genericNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "@babylonjs/node-particle-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-particle-editor/graphSystem/properties/framePropertyComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { GraphFrame } from "@babylonjs/node-particle-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-particle-editor/graphSystem/properties/frameNodePortPropertyComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { FrameNodePort } from "@babylonjs/node-particle-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-particle-editor/graphSystem/properties/debugNodePropertyComponent" {
+import * as React from "react";
+import { IPropertyComponentProps } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps";
+export class DebugPropertyTabComponent extends React.Component<IPropertyComponentProps> {
+    private _onUpdateRequiredObserver;
+    private _dataCollectedObserver;
+    constructor(props: IPropertyComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/updateDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export class UpdateDisplayManager implements IDisplayManager {
+    getHeaderClass(): string;
+    shouldDisplayPortLabels(): boolean;
+    getHeaderText(nodeData: INodeData): string;
+    getBackgroundColor(): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/triggerDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export class TriggerDisplayManager implements IDisplayManager {
+    getHeaderClass(): string;
+    shouldDisplayPortLabels(): boolean;
+    getHeaderText(nodeData: INodeData): string;
+    getBackgroundColor(): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/textureDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export class TextureDisplayManager implements IDisplayManager {
+    private _previewImage;
+    getHeaderClass(): string;
+    shouldDisplayPortLabels(): boolean;
+    getHeaderText(nodeData: INodeData): string;
+    getBackgroundColor(nodeData: INodeData): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/teleportOutDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { Nullable } from "@babylonjs/core/types";
+import { StateManager } from "@babylonjs/node-particle-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-particle-editor/graphSystem/display/teleportInDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { Nullable } from "@babylonjs/core/types";
+import { StateManager } from "@babylonjs/node-particle-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-particle-editor/graphSystem/display/systemDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export class SystemDisplayManager implements IDisplayManager {
+    getHeaderClass(): string;
+    shouldDisplayPortLabels(): boolean;
+    getHeaderText(nodeData: INodeData): string;
+    getBackgroundColor(): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/inputDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { NodeParticleBlockConnectionPointTypes } from "@babylonjs/core/Particles/Node/Enums/nodeParticleBlockConnectionPointTypes";
+export class InputDisplayManager implements IDisplayManager {
+    getHeaderClass(nodeData: INodeData): string;
+    getHeaderText(nodeData: INodeData): string;
+    shouldDisplayPortLabels(): boolean;
+    static GetBaseType(type: NodeParticleBlockConnectionPointTypes): string;
+    getBackgroundColor(nodeData: INodeData): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/emitterDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export class EmitterDisplayManager implements IDisplayManager {
+    getHeaderClass(): string;
+    shouldDisplayPortLabels(): boolean;
+    getHeaderText(nodeData: INodeData): string;
+    getBackgroundColor(): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/graphSystem/display/elbowDisplayManager" {
+import { IDisplayManager, VisualContentDescription } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-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-particle-editor/graphSystem/display/debugDisplayManager" {
+import { IDisplayManager, VisualContentDescription } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-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-particle-editor/graphSystem/display/conditionDisplayManager" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export class ConditionDisplayManager implements IDisplayManager {
+    getHeaderClass(): string;
+    shouldDisplayPortLabels(): boolean;
+    getHeaderText(nodeData: INodeData): string;
+    getBackgroundColor(): string;
+    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/propertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { Nullable } from "@babylonjs/core/types";
+import "@babylonjs/node-particle-editor/components/propertyTab/propertyTab.scss";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { FrameNodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+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;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/inputsPropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import "@babylonjs/node-particle-editor/components/propertyTab/propertyTab.scss";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IInputsPropertyTabComponentProps {
+    globalState: GlobalState;
+    inputs: ParticleInputBlock[];
+    lockObject: LockObject;
+}
+export class InputsPropertyTabComponent extends React.Component<IInputsPropertyTabComponentProps> {
+    constructor(props: IInputsPropertyTabComponentProps);
+    processInputBlockUpdate(): void;
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/properties/vector4PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IVector4PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: ParticleInputBlock;
+    lockObject: LockObject;
+}
+export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/properties/vector3PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IVector3PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: ParticleInputBlock;
+    lockObject: LockObject;
+}
+export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/properties/vector2PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IVector2PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: ParticleInputBlock;
+    lockObject: LockObject;
+}
+export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/properties/floatPropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IFloatPropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: ParticleInputBlock;
+}
+export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/properties/color4PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IColor4PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: ParticleInputBlock;
+    lockObject: LockObject;
+}
+export class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/propertyTab/properties/color3PropertyTabComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ParticleInputBlock } from "@babylonjs/core/Particles/Node/Blocks/particleInputBlock";
+interface IColor3PropertyTabComponentProps {
+    globalState: GlobalState;
+    inputBlock: ParticleInputBlock;
+    lockObject: LockObject;
+}
+export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/preview/previewMeshControlComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+interface IPreviewMeshControlComponent {
+    globalState: GlobalState;
+    togglePreviewAreaComponent: () => void;
+    onMounted?: () => void;
+}
+interface IPreviewMeshControlComponentState {
+    center: boolean;
+}
+export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent, IPreviewMeshControlComponentState> {
+    private _colorInputRef;
+    private _onResetRequiredObserver;
+    private _onRefreshPreviewMeshControlComponentRequiredObserver;
+    constructor(props: IPreviewMeshControlComponent);
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    onPopUp(): void;
+    changeBackground(value: string): void;
+    changeBackgroundClick(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/preview/previewManager" {
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+export class PreviewManager {
+    private _nodeParticleSystemSet;
+    private _onBuildObserver;
+    private _onPreviewBackgroundChangedObserver;
+    private _engine;
+    private _scene;
+    private _camera;
+    private _globalState;
+    private _particleSystemSet;
+    private _callId;
+    constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
+    private _refreshPreview;
+    private _updatePreviewAsync;
+    dispose(): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/preview/previewAreaComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+interface IPreviewAreaComponentProps {
+    globalState: GlobalState;
+    onMounted?: () => void;
+}
+export class PreviewAreaComponent extends React.Component<IPreviewAreaComponentProps, {
+    isLoading: boolean;
+}> {
+    private _onIsLoadingChangedObserver;
+    private _onResetRequiredObserver;
+    private _leftRef;
+    private _rightRef;
+    constructor(props: IPreviewAreaComponentProps);
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    _onPointerOverCanvas: () => void;
+    _onPointerOutCanvas: () => void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/nodeList/nodeListComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import "@babylonjs/node-particle-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-particle-editor/components/log/logComponent" {
+import * as React from "react";
+import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
+import "@babylonjs/node-particle-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-particle-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-particle-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-particle-editor/propertyChangedEvent" {
+export class PropertyChangedEvent {
+    object: any;
+    property: string;
+    value: any;
+    initialValue: any;
+    allowNullValue?: boolean;
+}
+
+}
+declare module "@babylonjs/node-particle-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-particle-editor/historyStack" {
+import { IDisposable } from "@babylonjs/core/scene";
+/**
+ * Class handling undo / redo operations
+ */
+export class HistoryStack implements IDisposable {
+    private _historyStack;
+    private _redoStack;
+    private _activeData;
+    private readonly _maxHistoryLength;
+    private _locked;
+    private _dataProvider;
+    private _applyUpdate;
+    /**
+     * Gets or sets a boolean indicating if the stack is enabled
+     */
+    isEnabled: boolean;
+    /**
+     * Constructor
+     * @param dataProvider defines the data provider function
+     * @param applyUpdate defines the code to execute when undo/redo operation is required
+     */
+    constructor(dataProvider: () => any, applyUpdate: (data: any) => void);
+    /**
+     * Process key event to handle undo / redo
+     * @param evt defines the keyboard event to process
+     * @returns true if the event was processed
+     */
+    processKeyEvent(evt: KeyboardEvent): boolean;
+    /**
+     * Resets the stack
+     */
+    reset(): void;
+    /**
+     * Remove the n-1 element of the stack
+     */
+    collapseLastTwo(): void;
+    private _generateJSONDiff;
+    private _applyJSONDiff;
+    private _copy;
+    /**
+     * Stores the current state
+     */
+    store(): void;
+    /**
+     * Undo the latest operation
+     */
+    undo(): void;
+    /**
+     * Redo the latest undo operation
+     */
+    redo(): void;
+    /**
+     * Disposes the stack
+     */
+    dispose(): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/copyCommandToClipboard" {
+export function copyCommandToClipboard(strCommand: string): void;
+export function getClassNameWithNamespace(obj: any): {
+    className: string;
+    babylonNamespace: string;
+};
+
+}
+declare module "@babylonjs/node-particle-editor/constToOptionsMaps" {
+/**
+ * Used by both particleSystem and alphaBlendModes
+ */
+export const CommonBlendModes: {
+    label: string;
+    value: number;
+}[];
+/**
+ * Used to populated the blendMode dropdown in our various tools (Node Editor, Inspector, etc.)
+ * The below ParticleSystem consts were defined before new Engine alpha blend modes were added, so we have to reference
+ * the ParticleSystem.FOO consts explicitly (as the underlying const values are different - they get mapped to engine consts within baseParticleSystem.ts)
+ */
+export const BlendModeOptions: {
+    label: string;
+    value: number;
+}[];
+/**
+ * Used to populated the alphaMode dropdown in our various tools (Node Editor, Inspector, etc.)
+ */
+export const AlphaModeOptions: {
+    label: string;
+    value: number;
+}[];
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject" {
+/**
+ * Class used to provide lock mechanism
+ */
+export class LockObject {
+    /**
+     * Gets or set if the lock is engaged
+     */
+    lock: boolean;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface ITextBlockPropertyGridComponentProps {
+    textBlock: TextBlock;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
+    constructor(props: ITextBlockPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
+interface IStackPanelPropertyGridComponentProps {
+    stackPanel: StackPanel;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
+    constructor(props: IStackPanelPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
+interface ISliderPropertyGridComponentProps {
+    slider: Slider;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
+    constructor(props: ISliderPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
+interface IScrollViewerPropertyGridComponentProps {
+    scrollViewer: ScrollViewer;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
+    constructor(props: IScrollViewerPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
+interface IRectanglePropertyGridComponentProps {
+    rectangle: Rectangle;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
+    constructor(props: IRectanglePropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
+interface IRadioButtonPropertyGridComponentProps {
+    radioButtons: RadioButton[];
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
+    constructor(props: IRadioButtonPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/linePropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Line } from "@babylonjs/gui/2D/controls/line";
+interface ILinePropertyGridComponentProps {
+    line: Line;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
+    constructor(props: ILinePropertyGridComponentProps);
+    onDashChange(value: string): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { InputText } from "@babylonjs/gui/2D/controls/inputText";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IInputTextPropertyGridComponentProps {
+    inputText: InputText;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
+    constructor(props: IInputTextPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/imagePropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Image } from "@babylonjs/gui/2D/controls/image";
+interface IImagePropertyGridComponentProps {
+    image: Image;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
+    constructor(props: IImagePropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
+interface IImageBasedSliderPropertyGridComponentProps {
+    imageBasedSlider: ImageBasedSlider;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
+    constructor(props: IImageBasedSliderPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/gridPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Grid } from "@babylonjs/gui/2D/controls/grid";
+interface IGridPropertyGridComponentProps {
+    grid: Grid;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
+    constructor(props: IGridPropertyGridComponentProps);
+
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
+interface IEllipsePropertyGridComponentProps {
+    ellipse: Ellipse;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
+    constructor(props: IEllipsePropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/controlPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { Control } from "@babylonjs/gui/2D/controls/control";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IControlPropertyGridComponentProps {
+    control: Control;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
+    constructor(props: IControlPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { Control } from "@babylonjs/gui/2D/controls/control";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface ICommonControlPropertyGridComponentProps {
+    controls?: Control[];
+    control?: Control;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
+    constructor(props: ICommonControlPropertyGridComponentProps);
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IColorPickerPropertyGridComponentProps {
+    colorPicker: ColorPicker;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
+    constructor(props: IColorPickerPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
+interface ICheckboxPropertyGridComponentProps {
+    checkbox: Checkbox;
+    lockObject: LockObject;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+}
+export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
+    constructor(props: ICheckboxPropertyGridComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/split/splitter" {
+import { ControlledSize } from "@babylonjs/node-particle-editor/split/splitContext";
+/**
+ * Splitter component properties
+ */
+export interface ISplitterProps {
+    /**
+     * Unique identifier
+     */
+    id?: string;
+    /**
+     * Splitter size
+     */
+    size: number;
+    /**
+     * Minimum size for the controlled element
+     */
+    minSize?: number;
+    /**
+     * Maximum size for the controlled element
+     */
+    maxSize?: number;
+    /**
+     * Initial size for the controlled element
+     */
+    initialSize?: number;
+    /**
+     * Defines the controlled side
+     */
+    controlledSide: ControlledSize;
+    /**
+     * refObject to the splitter element
+     */
+    refObject?: React.RefObject<HTMLDivElement>;
+}
+/**
+ * Creates a splitter component
+ * @param props defines the splitter properties
+ * @returns the splitter component
+ */
+export const Splitter: React.FC<ISplitterProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/split/splitContext" {
+export enum ControlledSize {
+    First = 0,
+    Second = 1
+}
+export enum SplitDirection {
+    Horizontal = 0,
+    Vertical = 1
+}
+/**
+ * Context used to share data with splitters
+ */
+export interface ISplitContext {
+    /**
+     * Split direction
+     */
+    direction: SplitDirection;
+    /**
+     * Function called by splitters to update the offset
+     * @param offset new offet
+     * @param source source element
+     * @param controlledSide defined controlled element
+     */
+    drag: (offset: number, source: HTMLElement, controlledSide: ControlledSize) => void;
+    /**
+     * Function called by splitters to begin dragging
+     */
+    beginDrag: () => void;
+    /**
+     * Function called by splitters to end dragging
+     */
+    endDrag: () => void;
+    /**
+     * Sync sizes for the elements
+     * @param source source element
+     * @param controlledSide defined controlled element
+     * @param size size of the controlled element
+     * @param minSize minimum size for the controlled element
+     * @param maxSize maximum size for the controlled element
+     */
+    sync: (source: HTMLElement, controlledSide: ControlledSize, size?: number, minSize?: number, maxSize?: number) => void;
+}
+export const SplitContext: import("react").Context<ISplitContext>;
+
+}
+declare module "@babylonjs/node-particle-editor/split/splitContainer" {
+import { PropsWithChildren } from "react";
+import { SplitDirection } from "@babylonjs/node-particle-editor/split/splitContext";
+/**
+ * Split container properties
+ */
+export interface ISplitContainerProps {
+    /**
+     * Unique identifier
+     */
+    id?: string;
+    /**
+     * Split direction
+     */
+    direction: SplitDirection;
+    /**
+     * Minimum size for the floating elements
+     */
+    floatingMinSize?: number;
+    /**
+     * RefObject to the root div element
+     */
+    containerRef?: React.RefObject<HTMLDivElement>;
+    /**
+     * Optional class name
+     */
+    className?: string;
+    /**
+     * Pointer down
+     * @param event pointer events
+     */
+    onPointerDown?: (event: React.PointerEvent) => void;
+    /**
+     * Pointer move
+     * @param event pointer events
+     */
+    onPointerMove?: (event: React.PointerEvent) => void;
+    /**
+     * Pointer up
+     * @param event pointer events
+     */
+    onPointerUp?: (event: React.PointerEvent) => void;
+    /**
+     * Drop
+     * @param event drag events
+     */
+    onDrop?: (event: React.DragEvent<HTMLDivElement>) => void;
+    /**
+     * Drag over
+     * @param event drag events
+     */
+    onDragOver?: (event: React.DragEvent<HTMLDivElement>) => void;
+}
+/**
+ * Creates a split container component
+ * @param props defines the split container properties
+ * @returns the split container component
+ */
+export const SplitContainer: React.FC<PropsWithChildren<ISplitContainerProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/typeLedger" {
+import { INodeContainer } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeContainer";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+export class TypeLedger {
+    static PortDataBuilder: (port: NodePort, nodeContainer: INodeContainer) => IPortData;
+    static NodeDataBuilder: (data: any, nodeContainer: INodeContainer) => INodeData;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/tools" {
+import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { NodeLink } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodeLink";
+import { FramePortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/types/framePortData";
+export const IsFramePortData: (variableToCheck: any) => variableToCheck is FramePortData;
+export const RefreshNode: (node: GraphNode, visitedNodes?: Set<GraphNode>, visitedLinks?: Set<NodeLink>, canvas?: GraphCanvasComponent) => void;
+export const BuildFloatUI: (container: HTMLDivElement, document: Document, displayName: string, isInteger: boolean, source: any, propertyName: string, onChange: () => void, min?: number, max?: number, visualPropertiesRefresh?: Array<() => void>, additionalClassName?: string) => void;
+export function GetListOfAcceptedTypes<T extends Record<string, string | number>>(types: T, allValue: number, autoDetectValue: number, port: {
+    acceptedConnectionPointTypes: number[];
+    excludedConnectionPointTypes: number[];
+    type: number;
+}, skips?: number[]): string[];
+export function GetConnectionErrorMessage<T extends Record<string, string | number>>(sourceType: number, types: T, allValue: number, autoDetectValue: number, port: {
+    acceptedConnectionPointTypes: number[];
+    excludedConnectionPointTypes: number[];
+    type: number;
+}, skips?: number[]): string;
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager" {
+import { Vector2 } from "@babylonjs/core/Maths/math.vector";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { Nullable } from "@babylonjs/core/types";
+import { FrameNodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { INodeContainer } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeContainer";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { ISelectionChangedOptions } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/selectionChangedOptions";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { HistoryStack } from "@babylonjs/node-particle-editor/historyStack";
+import { Scene } from "@babylonjs/core/scene";
+export class StateManager {
+    data: any;
+    hostDocument: Document;
+    lockObject: any;
+    modalIsDisplayed: boolean;
+    historyStack: HistoryStack;
+    onSearchBoxRequiredObservable: Observable<{
+        x: number;
+        y: number;
+    }>;
+    onSelectionChangedObservable: Observable<Nullable<ISelectionChangedOptions>>;
+    onFrameCreatedObservable: Observable<GraphFrame>;
+    onUpdateRequiredObservable: Observable<any>;
+    onGraphNodeRemovalObservable: Observable<GraphNode>;
+    onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
+    onCandidateLinkMoved: Observable<Nullable<Vector2>>;
+    onCandidatePortSelectedObservable: Observable<Nullable<FrameNodePort | NodePort>>;
+    onNewNodeCreatedObservable: Observable<GraphNode>;
+    onRebuildRequiredObservable: Observable<void>;
+    onNodeMovedObservable: Observable<GraphNode>;
+    onErrorMessageDialogRequiredObservable: Observable<string>;
+    onExposePortOnFrameObservable: Observable<GraphNode>;
+    onGridSizeChanged: Observable<void>;
+    onNewBlockRequiredObservable: Observable<{
+        type: string;
+        targetX: number;
+        targetY: number;
+        needRepositioning?: boolean;
+        smartAdd?: boolean;
+    }>;
+    onHighlightNodeObservable: Observable<{
+        data: any;
+        active: boolean;
+    }>;
+    onPreviewCommandActivated: Observable<boolean>;
+    exportData: (data: any, frame?: Nullable<GraphFrame>) => string;
+    isElbowConnectionAllowed: (nodeA: FrameNodePort | NodePort, nodeB: FrameNodePort | NodePort) => boolean;
+    isDebugConnectionAllowed: (nodeA: FrameNodePort | NodePort, nodeB: FrameNodePort | NodePort) => boolean;
+    applyNodePortDesign: (data: IPortData, element: HTMLElement, imgHost: HTMLImageElement, pip: HTMLDivElement) => boolean;
+    getPortColor: (portData: IPortData) => string;
+    storeEditorData: (serializationObject: any, frame?: Nullable<GraphFrame>) => void;
+    getEditorDataMap: () => {
+        [key: number]: number;
+    };
+    getScene?: () => Scene;
+    createDefaultInputData: (rootData: any, portData: IPortData, nodeContainer: INodeContainer) => Nullable<{
+        data: INodeData;
+        name: string;
+    }>;
+    private _isRebuildQueued;
+    queueRebuildCommand(): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/searchBox" {
+import * as React from "react";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import "@babylonjs/node-particle-editor/nodeGraphSystem/searchBox.scss";
+export interface ISearchBoxComponentProps {
+    stateManager: StateManager;
+}
+/**
+ * The search box component.
+ */
+export class SearchBoxComponent extends React.Component<ISearchBoxComponentProps, {
+    isVisible: boolean;
+    filter: string;
+    selectedIndex: number;
+}> {
+    private _handleEscKey;
+    private _targetX;
+    private _targetY;
+    private _nodes;
+    constructor(props: ISearchBoxComponentProps);
+    hide(): void;
+    onFilterChange(evt: React.ChangeEvent<HTMLInputElement>): void;
+    onNewNodeRequested(name: string): void;
+    onKeyDown(evt: React.KeyboardEvent): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/propertyLedger" {
+import { ComponentClass } from "react";
+import { IPropertyComponentProps } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps";
+export class PropertyLedger {
+    static DefaultControl: ComponentClass<IPropertyComponentProps>;
+    static RegisteredControls: {
+        [key: string]: ComponentClass<IPropertyComponentProps>;
+    };
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort" {
+import { Nullable } from "@babylonjs/core/types";
+import { Observer } from "@babylonjs/core/Misc/observable";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { ISelectionChangedOptions } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/selectionChangedOptions";
+import { FrameNodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort";
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { type IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+export class NodePort {
+    portData: IPortData;
+    node: GraphNode;
+    protected _element: HTMLDivElement;
+    protected _portContainer: HTMLElement;
+    protected _imgHost: HTMLImageElement;
+    protected _pip: HTMLDivElement;
+    protected _stateManager: StateManager;
+    protected _portLabelElement: Element;
+    protected _onCandidateLinkMovedObserver: Nullable<Observer<Nullable<Vector2>>>;
+    protected _onSelectionChangedObserver: Nullable<Observer<Nullable<ISelectionChangedOptions>>>;
+    protected _exposedOnFrame: boolean;
+    protected _portUIcontainer?: HTMLDivElement;
+    delegatedPort: Nullable<FrameNodePort>;
+    get element(): HTMLDivElement;
+    get container(): HTMLElement;
+    get portName(): string;
+    set portName(newName: string);
+    get disabled(): boolean;
+    hasLabel(): boolean;
+    get exposedOnFrame(): boolean;
+    set exposedOnFrame(value: boolean);
+    get exposedPortPosition(): number;
+    set exposedPortPosition(value: number);
+    private _isConnectedToNodeOutsideOfFrame;
+    refresh(): void;
+    constructor(portContainer: HTMLElement, portData: IPortData, node: GraphNode, stateManager: StateManager, portUIcontainer?: HTMLDivElement);
+    dispose(): void;
+    static CreatePortElement(portData: IPortData, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, stateManager: StateManager): NodePort;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/nodeLink" {
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { FrameNodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
+export class NodeLink {
+    private _graphCanvas;
+    private _portA;
+    private _portB?;
+    private _nodeA;
+    private _nodeB?;
+    private _path;
+    private _selectionPath;
+    private _onSelectionChangedObserver;
+    private _isVisible;
+    private _isTargetCandidate;
+    private _gradient;
+    onDisposedObservable: Observable<NodeLink>;
+    get isTargetCandidate(): boolean;
+    set isTargetCandidate(value: boolean);
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    get portA(): FrameNodePort | NodePort;
+    get portB(): FrameNodePort | NodePort | undefined;
+    get nodeA(): GraphNode;
+    get nodeB(): GraphNode | undefined;
+    intersectsWith(rect: DOMRect): boolean;
+    update(endX?: number, endY?: number, straight?: boolean): void;
+    get path(): SVGPathElement;
+    get selectionPath(): SVGPathElement;
+    constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode);
+    onClick(evt: MouseEvent): void;
+    dispose(notify?: boolean): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/nodeLedger" {
+export class NodeLedger {
+    static RegisteredNodeNames: string[];
+    static NameFormatter: (name: string) => string;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode" {
+import { Nullable } from "@babylonjs/core/types";
+import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { NodeLink } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodeLink";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { IEditablePropertyOption } from "@babylonjs/core/Decorators/nodeDecorator";
+export class GraphNode {
+    content: INodeData;
+    private static _IdGenerator;
+    private _visual;
+    private _headerContainer;
+    private _headerIcon;
+    private _headerIconImg;
+    private _headerCollapseImg;
+    private _header;
+    private _headerCollapse;
+    private _connections;
+    private _optionsContainer;
+    private _inputsContainer;
+    private _outputsContainer;
+    private _content;
+    private _comments;
+    private _executionTime;
+    private _selectionBorder;
+    private _inputPorts;
+    private _outputPorts;
+    private _links;
+    private _x;
+    private _y;
+    private _gridAlignedX;
+    private _gridAlignedY;
+    private _mouseStartPointX;
+    private _mouseStartPointY;
+    private _stateManager;
+    private _onSelectionChangedObserver;
+    private _onSelectionBoxMovedObserver;
+    private _onFrameCreatedObserver;
+    private _onUpdateRequiredObserver;
+    private _onHighlightNodeObserver;
+    private _ownerCanvas;
+    private _displayManager;
+    private _isVisible;
+    private _enclosingFrameId;
+    private _visualPropertiesRefresh;
+    private _lastClick;
+    addClassToVisual(className: string): void;
+    removeClassFromVisual(className: string): void;
+    get isCollapsed(): boolean;
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    private _upateNodePortNames;
+    get outputPorts(): NodePort[];
+    get inputPorts(): NodePort[];
+    get links(): NodeLink[];
+    get gridAlignedX(): number;
+    get gridAlignedY(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    get height(): number;
+    get id(): number;
+    get name(): string;
+    get enclosingFrameId(): number;
+    set enclosingFrameId(value: number);
+    setIsSelected(value: boolean, marqueeSelection: boolean): void;
+    get rootElement(): HTMLDivElement;
+    constructor(content: INodeData, stateManager: StateManager);
+    isOverlappingFrame(frame: GraphFrame): boolean;
+    getPortForPortData(portData: IPortData): NodePort | null;
+    getPortDataForPortDataContent(data: any): IPortData | null;
+    getLinksForPortDataContent(data: any): NodeLink[];
+    getLinksForPortData(portData: IPortData): NodeLink[];
+    private _refreshFrames;
+    _refreshLinks(): void;
+    refresh(): void;
+    private _expand;
+    private _searchMiddle;
+    private _onDown;
+    cleanAccumulation(useCeil?: boolean): void;
+    private _onUp;
+    private _onMove;
+    renderProperties(): Nullable<JSX.Element>;
+    _forceRebuild(source: any, propertyName: string, notifiers?: IEditablePropertyOption["notifiers"]): void;
+    private _isCollapsed;
+    /**
+     * Collapse the node
+     */
+    collapse(): void;
+    /**
+     * Expand the node
+     */
+    expand(): void;
+    private _portUICount;
+    private _buildInputPorts;
+    appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
+    dispose(): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame" {
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
+import { Nullable } from "@babylonjs/core/types";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+import { FrameNodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort";
+import { IFrameData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
+export enum FramePortPosition {
+    Top = 0,
+    Middle = 1,
+    Bottom = 2
+}
+export class GraphFrame {
+    private readonly _collapsedWidth;
+    private static _FrameCounter;
+    private static _FramePortCounter;
+    private _name;
+    private _color;
+    private _x;
+    private _y;
+    private _gridAlignedX;
+    private _gridAlignedY;
+    private _width;
+    private _height;
+    element: HTMLDivElement;
+    private _borderElement;
+    private _headerElement;
+    private _headerTextElement;
+    private _headerCollapseElement;
+    private _headerCloseElement;
+    private _headerFocusElement;
+    private _commentsElement;
+    private _portContainer;
+    private _outputPortContainer;
+    private _inputPortContainer;
+    private _nodes;
+    private _ownerCanvas;
+    private _mouseStartPointX;
+    private _mouseStartPointY;
+    private _onSelectionChangedObserver;
+    private _onGraphNodeRemovalObserver;
+    private _onExposePortOnFrameObserver;
+    private _onNodeLinkDisposedObservers;
+    private _isCollapsed;
+    private _frameInPorts;
+    private _frameOutPorts;
+    private _controlledPorts;
+    private _exposedInPorts;
+    private _exposedOutPorts;
+    private _id;
+    private _comments;
+    private _frameIsResizing;
+    private _resizingDirection;
+    private _minFrameHeight;
+    private _minFrameWidth;
+    private _mouseXLimit;
+    onExpandStateChanged: Observable<GraphFrame>;
+    private readonly _closeSVG;
+    private readonly _expandSVG;
+    private readonly _collapseSVG;
+    private readonly _focusSVG;
+    get id(): number;
+    get isCollapsed(): boolean;
+    private _createInputPort;
+    private _markFramePortPositions;
+    private _createFramePorts;
+    private _removePortFromExposedWithNode;
+    private _removePortFromExposedWithLink;
+    private _createInputPorts;
+    private _createOutputPorts;
+    redrawFramePorts(): void;
+    set isCollapsed(value: boolean);
+    get nodes(): GraphNode[];
+    get ports(): FrameNodePort[];
+    get name(): string;
+    set name(value: string);
+    get color(): Color3;
+    set color(value: Color3);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get comments(): string;
+    set comments(comments: string);
+    constructor(candidate: Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
+    private _isFocused;
+    /**
+     * Enter/leave focus mode
+     */
+    switchFocusMode(): void;
+    refresh(): void;
+    addNode(node: GraphNode): void;
+    removeNode(node: GraphNode): void;
+    syncNode(node: GraphNode): void;
+    cleanAccumulation(): void;
+    private _onDown;
+    move(newX: number, newY: number, align?: boolean): void;
+    private _onUp;
+    _moveFrame(offsetX: number, offsetY: number): void;
+    private _onMove;
+    moveFramePortUp(nodePort: FrameNodePort): void;
+    private _movePortUp;
+    moveFramePortDown(nodePort: FrameNodePort): void;
+    private _movePortDown;
+    private _initResizing;
+    private _cleanUpResizing;
+    private _updateMinHeightWithComments;
+    private _isResizingTop;
+    private _isResizingRight;
+    private _isResizingBottom;
+    private _isResizingLeft;
+    private _onRightHandlePointerDown;
+    private _onRightHandlePointerMove;
+    private _moveRightHandle;
+    private _onRightHandlePointerUp;
+    private _onBottomHandlePointerDown;
+    private _onBottomHandlePointerMove;
+    private _moveBottomHandle;
+    private _onBottomHandlePointerUp;
+    private _onLeftHandlePointerDown;
+    private _onLeftHandlePointerMove;
+    private _moveLeftHandle;
+    private _onLeftHandlePointerUp;
+    private _onTopHandlePointerDown;
+    private _onTopHandlePointerMove;
+    private _moveTopHandle;
+    private _onTopHandlePointerUp;
+    private _onTopRightHandlePointerDown;
+    private _onTopRightHandlePointerMove;
+    private _moveTopRightHandle;
+    private _onTopRightHandlePointerUp;
+    private _onBottomRightHandlePointerDown;
+    private _onBottomRightHandlePointerMove;
+    private _moveBottomRightHandle;
+    private _onBottomRightHandlePointerUp;
+    private _onBottomLeftHandlePointerDown;
+    private _onBottomLeftHandlePointerMove;
+    private _moveBottomLeftHandle;
+    private _onBottomLeftHandlePointerUp;
+    private _onTopLeftHandlePointerDown;
+    private _onTopLeftHandlePointerMove;
+    private _moveTopLeftHandle;
+    private _onTopLeftHandlePointerUp;
+    private _expandLeft;
+    private _expandTop;
+    private _expandRight;
+    private _expandBottom;
+    dispose(): void;
+    private _serializePortData;
+    serialize(saveCollapsedState: boolean): IFrameData;
+    export(): void;
+    adjustPorts(): void;
+    static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: {
+        [key: number]: number;
+    }): GraphFrame;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas" {
+import * as React from "react";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { Nullable } from "@babylonjs/core/types";
+import { NodeLink } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodeLink";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { IEditorData, IFrameData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { INodeContainer } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeContainer";
+export interface IGraphCanvasComponentProps {
+    stateManager: StateManager;
+    onEmitNewNode: (nodeData: INodeData) => GraphNode;
+}
+export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> implements INodeContainer {
+    static readonly NodeWidth: number;
+    private readonly _minZoom;
+    private readonly _maxZoom;
+    private _hostCanvasRef;
+    private _hostCanvas;
+    private _graphCanvasRef;
+    private _graphCanvas;
+    private _selectionContainerRef;
+    private _selectionContainer;
+    private _frameContainerRef;
+    private _frameContainer;
+    private _svgCanvasRef;
+    private _svgCanvas;
+    private _rootContainerRef;
+    private _rootContainer;
+    private _nodes;
+    private _links;
+    private _mouseStartPointX;
+    private _mouseStartPointY;
+    private _dropPointX;
+    private _dropPointY;
+    private _selectionStartX;
+    private _selectionStartY;
+    private _candidateLinkedHasMoved;
+    private _x;
+    private _y;
+    private _lastx;
+    private _lasty;
+    private _zoom;
+    private _selectedNodes;
+    private _selectedLink;
+    private _selectedPort;
+    private _candidateLink;
+    private _candidatePort;
+    private _gridSize;
+    private _selectionBox;
+    private _selectedFrames;
+    private _frameCandidate;
+    private _frames;
+    private _nodeDataContentList;
+    private _altKeyIsPressed;
+    private _shiftKeyIsPressed;
+    private _multiKeyIsPressed;
+    private _oldY;
+    _frameIsMoving: boolean;
+    _isLoading: boolean;
+    _targetLinkCandidate: Nullable<NodeLink>;
+    private _copiedNodes;
+    private _copiedFrames;
+    get gridSize(): number;
+    set gridSize(value: number);
+    get stateManager(): StateManager;
+    get nodes(): GraphNode[];
+    get links(): NodeLink[];
+    get frames(): GraphFrame[];
+    get zoom(): number;
+    set zoom(value: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get selectedNodes(): GraphNode[];
+    get selectedLink(): Nullable<NodeLink>;
+    get selectedFrames(): GraphFrame[];
+    get selectedPort(): Nullable<NodePort>;
+    get canvasContainer(): HTMLDivElement;
+    get hostCanvas(): HTMLDivElement;
+    get svgCanvas(): HTMLElement;
+    get selectionContainer(): HTMLDivElement;
+    get frameContainer(): HTMLDivElement;
+    private _selectedFrameAndNodesConflict;
+    constructor(props: IGraphCanvasComponentProps);
+    populateConnectedEntriesBeforeRemoval(item: GraphNode, items: GraphNode[], inputs: Nullable<IPortData>[], outputs: Nullable<IPortData>[]): void;
+    automaticRewire(inputs: Nullable<IPortData>[], outputs: Nullable<IPortData>[], firstOnly?: boolean): void;
+    smartAddOverLink(node: GraphNode, link: NodeLink): void;
+    smartAddOverNode(node: GraphNode, source: GraphNode): void;
+    deleteSelection(onRemove: (nodeData: INodeData) => void, autoReconnect?: boolean): void;
+    handleKeyDown(evt: KeyboardEvent, onRemove: (nodeData: INodeData) => void, mouseLocationX: number, mouseLocationY: number, dataGenerator: (nodeData: INodeData) => any, rootElement: HTMLDivElement): void;
+    pasteSelection(copiedNodes: GraphNode[], currentX: number, currentY: number, dataGenerator: (nodeData: INodeData) => any, selectNew?: boolean): GraphNode[];
+    reconnectNewNodes(nodeIndex: number, newNodes: GraphNode[], sourceNodes: GraphNode[], done: boolean[]): void;
+    getCachedData(): any[];
+    removeDataFromCache(data: any): void;
+    createNodeFromObject(nodeData: INodeData, onNodeCreated: (data: any) => void, recursion?: boolean): GraphNode;
+    getGridPosition(position: number, useCeil?: boolean): number;
+    getGridPositionCeil(position: number): number;
+    updateTransform(): void;
+    onKeyUp(): void;
+    findNodeFromData(data: any): GraphNode;
+    reset(): void;
+    connectPorts(pointA: IPortData, pointB: IPortData): void;
+    removeLink(link: NodeLink): void;
+    appendNode(nodeData: INodeData): GraphNode;
+    distributeGraph(): void;
+    componentDidMount(): void;
+    onMove(evt: React.PointerEvent): void;
+    onDown(evt: React.PointerEvent<HTMLElement>): void;
+    onUp(evt: React.PointerEvent): void;
+    onWheel(evt: React.WheelEvent): void;
+    zoomToFit(): void;
+    processCandidatePort(): void;
+    connectNodes(nodeA: GraphNode, pointA: IPortData, nodeB: GraphNode, pointB: IPortData): void;
+    drop(newNode: GraphNode, targetX: number, targetY: number, offsetX: number, offsetY: number): void;
+    processEditorData(editorData: IEditorData): void;
+    reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
+    addFrame(frameData: IFrameData): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort" {
+import { IDisplayManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { Nullable } from "@babylonjs/core/types";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { FramePortPosition } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+export class FrameNodePort extends NodePort {
+    portData: IPortData;
+    node: GraphNode;
+    private _parentFrameId;
+    private _isInput;
+    private _framePortPosition;
+    private _framePortId;
+    private _onFramePortPositionChangedObservable;
+    get parentFrameId(): number;
+    get onFramePortPositionChangedObservable(): Observable<FrameNodePort>;
+    get isInput(): boolean;
+    get framePortId(): number;
+    get framePortPosition(): FramePortPosition;
+    set framePortPosition(position: FramePortPosition);
+    constructor(portContainer: HTMLElement, portData: IPortData, node: GraphNode, stateManager: StateManager, isInput: boolean, framePortId: number, parentFrameId: number);
+    static CreateFrameNodePortElement(portData: IPortData, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, stateManager: StateManager, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/displayLedger" {
+export class DisplayLedger {
+    static RegisteredControls: {
+        [key: string]: any;
+    };
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/automaticProperties" {
+import { IEditablePropertyOption } from "@babylonjs/core/Decorators/nodeDecorator";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+/**
+ * Function used to force a rebuild of the node system
+ * @param source source object
+ * @param stateManager defines the state manager to use
+ * @param propertyName name of the property that has been changed
+ * @param notifiers list of notifiers to use
+ */
+export function ForceRebuild(source: any, stateManager: StateManager, propertyName: string, notifiers?: IEditablePropertyOption["notifiers"]): void;
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/types/framePortData" {
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { FrameNodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/frameNodePort";
+export type FramePortData = {
+    frame: GraphFrame;
+    port: FrameNodePort;
+};
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/selectionChangedOptions" {
+import { Nullable } from "@babylonjs/core/types";
+import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { NodeLink } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodeLink";
+import { NodePort } from "@babylonjs/node-particle-editor/nodeGraphSystem/nodePort";
+import { FramePortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/types/framePortData";
+export interface ISelectionChangedOptions {
+    selection: Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
+    forceKeepSelection?: boolean;
+    marqueeSelection?: boolean;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps" {
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export interface IPropertyComponentProps {
+    stateManager: StateManager;
+    nodeData: INodeData;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData" {
+import { Nullable } from "@babylonjs/core/types";
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+export enum PortDataDirection {
+    /** Input */
+    Input = 0,
+    /** Output */
+    Output = 1
+}
+export enum PortDirectValueTypes {
+    Float = 0,
+    Int = 1
+}
+export interface IPortDirectValueDefinition {
+    /**
+     * Gets the source object
+     */
+    source: any;
+    /**
+     * Gets the property name used to store the value
+     */
+    propertyName: string;
+    /**
+     * Gets or sets the min value accepted for this point if nothing is connected
+     */
+    valueMin: Nullable<any>;
+    /**
+     * Gets or sets the max value accepted for this point if nothing is connected
+     */
+    valueMax: Nullable<any>;
+    /**
+     * Gets or sets the type of the value
+     */
+    valueType: PortDirectValueTypes;
+}
+export interface IPortData {
+    data: any;
+    name: string;
+    internalName: string;
+    isExposedOnFrame: boolean;
+    exposedPortPosition: number;
+    isConnected: boolean;
+    direction: PortDataDirection;
+    ownerData: any;
+    connectedPort: Nullable<IPortData>;
+    needDualDirectionValidation: boolean;
+    hasEndpoints: boolean;
+    endpoints: Nullable<IPortData[]>;
+    directValueDefinition?: IPortDirectValueDefinition;
+    updateDisplayName: (newName: string) => void;
+    canConnectTo: (port: IPortData) => boolean;
+    connectTo: (port: IPortData) => void;
+    disconnectFrom: (port: IPortData) => void;
+    checkCompatibilityState(port: IPortData): number;
+    getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeLocationInfo" {
+export interface INodeLocationInfo {
+    blockId: number;
+    x: number;
+    y: number;
+    isCollapsed: boolean;
+}
+export interface IFrameData {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: number[];
+    name: string;
+    isCollapsed: boolean;
+    blocks: number[];
+    comments: string;
+}
+export interface IEditorData {
+    locations: INodeLocationInfo[];
+    x: number;
+    y: number;
+    zoom: number;
+    frames?: IFrameData[];
+    map?: {
+        [key: number]: number;
+    };
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData" {
+import { Nullable } from "@babylonjs/core/types";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+export interface INodeData {
+    data: any;
+    name: string;
+    uniqueId: number;
+    isInput: boolean;
+    comments: string;
+    executionTime?: number;
+    refreshCallback?: () => void;
+    prepareHeaderIcon: (iconDiv: HTMLDivElement, img: HTMLImageElement) => void;
+    getClassName: () => string;
+    dispose: () => void;
+    getPortByName: (name: string) => Nullable<IPortData>;
+    inputs: IPortData[];
+    outputs: IPortData[];
+    invisibleEndpoints?: Nullable<any[]>;
+    isConnectedToOutput?: () => boolean;
+    isActive?: boolean;
+    setIsActive?: (value: boolean) => void;
+    canBeActivated?: boolean;
+    onInputCountChanged?: () => void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeContainer" {
+import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+export interface INodeContainer {
+    nodes: GraphNode[];
+    appendNode(data: INodeData): GraphNode;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/displayManager" {
+import { Nullable } from "@babylonjs/core/types";
+import { StateManager } from "@babylonjs/node-particle-editor/nodeGraphSystem/stateManager";
+import { INodeData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeData";
+import { IPortData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/portData";
+export interface VisualContentDescription {
+    [key: string]: HTMLElement;
+}
+export interface IDisplayManager {
+    getHeaderClass(data: INodeData): string;
+    shouldDisplayPortLabels(data: IPortData): boolean;
+    updatePreviewContent(data: INodeData, contentArea: HTMLDivElement): void;
+    updateFullVisualContent?(data: INodeData, visualContent: VisualContentDescription): void;
+    getBackgroundColor(data: INodeData): string;
+    getHeaderText(data: INodeData): string;
+    onSelectionChanged?(data: INodeData, selectedData: Nullable<INodeData>, manager: StateManager): void;
+    onDispose?(nodeData: INodeData, manager: StateManager): void;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/vector4LineComponent" {
+import * as React from "react";
+import { Vector4 } from "@babylonjs/core/Maths/math.vector";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IVector4LineComponentProps {
+    label: string;
+    target?: any;
+    propertyName?: string;
+    step?: number;
+    onChange?: (newvalue: Vector4) => void;
+    useEuler?: boolean;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    icon?: string;
+    iconLabel?: string;
+    value?: Vector4;
+    lockObject: LockObject;
+}
+export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
+    isExpanded: boolean;
+    value: Vector4;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: IVector4LineComponentProps);
+    getCurrentValue(): any;
+    shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
+        isExpanded: boolean;
+        value: Vector4;
+    }): boolean;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Vector4): void;
+    updateVector4(): void;
+    updateStateX(value: number): void;
+    updateStateY(value: number): void;
+    updateStateZ(value: number): void;
+    updateStateW(value: number): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/vector3LineComponent" {
+import * as React from "react";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IVector3LineComponentProps {
+    label: string;
+    target?: any;
+    propertyName?: string;
+    step?: number;
+    onChange?: (newvalue: Vector3) => void;
+    useEuler?: boolean;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    noSlider?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+    directValue?: Vector3;
+    additionalCommands?: JSX.Element[];
+}
+export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
+    isExpanded: boolean;
+    value: Vector3;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: IVector3LineComponentProps);
+    getCurrentValue(): any;
+    shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
+        isExpanded: boolean;
+        value: Vector3;
+    }): boolean;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Vector3): void;
+    updateVector3(): void;
+    updateStateX(value: number): void;
+    updateStateY(value: number): void;
+    updateStateZ(value: number): void;
+    onCopyClick(): string;
+
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/vector2LineComponent" {
+import * as React from "react";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IVector2LineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    step?: number;
+    onChange?: (newvalue: Vector2) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+}
+export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
+    isExpanded: boolean;
+    value: Vector2;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: IVector2LineComponentProps);
+    shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
+        isExpanded: boolean;
+        value: Vector2;
+    }): boolean;
+    switchExpandState(): void;
+    raiseOnPropertyChanged(previousValue: Vector2): void;
+    updateStateX(value: number): void;
+    updateStateY(value: number): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/valueLineComponent" {
+import * as React from "react";
+interface IValueLineComponentProps {
+    label: string;
+    value: number;
+    color?: string;
+    fractionDigits?: number;
+    units?: string;
+    icon?: string;
+    iconLabel?: string;
+}
+export class ValueLineComponent extends React.Component<IValueLineComponentProps> {
+    constructor(props: IValueLineComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/unitButton" {
+interface IUnitButtonProps {
+    unit: string;
+    locked?: boolean;
+    onClick?: (unit: string) => void;
+}
+
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/textureButtonLineComponent" {
+import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
+import { Scene } from "@babylonjs/core/scene";
+import * as React from "react";
+interface ITextureButtonLineProps {
+    label: string;
+    scene: Scene;
+    onClick: (file: File) => void;
+    onLink: (texture: BaseTexture) => void;
+    accept: string;
+}
+interface ITextureButtonLineState {
+    isOpen: boolean;
+}
+export class TextureButtonLine extends React.Component<ITextureButtonLineProps, ITextureButtonLineState> {
+    private static _IdGenerator;
+    private _id;
+    private _uploadInputRef;
+    constructor(props: ITextureButtonLineProps);
+    onChange(evt: any): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/textLineComponent" {
+import * as React from "react";
+interface ITextLineComponentProps {
+    label?: string;
+    value?: string;
+    color?: string;
+    underline?: boolean;
+    onLink?: () => void;
+    url?: string;
+    ignoreValue?: boolean;
+    additionalClass?: string;
+    icon?: string;
+    iconLabel?: string;
+    tooltip?: string;
+    onCopy?: true | (() => string);
+}
+export class TextLineComponent extends React.Component<ITextLineComponentProps> {
+    constructor(props: ITextLineComponentProps);
+    onLink(): void;
+    copyFn(): (() => string) | undefined;
+
+
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/textInputLineComponent" {
+import { ReactNode, KeyboardEvent } from "react";
+import { Component } from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface ITextInputLineComponentProps {
+    label?: string;
+    lockObject?: LockObject;
+    target?: any;
+    propertyName?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    icon?: string;
+    iconLabel?: string;
+    noUnderline?: boolean;
+    numbersOnly?: boolean;
+    delayInput?: boolean;
+    arrows?: boolean;
+    arrowsIncrement?: (amount: number) => void;
+    step?: number;
+    numeric?: boolean;
+    roundValues?: boolean;
+    min?: number;
+    max?: number;
+    placeholder?: string;
+    unit?: ReactNode;
+    validator?: (value: string) => boolean;
+    multilines?: boolean;
+    throttlePropertyChangedNotification?: boolean;
+    throttlePropertyChangedNotificationDelay?: number;
+    disabled?: boolean;
+}
+export class TextInputLineComponent extends Component<ITextInputLineComponentProps, {
+    value: string;
+    dragging: boolean;
+}> {
+    private _localChange;
+    constructor(props: ITextInputLineComponentProps);
+    componentWillUnmount(): void;
+    shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
+        value: string;
+        dragging: boolean;
+    }): boolean;
+    raiseOnPropertyChanged(newValue: string, previousValue: string): void;
+    getCurrentNumericValue(value: string): number;
+    updateValue(value: string, valueToValidate?: string): void;
+    incrementValue(amount: number): void;
+    onKeyDown(event: KeyboardEvent): void;
+
+
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/targetsProxy" {
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { Observable } from "@babylonjs/core/Misc/observable";
+export const conflictingValuesPlaceholder = "\u2014";
+/**
+ *
+ * @param targets a list of selected targets
+ * @param onPropertyChangedObservable
+ * @param getProperty
+ * @returns a proxy object that can be passed as a target into the input
+ */
+export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
+
+}
+declare module "@babylonjs/node-particle-editor/lines/sliderLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface ISliderLineComponentProps {
+    label: string;
+    target?: any;
+    propertyName?: string;
+    minimum: number;
+    maximum: number;
+    step: number;
+    directValue?: number;
+    useEuler?: boolean;
+    onChange?: (value: number) => void;
+    onInput?: (value: number) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    decimalCount?: number;
+    margin?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+    unit?: React.ReactNode;
+    allowOverflow?: boolean;
+}
+export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
+    value: number;
+}> {
+    private _localChange;
+    constructor(props: ISliderLineComponentProps);
+    shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
+        value: number;
+    }): boolean;
+    onChange(newValueString: any): void;
+    onInput(newValueString: any): void;
+    prepareDataToRead(value: number): number;
+    onCopyClick(): void;
+
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/radioLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+interface IRadioButtonLineComponentProps {
+    onSelectionChangedObservable: Observable<RadioButtonLineComponent>;
+    label: string;
+    isSelected: () => boolean;
+    onSelect: () => void;
+    icon?: string;
+    iconLabel?: string;
+}
+export class RadioButtonLineComponent extends React.Component<IRadioButtonLineComponentProps, {
+    isSelected: boolean;
+}> {
+    private _onSelectionChangedObserver;
+    constructor(props: IRadioButtonLineComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    onChange(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/optionsLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { IInspectableOptions } from "@babylonjs/core/Misc/iInspectable";
+export const Null_Value: number;
+export interface IOptionsLineProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    options: IInspectableOptions[];
+    noDirectUpdate?: boolean;
+    onSelect?: (value: number | string) => void;
+    extractValue?: (target: any) => number | string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    allowNullValue?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    className?: string;
+    valuesAreStrings?: boolean;
+    defaultIfNull?: number;
+}
+export class OptionsLine extends React.Component<IOptionsLineProps, {
+    value: number | string;
+}> {
+    private _localChange;
+    private _remapValueIn;
+    private _remapValueOut;
+    private _getValue;
+    constructor(props: IOptionsLineProps);
+    shouldComponentUpdate(nextProps: IOptionsLineProps, nextState: {
+        value: number;
+    }): boolean;
+    raiseOnPropertyChanged(newValue: number, previousValue: number): void;
+    setValue(value: string | number): void;
+    updateValue(valueString: string): void;
+    onCopyClickStr(): string;
+    private _renderFluent;
+    private _renderOriginal;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/numericInputComponent" {
+import * as React from "react";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface INumericInputProps {
+    label: string;
+    labelTooltip?: string;
+    value: number;
+    step?: number;
+    onChange: (value: number) => void;
+    precision?: number;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+}
+export class NumericInput extends React.Component<INumericInputProps, {
+    value: string;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: INumericInputProps);
+    componentWillUnmount(): void;
+    shouldComponentUpdate(nextProps: INumericInputProps, nextState: {
+        value: string;
+    }): boolean;
+    updateValue(valueString: string): void;
+    onBlur(): void;
+    incrementValue(amount: number): void;
+    onKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/messageLineComponent" {
+import * as React from "react";
+
+interface IMessageLineComponentProps {
+    text: string;
+    color?: string;
+    icon?: any;
+}
+export class MessageLineComponent extends React.Component<IMessageLineComponentProps> {
+    constructor(props: IMessageLineComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/matrixLineComponent" {
+import * as React from "react";
+import { Vector3, Vector4 } from "@babylonjs/core/Maths/math.vector";
+import { Matrix } from "@babylonjs/core/Maths/math.vector";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IMatrixLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    step?: number;
+    onChange?: (newValue: Matrix) => void;
+    onModeChange?: (mode: number) => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    mode?: number;
+    lockObject: LockObject;
+}
+export class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
+    value: Matrix;
+    mode: number;
+    angle: number;
+}> {
+    private _localChange;
+    constructor(props: IMatrixLineComponentProps);
+    shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
+        value: Matrix;
+        mode: number;
+        angle: number;
+    }): boolean;
+    raiseOnPropertyChanged(previousValue: Vector3): void;
+    updateMatrix(): void;
+    updateRow(value: Vector4, row: number): void;
+    updateBasedOnMode(value: number): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/linkButtonComponent" {
+import * as React from "react";
+
+interface ILinkButtonComponentProps {
+    label: string;
+    buttonLabel: string;
+    url?: string;
+    onClick: () => void;
+    icon?: any;
+    onIconClick?: () => void;
+}
+export class LinkButtonComponent extends React.Component<ILinkButtonComponentProps> {
+    constructor(props: ILinkButtonComponentProps);
+    onLink(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/lineWithFileButtonComponent" {
+import * as React from "react";
+interface ILineWithFileButtonComponentProps {
+    title: string;
+    closed?: boolean;
+    multiple?: boolean;
+    label: string;
+    iconImage: any;
+    onIconClick: (file: File) => void;
+    accept: string;
+    uploadName?: string;
+}
+export class LineWithFileButtonComponent extends React.Component<ILineWithFileButtonComponentProps, {
+    isExpanded: boolean;
+}> {
+    private _uploadRef;
+    constructor(props: ILineWithFileButtonComponentProps);
+    onChange(evt: any): void;
+    switchExpandedState(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/lineContainerComponent" {
+import * as React from "react";
+import { ISelectedLineContainer } from "@babylonjs/node-particle-editor/lines/iSelectedLineContainer";
+interface ILineContainerComponentProps {
+    selection?: ISelectedLineContainer;
+    title: string;
+    children: any[] | any;
+    closed?: boolean;
+}
+export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
+    isExpanded: boolean;
+    isHighlighted: boolean;
+}> {
+    constructor(props: ILineContainerComponentProps);
+    switchExpandedState(): void;
+
+    componentDidMount(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/inputArrowsComponent" {
+import * as React from "react";
+interface IInputArrowsComponentProps {
+    incrementValue: (amount: number) => void;
+    setDragging: (dragging: boolean) => void;
+}
+export class InputArrowsComponent extends React.Component<IInputArrowsComponentProps> {
+    private _arrowsRef;
+    private _drag;
+    private _releaseListener;
+    private _lockChangeListener;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/indentedTextLineComponent" {
+import * as React from "react";
+interface IIndentedTextLineComponentProps {
+    value?: string;
+    color?: string;
+    underline?: boolean;
+    onLink?: () => void;
+    url?: string;
+    additionalClass?: string;
+}
+export class IndentedTextLineComponent extends React.Component<IIndentedTextLineComponentProps> {
+    constructor(props: IIndentedTextLineComponentProps);
+    onLink(): void;
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/iconComponent" {
+import * as React from "react";
+interface IIconComponentProps {
+    icon: string;
+    label?: string;
+}
+export class IconComponent extends React.Component<IIconComponentProps> {
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/iconButtonLineComponent" {
+import * as React from "react";
+export interface IIconButtonLineComponentProps {
+    icon: string;
+    onClick: () => void;
+    tooltip: string;
+    active?: boolean;
+}
+export class IconButtonLineComponent extends React.Component<IIconButtonLineComponentProps> {
+    constructor(props: IIconButtonLineComponentProps);
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/iSelectedLineContainer" {
+export interface ISelectedLineContainer {
+    selectedLineContainerTitles: Array<string>;
+    selectedLineContainerTitlesNoFocus: Array<string>;
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/hexLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IHexLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    lockObject?: LockObject;
+    onChange?: (newValue: number) => void;
+    isInteger?: boolean;
+    replaySourceReplacement?: string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    additionalClass?: string;
+    step?: string;
+    digits?: number;
+    useEuler?: boolean;
+    min?: number;
+    icon?: string;
+    iconLabel?: string;
+}
+export class HexLineComponent extends React.Component<IHexLineComponentProps, {
+    value: string;
+}> {
+    private _localChange;
+    private _store;
+    private _propertyChange;
+    constructor(props: IHexLineComponentProps);
+    componentWillUnmount(): void;
+    shouldComponentUpdate(nextProps: IHexLineComponentProps, nextState: {
+        value: string;
+    }): boolean;
+    raiseOnPropertyChanged(newValue: number, previousValue: number): void;
+    convertToHexString(valueString: string): string;
+    updateValue(valueString: string, raisePropertyChanged: boolean): void;
+    lock(): void;
+    unlock(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/floatLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface IFloatLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    lockObject: LockObject;
+    onChange?: (newValue: number) => void;
+    isInteger?: boolean;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    additionalClass?: string;
+    step?: string;
+    digits?: number;
+    useEuler?: boolean;
+    min?: number;
+    max?: number;
+    smallUI?: boolean;
+    onEnter?: (newValue: number) => void;
+    icon?: string;
+    iconLabel?: string;
+    defaultValue?: number;
+    arrows?: boolean;
+    unit?: React.ReactNode;
+    onDragStart?: (newValue: number) => void;
+    onDragStop?: (newValue: number) => void;
+    disabled?: boolean;
+}
+export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
+    value: string;
+    dragging: boolean;
+}> {
+    private _localChange;
+    private _store;
+    constructor(props: IFloatLineComponentProps);
+    componentWillUnmount(): void;
+    getValueString(value: any, props: IFloatLineComponentProps): string;
+    shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
+        value: string;
+        dragging: boolean;
+    }): boolean;
+    raiseOnPropertyChanged(newValue: number, previousValue: number): void;
+    updateValue(valueString: string): void;
+    lock(): void;
+    unlock(): void;
+    incrementValue(amount: number, processStep?: boolean): void;
+    onKeyDown(event: React.KeyboardEvent<HTMLInputElement>): void;
+    onCopyClick(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/fileMultipleButtonLineComponent" {
+import * as React from "react";
+interface IFileMultipleButtonLineComponentProps {
+    label: string;
+    onClick: (event: any) => void;
+    accept: string;
+    icon?: string;
+    iconLabel?: string;
+}
+export class FileMultipleButtonLineComponent extends React.Component<IFileMultipleButtonLineComponentProps> {
+    private static _IdGenerator;
+    private _id;
+    private _uploadInputRef;
+    constructor(props: IFileMultipleButtonLineComponentProps);
+    onChange(evt: any): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/fileButtonLineComponent" {
+import * as React from "react";
+interface IFileButtonLineProps {
+    label: string;
+    onClick: (file: File) => void;
+    accept: string;
+    icon?: string;
+    iconLabel?: string;
+}
+export class FileButtonLine extends React.Component<IFileButtonLineProps> {
+    private static _IdGenerator;
+    private _id;
+    private _uploadInputRef;
+    constructor(props: IFileButtonLineProps);
+    onChange(evt: any): void;
+
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/draggableLineWithButtonComponent" {
+import * as React from "react";
+export interface IDraggableLineWithButtonComponent {
+    format: string;
+    data: string;
+    tooltip: string;
+    iconImage: any;
+    onIconClick: (value: string) => void;
+    iconTitle: string;
+    lenSuffixToRemove?: number;
+}
+export class DraggableLineWithButtonComponent extends React.Component<IDraggableLineWithButtonComponent> {
+    constructor(props: IDraggableLineWithButtonComponent);
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/draggableLineComponent" {
+import * as React from "react";
+export interface IButtonLineComponentProps {
+    format: string;
+    data: string;
+    tooltip: string;
+}
+export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
+    constructor(props: IButtonLineComponentProps);
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/colorPickerComponent" {
+import * as React from "react";
+import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColorPickerLineProps {
+    value: Color4 | Color3;
+    linearHint?: boolean;
+    onColorChanged: (newOne: string) => void;
+    icon?: string;
+    iconLabel?: string;
+    shouldPopRight?: boolean;
+    lockObject?: LockObject;
+}
+interface IColorPickerComponentState {
+    pickerEnabled: boolean;
+    color: Color3 | Color4;
+    hex: string;
+}
+export class ColorPickerLine extends React.Component<IColorPickerLineProps, IColorPickerComponentState> {
+    private _floatRef;
+    private _floatHostRef;
+    constructor(props: IColorPickerLineProps);
+    syncPositions(): void;
+    shouldComponentUpdate(nextProps: IColorPickerLineProps, nextState: IColorPickerComponentState): boolean;
+    getHexString(props?: Readonly<IColorPickerLineProps>): string;
+    componentDidUpdate(): void;
+    componentDidMount(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/colorLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColorLineProps {
+    label: string;
+    target?: any;
+    propertyName: string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    onChange?: () => void;
+    isLinear?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    disableAlpha?: boolean;
+    lockObject: LockObject;
+}
+interface IColorLineComponentState {
+    isExpanded: boolean;
+    color: Color4;
+}
+export class ColorLine extends React.Component<IColorLineProps, IColorLineComponentState> {
+    constructor(props: IColorLineProps);
+    shouldComponentUpdate(nextProps: IColorLineProps, nextState: IColorLineComponentState): boolean;
+    getValue(props?: Readonly<IColorLineProps>): Color4;
+    setColorFromString(colorString: string): void;
+    setColor(newColor: Color4): void;
+    switchExpandState(): void;
+    updateStateR(value: number): void;
+    updateStateG(value: number): void;
+    updateStateB(value: number): void;
+    updateStateA(value: number): void;
+    private _convertToColor;
+    private _toColor3;
+    onCopyClick(): void;
+
+
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/lines/color4LineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColor4LineComponentProps {
+    label: string;
+    target?: any;
+    propertyName: string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    onChange?: () => void;
+    isLinear?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+}
+export class Color4LineComponent extends React.Component<IColor4LineComponentProps> {
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/color3LineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColor3LineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    isLinear?: boolean;
+    icon?: string;
+    lockObject: LockObject;
+    iconLabel?: string;
+    onChange?: () => void;
+}
+export class Color3LineComponent extends React.Component<IColor3LineComponentProps> {
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/checkBoxLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+
+export interface ICheckBoxLineComponentProps {
+    label?: string;
+    target?: any;
+    propertyName?: string;
+    isSelected?: boolean | (() => boolean);
+    onSelect?: (value: boolean) => void;
+    onValueChanged?: () => void;
+    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+    disabled?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    faIcons?: {
+        enabled: any;
+        disabled: any;
+    };
+    large?: boolean;
+}
+export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
+    isSelected: boolean;
+    isDisabled?: boolean;
+    isConflict: boolean;
+}> {
+    private _localChange;
+    constructor(props: ICheckBoxLineComponentProps);
+    shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
+        isSelected: boolean;
+        isDisabled: boolean;
+        isConflict: boolean;
+    }): boolean;
+    onChange(): void;
+    onCopyClick(): void;
+
+
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/buttonLineComponent" {
+import * as React from "react";
+export interface IButtonLineComponentProps {
+    label: string;
+    onClick: () => void;
+    icon?: string;
+    iconLabel?: string;
+    isDisabled?: boolean;
+}
+export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
+    constructor(props: IButtonLineComponentProps);
+
+
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/lines/booleanLineComponent" {
+import * as React from "react";
+export interface IBooleanLineComponentProps {
+    label: string;
+    value: boolean;
+    icon?: string;
+    iconLabel?: string;
+}
+export class BooleanLineComponent extends React.Component<IBooleanLineComponentProps> {
+    constructor(props: IBooleanLineComponentProps);
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/textarea" {
+
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type TextareaProps = BaseComponentProps<string> & {
+    placeholder?: string;
+};
+/**
+ * This is a texarea box that stops propagation of change/keydown events
+ * @param props
+ * @returns
+ */
+export const Textarea: FunctionComponent<any>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/syncedSlider" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type SyncedSliderProps = BaseComponentProps<number> & {
+    min?: number;
+    max?: number;
+    step?: number;
+};
+/**
+ * Component which synchronizes a slider and an input field, allowing the user to change a value using either control
+ * @param props
+ * @returns SyncedSlider component
+ */
+export const SyncedSliderInput: FunctionComponent<SyncedSliderProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/switch" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type SwitchProps = BaseComponentProps<boolean>;
+/**
+ * This is a primitive fluent boolean switch component whose only knowledge is the shared styling across all tools
+ * @param props
+ * @returns Switch component
+ */
+export const Switch: FunctionComponent<SwitchProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/spinButton" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type SpinButtonProps = BaseComponentProps<number>;
+export const SpinButton: FunctionComponent<SpinButtonProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/link" {
+
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/input" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type InputProps<T extends string | number> = BaseComponentProps<T> & {
+    step?: number;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+};
+/**
+ * This is an input text box that stops propagation of change events and sets its width based on the type of input (text or number)
+ * @param props
+ * @returns
+ */
+export const Input: FunctionComponent<InputProps<string | number>>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/dropdown" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type AcceptedDropdownValue = string | number;
+export type DropdownOption = {
+    /**
+     * Defines the visible part of the option
+     */
+    label: string;
+    /**
+     * Defines the value part of the option
+     */
+    value: AcceptedDropdownValue;
+};
+export type DropdownProps = BaseComponentProps<AcceptedDropdownValue | undefined> & {
+    options: DropdownOption[];
+    includeUndefined?: boolean;
+};
+/**
+ * Renders a fluent UI dropdown component for the options passed in, and an additional 'Not Defined' option if includeUndefined is set to true
+ * @param props
+ * @returns dropdown component
+ */
+export const Dropdown: FunctionComponent<DropdownProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/colorPicker" {
+import { FunctionComponent } from "react";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type ColorPickerProps<C extends Color3 | Color4> = {
+    isLinearMode?: boolean;
+} & BaseComponentProps<C>;
+export const ColorPickerPopup: FunctionComponent<ColorPickerProps<Color3 | Color4>>;
+type HsvKey = "h" | "s" | "v";
+export type InputHexProps = BaseComponentProps<Color3 | Color4> & {
+    label?: string;
+    linearHex?: boolean;
+    isLinearMode?: boolean;
+};
+/**
+ * Component which displays the passed in color's HEX value, either in linearSpace (if linearHex is true) or in gamma space
+ * When the hex color is changed by user, component calculates the new Color3/4 value and calls onChange
+ *
+ * Component uses the isLinearMode boolean to display an informative label regarding linear / gamma space
+ * @param props - The properties for the InputHexField component.
+ * @returns
+ */
+export const InputHexField: FunctionComponent<InputHexProps>;
+type InputHsvFieldProps = {
+    color: Color3 | Color4;
+    label: string;
+    hsvKey: HsvKey;
+    onChange: (color: Color3 | Color4) => void;
+    max: number;
+    scale?: number;
+};
+/**
+ * In the HSV (Hue, Saturation, Value) color model, Hue (H) ranges from 0 to 360 degrees, representing the color's position on the color wheel.
+ * Saturation (S) ranges from 0 to 100%, indicating the intensity or purity of the color, with 0 being shades of gray and 100 being a fully saturated color.
+ * Value (V) ranges from 0 to 100%, representing the brightness of the color, with 0 being black and 100 being the brightest.
+ * @param props - The properties for the InputHsvField component.
+ */
+export const InputHsvField: FunctionComponent<InputHsvFieldProps>;
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/checkbox" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+export type CheckboxProps = BaseComponentProps<boolean>;
+/**
+ * This is a primitive fluent checkbox that can both read and write checked state
+ * @param props
+ * @returns Checkbox component
+ */
+export const Checkbox: FunctionComponent<CheckboxProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/primitives/accordion" {
+import { FunctionComponent, PropsWithChildren } from "react";
+export type AccordionSectionProps = {
+    title: string;
+};
+export const AccordionSection: FunctionComponent<PropsWithChildren<AccordionSectionProps>>;
+export const Accordion: FunctionComponent<PropsWithChildren>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/vectorPropertyLine" {
+import { FunctionComponent } from "react";
+import { BaseComponentProps, PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { Vector4 } from "@babylonjs/core/Maths/math.vector";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+export type VectorPropertyLineProps<V extends Vector3 | Vector4> = BaseComponentProps<V> & PropertyLineProps & {
+    /**
+     * If passed, all sliders will use this for the min value
+     */
+    min?: number;
+    /**
+     * If passed, all sliders will use this for the max value
+     */
+    max?: number;
+    /**
+     * If passed, the UX will use the conversion functions to display/update values
+     */
+    valueConverter?: {
+        /**
+         * Will call from(val) before displaying in the UX
+         */
+        from: (val: number) => number;
+        /**
+         * Will call to(val) before calling onChange
+         */
+        to: (val: number) => number;
+    };
+};
+type RotationVectorPropertyLineProps = VectorPropertyLineProps<Vector3> & {
+    /**
+     * Display angles as degrees instead of radians
+     */
+    useDegrees?: boolean;
+};
+export const RotationVectorPropertyLine: FunctionComponent<RotationVectorPropertyLineProps>;
+export const Vector3PropertyLine: FunctionComponent<VectorPropertyLineProps<Vector3>>;
+export const Vector4PropertyLine: FunctionComponent<VectorPropertyLineProps<Vector4>>;
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/textPropertyLine" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+type TextProps = {
+    value: string;
+    tooltip?: string;
+};
+/**
+ * Wraps text in a property line
+ * @param props - PropertyLineProps and TextProps
+ * @returns property-line wrapped text
+ */
+export const TextPropertyLine: FunctionComponent<PropertyLineProps & TextProps>;
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/syncedSliderLine" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { SyncedSliderProps } from "@babylonjs/node-particle-editor/fluent/primitives/syncedSlider";
+import { FunctionComponent } from "react";
+type SyncedSliderLineProps = SyncedSliderProps & PropertyLineProps;
+/**
+ * Renders a simple wrapper around the SyncedSliderInput
+ * @param props
+ * @returns
+ */
+export const SyncedSliderLine: FunctionComponent<SyncedSliderLineProps>;
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/switchPropertyLine" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+import { SwitchProps } from "@babylonjs/node-particle-editor/fluent/primitives/switch";
+/**
+ * Wraps a switch in a property line
+ * @param props - The properties for the switch and property line
+ * @returns A React element representing the property line with a switch
+ */
+export const SwitchPropertyLine: FunctionComponent<PropertyLineProps & SwitchProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLine" {
+import { FunctionComponent } from "react";
+export type PropertyLineProps = {
+    /**
+     * The name of the property to display in the property line.
+     */
+    label: string;
+    /**
+     * Optional description for the property, shown on hover of the info icon
+     */
+    description?: string;
+    /**
+     * Optional function returning a string to copy to clipboard.
+     */
+    onCopy?: () => string;
+    /**
+     * If supplied, an 'expand' icon will be shown which, when clicked, renders this component within the property line.
+     */
+    expandedContent?: JSX.Element;
+    /**
+     * Link to the documentation for this property, available from the info icon either linked from the description (if provided) or defalt 'docs' text
+     */
+    docLink?: string;
+};
+export const LineContainer: import("react").ForwardRefExoticComponent<{
+    children?: import("react").ReactNode | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export type BaseComponentProps<T> = {
+    /**
+     * The value of the property to be displayed and modified.
+     */
+    value: T;
+    /**
+     * Callback function to handle changes to the value
+     */
+    onChange: (value: T) => void;
+    /**
+     * Optional flag to disable the component, preventing any interaction.
+     */
+    disabled?: boolean;
+    /**
+     * Optional class name to apply custom styles to the component.
+     */
+    className?: string;
+};
+/**
+ * A reusable component that renders a property line with a label and child content, and an optional description, copy button, and expandable section.
+ *
+ * @param props - The properties for the PropertyLine component.
+ * @returns A React element representing the property line.
+ *
+ */
+export const PropertyLine: import("react").ForwardRefExoticComponent<PropertyLineProps & {
+    children?: import("react").ReactNode | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export const PlaceholderPropertyLine: FunctionComponent<BaseComponentProps<any> & PropertyLineProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/linkPropertyLine" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+type LinkProps = {
+    value: string;
+    tooltip?: string;
+    onLink?: () => void;
+    url?: string;
+};
+/**
+ * Wraps a link in a property line
+ * @param props - PropertyLineProps and LinkProps
+ * @returns property-line wrapped link
+ */
+export const LinkPropertyLine: FunctionComponent<PropertyLineProps & LinkProps>;
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/inputPropertyLine" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+import { InputProps } from "@babylonjs/node-particle-editor/fluent/primitives/input";
+export const TextInputPropertyLine: FunctionComponent<InputProps<string> & PropertyLineProps>;
+export const FloatInputPropertyLine: FunctionComponent<InputProps<number> & PropertyLineProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/hexLineComponent" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+import { InputHexProps } from "@babylonjs/node-particle-editor/fluent/primitives/colorPicker";
+/**
+ * Wraps a hex input in a property line
+ * @param props - PropertyLineProps and InputHexProps
+ * @returns property-line wrapped input hex component
+ */
+export const HexPropertyLine: FunctionComponent<InputHexProps & PropertyLineProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/fluentToolWrapper" {
+import { PropsWithChildren, FunctionComponent } from "react";
+
+export type ToolHostProps = {
+    /**
+     * Allows host to pass in a theme
+     */
+    customTheme?: any;
+    /**
+     * Can be set to true to disable the copy button in the tool's property lines. Default is false (copy enabled)
+     */
+    disableCopy?: boolean;
+};
+export const ToolContext: import("react").Context<{
+    readonly useFluent: boolean;
+    readonly disableCopy: boolean;
+}>;
+/**
+ * For tools which are ready to move over the fluent, wrap the root of the tool (or the panel which you want fluentized) with this component
+ * Today we will only enable fluent if the URL has the `newUX` query parameter is truthy
+ * @param props
+ * @returns
+ */
+export const FluentToolWrapper: FunctionComponent<PropsWithChildren<ToolHostProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/fileUploadLine" {
+import { FunctionComponent } from "react";
+import { ButtonLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/buttonLine";
+type FileUploadLineProps = Omit<ButtonLineProps, "onClick"> & {
+    onClick: (file: File) => void;
+    accept: string;
+};
+export const FileUploadLine: FunctionComponent<FileUploadLineProps>;
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/dropdownPropertyLine" {
+import { DropdownProps } from "@babylonjs/node-particle-editor/fluent/primitives/dropdown";
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+/**
+ * Wraps a dropdown in a property line
+ * @param props - PropertyLineProps and DropdownProps
+ * @returns property-line wrapped dropdown
+ */
+export const DropdownPropertyLine: FunctionComponent<PropertyLineProps & DropdownProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/colorPropertyLine" {
+import { FunctionComponent } from "react";
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { ColorPickerProps } from "@babylonjs/node-particle-editor/fluent/primitives/colorPicker";
+export type ColorPropertyLineProps = ColorPickerProps<Color3 | Color4> & PropertyLineProps;
+export const Color3PropertyLine: FunctionComponent<ColorPickerProps<Color3> & PropertyLineProps>;
+export const Color4PropertyLine: FunctionComponent<ColorPickerProps<Color4> & PropertyLineProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/checkboxPropertyLine" {
+import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLine";
+import { FunctionComponent } from "react";
+import { CheckboxProps } from "@babylonjs/node-particle-editor/fluent/primitives/checkbox";
+/**
+ * Wraps a checkbox in a property line
+ * @param props - PropertyLineProps and CheckboxProps
+ * @returns property-line wrapped checkbox
+ */
+export const CheckboxPropertyLine: FunctionComponent<PropertyLineProps & CheckboxProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/fluent/hoc/buttonLine" {
+import { FunctionComponent } from "react";
+export type ButtonLineProps = {
+    label: string;
+    onClick: () => void;
+    disabled?: boolean;
+    icon?: string;
+    title?: string;
+};
+/**
+ * Wraps a button with a label in a line container
+ * @param props Button props plus a label
+ * @returns A button inside a line
+ */
+export const ButtonLine: FunctionComponent<ButtonLineProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/classNames" {
+export function ClassNames(names: any, styleObject: any): string;
+export function JoinClassNames(styleObject: any, ...names: string[]): string;
+
+}
+declare module "@babylonjs/node-particle-editor/components/Toggle" {
+export type ToggleProps = {
+    toggled: "on" | "mixed" | "off";
+    onToggle?: () => void;
+    padded?: boolean;
+    color?: "dark" | "light";
+};
+export const Toggle: React.FC<ToggleProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/TextInputWithSubmit" {
+export interface ITextInputProps {
+    label?: string;
+    placeholder?: string;
+    submitValue: (newValue: string) => void;
+    validateValue?: (value: string) => boolean;
+    cancelSubmit?: () => void;
+}
+/**
+ * This component represents a text input that can be submitted or cancelled on buttons
+ * @param props properties
+ * @returns TextInputWithSubmit element
+ */
+
+
+}
+declare module "@babylonjs/node-particle-editor/components/MessageDialog" {
+import * as React from "react";
+export interface MessageDialogProps {
+    message: string;
+    isError: boolean;
+    onClose?: () => void;
+}
+export const MessageDialog: React.FC<MessageDialogProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/Label" {
+import { ReactChild } from "react";
+export type LabelProps = {
+    text: string;
+    children?: ReactChild;
+    color?: "dark" | "light";
+};
+export const Label: React.FC<LabelProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/Icon" {
+export type IconProps = {
+    color?: "dark" | "light";
+    icon: string;
+};
+export const Icon: React.FC<IconProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/Button" {
+import { PropsWithChildren } from "react";
+export type ButtonProps = {
+    disabled?: boolean;
+    active?: boolean;
+    onClick?: () => void;
+    color: "light" | "dark";
+    size: "default" | "small" | "wide" | "smaller";
+    title?: string;
+    backgroundColor?: string;
+};
+export const Button: React.FC<PropsWithChildren<ButtonProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/useGraphContext" {
+/**
+ * utility hook to assist using the graph context
+ * @returns
+ */
+export const useGraphContext: () => import("@babylonjs/node-particle-editor/components/reactGraphSystem/GraphContextManager").IGraphContext;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/NodeRenderer" {
+import { ComponentType, PropsWithChildren } from "react";
+import { Nullable } from "@babylonjs/core/types";
+export type IVisualRecordsType = Record<string, {
+    x: number;
+    y: number;
+}>;
+export type IConnectionType = {
+    id: string;
+    sourceId: string;
+    targetId: string;
+};
+export type ICustomDataType = {
+    type: string;
+    value: any;
+};
+export type INodeType = {
+    id: string;
+    label: string;
+    customData?: ICustomDataType;
+};
+/**
+ * props for the node renderer
+ */
+export interface INodeRendererProps {
+    /**
+     * array of connections between nodes
+     */
+    connections: IConnectionType[];
+    /**
+     * function called when a new connection is created
+     */
+    updateConnections: (sourceId: string, targetId: string) => void;
+    /**
+     * function called when a connection is deleted
+     */
+    deleteLine: (lineId: string) => void;
+    /**
+     * function called when a node is deleted
+     */
+    deleteNode: (nodeId: string) => void;
+    /**
+     * array of all nodes
+     */
+    nodes: INodeType[];
+    /**
+     * id of the node to highlight
+     */
+    highlightedNode?: Nullable<string>;
+    /**
+     * function to be called if a node is selected
+     */
+    selectNode?: (nodeId: Nullable<string>) => void;
+    /**
+     * id of this renderer
+     */
+    id: string;
+    /**
+     * optional list of custom components to be rendered inside nodes of
+     * a certain type
+     */
+    customComponents?: Record<string, ComponentType<any>>;
+}
+/**
+ * This component is a bridge between the app logic related to the graph, and the actual rendering
+ * of it. It manages the nodes' positions and selection states.
+ * @param props
+ * @returns
+ */
+
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphNodesContainer" {
+import { FC, PropsWithChildren } from "react";
+export interface IGraphContainerProps {
+    onNodeMoved: (id: string, x: number, y: number) => void;
+    id: string;
+}
+/**
+ * This component contains all the nodes and handles their dragging
+ * @param props properties
+ * @returns graph node container element
+ */
+export const GraphNodesContainer: FC<PropsWithChildren<IGraphContainerProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphNode" {
+import { FC, PropsWithChildren } from "react";
+export interface IGraphNodeProps {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    selected?: boolean;
+    width?: number;
+    height?: number;
+    highlighted?: boolean;
+    parentContainerId: string;
+}
+export const SingleGraphNode: FC<PropsWithChildren<IGraphNodeProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphLinesContainer" {
+import { FC, PropsWithChildren } from "react";
+/**
+ * props for the GraphLineContainer
+ */
+export interface IGraphLinesContainerProps {
+    /**
+     * id of the container
+     */
+    id: string;
+}
+/**
+ * this component handles the dragging of new connections
+ * @param props
+ * @returns
+ */
+export const GraphLinesContainer: FC<PropsWithChildren<IGraphLinesContainerProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphLine" {
+import { FC } from "react";
+/**
+ * props for the GraphLine component
+ */
+export interface IGraphLineProps {
+    /**
+     * id of the line. temporary lines can have no id
+     */
+    id?: string;
+    /**
+     * starting x pos of the line
+     */
+    x1: number;
+    /**
+     * ending x pos of the line
+     */
+    x2: number;
+    /**
+     * starting y pos of the line
+     */
+    y1: number;
+    /**
+     * ending y pos of the line
+     */
+    y2: number;
+    /**
+     * is the line selected
+     */
+    selected?: boolean;
+    /**
+     * does the line have a direction
+     */
+    directional?: boolean;
+}
+export const MarkerArrowId = "arrow";
+/**
+ * This component draws a SVG line between two points, with an optional marker
+ * indicating direction
+ * @param props properties
+ * @returns graph line element
+ */
+export const GraphLine: FC<IGraphLineProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphContextManager" {
+/**
+ * this context is used to pass callbacks to the graph nodes and connections
+ */
+export interface IGraphContext {
+    onNodesConnected?: (sourceId: string, targetId: string) => void;
+    onLineSelected?: (lineId: string) => void;
+    onNodeSelected?: (nodeId: string) => void;
+}
+export const GraphContextManager: import("react").Context<IGraphContext>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphContainer" {
+import { FC, PropsWithChildren } from "react";
+export interface IGraphContainerProps {
+}
+/**
+ * This component is just a simple container to keep the nodes and lines containers
+ * together
+ * @param props
+ * @returns
+ */
+export const GraphContainer: FC<PropsWithChildren<IGraphContainerProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/reactGraphSystem/GraphConnectorHandle" {
+import { FC, PropsWithChildren } from "react";
+/**
+ * Props for the connector
+ */
+export interface IGraphConnectorHandlerProps {
+    /**
+     * id of the parent node
+     */
+    parentId: string;
+    /**
+     * x position of the parent node
+     */
+    parentX: number;
+    /**
+     * y position of the parent node
+     */
+    parentY: number;
+    /**
+     * x position of the connector relative to the parent node
+     */
+    offsetX?: number;
+    /**
+     * y position of the connector relative to the parent node
+     */
+    offsetY?: number;
+    /**
+     * width of the parent node
+     */
+    parentWidth: number;
+    /**
+     * height of the parent node
+     */
+    parentHeight: number;
+    /**
+     * id of the container where its parent node is
+     */
+    parentContainerId: string;
+}
+/**
+ * This component is used to initiate a connection between two nodes. Simply
+ * drag the handle in a node and drop it in another node to create a connection.
+ * @returns connector element
+ */
+export const GraphConnectorHandler: FC<PropsWithChildren<IGraphConnectorHandlerProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/lines/OptionsLineComponent" {
+/**
+ * This components represents an options menu with optional
+ * customizable properties. Option IDs should be unique.
+ */
+export interface IOption {
+    label: string;
+    value: string;
+    id: string;
+}
+export interface IOptionsLineComponentProps {
+    options: IOption[];
+    addOptionPlaceholder?: string;
+    onOptionAdded?: (newOption: IOption) => void;
+    onOptionSelected: (selectedOptionValue: string) => void;
+    selectedOptionValue: string;
+    validateNewOptionValue?: (newOptionValue: string) => boolean;
+    addOptionText?: string;
+}
+
+
+}
+declare module "@babylonjs/node-particle-editor/components/lines/NumericInputComponent" {
+import * as React from "react";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+interface INumericInputComponentProps {
+    label: string;
+    labelTooltip?: string;
+    value: number;
+    step?: number;
+    onChange: (value: number) => void;
+    precision?: number;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+}
+export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
+    value: string;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: INumericInputComponentProps);
+    componentWillUnmount(): void;
+    shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
+        value: string;
+    }): boolean;
+    updateValue(valueString: string): void;
+    onBlur(): void;
+    incrementValue(amount: number): void;
+    onKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/lines/FileButtonLineComponent" {
+import * as React from "react";
+export interface IFileButtonLineComponentProps {
+    label: string;
+    onClick: (file: File) => void;
+    accept: string;
+    icon?: string;
+    iconLabel?: string;
+}
+export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
+    private static _IdGenerator;
+    private _id;
+    private _uploadInputRef;
+    constructor(props: IFileButtonLineComponentProps);
+    onChange(evt: any): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/lines/ColorPickerLineComponent" {
+import * as React from "react";
+import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColorPickerLineComponentProps {
+    value: Color4 | Color3;
+    linearHint?: boolean;
+    onColorChanged: (newOne: string) => void;
+    icon?: string;
+    iconLabel?: string;
+    shouldPopRight?: boolean;
+    lockObject?: LockObject;
+    backgroundColor?: string;
+}
+interface IColorPickerComponentState {
+    pickerEnabled: boolean;
+    color: Color3 | Color4;
+    hex: string;
+}
+export class ColorPickerLineComponent extends React.Component<IColorPickerLineComponentProps, IColorPickerComponentState> {
+    private _floatRef;
+    private _floatHostRef;
+    private _coverRef;
+    constructor(props: IColorPickerLineComponentProps);
+    syncPositions(): void;
+    shouldComponentUpdate(nextProps: IColorPickerLineComponentProps, nextState: IColorPickerComponentState): boolean;
+    getHexString(props?: Readonly<IColorPickerLineComponentProps>): string;
+    componentDidUpdate(): void;
+    componentDidMount(): void;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/lines/ColorLineComponent" {
+import * as React from "react";
+import { Observable } from "@babylonjs/core/Misc/observable";
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { PropertyChangedEvent } from "@babylonjs/node-particle-editor/propertyChangedEvent";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColorLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    onPropertyChangedObservable: Observable<PropertyChangedEvent>;
+    onChange?: () => void;
+    isLinear?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    disableAlpha?: boolean;
+    lockObject: LockObject;
+}
+interface IColorLineComponentState {
+    isExpanded: boolean;
+    color: Color4;
+}
+export class ColorLineComponent extends React.Component<IColorLineComponentProps, IColorLineComponentState> {
+    constructor(props: IColorLineComponentProps);
+    shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean;
+    getValue(props?: Readonly<IColorLineComponentProps>): Color4;
+    setColorFromString(colorString: string): void;
+    setColor(newColor: Color4): void;
+    switchExpandState(): void;
+    updateStateR(value: number): void;
+    updateStateG(value: number): void;
+    updateStateB(value: number): void;
+    updateStateA(value: number): void;
+    copyToClipboard(): void;
+    private _convertToColor;
+    private _toColor3;
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/utils" {
+import { Layout, LayoutColumn, LayoutTabsRow } from "@babylonjs/node-particle-editor/components/layout/types";
+/**
+ * Given a column and row number in the layout, return the corresponding column/row
+ * @param layout
+ * @param column
+ * @param row
+ * @returns
+ */
+export const getPosInLayout: (layout: Layout, column: number, row?: number) => LayoutColumn | LayoutTabsRow;
+/**
+ * Remove a row in position row, column from the layout, and redistribute heights of remaining rows
+ * @param layout
+ * @param column
+ * @param row
+ */
+export const removeLayoutRowAndRedistributePercentages: (layout: Layout, column: number, row: number) => void;
+/**
+ * Add a percentage string to a number
+ * @param p1 the percentage string
+ * @param p2 the number
+ * @returns the sum of the percentage string and the number
+ */
+export const addPercentageStringToNumber: (p1: string, p2: number) => number;
+/**
+ * Parses a percentage string into a number
+ * @param p the percentage string
+ * @returns the parsed number
+ */
+export const parsePercentage: (p: string) => number;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/types" {
+import { ReactElement } from "react";
+export type LayoutTab = {
+    /**
+     * Tab id
+     */
+    id: string;
+    /**
+     * React component rendered by tab
+     */
+    component: ReactElement;
+    /**
+     * Tab title
+     */
+    title: string;
+};
+export type LayoutTabsRow = {
+    /**
+     * row id
+     */
+    id: string;
+    /**
+     * row height in its containing column
+     */
+    height: string;
+    /**
+     * selected tab in row
+     */
+    selectedTab: string;
+    /**
+     * list of tabs contained in row
+     */
+    tabs: LayoutTab[];
+};
+export type LayoutColumn = {
+    /**
+     * column id
+     */
+    id: string;
+    /**
+     * column width in the grid
+     */
+    width: string;
+    /**
+     * column rows
+     */
+    rows: LayoutTabsRow[];
+};
+export type Layout = {
+    /**
+     * layout columns
+     */
+    columns?: LayoutColumn[];
+};
+export type TabDrag = {
+    /**
+     * row number of the tab being dragged
+     */
+    rowNumber: number;
+    /**
+     * column number of the tab being dragged
+     */
+    columnNumber: number;
+    /**
+     * the tabs being dragged
+     */
+    tabs: {
+        /**
+         * id of tab being dragged
+         */
+        id: string;
+    }[];
+};
+export enum ElementTypes {
+    RESIZE_BAR = "0",
+    TAB = "1",
+    TAB_GROUP = "2",
+    NONE = "2"
+}
+export enum ResizeDirections {
+    ROW = "row",
+    COLUMN = "column"
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/LayoutContext" {
+import { Layout } from "@babylonjs/node-particle-editor/components/layout/types";
+export const LayoutContext: import("react").Context<{
+    /**
+     * The layout object
+     */
+    layout: Layout;
+    /**
+     * Function to set the layout object in the context
+     */
+    setLayout: (layout: Layout) => void;
+}>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleTabsContainer" {
+import { FC } from "react";
+import { LayoutTab } from "@babylonjs/node-particle-editor/components/layout/types";
+/**
+ * Arguments for the TabsContainer component.
+ */
+export interface IFlexibleTabsContainerProps {
+    /**
+     * The tabs to display
+     */
+    tabs: LayoutTab[];
+    /**
+     * Row index of component in layout
+     */
+    rowIndex: number;
+    /**
+     * Column index of component in layout
+     */
+    columnIndex: number;
+    /**
+     * Which tab is selected in the layout
+     */
+    selectedTab?: string;
+}
+/**
+ * This component contains a set of tabs of which only one is visible at a time.
+ * The tabs can also be dragged from and to different containers.
+ * @param props properties
+ * @returns tabs container element
+ */
+export const FlexibleTabsContainer: FC<IFlexibleTabsContainerProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleTab" {
+import { FC } from "react";
+import { TabDrag } from "@babylonjs/node-particle-editor/components/layout/types";
+/**
+ * Arguments for the FlexibleTab component.
+ */
+export interface IFlexibleTabProps {
+    /**
+     * The tab's title.
+     */
+    title: string;
+    /**
+     * If the tab is currently selected or not
+     */
+    selected: boolean;
+    /**
+     * What happens when the user clicks on the tab
+     */
+    onClick: () => void;
+    /**
+     * The object that will be sent to the drag event
+     */
+    item: TabDrag;
+    /**
+     * What happens when the user drops another tab after this one
+     */
+    onTabDroppedAction: (item: TabDrag) => void;
+}
+/**
+ * A component that renders a tab that the user can click
+ * to activate or drag to reorder. It also listens for
+ * drop events if the user wants to drop another tab
+ * after it.
+ * @param props properties
+ * @returns FlexibleTab element
+ */
+export const FlexibleTab: FC<IFlexibleTabProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleResizeBar" {
+import { FC } from "react";
+import { ResizeDirections } from "@babylonjs/node-particle-editor/components/layout/types";
+/**
+ * Arguments for the ResizeBar component.
+ */
+export interface IFlexibleRowResizerProps {
+    /**
+     * Row number of the component that is being resized
+     */
+    rowNumber: number;
+    /**
+     * Column number of the component being resized
+     */
+    columnNumber: number;
+    /**
+     * If the resizing happens in row or column direction
+     */
+    direction: ResizeDirections;
+}
+/**
+ * The item that will be sent to the drag event
+ */
+export type ResizeItem = {
+    /**
+     * If the resizing happens in row or column direction
+     */
+    direction: ResizeDirections;
+    /**
+     * The row number of the component that is being resized
+     */
+    rowNumber: number;
+    /**
+     * the column number of the component being resized
+     */
+    columnNumber: number;
+};
+/**
+ * A component that renders a bar that the user can drag to resize.
+ * @param props properties
+ * @returns resize bar element
+ */
+export const FlexibleResizeBar: FC<IFlexibleRowResizerProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleGridLayout" {
+import { FC } from "react";
+import { Layout } from "@babylonjs/node-particle-editor/components/layout/types";
+/**
+ * Arguments for the Layout component.
+ */
+export interface IFlexibleGridLayoutProps {
+    /**
+     * A definition of the layout which can be changed by the user
+     */
+    layoutDefinition: Layout;
+}
+/**
+ * This component represents a grid layout that can be resized and rearranged
+ * by the user.
+ * @param props properties
+ * @returns layout element
+ */
+export const FlexibleGridLayout: FC<IFlexibleGridLayoutProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleGridContainer" {
+import { FC } from "react";
+/**
+ * Arguments for the GridContainer component.
+ */
+export interface IFlexibleGridContainerProps {
+}
+/**
+ * Component responsible for mapping the layout to the actual components
+ * @returns GridContainer element
+ */
+export const FlexibleGridContainer: FC<IFlexibleGridContainerProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleDropZone" {
+import { FC, PropsWithChildren } from "react";
+/**
+ * Arguments for the FlexibleDropZone component.
+ */
+export interface IFlexibleDropZoneProps {
+    /**
+     * The row number of the component in the layout
+     */
+    rowNumber: number;
+    /**
+     * The column number of the component in the layout
+     */
+    columnNumber: number;
+}
+/**
+ * This component contains the drag and drop zone for the resize bars that
+ * allow redefining width and height of layout elements
+ * @param props properties
+ * @returns drop zone element
+ */
+export const FlexibleDropZone: FC<PropsWithChildren<IFlexibleDropZoneProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleDragHandler" {
+import { FC, PropsWithChildren } from "react";
+/**
+ * Arguments for the DragHandler component.
+ */
+export interface IFlexibleDragHandlerProps {
+    /**
+     * The size of the containing element. Used to calculate the percentage of
+     * space occupied by the component
+     */
+    containerSize: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * This component receives the drop events and updates the layout accordingly
+ * @param props properties
+ * @returns DragHandler element
+ */
+export const FlexibleDragHandler: FC<PropsWithChildren<IFlexibleDragHandlerProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/FlexibleColumn" {
+import { FC, PropsWithChildren } from "react";
+/**
+ * Arguments for the Column component.
+ */
+export interface IFlexibleColumnProps {
+    /**
+     * Width of column
+     */
+    width: string;
+}
+/**
+ * This component represents a single column in the layout. It receives a width
+ * that it occupies and the content to display
+ * @param props
+ * @returns
+ */
+export const FlexibleColumn: FC<PropsWithChildren<IFlexibleColumnProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/layout/DraggableIcon" {
+import { FC } from "react";
+import { ElementTypes, TabDrag } from "@babylonjs/node-particle-editor/components/layout/types";
+/**
+ * Arguments for the DraggableIcon component.
+ */
+export interface IDraggableIconProps {
+    /**
+     * Icon source
+     */
+    src: string;
+    /**
+     * Object that will be passed to the drag event
+     */
+    item: TabDrag;
+    /**
+     * Type of drag event
+     */
+    type: ElementTypes;
+}
+/**
+ * An icon that can be dragged by the user
+ * @param props properties
+ * @returns draggable icon element
+ */
+export const DraggableIcon: FC<IDraggableIconProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/colorPicker/HexColor" {
+import * as React from "react";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IHexColorProps {
+    value: string;
+    expectedLength: number;
+    onChange: (value: string) => void;
+    lockObject: LockObject;
+}
+export class HexColorComponent extends React.Component<IHexColorProps, {
+    hex: string;
+}> {
+    constructor(props: IHexColorProps);
+    shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
+        hex: string;
+    }): boolean;
+    lock(): void;
+    unlock(): void;
+    updateHexValue(valueString: string): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/colorPicker/ColorPicker" {
+import * as React from "react";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+/**
+ * Interface used to specify creation options for color picker
+ */
+export interface IColorPickerComponentProps {
+    color: Color3 | Color4;
+    linearhint?: boolean;
+    debugMode?: boolean;
+    onColorChanged?: (color: Color3 | Color4) => void;
+    lockObject: LockObject;
+    backgroundColor?: string;
+}
+/**
+ * Interface used to specify creation options for color picker
+ */
+export interface IColorPickerState {
+    color: Color3;
+    alpha: number;
+}
+/**
+ * Class used to create a color picker
+ */
+export class ColorPickerComponent extends React.Component<IColorPickerComponentProps, IColorPickerState> {
+    private _saturationRef;
+    private _hueRef;
+    private _isSaturationPointerDown;
+    private _isHuePointerDown;
+    constructor(props: IColorPickerComponentProps);
+    shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerState): boolean;
+    onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+    private _evaluateSaturation;
+    private _evaluateHue;
+    componentDidUpdate(): void;
+    raiseOnColorChanged(): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/colorPicker/ColorComponentEntry" {
+import * as React from "react";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColorComponentEntryProps {
+    value: number;
+    label: string;
+    max?: number;
+    min?: number;
+    onChange: (value: number) => void;
+    disabled?: boolean;
+    lockObject: LockObject;
+}
+export class ColorComponentComponentEntry extends React.Component<IColorComponentEntryProps> {
+    constructor(props: IColorComponentEntryProps);
+    updateValue(valueString: string): void;
+    lock(): void;
+    unlock(): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/components/bars/CommandDropdownComponent" {
+import * as React from "react";
+interface ICommandDropdownComponentProps {
+    icon?: string;
+    tooltip: string;
+    defaultValue?: string;
+    items: {
+        label: string;
+        icon?: string;
+        fileButton?: boolean;
+        onClick?: () => void;
+        onCheck?: (value: boolean) => void;
+        storeKey?: string;
+        isActive?: boolean;
+        defaultValue?: boolean | string;
+        subItems?: string[];
+    }[];
+    toRight?: boolean;
+}
+export class CommandDropdownComponent extends React.Component<ICommandDropdownComponentProps, {
+    isExpanded: boolean;
+    activeState: string;
+}> {
+    constructor(props: ICommandDropdownComponentProps);
+
+}
+export {};
+
+}
+declare module "@babylonjs/node-particle-editor/components/bars/CommandButtonComponent" {
+import * as React from "react";
+export interface ICommandButtonComponentProps {
+    tooltip: string;
+    shortcut?: string;
+    icon: string;
+    iconLabel?: string;
+    isActive: boolean;
+    onClick: () => void;
+    disabled?: boolean;
+}
+export const CommandButtonComponent: React.FC<ICommandButtonComponentProps>;
+
+}
+declare module "@babylonjs/node-particle-editor/components/bars/CommandBarComponent" {
+import { FC, PropsWithChildren } from "react";
+export interface ICommandBarComponentProps {
+    onSaveButtonClicked?: () => void;
+    onSaveToSnippetButtonClicked?: () => void;
+    onLoadFromSnippetButtonClicked?: () => void;
+    onHelpButtonClicked?: () => void;
+    onGiveFeedbackButtonClicked?: () => void;
+    onSelectButtonClicked?: () => void;
+    onPanButtonClicked?: () => void;
+    onZoomButtonClicked?: () => void;
+    onFitButtonClicked?: () => void;
+    onArtboardColorChanged?: (newColor: string) => void;
+    artboardColor?: string;
+    artboardColorPickerColor?: string;
+}
+export const CommandBarComponent: FC<PropsWithChildren<ICommandBarComponentProps>>;
+
+}
+declare module "@babylonjs/node-particle-editor/colorPicker/hexColor" {
+import * as React from "react";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IHexColorProps {
+    value: string;
+    expectedLength: number;
+    onChange: (value: string) => void;
+    lockObject: LockObject;
+}
+export class HexColor extends React.Component<IHexColorProps, {
+    hex: string;
+}> {
+    constructor(props: IHexColorProps);
+    shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
+        hex: string;
+    }): boolean;
+    lock(): void;
+    unlock(): void;
+    updateHexValue(valueString: string): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/colorPicker/colorPicker" {
+import * as React from "react";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+import "@babylonjs/node-particle-editor/colorPicker/colorPicker.scss";
+/**
+ * Interface used to specify creation options for color picker
+ */
+export interface IColorPickerProps {
+    color: Color3 | Color4;
+    linearhint?: boolean;
+    debugMode?: boolean;
+    onColorChanged?: (color: Color3 | Color4) => void;
+    lockObject: LockObject;
+}
+/**
+ * Interface used to specify creation options for color picker
+ */
+export interface IColorPickerState {
+    color: Color3;
+    alpha: number;
+}
+/**
+ * Class used to create a color picker
+ */
+export class ColorPicker extends React.Component<IColorPickerProps, IColorPickerState> {
+    private _saturationRef;
+    private _hueRef;
+    private _isSaturationPointerDown;
+    private _isHuePointerDown;
+    constructor(props: IColorPickerProps);
+    shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
+    onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+    private _evaluateSaturation;
+    private _evaluateHue;
+    componentDidUpdate(): void;
+    raiseOnColorChanged(): void;
+
+}
+
+}
+declare module "@babylonjs/node-particle-editor/colorPicker/colorComponentEntry" {
+import * as React from "react";
+import { LockObject } from "@babylonjs/node-particle-editor/tabs/propertyGrids/lockObject";
+export interface IColorComponentEntryProps {
+    value: number;
+    label: string;
+    max?: number;
+    min?: number;
+    onChange: (value: number) => void;
+    disabled?: boolean;
+    lockObject: LockObject;
+}
+export class ColorComponentEntry extends React.Component<IColorComponentEntryProps> {
+    constructor(props: IColorComponentEntryProps);
+    updateValue(valueString: string): void;
+    lock(): void;
+    unlock(): void;
+
+}
+
+}
+
+declare module "@babylonjs/node-particle-editor" {
+    export * from "@babylonjs/node-particle-editor/legacy/legacy";
+}
+
+
+