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;
    /** If true, the node particle system set will be disposed when the editor is closed (default: true) */
    disposeOnClose?: boolean;
}
/**
 * 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/main" {
/**
 * Vite dev server entry point for the Node Particle Editor.
 *
 * Uses dynamic import so the editor module graph loads only after
 * the CDN bootstrap has set window.BABYLON.
 */
type ShowArgs = Parameters<(typeof import("@babylonjs/node-particle-editor/nodeParticleEditor"))["NodeParticleEditor"]["Show"]>;
function StartEditor(args: ShowArgs): Promise<void>;
const Win: Record<string, unknown>;

}
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;
    render(): React.JSX.Element;
}
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;
    /** If true, the node particle system set will be disposed when the editor is closed (default: true) */
    disposeOnClose: boolean;
    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;
    mcpSessionUrl: string | null;
    mcpSessionConnected: boolean;
    mcpEventSource: EventSource | null;
    onMcpSessionStateChangedObservable: Observable<boolean>;
    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 { 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 { ParticleNumberMathBlock } from "@babylonjs/core/Particles/Node/Blocks/particleNumberMathBlock";
import { ParticleVectorMathBlock } from "@babylonjs/core/Particles/Node/Blocks/particleVectorMathBlock";
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 { UpdateSizeBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateSizeBlock";
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 { UpdateAgeBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateAgeBlock";
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 { UpdateNoiseBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateNoiseBlock";
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 { ConeShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/coneShapeBlock";
import { CylinderShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/cylinderShapeBlock";
import { CustomShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/customShapeBlock";
import { MeshShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/meshShapeBlock";
import { PointShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/pointShapeBlock";
import { SphereShapeBlock } from "@babylonjs/core/Particles/Node/Blocks/Emitters/sphereShapeBlock";
import { UpdateAttractorBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateAttractorBlock";
import { AlignAngleBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/alignAngleBlock";
import { BasicColorUpdateBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/basicColorUpdateBlock";
import { ParticleLocalVariableBlock } from "@babylonjs/core/Particles/Node/Blocks/particleLocalVariableBlock";
import { ParticleVectorLengthBlock } from "@babylonjs/core/Particles/Node/Blocks/particleVectorLengthBlock";
import { ParticleFloatToIntBlock } from "@babylonjs/core/Particles/Node/Blocks/particleFloatToIntBlock";
import { ParticleClampBlock } from "@babylonjs/core/Particles/Node/Blocks/particleClampBlock";
import { ParticleNLerpBlock } from "@babylonjs/core/Particles/Node/Blocks/particleNLerpBlock";
import { ParticleSmoothStepBlock } from "@babylonjs/core/Particles/Node/Blocks/particleSmoothStepBlock";
import { ParticleStepBlock } from "@babylonjs/core/Particles/Node/Blocks/particleStepBlock";
/**
 * Static class for BlockTools
 */
export class BlockTools {
    static GetBlockFromString(data: string): ParticleNLerpBlock | ParticleStepBlock | ParticleSmoothStepBlock | ParticleClampBlock | ParticleLocalVariableBlock | ParticleVectorLengthBlock | AlignAngleBlock | CreateParticleBlock | ParticleConditionBlock | UpdateSpriteCellIndexBlock | BasicSpriteUpdateBlock | SetupSpriteSheetBlock | ParticleTriggerBlock | BasicPositionUpdateBlock | BasicColorUpdateBlock | ParticleTeleportInBlock | ParticleTeleportOutBlock | ParticleElbowBlock | ParticleDebugBlock | ParticleConverterBlock | ParticleGradientBlock | ParticleGradientValueBlock | ParticleLerpBlock | UpdatePositionBlock | UpdateDirectionBlock | UpdateColorBlock | UpdateScaleBlock | UpdateSizeBlock | UpdateAngleBlock | UpdateAgeBlock | UpdateFlowMapBlock | UpdateNoiseBlock | UpdateAttractorBlock | SystemBlock | ParticleTextureSourceBlock | BoxShapeBlock | ConeShapeBlock | CustomShapeBlock | CylinderShapeBlock | MeshShapeBlock | PointShapeBlock | SphereShapeBlock | ParticleInputBlock | ParticleMathBlock | ParticleNumberMathBlock | ParticleVectorMathBlock | ParticleTrigonometryBlock | ParticleRandomBlock | ParticleFloatToIntBlock | 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>;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}

}
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" {
/**
 * Registers particle node blocks to the property ledger
 */
export const RegisterToPropertyTabManagers: () => void;

}
declare module "@babylonjs/node-particle-editor/graphSystem/registerToDisplayLedger" {
/**
 * Registers all display managers to the display ledger
 */
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, 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, 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 isInactive(): 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;
    onInputRemoved?: (index: number) => 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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
declare module "@babylonjs/node-particle-editor/graphSystem/properties/meshShapeNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class MeshShapePropertyTabComponent extends React.Component<IPropertyComponentProps, {
    isLoading: boolean;
}> {
    constructor(props: IPropertyComponentProps);
    loadMesh(file: File): Promise<void>;
    removeData(): void;
    render(): React.JSX.Element;
}

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

}
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 { NodeParticleConnectionPoint } from "@babylonjs/core/Particles/Node/nodeParticleBlockConnectionPoint";
/**
 *
 */
export class GenericPropertyComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);
    render(): React.JSX.Element;
}
/**
 *
 */
export class GeneralPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);
    processUpdate(): void;
    renderConnectionPoint(point: NodeParticleConnectionPoint): React.JSX.Element | null;
    render(): React.JSX.Element;
}
/**
 *
 */
export class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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;
    private _previewCanvas;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
    private _extractAndDisplayTextureAsync;
    private _textureDataToDataUrl;
}

}
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;
    render(): React.JSX.Element;
}
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;
    renderInputBlock(block: ParticleInputBlock): React.JSX.Element | null;
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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;
    private _updateCameraLimits;
    private _reconnectEmittersAsync;
    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;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
export {};

}
declare module "@babylonjs/node-particle-editor/components/mcpSession/mcpSessionComponent" {
import { FunctionComponent } from "react";
import { GlobalState } from "@babylonjs/node-particle-editor/globalState";
interface IMcpSessionComponentProps {
    globalState: GlobalState;
}
/**
 * Panel that connects to a live MCP session for bidirectional particle-system sync.
 * @param props - Component props.
 * @returns The React element.
 */
export const McpSessionComponent: FunctionComponent<IMcpSessionComponentProps>;
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;
    render(): React.JSX.Element;
}
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
     */
    storeAsync(): Promise<void>;
    /**
     * Checks if there is any data in the history stack
     */
    get hasData(): boolean;
    /**
     * Whether an undo operation is available
     */
    get canUndo(): boolean;
    /**
     * Whether a redo operation is available
     */
    get canRedo(): boolean;
    /**
     * 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: unknown): {
    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;
}[];
/**
 * Used to populate the billboardMode dropdown for particle systems.
 */
export const ParticleBillboardModeOptions: {
    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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    renderRows(): React.JSX.Element[];
    renderColumns(): React.JSX.Element[];
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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);
    renderGridInformation(control: Control): React.JSX.Element | null;
    render(): React.JSX.Element | undefined;
}
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);
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
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/projects/projectFile" {
import "@babylonjs/core/Loading/Plugins/babylonFileLoader";
import { Scene } from "@babylonjs/core/scene";
import { ISerializedSmartAssetMap } from "@babylonjs/core/SmartAssets/smartAssetSerializer";
import { IOverrideEntry } from "@babylonjs/node-particle-editor/projects/overrideEntry";
/**
 * ## `.babylonproj` project file format
 *
 * The `.babylonproj` zip on disk packages three layers:
 * 1. **SmartAsset registry** — URL references to external assets (glb/gltf/textures
 *    loaded via SAM). Local blob/data assets are bundled inside the zip and
 *    extracted to fresh blob URLs on load.
 * 2. **OverrideManager state** — declarative property overrides applied after load.
 * 3. **Companion `.babylon`** — meshes, lights, cameras, transform nodes, and
 *    materials that are *not* tracked by SAM (i.e. user-created scene content).
 *    Plus a `companionBindings` side table mapping material texture slots back
 *    to SAM-tracked textures so re-attachment works without embedding texture
 *    bytes in the companion.
 *
 * ### What round-trips cleanly
 * - SAM-tracked assets (re-fetched from their URLs or extracted from the zip)
 * - User-created `Mesh` geometry, `Material`s (Standard/PBR/Multi/Node), and
 *   `*Texture` slot bindings to SAM textures
 * - `Light`s, `Camera`s, `TransformNode`s, scene/material image processing,
 *   clear color, fog, environment intensity
 * - Property overrides on any of the above
 *
 * ### Known gaps (not preserved on save/load)
 * - `PostProcess` attachments to cameras (a post-process attaches to a *specific*
 *   camera instance; we dispose+recreate cameras, leaving post-processes orphaned).
 * - `AdvancedDynamicTexture` GUI controls — not in `.babylon` format.
 * - Audio (`Sound` / `AudioEngine` state).
 * - Particle systems with runtime state, baked vertex animations.
 * - Complex shader-driven content like GaussianSplatting: the mesh round-trips
 *   but its companion utility materials (`gaussianSplattingDepth`, `ProxyMaterial`)
 *   get duplicated on each load cycle.
 * - Skeleton animation playback state.
 *
 * If you hit a "the scene looks different after load" issue, it's almost
 * certainly one of the gaps above rather than camera or mesh state drift.
 */
/**
 * Reserved smart asset key for user-created objects (materials, lights, cameras)
 * that are persisted as a companion `.babylon` file alongside the project JSON.
 */
export const ProjectLocalsKey = "__project_locals__";
/**
 * The result of serializing a project. Contains the project JSON and,
 * if the scene has user-created objects, a companion `.babylon` blob.
 */
export interface IProjectBundle {
    /** The project JSON document (assets + overrides, no embedded scene data). */
    readonly project: ISerializedProject;
    /**
     * A companion `.babylon` file containing user-created objects not owned by
     * any smart asset. Undefined if there are no such objects.
     */
    readonly companionBabylon?: Blob;
}
/**
 * Maps each user-created material (by name) to its texture-slot bindings.
 * A binding records "this `*Texture` slot on this material should be
 * re-attached to the SmartAsset registered under this key" so that texture
 * references survive a save/load round-trip without embedding the texture
 * data inside the companion `.babylon`.
 */
export type CompanionTextureBindings = Record<string, Record<string, string>>;
/**
 * A versioned project file that composes a smart asset map with overrides.
 * This is the unified on-disk format for persisting a complete project.
 */
export interface ISerializedProject {
    /** Schema version. Must be 2 for the current version. */
    readonly version: 2;
    /** Smart asset key→URL mappings (from SmartAssetManager). */
    readonly assets: ISerializedSmartAssetMap["assets"];
    /** Property overrides (from OverrideManager). */
    readonly overrides: IOverrideEntry[];
    /**
     * Optional bindings that re-attach SmartAsset-tracked textures to
     * user-created material slots after the companion `.babylon` loads.
     * Omitted when no user-created material references a SmartAsset texture.
     */
    readonly companionBindings?: CompanionTextureBindings;
}
/**
 * Serializes a scene's smart asset map and override registry into a project
 * bundle. User-created objects (materials, lights, cameras not owned by any
 * smart asset) are serialized into a companion `.babylon` file rather than
 * embedded in the project JSON.
 *
 * Both managers are looked up (and created if missing) via their respective
 * `Get…Manager(scene)` accessors, so this function can be called on any scene.
 *
 * @param scene - The scene to serialize.
 * @param baseUrl - Optional base URL for making asset paths relative.
 * @returns A project bundle containing the JSON document and optional companion file.
 */
export function SerializeProject(scene: Scene, baseUrl?: string): IProjectBundle;
/**
 * Loads a project file from a URL, File, or pre-parsed object.
 * Registers all asset entries on the scene's SmartAssetManager, loads all
 * assets (including the companion `.babylon` for user-created objects), then
 * applies all overrides via the OverrideManager.
 *
 * For loading the `.babylonproj` zip on-disk format, use {@link LoadProjectFileAsync}
 * instead — it extracts the zip and then calls this function with the embedded
 * JSON document.
 *
 * @param scene - The scene to populate.
 * @param source - A URL string, File object, or pre-parsed ISerializedProject.
 * @param rootUrl - Optional root URL for resolving relative asset paths.
 */
export function LoadProjectAsync(scene: Scene, source: string | File | ISerializedProject, rootUrl?: string): Promise<void>;
/**
 * Validates and parses a serialized project document.
 * @param data - The raw data to validate (typically parsed JSON).
 * @returns The validated project document.
 * @throws If the data does not conform to the expected schema.
 */
export function DeserializeProject(data: unknown): ISerializedProject;
/**
 * Serializes a scene's project (smart assets + overrides) into a `.babylonproj`
 * zip bundle.
 *
 * The zip contains:
 * - `project.json` — the project document (assets + overrides)
 * - `__project_locals__.babylon` — companion file for user-created objects (if any)
 * - Bundled local asset files (blobs the user dragged in from disk)
 *
 * Remote URLs (http/https) are left as references and not bundled.
 *
 * @param scene - The scene to serialize.
 * @returns A Blob containing the zip bundle.
 */
export function SaveProjectFileAsync(scene: Scene): Promise<Blob>;
/**
 * Loads a `.babylonproj` zip bundle into a scene. Extracts all files, creates
 * blob URLs for bundled assets, and loads the project through SAM.
 *
 * @param scene - The scene to load the project into.
 * @param zipFile - The `.babylonproj` zip file to load.
 */
export function LoadProjectFileAsync(scene: Scene, zipFile: File): Promise<void>;

}
declare module "@babylonjs/node-particle-editor/projects/overrideManager" {
import { Scene } from "@babylonjs/core/scene";
import { Observable, Observer } from "@babylonjs/core/Misc/observable";
import { IOverrideEntry, OverrideTargetType } from "@babylonjs/node-particle-editor/projects/overrideEntry";
/**
 * Stateful handle for a scene's property override registry.
 *
 * Override behavior is exposed through module-level functions rather than
 * class methods so callers can import only the operations they need.
 *
 * Overrides are property diffs applied to scene objects identified by name.
 * They persist across reloads and are typically saved alongside a project
 * file. The override manager is fully independent of any other scene
 * subsystem (SmartAssetManager, loaders, etc.) — it works with any object
 * in the scene's standard collections (meshes, materials, lights, …)
 * regardless of how that object was created.
 *
 * When multiple objects share a name (e.g. two materials both called
 * "Default" loaded from different glTFs), {@link IOverrideEntry.targetIndex}
 * disambiguates: it stores the object's position among same-named siblings
 * at capture time and is used to pick the correct one at apply time.
 *
 * @example
 * ```typescript
 * AddOverride(scene, {
 *     targetType: "materials",
 *     targetName: "canPaint",
 *     targetIndex: 0,
 *     propertyPath: "albedoColor",
 *     value: [1, 0, 0],
 * });
 * ```
 */
export type OverrideManager = {
    /**
     * The scene this manager is attached to.
     */
    readonly scene: Scene;
    /**
     * Fires whenever the override registry or applied state changes.
     */
    readonly onChangedObservable: Observable<void>;
};
/**
 * Returns the OverrideManager attached to the given scene, creating and
 * attaching one if none exists.
 * @param scene - The scene to look up or attach a manager to.
 * @returns The existing or newly created OverrideManager.
 */
export function GetOverrideManager(scene: Scene): OverrideManager;
/**
 * Adds an observer that is notified whenever an OverrideManager is created.
 * @param callback - The callback to invoke with each newly created manager.
 * @returns The observer registration.
 */
export function AddOverrideManagerCreatedObserver(callback: (manager: OverrideManager) => void): Observer<OverrideManager>;
/**
 * Options for {@link AddOverride}.
 */
export type AddOverrideOptions = {
    /**
     * If the `originalValue` field is present, the override is recorded *without*
     * re-applying it (the caller is presumed to have already mutated the entity)
     * and the field's content is captured as the property's pre-override
     * "original" so {@link RemoveOverride} can restore it later.
     *
     * Inspector-driven edits use this: by the time `onPropertyChanged` fires,
     * the binding has already written the new value, but it still has the prior
     * value in hand. Without this seeding path, an override created via
     * Inspector could never be reverted (the manager would have no record of
     * the pre-edit value).
     *
     * If the field is absent, the override is applied normally and the original
     * is captured by reading the property's current value on first apply.
     */
    readonly originalValue?: unknown;
};
/**
 * Adds an override entry and immediately applies it.
 * If an override with the same target coordinates already exists, it is replaced.
 *
 * When the caller has already mutated the target (e.g. an Inspector edit),
 * pass `{ originalValue }` containing the property's prior value — this seeds
 * the original-value map (so {@link RemoveOverride} can restore it) and skips
 * the redundant apply step.
 * @param scene - The scene whose override registry to update.
 * @param entry - The override to add.
 * @param options - Optional behavior modifiers; see {@link AddOverrideOptions}.
 */
export function AddOverride(scene: Scene, entry: IOverrideEntry, options?: AddOverrideOptions): void;
/**
 * Removes a single override matching the given coordinates. Restores the
 * original value if one was captured.
 * @param scene - The scene whose override registry to update.
 * @param targetType - The target type.
 * @param targetName - The target object name.
 * @param targetIndex - The target index among same-named siblings.
 * @param propertyPath - The property path to un-override.
 * @returns True if an override was removed.
 */
export function RemoveOverride(scene: Scene, targetType: OverrideTargetType, targetName: string, targetIndex: number, propertyPath: string): boolean;
/**
 * Returns all overrides currently registered with the scene.
 * @param scene - The scene whose override registry to read.
 * @returns A read-only array of override entries.
 */
export function GetOverrides(scene: Scene): readonly IOverrideEntry[];
/**
 * Removes all overrides, optionally restoring original values.
 * @param scene - The scene whose override registry to clear.
 * @param restoreOriginals - If true, restores all captured original values.
 */
export function ClearOverrides(scene: Scene, restoreOriginals?: boolean): void;
/**
 * Updates the target coordinates on the override matching a specific (type,
 * old-name, old-index) so it follows an entity rename. Used by capture services
 * to keep overrides attached to a specific object after the user renames it.
 *
 * Only the override at the exact `(targetType, oldName, oldIndex)` slot is
 * updated, so other same-named siblings keep their own overrides untouched.
 *
 * @param scene - The scene whose override registry to update.
 * @param targetType - The target type.
 * @param oldName - The previous name of the renamed entity.
 * @param oldIndex - The previous index of the renamed entity among same-named siblings.
 * @param newName - The new name of the renamed entity.
 * @param newIndex - The new index of the renamed entity among same-named siblings.
 */
export function RenameOverrideTarget(scene: Scene, targetType: OverrideTargetType, oldName: string, oldIndex: number, newName: string, newIndex: number): void;
/**
 * Rewrites override *values* that reference an entity by name when that entity
 * has been renamed. Mirrors {@link RenameOverrideTarget} but operates on the
 * `value` field rather than the `targetName` field, so overrides whose value
 * is `"ref:oldName"` (material/light/camera references) or `"texture:oldName"`
 * (non-SmartAsset texture references) follow the rename instead of silently
 * pointing at a non-existent entity.
 *
 * SmartAsset texture references (`"samTexture:<key>"`) are unaffected because
 * the SmartAsset key is decoupled from the texture's runtime `name` field.
 *
 * @param scene - The scene whose override registry to update.
 * @param valueScheme - Which encoded-reference prefix to rewrite: `"ref"` for
 * material/light/camera references, `"texture"` for non-SAM textures.
 * @param oldName - The previous name embedded in the reference.
 * @param newName - The new name embedded in the reference.
 */
export function RenameOverrideValueReferences(scene: Scene, valueScheme: "ref" | "texture", oldName: string, newName: string): void;
/**
 * Applies all overrides to their current targets in the scene.
 *
 * Call this after any scene mutation that might have invalidated previously
 * applied state (asset reload, object recreation, project load). The override
 * manager does not auto-subscribe to other scene subsystems — coordination is
 * the caller's responsibility, which keeps the override system independent.
 * @param scene - The scene whose overrides to apply.
 */
export function ApplyAllOverrides(scene: Scene): void;
/**
 * Serializes all overrides to a JSON-compatible array.
 * The on-disk shape is identical to the in-memory `IOverrideEntry`.
 * @param scene - The scene whose overrides to serialize.
 * @returns An array of override entries (shallow copies).
 */
export function SerializeOverrides(scene: Scene): IOverrideEntry[];
/**
 * Loads overrides from a serialized array and applies them.
 * @param scene - The scene whose override registry to populate.
 * @param data - Array of override entries.
 */
export function DeserializeAndApplyOverrides(scene: Scene, data: IOverrideEntry[]): void;
/**
 * Disposes the manager, clearing all overrides and detaching it from its scene.
 * Safe to call multiple times; subsequent calls are no-ops. Automatically invoked when the
 * owning scene is disposed.
 * @param manager - The override manager state.
 */
export function DisposeOverrideManager(manager: OverrideManager): void;

}
declare module "@babylonjs/node-particle-editor/projects/overrideEntry" {
/**
 * Defines the shape of an override entry — a property diff applied to a
 * scene object identified by name. Overrides target any object in the
 * scene's standard collections (meshes, materials, lights, etc.) regardless
 * of how that object was created.
 */
export interface IOverrideEntry {
    /** The type of object to target (e.g., "meshes", "materials", "lights"). */
    readonly targetType: OverrideTargetType;
    /** The name of the target object. Use "" for scene-level overrides. */
    readonly targetName: string;
    /**
     * Disambiguator for when multiple objects in `scene[targetType]` share the
     * same `targetName`. The override applies to the N-th match (0-based) at
     * apply time. When names are unique, use 0.
     */
    readonly targetIndex: number;
    /** Dot-separated property path on the target (e.g., "albedoColor", "position.x"). */
    readonly propertyPath: string;
    /** The override value. */
    readonly value: OverrideValue;
}
/**
 * The types of scene objects that can be targeted by overrides.
 */
export type OverrideTargetType = "meshes" | "transformNodes" | "materials" | "textures" | "lights" | "cameras" | "animationGroups" | "scene";
/**
 * An override value. Supports scalars, color/vector arrays, object references,
 * and null (used to clear a slot, e.g. removing a material assignment).
 * - number: scalar property (e.g., intensity, alpha)
 * - string: string property, or "ref:name" / "samTexture:key" / "texture:name" object reference
 * - boolean: boolean property
 * - number[]: array property mapped to Vector3, Color3, Color4, etc.
 * - null: explicitly clear an object-typed slot
 */
export type OverrideValue = number | string | boolean | number[] | null;

}
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/teleportInPropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/propertyComponentProps";
/**
 * Cycles through a teleport entry's references without changing the selected node.
 */
export class TeleportInPropertyComponent extends React.Component<IPropertyComponentProps> {
    private _lastEndpoint;
    private _onUpdateRequiredObserver;
    private _onRebuildRequiredObserver;
    componentDidMount(): void;
    componentDidUpdate(previousProps: IPropertyComponentProps): void;
    componentWillUnmount(): void;
    private _focusNextReference;
    render(): React.JSX.Element;
}

}
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;
    activeNode: Nullable<GraphNode>;
    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>>;
    /** The source port data for the current drag operation, used for design-time compatibility checks */
    candidateSourcePortData: Nullable<IPortData>;
    /** When true, ports glow red during drag when hovering over an incompatible target. Default false. */
    enablePortCompatibilityHighlight: boolean;
    /** When true, nodes can display validation and breakpoint badge overlays. Default false. */
    enableNodeBadges: boolean;
    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;
    }>;
    /**
     * Requests centering on the graph node associated with the supplied underlying block data.
     * The current selection and zoom are preserved.
     */
    onFocusNodeObservable: Observable<unknown>;
    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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element | null;
    render(): React.JSX.Element;
}

}
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 { 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);
    refreshLabel(): void;
    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);
    remove(): void;
    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;
    private _flowAnimationActive;
    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;
    /** Ensure the shared SVG glow filter exists, return its id
     * @param svg the SVG element to check for the filter and add it to if not present
     * @returns the id of the glow filter to use in this SVG
     */
    private static _EnsureGlowFilter;
    /**
     * Triggers a brief animated dot traveling along the link path from port A to port B.
     * @param durationMs how long the animation takes (default 600ms)
     * @param color the color of the dot (default green)
     */
    triggerFlowAnimation(durationMs?: number, color?: string): void;
    /**
     * Disposes this visual link.
     * @param notify - Whether to notify observers that the link was disposed.
     * @param disconnectPorts - Whether to disconnect the underlying port data.
     */
    dispose(notify?: boolean, disconnectPorts?: 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/graphStickyNote" {
import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
import { IStickyNoteData } from "@babylonjs/node-particle-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
/**
 * A free-floating sticky note annotation on the graph canvas.
 *
 * Sticky notes are lightweight, text-only overlays that live in the frame container.
 * They support dragging, resizing, and inline editing of both title and body text.
 * Unlike frames, they do not group or contain nodes.
 */
export class GraphStickyNote {
    /** The root DOM element for this sticky note. */
    element: HTMLDivElement;
    private _ownerCanvas;
    private _id;
    private _x;
    private _y;
    private _width;
    private _height;
    private _name;
    private _body;
    private _color;
    private _headerElement;
    private _titleElement;
    private _bodyElement;
    private _resizeHandle;
    private _mouseStartX;
    private _mouseStartY;
    private _isDragging;
    private _isResizing;
    private _resizeStartW;
    private _resizeStartH;
    /** Unique ID for this sticky note */
    get id(): number;
    /** X position in canvas space */
    get x(): number;
    /** X position in canvas space */
    set x(value: number);
    /** Y position in canvas space */
    get y(): number;
    /** Y position in canvas space */
    set y(value: number);
    /** Width in pixels */
    get width(): number;
    /** Width in pixels */
    set width(value: number);
    /** Height in pixels */
    get height(): number;
    /** Height in pixels */
    set height(value: number);
    /** Display name */
    get name(): string;
    /** Display name */
    set name(value: string);
    /** Body text content */
    get body(): string;
    /** Body text content */
    set body(value: string);
    /** Background color CSS value */
    get color(): string;
    /** Background color CSS value */
    set color(value: string);
    /**
     * Create a new sticky note on the canvas.
     * @param canvas - the owning graph canvas component
     */
    constructor(canvas: GraphCanvasComponent);
    /**
     * Mark this note as visually selected or deselected.
     * @param selected - whether the note is selected
     */
    setIsSelected(selected: boolean): void;
    /**
     * Serialize this sticky note to a plain data object.
     * @returns the serialized data
     */
    serialize(): IStickyNoteData;
    /**
     * Create a sticky note from serialized data.
     * @param data - the serialized sticky note data
     * @param canvas - the owning graph canvas
     * @returns the new sticky note instance
     */
    static Parse(data: IStickyNoteData, canvas: GraphCanvasComponent): GraphStickyNote;
    /**
     * Remove this sticky note from the canvas and clean up.
     */
    dispose(): void;
    private _onDragStart;
    private _onDragMoveHandler;
    private _onDragEndHandler;
    private _onResizeStart;
    private _onResizeMoveHandler;
    private _onResizeEndHandler;
}

}
declare module "@babylonjs/node-particle-editor/nodeGraphSystem/graphSearch" {
import * as React from "react";
import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
import { GraphNode } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphFrame";
/** A search result pointing to either a node or a frame. */
interface ISearchResult {
    node?: GraphNode;
    frame?: GraphFrame;
    label: string;
}
/**
 * Props for the GraphSearchComponent.
 */
export interface IGraphSearchComponentProps {
    /** The graph canvas to search within */
    canvas: GraphCanvasComponent;
}
/** Internal state for GraphSearchComponent. */
interface IGraphSearchState {
    /** Whether the search overlay is visible */
    visible: boolean;
    /** The current search query */
    query: string;
    /** Index of the currently focused result */
    currentIndex: number;
    /** Matching search results */
    results: ISearchResult[];
}
/**
 * An overlay search bar for finding nodes and frames in the graph by name or type.
 * Triggered via an observable; press Escape or the close button to dismiss.
 */
export class GraphSearchComponent extends React.Component<IGraphSearchComponentProps, IGraphSearchState> {
    private _inputRef;
    private _escHandler;
    /** @internal */
    constructor(props: IGraphSearchComponentProps);
    /** Show the search bar and focus the input. */
    show(): void;
    /** Hide the search bar and clear highlights. */
    hide(): void;
    private _search;
    private _applyHighlights;
    private _clearHighlights;
    private _navigateTo;
    private _goNext;
    private _goPrev;
    private _onKeyDown;
    /** @internal */
    componentWillUnmount(): void;
    /** @internal */
    render(): React.JSX.Element | null;
}
export {};

}
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 _validationBadge;
    private _breakpointBadge;
    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 _lastClick;
    _visualPropertiesRefresh: Array<() => void>;
    /** Direct access to the execution time label element for lightweight updates */
    get executionTimeElement(): HTMLDivElement;
    addClassToVisual(className: string): void;
    removeClassFromVisual(className: string): void;
    /**
     * Shows a validation badge on the node header.
     * @param severity - "error" | "warning" | null. Pass null to hide the badge.
     * @param tooltip - tooltip text shown on hover.
     * @param onClick - optional callback invoked when the badge is clicked.
     */
    setValidationState(severity: "error" | "warning" | null, tooltip?: string, onClick?: () => void): void;
    /**
     * Shows or hides a breakpoint indicator on the node.
     * @param active - true to show the red breakpoint dot, false to hide.
     * @param paused - true if execution is currently paused on this breakpoint.
     */
    setBreakpointState(active: boolean, paused?: boolean): 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;
    private _removeInputPort;
    private _buildOutputPorts;
    private _removeOutputPort;
    appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
    /**
     * Disposes this visual graph node.
     * @param disposeContent - Whether to dispose the underlying node content and disconnect links.
     */
    dispose(disposeContent?: boolean): void;
}

}
declare module "@babylonjs/node-particle-editor/nodeGraphSystem/graphMinimap" {
import * as React from "react";
import { GraphCanvasComponent } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphCanvas";
/**
 * Props for the GraphMinimapComponent.
 * This component can be reused by any editor that uses GraphCanvasComponent.
 */
export interface IGraphMinimapComponentProps {
    /** The graph canvas to visualize */
    canvas: GraphCanvasComponent;
    /** How long (ms) the minimap stays visible after the last interaction. Default 1500. */
    hideDelayMs?: number;
    /** Width of the minimap in pixels. Default 200. */
    width?: number;
    /** Height of the minimap in pixels. Default 140. */
    height?: number;
}
/**
 * A minimap overlay that shows a scaled-down overview of the node graph.
 * It appears when the user zooms or pans and auto-hides after a delay.
 * Clicking/dragging on the minimap pans the canvas to that position.
 *
 * This is a reusable component that works with any GraphCanvasComponent-based editor
 * (Flow Graph Editor, Node Material Editor, Node Geometry Editor, etc.).
 */
export class GraphMinimapComponent extends React.Component<IGraphMinimapComponentProps> {
    private _canvasRef;
    private _containerRef;
    private _rafId;
    private _hideTimer;
    private _visible;
    private _isDragging;
    /** Track last canvas state to detect changes driven by external APIs (zoomToFit, etc.) */
    private _lastX;
    private _lastY;
    private _lastZoom;
    /** Stored transform values for minimap hit-testing */
    private _mapScale;
    private _mapOffsetX;
    private _mapOffsetY;
    private _mapTotalMinX;
    private _mapTotalMinY;
    private get _hideDelay();
    private get _width();
    private get _height();
    /** @internal */
    componentDidMount(): void;
    /** @internal */
    componentWillUnmount(): void;
    /**
     * Show the minimap and schedule auto-hide.
     */
    private _show;
    private _applyVisibility;
    /**
     * Main render loop — polls the canvas state every frame and redraws
     * the minimap when a change is detected.
     */
    private _tick;
    /**
     * Compute the bounding box of all nodes and frames in graph-space.
     * @returns the min/max coordinates of the graph content
     */
    private _computeGraphBounds;
    /**
     * Draw the minimap onto the <canvas> element.
     */
    private _draw;
    /**
     * Convert a pointer event on the minimap to graph-space coordinates and
     * pan the canvas to center on that point.
     * @param evt - the pointer event from the minimap
     */
    private _panToMinimapPoint;
    private _onPointerDown;
    private _onPointerMove;
    private _onPointerUp;
    /** @internal */
    render(): React.JSX.Element;
}

}
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 _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;
    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 { GraphStickyNote } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphStickyNote";
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;
    /** When true, a minimap overlay is shown during zoom/pan. Default false. */
    enableMinimap?: boolean;
    /** When true, sticky note annotations can be created and managed on the canvas. Default false. */
    enableStickyNotes?: boolean;
    /** When true, Ctrl+F opens a find-in-graph search bar. Default false. */
    enableFindInGraph?: boolean;
    /** When true, ports glow red during drag when hovering over an incompatible target. Default false. */
    enablePortCompatibilityHighlight?: boolean;
    /** When true, nodes can display validation and breakpoint badge overlays. Default false. */
    enableNodeBadges?: boolean;
}
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 _stickyNotes;
    private _selectedStickyNotes;
    private _nodeDataContentList;
    private _altKeyIsPressed;
    private _shiftKeyIsPressed;
    private _multiKeyIsPressed;
    private _oldY;
    private _keyUpHandler;
    private _keyDownHandler;
    private _blurHandler;
    private _onFocusNodeObserver;
    _frameIsMoving: boolean;
    _isLoading: boolean;
    _targetLinkCandidate: Nullable<NodeLink>;
    private _isCopyingOrPasting;
    private _copiedNodes;
    private _copiedFrames;
    private _searchRef;
    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 stickyNotes(): GraphStickyNote[];
    get selectedStickyNotes(): GraphStickyNote[];
    get selectedPort(): Nullable<NodePort>;
    get canvasContainer(): HTMLDivElement;
    get hostCanvas(): HTMLDivElement;
    get svgCanvas(): HTMLElement;
    get selectionContainer(): HTMLDivElement;
    get frameContainer(): HTMLDivElement;
    private _selectedFrameAndNodesConflict;
    private _deselectAllStickyNotes;
    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;
    handleKeyDownAsync(evt: KeyboardEvent, onRemove: (nodeData: INodeData) => void, mouseLocationX: number, mouseLocationY: number, dataGenerator: (nodeData: INodeData) => Promise<Nullable<GraphNode>>, rootElement: HTMLDivElement): Promise<void>;
    pasteSelectionAsync(copiedNodes: GraphNode[], currentX: number, currentY: number, dataGenerator: (nodeData: INodeData) => Promise<Nullable<GraphNode>>, selectNew?: boolean): Promise<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;
    /**
     * Clears the canvas visuals.
     * @param disposeContent - Whether to dispose the underlying graph data while clearing visuals.
     */
    reset(disposeContent?: boolean): void;
    connectPorts(pointA: IPortData, pointB: IPortData): void;
    removeLink(link: NodeLink): void;
    appendNode(nodeData: INodeData): GraphNode;
    distributeGraph(): void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    onMove(evt: React.PointerEvent): void;
    onDown(evt: React.PointerEvent<HTMLElement>): void;
    onUp(evt: React.PointerEvent): void;
    onWheel(evt: React.WheelEvent): void;
    zoomToFit(): void;
    /**
     * Reveals and centers the given node without changing selection or zoom.
     * @param node - the node to bring into view
     */
    zoomToNode(node: GraphNode): 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;
    /**
     * Create a new sticky note at the given canvas-space position.
     * @param x - x position in canvas space
     * @param y - y position in canvas space
     * @returns the created sticky note
     */
    addStickyNote(x: number, y: number): GraphStickyNote | null;
    /**
     * Open the find-in-graph search bar, if enabled.
     */
    showSearch(): void;
    render(): React.JSX.Element;
}

}
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
 * @param engageActiveRefresh if active refresh should be engaged
 */
export function ForceRebuild(source: any, stateManager: StateManager, propertyName: string, notifiers?: IEditablePropertyOption["notifiers"], engageActiveRefresh?: boolean): 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 { GraphStickyNote } from "@babylonjs/node-particle-editor/nodeGraphSystem/graphStickyNote";
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 | GraphStickyNote>;
    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,
    String = 2
}
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;
    isInactive: 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 IStickyNoteData {
    x: number;
    y: number;
    width: number;
    height: number;
    name: string;
    body: string;
    color?: string;
}
export interface IEditorData {
    locations: INodeLocationInfo[];
    x: number;
    y: number;
    zoom: number;
    frames?: IFrameData[];
    stickyNotes?: IStickyNoteData[];
    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;
    onInputRemoved?: (index: number) => void;
    onOutputCountChanged?: () => void;
    onOutputRemoved?: (index: number) => 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/modularTool/modularTool" {
import { IExtensionFeed } from "@babylonjs/node-particle-editor/modularTool/extensibility/extensionFeed";
import { WeaklyTypedServiceDefinition, ServiceContainer } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceContainer";
import { ShellServiceOptions } from "@babylonjs/node-particle-editor/modularTool/services/shellService";
import { ThemeMode } from "@babylonjs/node-particle-editor/modularTool/services/themeService";
export type ModularToolOptions = {
    /**
     * The namespace for the tool, used for scoping persisted settings and other storage.
     */
    namespace: string;
    /**
     * The container element where the tool will be rendered.
     */
    containerElement: HTMLElement;
    /**
     * The service definitions to be registered with the tool.
     */
    serviceDefinitions: readonly WeaklyTypedServiceDefinition[];
    /**
     * The theme mode to use. If not specified, the default is "system", which uses the system/browser preference, and the last used mode is persisted.
     */
    themeMode?: ThemeMode;
    /**
     * Whether to show the theme selector in the toolbar. Default is true.
     */
    showThemeSelector?: boolean;
    /**
     * The extension feeds that provide optional extensions the user can install.
     */
    extensionFeeds?: readonly IExtensionFeed[];
    /**
     * An optional parent ServiceContainer. Dependencies not found in the tool's own container
     * will be resolved from this parent.
     */
    parentContainer?: ServiceContainer;
    /**
     * When true, all teaching moments are disabled and will not be shown.
     */
    disableTeachingMoments?: boolean;
} & ShellServiceOptions;
/**
 * Creates a modular tool with a base set of common tool services, including the toolbar/side pane basic UI layout.
 * @param options The options for the tool.
 * @returns A token that can be used to dispose of the tool.
 */
export function MakeModularTool(options: ModularToolOptions): {
    dispose: () => Promise<void>;
};

}
declare module "@babylonjs/node-particle-editor/modularTool/modularBridge" {
import { IDisposable } from "@babylonjs/core/index";
import { WeaklyTypedServiceDefinition, ServiceContainer } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceContainer";
/**
 * Options for creating a modular bridge container.
 * @experimental
 * @internal
 */
export type ModularBridgeOptions = {
    /**
     * WebSocket port for the bridge's browser port. Defaults to 4400.
     */
    port?: number;
    /**
     * Session display name reported to the bridge. Defaults to `document.title`.
     */
    name?: string;
    /**
     * Whether the bridge should automatically enable trying to connect.
     * Defaults to true.
     */
    autoEnable?: boolean;
    /**
     * Additional service definitions to register with the bridge container.
     */
    serviceDefinitions?: readonly WeaklyTypedServiceDefinition[];
};
/**
 * A token returned by {@link MakeModularBridge} that owns the headless
 * {@link ServiceContainer}. Dispose it to tear down the bridge and all services.
 * @experimental
 * @internal
 */
export type ModularBridgeToken = IDisposable & {
    /**
     * The headless ServiceContainer that hosts the bridge.
     */
    readonly serviceContainer: ServiceContainer;
    /**
     * Whether this token has been disposed.
     */
    readonly isDisposed: boolean;
};
/**
 * Creates a headless {@link ServiceContainer} that hosts a bridge service.
 *
 * The returned token owns the container. Dispose it to tear down the bridge.
 *
 * @param options Optional configuration for the bridge.
 * @returns A {@link ModularBridgeToken} that owns the container.
 * @experimental
 * @internal
 */
export function MakeModularBridge(options?: ModularBridgeOptions): ModularBridgeToken;

}
declare module "@babylonjs/node-particle-editor/modularTool/themes/babylonTheme" {

export const LightTheme: any;
export const DarkTheme: any;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/toastService" {
import { IService } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { ToastOptions } from "@babylonjs/node-particle-editor/fluent/primitives/toast";
/**
 * The unique identity symbol for the toast service.
 */
export const ToastServiceIdentity: unique symbol;
/**
 * Provides the ability to show toast notifications from non-React code (e.g. Observable callbacks).
 */
export interface IToastService extends IService<typeof ToastServiceIdentity> {
    /**
     * Shows a toast notification with the given message.
     * @param message The message to display.
     * @param options Optional toast configuration such as intent.
     */
    showToast(message: string, options?: ToastOptions): void;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/services/themeService" {

import { IDisposable, IReadonlyObservable } from "@babylonjs/core/index";
import { IService, ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { ISettingsStore, SettingDescriptor } from "@babylonjs/node-particle-editor/modularTool/services/settingsStore";
/**
 * Represents the theme mode preference.
 */
export type ThemeMode = "system" | "light" | "dark";
/**
 * The setting descriptor for persisting the theme mode preference.
 */
export const ThemeModeSettingDescriptor: SettingDescriptor<ThemeMode>;
/**
 * Resolves the current theme based on user preference and system settings.
 * Listens for changes to both the persisted theme mode and the OS-level dark mode preference.
 */
export class ThemeResolver implements IDisposable {
    private readonly _settingsStore;
    private readonly _darkModeMediaQuery;
    private readonly _onChanged;
    private readonly _onDarkModeMediaQueryChange;
    private readonly _settingsStoreObserver;
    constructor(_settingsStore: ISettingsStore);
    get onChanged(): IReadonlyObservable<void>;
    get mode(): ThemeMode;
    set mode(value: ThemeMode);
    get isDark(): boolean;
    toggle(): void;
    dispose(): void;
}
/**
 * The unique identity symbol for the theme service.
 */
export const ThemeServiceIdentity: unique symbol;
/**
 * Exposes the current theme used by the application.
 */
export interface IThemeService extends IService<typeof ThemeServiceIdentity> {
    /**
     * Whether the current theme is the dark variant or not.
     */
    readonly isDark: boolean;
    /**
     * The current theme mode, which can be either "light", "dark" or "system". When set to "system", the theme will match the user's OS-level preference and update automatically when it changes.
     */
    mode: ThemeMode;
    /**
     * Toggles the theme mode between light and dark. If the current mode is "system", it will toggle based on the current OS-level preference.
     */
    toggle(): void;
    /**
     * The current theme used by the application.
     */
    readonly theme: any;
    /**
     * Observable that fires whenever the theme changes.
     */
    readonly onChanged: IReadonlyObservable<void>;
}
export const ThemeServiceDefinition: ServiceDefinition<[IThemeService], [ISettingsStore]>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/themeSelectorService" {
import { ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { IShellService } from "@babylonjs/node-particle-editor/modularTool/services/shellService";
export const ThemeSelectorServiceDefinition: ServiceDefinition<[], [IShellService]>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/shellSettingsService" {
import { ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { ISettingsService } from "@babylonjs/node-particle-editor/modularTool/services/settingsService";
export const ShellSettingsServiceDefinition: ServiceDefinition<[], [ISettingsService]>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/shellService" {
import { ComponentType } from "react";
import { IDisposable, Nullable } from "@babylonjs/core/index";
import { IService, ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { SettingDescriptor } from "@babylonjs/node-particle-editor/modularTool/services/settingsStore";
/**
 * Setting descriptor for persisting side pane dock location overrides.
 */
export const SidePaneDockOverridesSettingDescriptor: SettingDescriptor<Record<string, Readonly<{
    horizontalLocation: HorizontalLocation;
    verticalLocation: VerticalLocation;
}> | undefined>>;
/**
 * Setting descriptor for persisting the left side pane width adjustment.
 */
export const LeftSidePaneWidthAdjustSettingDescriptor: SettingDescriptor<number>;
/**
 * Setting descriptor for persisting the left side pane height adjustment.
 */
export const LeftSidePaneHeightAdjustSettingDescriptor: SettingDescriptor<number>;
/**
 * Setting descriptor for persisting the right side pane width adjustment.
 */
export const RightSidePaneWidthAdjustSettingDescriptor: SettingDescriptor<number>;
/**
 * Setting descriptor for persisting the right side pane height adjustment.
 */
export const RightSidePaneHeightAdjustSettingDescriptor: SettingDescriptor<number>;
/**
 * Represents a horizontal location in the shell layout.
 */
export type HorizontalLocation = "left" | "right";
/**
 * Represents a vertical location in the shell layout.
 */
export type VerticalLocation = "top" | "bottom";
type TeachingMomentInfo = boolean | {
    readonly title: string;
    readonly description: string;
};
/**
 * Describes an item that can be added to one of the shell's toolbars.
 */
export type ToolbarItemDefinition = {
    /**
     * A unique key for the toolbar item.
     */
    key: string;
    /**
     * The component to render for the toolbar item.
     */
    component: ComponentType;
    /**
     * An optional order for the toolbar item, relative to other items.
     * Defaults to 0.
     */
    order?: number;
    /**
     * The horizontal location of the toolbar item.
     * Can be either "left" or "right".
     * In "compact" toolbar mode, "left" and "right" mean the "compact" toolbars at the top/bottom of the left/right side panes.
     * In "full" toolbar mode, "left" and "right" mean the left side and right side of the full width toolbars above/below the side panes.
     */
    horizontalLocation: HorizontalLocation;
    /**
     * The vertical location of the toolbar item.
     * Can be either "top" or "bottom".
     */
    verticalLocation: VerticalLocation;
    /**
     * An optional display name for the toolbar item, used for teaching moments, tooltips, etc.
     */
    displayName?: string;
    /**
     * An optional teaching moment info. The default assumes the toolbar item was added by an extension and provides a generic title and description based on the display name or id, which is helpful for discoverability of new items.
     * Set this to false to suppress the teaching moment, which may be desirable for built in items or items that are added in a non-dynamic way.
     * Set it to an object with a title and description to provide a custom teaching moment, which may be desirable if the generic title and description are not sufficient.
     * Teaching moments are more helpful for dynamically added items, possibly from extensions.
     */
    teachingMoment?: TeachingMomentInfo;
};
/**
 * Describes a side pane that can be added to the shell's left or right side.
 */
export type SidePaneDefinition = {
    /**
     * A unique key for the side pane.
     */
    key: string;
    /**
     * An icon component to render for the pane tab.
     */
    icon: ComponentType;
    /**
     * The component to render for the side pane's content.
     */
    content: ComponentType;
    /**
     * An optional order for the side pane, relative to other panes.
     * Defaults to 0.
     */
    order?: number;
    /**
     * The horizontal location of the side pane.
     * Can be either "left" or "right".
     */
    horizontalLocation: HorizontalLocation;
    /**
     * The vertical location of the side pane.
     * Can be either "top" or "bottom".
     */
    verticalLocation: VerticalLocation;
    /**
     * The title of the side pane, displayed as a standardized header at the top of the pane.
     */
    title: string;
    /**
     * An optional teaching moment info. The default assumes the side pane was added by an extension and provides a generic title and description based on the display name or id, which is helpful for discoverability of new items.
     * Set this to false to suppress the teaching moment, which may be desirable for built in items or items that are added in a non-dynamic way.
     * Set it to an object with a title and description to provide a custom teaching moment, which may be desirable if the generic title and description are not sufficient.
     * Teaching moments are more helpful for dynamically added panes, possibly from extensions.
     */
    teachingMoment?: TeachingMomentInfo;
    /**
     * Keep the pane mounted even when it is not visible. This is useful if you don't want the
     * user to lose the complex visual state when switching between tabs.
     */
    keepMounted?: boolean;
};
type RegisteredSidePane = {
    readonly key: string;
    select(): void;
};
type SidePaneContainer = {
    readonly isDocked: boolean;
    dock(): void;
    undock(): void;
    readonly isCollapsed: boolean;
    collapse(): void;
    expand(): void;
};
/**
 * Describes content that can be added to the shell's central area (between the side panes and toolbars - e.g. the main content).
 */
export type CentralContentDefinition = {
    /**
     * A unique key for the central content.
     */
    key: string;
    /**
     * The component to render for the central content.
     */
    component: ComponentType;
    /**
     * An optional order for content, relative to other central content.
     * Defaults to 0.
     */
    order?: number;
};
/**
 * The unique identity symbol for the root component service.
 */
export const RootComponentServiceIdentity: unique symbol;
/**
 * Exposes a top level component that should be rendered as the React root.
 */
export interface IRootComponentService extends IService<typeof RootComponentServiceIdentity> {
    /**
     * The root component that should be rendered as the React root.
     */
    readonly rootComponent: ComponentType;
}
/**
 * The unique identity symbol for the shell service.
 */
export const ShellServiceIdentity: unique symbol;
/**
 * Provides a shell for the application, including toolbars, side panes, and central content.
 * This service allows adding toolbar items, side panes, and central content dynamically.
 */
export interface IShellService extends IService<typeof ShellServiceIdentity> {
    /**
     * Adds a new item to one of the shell's toolbars.
     * @param item Defines the item to add.
     */
    addToolbarItem(item: Readonly<ToolbarItemDefinition>): IDisposable;
    /**
     * Adds a new side pane to the shell.
     * @param pane Defines the side pane to add.
     */
    addSidePane(pane: Readonly<SidePaneDefinition>): IDisposable;
    /**
     * Adds new central content to the shell.
     * @param content Defines the content area to add.
     */
    addCentralContent(content: Readonly<CentralContentDefinition>): IDisposable;
    /**
     * The left side pane container.
     */
    readonly leftSidePaneContainer: Nullable<SidePaneContainer>;
    /**
     * The right side pane container.
     */
    readonly rightSidePaneContainer: Nullable<SidePaneContainer>;
    /**
     * The side panes currently present in the shell.
     */
    readonly sidePanes: readonly RegisteredSidePane[];
}
type ToolbarMode = "full" | "compact";
/**
 * Options for configuring the shell service.
 */
export type ShellServiceOptions = {
    /**
     * The default width of the left side pane.
     */
    leftPaneDefaultWidth?: number;
    /**
     * The minimum width of the left side pane.
     */
    leftPaneMinWidth?: number;
    /**
     * The default width of the right side pane.
     */
    rightPaneDefaultWidth?: number;
    /**
     * The minimum width of the right side pane.
     */
    rightPaneMinWidth?: number;
    /**
     * The mode of the toolbars.
     * Can be either "full" (default) or "compact".
     * In "full" mode, toolbars are displayed above and below the side panes.
     * In "compact" mode, toolbars are displayed at the top and bottom of the left and right side panes.
     */
    toolbarMode?: ToolbarMode;
    /**
     * Whether the left side pane should start collapsed. Default is false.
     */
    leftPaneDefaultCollapsed?: boolean;
    /**
     * Whether the right side pane should start collapsed. Default is false.
     */
    rightPaneDefaultCollapsed?: boolean;
    /**
     * A function that can remap the default location of side panes.
     * @param sidePane The side pane to remap.
     * @returns The new location for the side pane.
     */
    sidePaneRemapper?: (sidePane: Readonly<SidePaneDefinition>) => Nullable<{
        horizontalLocation: HorizontalLocation;
        verticalLocation: VerticalLocation;
    }>;
};
export function MakeShellServiceDefinition({ leftPaneDefaultWidth, leftPaneMinWidth, rightPaneDefaultWidth, rightPaneMinWidth, leftPaneDefaultCollapsed, rightPaneDefaultCollapsed, toolbarMode, sidePaneRemapper, }?: ShellServiceOptions): ServiceDefinition<[IShellService, IRootComponentService], []>;
export {};

}
declare module "@babylonjs/node-particle-editor/modularTool/services/settingsStore" {
import { IReadonlyObservable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
/**
 * The unique identity symbol for the settings store service.
 */
export const SettingsStoreIdentity: unique symbol;
/**
 * Describes a setting by its key and default value.
 */
export type SettingDescriptor<T> = {
    /**
     * The unique key used to identify this setting in the store.
     */
    readonly key: string;
    /**
     * The default value to use when the setting has not been explicitly set.
     */
    readonly defaultValue: T;
};
/**
 * Provides a key-value store for persisting user settings.
 */
export interface ISettingsStore extends IService<typeof SettingsStoreIdentity> {
    /**
     * An observable that notifies when a setting has changed, providing the key of the changed setting.
     */
    onChanged: IReadonlyObservable<string>;
    /**
     * Reads a setting from the store.
     * @param descriptor The descriptor of the setting to read.
     * @returns The current value of the setting, or the default value if it has not been set.
     */
    readSetting<T>(descriptor: SettingDescriptor<T>): T;
    /**
     * Writes a setting to the store.
     * @param descriptor The descriptor of the setting to write.
     * @param value The value to write.
     */
    writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
}
/**
 * Default implementation of {@link ISettingsStore} that persists settings using browser local storage.
 */
export class SettingsStore implements ISettingsStore {
    private readonly _namespace;
    private readonly _onChanged;
    /**
     * Creates a new settings store.
     * @param _namespace A namespace used to scope the settings keys to avoid collisions with other stores.
     */
    constructor(_namespace: string);
    get onChanged(): IReadonlyObservable<Readonly<string>>;
    readSetting<T>(descriptor: SettingDescriptor<T>): T;
    writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/services/settingsService" {
import { IDisposable } from "@babylonjs/core/index";
import { DynamicAccordionSection, DynamicAccordionSectionContent } from "@babylonjs/node-particle-editor/modularTool/components/extensibleAccordion";
import { IService, ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { IShellService } from "@babylonjs/node-particle-editor/modularTool/services/shellService";
/**
 * The unique identity symbol for the settings service.
 */
export const SettingsServiceIdentity: unique symbol;
/**
 * Allows new sections or content to be added to the Settings pane.
 */
export interface ISettingsService extends IService<typeof SettingsServiceIdentity> {
    /**
     * Adds a new section to the settings pane.
     * @param section A description of the section to add.
     */
    addSection(section: DynamicAccordionSection): IDisposable;
    /**
     * Adds content to one or more sections in the settings pane.
     * @param content A description of the content to add.
     */
    addSectionContent(content: DynamicAccordionSectionContent<unknown>): IDisposable;
}
export const SettingsServiceDefinition: ServiceDefinition<[ISettingsService], [IShellService]>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/reactContextService" {
import { Context } from "react";
import { IDisposable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
/**
 * The unique identity symbol for the react context service.
 */
export const ReactContextServiceIdentity: unique symbol;
export type ReactContextHandle<T> = IDisposable & {
    updateValue: (newValue: T) => void;
};
/**
 * ReactContextService allows global React contexts to be added/removed/updated.
 */
export interface IReactContextService extends IService<typeof ReactContextServiceIdentity> {
    addContext<T>(provider: Context<T>["Provider"], initialValue: T, options?: {
        order?: number;
    }): ReactContextHandle<T>;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/services/globalSettings" {
import { SettingDescriptor } from "@babylonjs/node-particle-editor/modularTool/services/settingsStore";
export const CompactModeSettingDescriptor: SettingDescriptor<boolean>;
export const DisableCopySettingDescriptor: SettingDescriptor<boolean>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/extensionsListService" {
import { ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { IShellService } from "@babylonjs/node-particle-editor/modularTool/services/shellService";
export const ExtensionListServiceDefinition: ServiceDefinition<[], [IShellService]>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/dialogService" {
import { IService } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";

export type DialogOptions = {
    type: "alert";
    intent?: any;
    title: string;
    content?: JSX.Element;
};
/**
 * The unique identity symbol for the dialog service.
 */
export const DialogServiceIdentity: unique symbol;
/**
 * Provides the ability to show dialog from non-React code (e.g. Observable callbacks).
 */
export interface IDialogService extends IService<typeof DialogServiceIdentity> {
    /**
     * Shows a dialog with the given content.
     * @param options The dialog options to display.
     */
    showDialog(options: DialogOptions): void;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/services/cli/protocol" {
/**
 * Serializable description of a command argument, used in protocol messages.
 */
export type CommandArgInfo = {
    /** The name of the argument. */
    name: string;
    /** A human-readable description of the argument. */
    description: string;
    /** Whether this argument is required. */
    required?: boolean;
    /** The type of the argument. Defaults to "string". When "file", the CLI reads the file and sends its contents. */
    type?: "string" | "file";
};
/**
 * Serializable description of a command, used in protocol messages.
 */
export type CommandInfo = {
    /** A unique identifier for the command. */
    id: string;
    /** A human-readable description of the command. */
    description: string;
    /** The arguments this command accepts. */
    args?: CommandArgInfo[];
};
/**
 * Serializable description of a session, used in protocol messages.
 */
export type SessionInfo = {
    /** The numeric session identifier. */
    id: number;
    /** The display name of the session. */
    name: string;
    /** ISO 8601 timestamp of when the session connected. */
    connectedAt: string;
};
/**
 * CLI → Bridge: Request the list of active browser sessions.
 */
export type SessionsRequest = {
    /** The message type discriminator. */
    type: "sessions";
};
/**
 * CLI → Bridge: Request the list of commands available from a session.
 */
export type CommandsRequest = {
    /** The message type discriminator. */
    type: "commands";
    /** The session to query for commands. */
    sessionId: number;
};
/**
 * CLI → Bridge: Execute a command on a session.
 */
export type ExecRequest = {
    /** The message type discriminator. */
    type: "exec";
    /** The session to execute the command on. */
    sessionId: number;
    /** The identifier of the command to execute. */
    commandId: string;
    /** Key-value pairs of arguments for the command. */
    args: Record<string, string>;
};
/**
 * CLI → Bridge: Stop the bridge process.
 */
export type StopRequest = {
    /** The message type discriminator. */
    type: "stop";
};
/**
 * All messages that the CLI sends to the bridge.
 */
export type CliRequest = SessionsRequest | CommandsRequest | ExecRequest | StopRequest;
/**
 * Bridge → CLI: Response with the list of active sessions.
 */
export type SessionsResponse = {
    /** The message type discriminator. */
    type: "sessionsResponse";
    /** The list of active sessions. */
    sessions: SessionInfo[];
};
/**
 * Bridge → CLI: Response with the list of commands from a session.
 */
export type CommandsResponse = {
    /** The message type discriminator. */
    type: "commandsResponse";
    /** The list of available commands, if successful. */
    commands?: CommandInfo[];
    /** An error message, if the request failed. */
    error?: string;
};
/**
 * Bridge → CLI: Response with the result of a command execution.
 */
export type ExecResponse = {
    /** The message type discriminator. */
    type: "execResponse";
    /** The result of the command execution, if successful. */
    result?: string;
    /** An error message, if the execution failed. */
    error?: string;
};
/**
 * Bridge → CLI: Acknowledgement that the bridge is stopping.
 */
export type StopResponse = {
    /** The message type discriminator. */
    type: "stopResponse";
    /** Whether the bridge stopped successfully. */
    success: boolean;
};
/**
 * All messages that the bridge sends to the CLI.
 */
export type CliResponse = SessionsResponse | CommandsResponse | ExecResponse | StopResponse;
/**
 * Browser → Bridge: Register a new session.
 */
export type RegisterRequest = {
    /** The message type discriminator. */
    type: "register";
    /** The display name for this session. */
    name: string;
};
/**
 * Browser → Bridge: Response to a listCommands request from the bridge.
 */
export type CommandListResponse = {
    /** The message type discriminator. */
    type: "commandListResponse";
    /** The identifier of the original request. */
    requestId: string;
    /** The list of registered commands. */
    commands: CommandInfo[];
};
/**
 * Browser → Bridge: Response to an execCommand request from the bridge.
 */
export type CommandResponse = {
    /** The message type discriminator. */
    type: "commandResponse";
    /** The identifier of the original request. */
    requestId: string;
    /** The result of the command execution, if successful. */
    result?: string;
    /** An error message, if the execution failed. */
    error?: string;
};
/**
 * Browser → Bridge: Response to a getInfo request from the bridge.
 */
export type InfoResponse = {
    /** The message type discriminator. */
    type: "infoResponse";
    /** The identifier of the original request. */
    requestId: string;
    /** The current display name of the session. */
    name: string;
};
/**
 * All messages that the browser sends to the bridge.
 */
export type BrowserRequest = RegisterRequest | CommandListResponse | CommandResponse | InfoResponse;
/**
 * Bridge → Browser: Request the list of registered commands.
 */
export type ListCommandsRequest = {
    /** The message type discriminator. */
    type: "listCommands";
    /** A unique identifier for this request. */
    requestId: string;
};
/**
 * Bridge → Browser: Request execution of a command.
 */
export type ExecCommandRequest = {
    /** The message type discriminator. */
    type: "execCommand";
    /** A unique identifier for this request. */
    requestId: string;
    /** The identifier of the command to execute. */
    commandId: string;
    /** Key-value pairs of arguments for the command. */
    args: Record<string, string>;
};
/**
 * Bridge → Browser: Request current session information.
 */
export type GetInfoRequest = {
    /** The message type discriminator. */
    type: "getInfo";
    /** A unique identifier for this request. */
    requestId: string;
};
/**
 * All messages that the bridge sends to the browser.
 */
export type BrowserResponse = ListCommandsRequest | ExecCommandRequest | GetInfoRequest;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/cli/bridgeService" {
import { ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
import { ICliConnectionStatus } from "@babylonjs/node-particle-editor/modularTool/services/cli/bridgeConnectionStatus";
import { IBridgeCommandRegistry } from "@babylonjs/node-particle-editor/modularTool/services/cli/bridgeCommandRegistry";
/**
 * Options for the CLI bridge service.
 * @experimental
 * @internal
 */
export type BridgeServiceOptions = {
    /**
     * The WebSocket port for the bridge's browser port.
     */
    port: number;
    /**
     * The session display name sent to the bridge.
     * Can be a getter to provide a dynamic value that is re-read
     * each time the bridge queries session information.
     */
    name: string;
    /**
     * Whether to automatically enable connecting when the service is created.
     */
    autoEnable: boolean;
};
/**
 * Creates the service definition for the CLI Bridge Service.
 * @param options The options for connecting to the bridge.
 * @returns A service definition that produces an IBridgeCommandRegistry and ICliConnectionStatus.
 * @experimental
 * @internal
 */
export function MakeBridgeServiceDefinition(options: BridgeServiceOptions): ServiceDefinition<[IBridgeCommandRegistry, ICliConnectionStatus], []>;

}
declare module "@babylonjs/node-particle-editor/modularTool/services/cli/bridgeConnectionStatus" {
import { IReadonlyObservable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
/**
 * The service identity for the CLI connection status.
 * @experimental
 * @internal
 */
export const CliConnectionStatusIdentity: unique symbol;
/**
 * Provides the connection status and enable/disable control for the CLI bridge.
 * @experimental
 * @internal
 */
export interface ICliConnectionStatus extends IService<typeof CliConnectionStatusIdentity> {
    /**
     * Whether the bridge is enabled. When true, the bridge actively tries to
     * maintain a WebSocket connection. When false, the bridge is disconnected
     * and idle.
     */
    isEnabled: boolean;
    /**
     * Whether the bridge WebSocket is currently connected.
     */
    readonly isConnected: boolean;
    /**
     * Observable that fires when either {@link isEnabled} or {@link isConnected} changes.
     */
    readonly onConnectionStatusChanged: IReadonlyObservable<void>;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/services/cli/bridgeCommandRegistry" {
import { IDisposable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
/**
 * The type of a bridge command argument, which determines how
 * the CLI processes the value before sending it to the browser.
 * @experimental
 * @internal
 */
export type BridgeCommandArgType = "string" | "file";
/**
 * Describes an argument for a bridge command.
 * @experimental
 * @internal
 */
export type BridgeCommandArg = {
    /**
     * The name of the argument.
     */
    name: string;
    /**
     * A description of the argument.
     */
    description: string;
    /**
     * Whether the argument is required.
     */
    required?: boolean;
    /**
     * The type of the argument. Defaults to "string".
     * When set to "file", the CLI reads the file at the given path
     * and passes its contents as the argument value.
     */
    type?: BridgeCommandArgType;
};
/**
 * Describes a command that can be invoked from the bridge.
 * @experimental
 * @internal
 */
export type BridgeCommandDescriptor = {
    /**
     * A unique identifier for the command.
     */
    id: string;
    /**
     * A human-readable description of what the command does.
     */
    description: string;
    /**
     * The arguments that this command accepts.
     */
    args?: BridgeCommandArg[];
    /**
     * Executes the command with the given arguments and returns a result string.
     * @param args A map of argument names to their values.
     * @returns A promise that resolves to the result string.
     */
    executeAsync: (args: Record<string, string>) => Promise<string>;
};
/**
 * The service identity for the bridge command registry.
 * @experimental
 * @internal
 */
export const BridgeCommandRegistryIdentity: unique symbol;
/**
 * A registry for commands that can be invoked from the bridge.
 * @experimental
 * @internal
 */
export interface IBridgeCommandRegistry extends IService<typeof BridgeCommandRegistryIdentity> {
    /**
     * Registers a command that can be invoked from the bridge.
     * @param descriptor The command descriptor.
     * @returns A disposable token that unregisters the command when disposed.
     */
    addCommand(descriptor: BridgeCommandDescriptor): IDisposable;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition" {
import { IDisposable } from "@babylonjs/core/index";
/**
 * A helper to create a service factory function from a class constructor.
 * @param constructor The class to create a factory function for.
 * @returns A factory function that creates an instance of the class.
 */
export function ConstructorFactory<Class extends new (...args: any) => any>(constructor: Class): (...args: ConstructorParameters<Class>) => InstanceType<Class>;
const Contract: unique symbol;
/**
 * This interface must be implemented by all service contracts.
 */
export interface IService<ContractIdentity extends symbol> {
    /**
     * @internal
     */
    readonly [Contract]?: ContractIdentity;
}
type ExtractContractIdentity<ServiceContract extends IService<symbol>> = ServiceContract extends IService<infer ContractIdentity> ? ContractIdentity : never;
type ExtractContractIdentities<ServiceContracts extends IService<symbol>[]> = {
    [Index in keyof ServiceContracts]: ExtractContractIdentity<ServiceContracts[Index]>;
};
type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
/**
 * A factory function responsible for creating a service instance.
 * Consumed services are passed as arguments to the factory function.
 * The returned value must implement all produced services, and may implement IDisposable.
 * If no services are produced, the returned value may implement IDisposable, otherwise it may return void.
 */
export type ServiceFactory<Produces extends IService<symbol>[], Consumes extends IService<symbol>[]> = (...dependencies: [...Consumes]) => Produces extends [] ? Partial<IDisposable> | void : Partial<IDisposable> & UnionToIntersection<Produces[number]>;
/**
 * Defines a service, which is a logical unit that consumes other services (dependencies), and optionally produces services that can be consumed by other services (dependents).
 */
export type ServiceDefinition<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []> = {
    /**
     * A human readable name for the service to help with debugging.
     */
    friendlyName: string;
    /**
     * A function that instantiates the service.
     */
    factory: ServiceFactory<Produces, Consumes>;
} & (Produces extends [] ? {
    /**
     * An empty list or undefined, since the type specification has indicated no contracts are produced.
     */
    produces?: [];
} : {
    /**
     * The list of contract identities that this service produces for consumption by other services.
     */
    produces: ExtractContractIdentities<Produces>;
}) & (Consumes extends [] ? {
    /**
     * An empty list or undefined, since the type specification has indicated that no other services are consumed.
     */
    consumes?: [];
} : {
    /**
     * The list of contract identities of other services that this service consumes.
     */
    consumes: ExtractContractIdentities<Consumes>;
});
export {};

}
declare module "@babylonjs/node-particle-editor/modularTool/modularity/serviceContainer" {
import { IDisposable } from "@babylonjs/core/index";
import { IService, ServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceDefinition";
export type WeaklyTypedServiceDefinition = Omit<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>, "factory"> & {
    /**
     * A factory function responsible for creating a service instance.
     */
    factory: (...args: any) => ReturnType<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>["factory"]>;
};
/**
 * A service container manages the lifetimes of a set of services.
 * It takes care of instantiating the services in the correct order based on their dependencies,
 * passing dependencies through to services, and disposing of services when the container is disposed.
 */
export class ServiceContainer implements IDisposable {
    private readonly _friendlyName;
    private readonly _parent?;
    private _isDisposed;
    private readonly _serviceDefinitions;
    private readonly _serviceDependents;
    private readonly _serviceInstances;
    private readonly _children;
    /**
     * Creates a new ServiceContainer.
     * @param _friendlyName A human-readable name for debugging.
     * @param _parent An optional parent container. Dependencies not found locally will be resolved from the parent.
     */
    constructor(_friendlyName: string, _parent?: ServiceContainer | undefined);
    /**
     * Adds a set of service definitions to the service container.
     * The services are sorted based on their dependencies.
     * @param serviceDefinitions The service definitions to register.
     * @returns A disposable that will remove the service definitions from the service container.
     */
    addServices(...serviceDefinitions: WeaklyTypedServiceDefinition[]): IDisposable;
    /**
     * Registers a service definition in the service container.
     * @param serviceDefinition The service definition to register.
     * @returns A disposable that will remove the service definition from the service container.
     */
    addService<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []>(serviceDefinition: ServiceDefinition<Produces, Consumes>): IDisposable;
    private _addService;
    /**
     * Resolves a dependency by contract identity for a consuming service.
     * Checks local services first, then walks up the parent chain.
     * Registers the consumer as a dependent in whichever container owns the dependency.
     * @param contract The contract identity to resolve.
     * @param consumer The service definition that consumes this dependency.
     * @returns The resolved service instance.
     */
    private _resolveDependency;
    /**
     * Removes a consumer from the dependent set for a given contract, checking locally first then the parent chain.
     * @param contract The contract identity.
     * @param consumer The service definition to remove as a dependent.
     */
    private _removeDependentFromChain;
    private _removeService;
    /**
     * Disposes the service container and all contained services.
     * Throws if this container is still a parent of any live child containers.
     */
    dispose(): void;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/misc/observableCollection" {
import { IDisposable, IReadonlyObservable } from "@babylonjs/core/index";
/**
 * A read-only view of a collection whose changes can be observed.
 */
export interface IReadonlyObservableCollection<T> {
    /**
     * An observable that notifies observers when the collection changes.
     */
    readonly observable: IReadonlyObservable<void>;
    /**
     * The items in the collection.
     */
    readonly items: readonly T[];
}
/**
 * A collection of items that can be observed for changes.
 */
export class ObservableCollection<T> implements IReadonlyObservableCollection<T>, IDisposable {
    private readonly _items;
    private readonly _keys;
    private readonly _observable;
    private _isDisposed;
    /**
     * An observable that notifies observers when the collection changes.
     */
    get observable(): IReadonlyObservable<void>;
    /**
     * The items in the collection.
     */
    get items(): readonly T[];
    /**
     * Adds an item to the collection.
     * @param item The item to add.
     * @returns A disposable that removes the item from the collection when disposed.
     */
    add(item: T): IDisposable;
    /**
     * Removes all items and observers and rejects subsequent additions.
     */
    dispose(): void;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/misc/graphUtils" {
/**
 * Performs a topological sort on a graph.
 * @param graph The set of nodes that make up the graph.
 * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
 * @param onSortedNode A function that is called for each node in the sorted order.
 * @remarks
 * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
 */
export function SortGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
/**
 * Traverses a graph.
 * @param graph The set of nodes that make up the graph.
 * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
 * @param onBeforeTraverse A function that is called before traversing each node.
 * @param onAfterTraverse A function that is called after traversing each node.
 * @remarks
 * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
 */
export function TraverseGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
/**
 * A utility class for performing graph operations.
 * @remarks
 * The class allocates new objects, but each operation (e.g. sort, traverse) is allocation free. This is useful when used in the hot path.
 */
export class GraphUtils<DefaultNodeT = unknown> {
    private readonly _traversalState;
    private _isTraversing;
    /**
     * Performs a topological sort on a graph.
     * @param graph The set of nodes that make up the graph.
     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
     * @param onSortedNode A function that is called for each node in the sorted order.
     */
    sort<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
    /**
     * Traverses a graph.
     * @param graph The set of nodes that make up the graph.
     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
     * @param onBeforeTraverse A function that is called before traversing each node.
     * @param onAfterTraverse A function that is called after traversing each node.
     */
    traverse<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
    private _traverseCore;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/misc/assert" {
/**
 * Asserts that the given value is truthy.
 * @param value The value to check.
 */
export function Assert(value: unknown): asserts value;

}
declare module "@babylonjs/node-particle-editor/modularTool/hooks/themeHooks" {
import { ThemeMode } from "@babylonjs/node-particle-editor/modularTool/services/themeService";
/**
 * Hook that provides the current theme mode state and controls for changing it.
 * @returns An object with the current dark mode state, theme mode, and functions to set or toggle the theme.
 */
export function useThemeMode(): {
    readonly isDarkMode: boolean;
    readonly themeMode: ThemeMode;
    readonly setThemeMode: (mode: ThemeMode) => void;
    readonly toggleThemeMode: () => void | undefined;
};
/**
 * Hook that returns the current Fluent UI theme based on the active theme mode.
 * @param invert If true, inverts the theme (returns light theme in dark mode and vice versa). Defaults to false.
 * @returns The current Fluent UI theme object.
 */


}
declare module "@babylonjs/node-particle-editor/modularTool/hooks/teachingMomentHooks" {
import { Nullable } from "@babylonjs/core/index";

/**
 * Creates a hook for managing teaching moment state.
 * @param name The unique name of the teaching moment.
 * @returns A hook that returns the teaching moment state.
 */
export function MakeTeachingMoment(name: string): (suppress?: boolean) => {
    readonly shouldDisplay: boolean;
    readonly onDismissed: () => void;
    readonly reset: () => void;
};
/**
 * Creates a hook for managing teaching moment state for a dialog.
 * @param name The unique name of the teaching moment.
 * @returns A hook that returns the teaching moment state for a dialog.
 */
export function MakeDialogTeachingMoment(name: string): (suppress?: boolean) => {
    readonly shouldDisplay: boolean;
    readonly onOpenChange: (e: unknown, data: any) => void;
    readonly reset: () => void;
};
/**
 * Creates a hook for managing teaching moment state for a popover.
 * @param name The unique name of the teaching moment.
 * @returns A hook that returns the teaching moment state for a popover.
 */
export function MakePopoverTeachingMoment(name: string): (suppress?: boolean) => {
    readonly shouldDisplay: boolean;
    readonly positioningRef: import("react").Dispatch<import("react").SetStateAction<Nullable<any>>>;
    readonly targetRef: import("react").Dispatch<import("react").SetStateAction<Nullable<HTMLElement>>>;
    readonly onOpenChange: (e: unknown, data: any) => void;
    readonly reset: () => void;
};

}
declare module "@babylonjs/node-particle-editor/modularTool/hooks/settingsHooks" {
import { Dispatch, SetStateAction } from "react";
import { SettingDescriptor } from "@babylonjs/node-particle-editor/modularTool/services/settingsStore";
/**
 * Hook that reads and writes a setting from the settings store.
 * @param descriptor The setting descriptor that identifies the setting and its default value.
 * @returns A tuple of [currentValue, setValue, resetValue] similar to React's useState.
 */
export function useSetting<T>(descriptor: SettingDescriptor<T>): [T, Dispatch<SetStateAction<T>>, () => void];

}
declare module "@babylonjs/node-particle-editor/modularTool/hooks/resourceHooks" {
import { DependencyList } from "react";
import { IDisposable } from "@babylonjs/core/index";
/**
 * Custom hook to manage a resource with automatic disposal. The resource is created once initially, and recreated
 * if the factory function or any dependency changes. Whenever the resource is recreated, the previous instance is
 * disposed. The final instance is disposed when the component using this hook unmounts.
 * @param factory A function that creates the resource.
 * @param deps An optional dependency list. When any dependency changes, the resource is disposed and recreated.
 * @returns The created resource.
 */
export function useResource<T extends IDisposable | null | undefined>(factory: () => T, deps?: DependencyList): T;
/**
 * Custom hook to manage an asynchronous resource with automatic disposal. The resource is created once initially, and recreated
 * if the factory function or any dependency changes. Whenever the resource is recreated, the previous instance is
 * disposed. The final instance is disposed when the component using this hook unmounts.
 * @param factory A function that creates the resource.
 * @param deps An optional dependency list. When any dependency changes, the resource is disposed and recreated.
 * @returns The created resource.
 */
export function useAsyncResource<T extends IDisposable | null | undefined>(factory: (abortSignal: AbortSignal) => Promise<T>, deps?: DependencyList): T | undefined;

}
declare module "@babylonjs/node-particle-editor/modularTool/hooks/observableHooks" {
import { IReadonlyObservable } from "@babylonjs/core/index";
import { IReadonlyObservableCollection } from "@babylonjs/node-particle-editor/modularTool/misc/observableCollection";
/**
 * Returns the current value of the accessor and updates it when the specified event is fired on the specified element.
 * @param accessor A function that returns the current value.
 * @param element The element to listen for the event on.
 * @param eventNames The names of the events to listen for.
 * @returns The current value of the accessor.
 *  * @remarks If the accessor function is not idempotent (e.g. it returns a different array or object instance each time it is called),
 * then there is a good chance it should be wrapped in a `useCallback` to prevent unnecessary re-renders or re-render infinite loops.
 */
export function useEventfulState<T>(accessor: () => T, element: HTMLElement | null | undefined, ...eventNames: string[]): T;
/**
 * Returns the current value of the accessor and updates it when any of the specified observables change.
 * @param accessor A function that returns the current value.
 * @param observables The observables to listen for changes on.
 * @returns The current value of the accessor.
 * @remarks Prefer this hook when the source already exposes precise change observables. Pair it
 * with a polling observable only when a fixed refresh cadence is intentional; use the source
 * system's adapter hook when refresh policy is configurable elsewhere.
 *
 * If the accessor function is not idempotent (e.g. it returns a different array or object instance
 * each time it is called), then there is a good chance it should be wrapped in a `useCallback` to
 * prevent unnecessary re-renders or re-render infinite loops.
 */
export function useObservableState<T>(accessor: () => T, ...observables: Array<IReadonlyObservable | null | undefined>): T;
/**
 * Returns a copy of the items in the collection and updates it when the collection changes.
 * @param collection The collection to observe.
 * @returns A copy of the items in the collection.
 */
export function useObservableCollection<T>(collection: IReadonlyObservableCollection<T>): T[];
/**
 * Returns a copy of the items in the collection sorted by the order property and updates it when the collection changes.
 * @param collection The collection to observe.
 * @returns A copy of the items in the collection sorted by the order property.
 */
export function useOrderedObservableCollection<T extends Readonly<{
    order?: number;
}>>(collection: IReadonlyObservableCollection<T>): T[];

}
declare module "@babylonjs/node-particle-editor/modularTool/extensibility/extensionManager" {
import { IDisposable } from "@babylonjs/core/index";
import { ServiceContainer } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceContainer";
import { IExtensionFeed, ExtensionMetadata } from "@babylonjs/node-particle-editor/modularTool/extensibility/extensionFeed";
/**
 * Represents a loaded extension.
 */
export interface IExtension {
    /**
     * The metadata for the extension.
     */
    readonly metadata: ExtensionMetadata;
    /**
     * Whether the extension is currently being installed, uninstalled, enabled, or disabled.
     */
    readonly isStateChanging: boolean;
    /**
     * Whether the extension is enabled.
     */
    readonly isInstalled: boolean;
    /**
     * Installs the extension.
     */
    installAsync(): Promise<void>;
    /**
     * Uninstalls the extension.
     */
    uninstallAsync(): Promise<void>;
    /**
     * Adds a handler that is called when the state of the extension changes.
     * @param handler The handler to add.
     * @returns A disposable that removes the handler when disposed.
     */
    addStateChangedHandler(handler: () => void): IDisposable;
}
/**
 * Provides information about an extension installation failure.
 */
export type InstallFailedInfo = {
    /**
     * The metadata of the extension that failed to install.
     */
    extension: ExtensionMetadata;
    /**
     * The error that occurred during the installation.
     */
    error: unknown;
};
/**
 * Represents a query for loaded extensions.
 */
export interface IExtensionQuery {
    /**
     * The total number of extensions that satisfy the query.
     */
    readonly totalCount: number;
    /**
     * Fetches a range of extensions from the query.
     * @param index The index of the first extension to fetch.
     * @param count The number of extensions to fetch.
     * @returns A promise that resolves to the extensions.
     */
    getExtensionsAsync(index: number, count: number): Promise<IExtension[]>;
}
/**
 * Manages the installation, uninstallation, enabling, and disabling of extensions.
 */
export class ExtensionManager implements IDisposable {
    private readonly _namespace;
    private readonly _serviceContainer;
    private readonly _feeds;
    private readonly _onInstallFailed;
    private readonly _installedExtensions;
    private readonly _stateChangedHandlers;
    private constructor();
    /**
     * Creates a new instance of the ExtensionManager.
     * This will automatically rehydrate previously installed and enabled extensions.
     * @param namespace The namespace to use for storing extension state in local storage.
     * @param serviceContainer The service container to use.
     * @param feeds The extension feeds to include.
     * @param onInstallFailed A callback that is called when an extension installation fails.
     * @returns A promise that resolves to the new instance of the ExtensionManager.
     */
    static CreateAsync(namespace: string, serviceContainer: ServiceContainer, feeds: readonly IExtensionFeed[], onInstallFailed: (info: InstallFailedInfo) => void): Promise<ExtensionManager>;
    /**
     * Gets the names of the feeds that are included in the extension manager.
     * @returns The names of the feeds.
     */
    get feedNames(): string[];
    /**
     * Queries the extension manager for extensions.
     * @param filter The filter to apply to the query.
     * @param feeds The feeds to include in the query.
     * @param installedOnly Whether to only include installed extensions.
     * @returns A promise that resolves to the extension query.
     */
    queryExtensionsAsync(filter?: string, feeds?: string[], installedOnly?: boolean): Promise<IExtensionQuery>;
    /**
     * Disposes the extension manager.
     */
    dispose(): void;
    private _getInstalledExtensionStorageKey;
    private _updateInstalledExtensionsStorage;
    private _installAsync;
    private _uninstallAsync;
    private _enableAsync;
    private _disableAsync;
    private _addStateChangedHandler;
    private _createExtension;
    private _createInstalledExtension;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/extensibility/extensionFeed" {
import { WeaklyTypedServiceDefinition } from "@babylonjs/node-particle-editor/modularTool/modularity/serviceContainer";
export type PersonMetadata = {
    /**
     * The name of the person.
     */
    readonly name: string;
    /**
     * The email address of the person.
     */
    readonly email?: string;
    /**
     * The URL to the person's website.
     */
    readonly url?: string;
    /**
     * The Babylon forum username of the person.
     */
    readonly forumUserName?: string;
    /**
     * A base64 encoded PNG image to use as the person's avatar.
     */
    readonly avatar?: string;
};
export type ExtensionMetadata = {
    /**
     * The name of the extension.
     */
    readonly name: string;
    /**
     * The version of the extension (as valid semver).
     */
    readonly version?: string;
    /**
     * The description of the extension.
     */
    readonly description: string;
    /**
     * The keywords of the extension.
     */
    readonly keywords?: readonly string[];
    /**
     * The URL to the extension homepage.
     */
    readonly homepage?: string;
    /**
     * Specify the place where your code lives. This is helpful for people who want to contribute.
     */
    readonly repository?: string;
    /**
     * The URL to your extension's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your extension.
     */
    readonly bugs?: string;
    /**
     * A license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.
     */
    readonly license?: string;
    /**
     * The primary author of the extension.
     */
    readonly author?: string | PersonMetadata;
    /**
     * The contributors to the extension.
     */
    readonly contributors?: readonly (string | PersonMetadata)[];
};
export type ExtensionModule = {
    /**
     * The default export of the module (e.g. export default).
     */
    default: {
        /**
         * The services that are included with the extension.
         */
        serviceDefinitions?: readonly WeaklyTypedServiceDefinition[];
    };
};
/**
 * Represents a query to fetch subset ranges of extension metadata from a feed.
 */
export interface IExtensionMetadataQuery {
    /**
     * The total number of extensions that satisfy the query.
     */
    readonly totalCount: number;
    /**
     * Fetches a range of extension metadata from the feed.
     * @param index The index of the first extension to fetch.
     * @param count The number of extensions to fetch.
     * @returns A promise that resolves to the extension metadata.
     */
    getExtensionMetadataAsync(index: number, count: number): Promise<readonly ExtensionMetadata[]>;
}
/**
 * Represents a feed/source of extensions.
 */
export interface IExtensionFeed {
    /**
     * The name of the feed.
     */
    readonly name: string;
    /**
     * Creates an extension metadata query given a filter.
     * @param filter The filter to apply to the query.
     * @returns A promise that resolves to the extension metadata query.
     */
    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;
    /**
     * Gets the extension module for the specified extension.
     * @param name The name of the extension.
     * @returns A promise that resolves to the extension module.
     */
    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/extensibility/builtInsExtensionFeed" {
import { IExtensionFeed, ExtensionMetadata, IExtensionMetadataQuery, ExtensionModule } from "@babylonjs/node-particle-editor/modularTool/extensibility/extensionFeed";
export type BuiltInExtension = ExtensionMetadata & {
    /**
     * Gets the extension module, typically dynamically importing the extension.
     * @returns The extension module (e.g. a collection of ServiceDefinitions).
     */
    getExtensionModuleAsync(): Promise<ExtensionModule>;
};
/**
 * A simple extension feed implementation that provides a fixed set of "built in" extensions.
 * "Built in" in this context means extensions that are known at bundling time, and included
 * in the bundle. Each extension can be dynamically imported so they are split into separate
 * bundle chunks and downloaded only when first installed.
 */
export class BuiltInsExtensionFeed implements IExtensionFeed {
    readonly name: string;
    private readonly _extensions;
    constructor(name: string, extensions: Iterable<BuiltInExtension>);
    queryExtensionsAsync(filter?: string): Promise<IExtensionMetadataQuery>;
    getExtensionModuleAsync(name: string): Promise<ExtensionModule | undefined>;
}

}
declare module "@babylonjs/node-particle-editor/modularTool/contexts/teachingMomentsContext" {
type TeachingMomentsContext = {
    /**
     * When true, all teaching moments are suppressed regardless of any caller-supplied
     * `suppress` argument and regardless of whether the user has previously dismissed
     * the teaching moment.
     */
    disabled: boolean;
};
export const TeachingMomentsContext: import("react").Context<TeachingMomentsContext>;
/**
 * Returns the teaching moments context provided by the surrounding modular tool framework.
 * @returns The current teaching moments context.
 */
export function useTeachingMomentsContext(): TeachingMomentsContext;
export {};

}
declare module "@babylonjs/node-particle-editor/modularTool/contexts/settingsContext" {
import { ISettingsStore } from "@babylonjs/node-particle-editor/modularTool/services/settingsStore";
export const SettingsStoreContext: import("react").Context<ISettingsStore | undefined>;
export function useSettingsStore(): ISettingsStore | undefined;

}
declare module "@babylonjs/node-particle-editor/modularTool/contexts/extensionManagerContext" {
import { ExtensionManager } from "@babylonjs/node-particle-editor/modularTool/extensibility/extensionManager";
export type ExtensionManagerContext = {
    readonly extensionManager: ExtensionManager;
};
export const ExtensionManagerContext: import("react").Context<ExtensionManagerContext | undefined>;
export function useExtensionManager(): ExtensionManager | undefined;

}
declare module "@babylonjs/node-particle-editor/modularTool/contexts/dialogContext" {
import { DialogOptions } from "@babylonjs/node-particle-editor/modularTool/services/dialogService";
type DialogContext = {
    showDialog: (options: DialogOptions) => void;
};
export const DialogContext: import("react").Context<DialogContext>;
/**
 * Returns the showDialog function provided by the surrounding modular tool framework.
 * If called outside of a DialogContext provider, falls back to the default context
 * value, whose showDialog implementation invokes the browser's blocking `alert` with
 * the dialog title.
 * @returns A function that displays a dialog when called.
 */
export function useDialog(): DialogContext;
export {};

}
declare module "@babylonjs/node-particle-editor/modularTool/components/uxContextProvider" {
import { FunctionComponent, PropsWithChildren } from "react";
export const UXContextProvider: FunctionComponent<PropsWithChildren>;

}
declare module "@babylonjs/node-particle-editor/modularTool/components/theme" {

import { FunctionComponent } from "react";
/**
 * A themed Fluent UI provider that applies the current theme mode (light or dark).
 * @param props Fluent provider props, plus an optional `invert` flag to swap the theme.
 *              When `targetDocument` is provided and differs from the inherited Fluent
 *              document (e.g. when rendering into a popup window), a Griffel renderer
 *              scoped to that document is created so styles are injected into it.
 *              When omitted, `targetDocument` is inherited from the ambient Fluent
 *              context so nested Theme components do not lose cross-window targeting.
 * @returns The themed Fluent UI provider component.
 */
export const Theme: FunctionComponent<any & {
    invert?: boolean;
}>;

}
declare module "@babylonjs/node-particle-editor/modularTool/components/teachingMoment" {
import { FunctionComponent } from "react";
import { MakePopoverTeachingMoment } from "@babylonjs/node-particle-editor/modularTool/hooks/teachingMomentHooks";
/**
 * The state returned by the teaching moment hook.
 */
type TeachingMomentState = ReturnType<ReturnType<typeof MakePopoverTeachingMoment>>;
/**
 * Props for the {@link TeachingMoment} component.
 */
type TeachingMomentProps = Pick<TeachingMomentState, "shouldDisplay" | "positioningRef" | "onOpenChange"> & {
    title: string;
    description: string;
};
/**
 * A component that displays a teaching moment popover.
 * @param props Props for the teaching moment popover.
 * @returns The teaching moment popover.
 */
export const TeachingMoment: FunctionComponent<TeachingMomentProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/modularTool/components/pane" {
/**
 * Used to apply common styles to panes.
 */
export const SidePaneContainer: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

}
declare module "@babylonjs/node-particle-editor/modularTool/components/extensibleAccordion" {
import { ComponentType, PropsWithChildren, Ref } from "react";
import { AccordionProps } from "@babylonjs/node-particle-editor/fluent/primitives/accordion";
/**
 * Describes a section within a dynamic accordion that can be added at runtime.
 */
export type DynamicAccordionSection = Readonly<{
    /**
     * A unique identity for the section, which can be referenced by section content.
     */
    identity: string;
    /**
     * An optional order for the section, relative to other sections.
     * Defaults to 0.
     */
    order?: number;
    /**
     * An optional flag indicating whether the section should be collapsed by default.
     * Defaults to false.
     */
    collapseByDefault?: boolean;
}>;
/**
 * Describes content that belongs to a section within a dynamic accordion.
 */
export type DynamicAccordionSectionContent<ContextT> = Readonly<{
    /**
     * A unique key for the the content.
     */
    key: string;
    /**
     * The section this content belongs to.
     */
    section: string;
    /**
     * An optional order for the content within the section.
     * Defaults to 0.
     */
    order?: number;
    /**
     * The React component that will be rendered for this content.
     */
    component: ComponentType<{
        context: ContextT;
    }>;
}>;
/**
 * Imperative handle for controlling section highlights on the extensible accordion.
 */
export type SectionsImperativeRef = {
    /**
     * Highlights the specified sections, collapsing all others until the context changes.
     * @param sections The identity strings of the sections to highlight.
     */
    highlightSections: (sections: readonly string[]) => void;
};
/**
 * An accordion component that supports dynamically adding sections and section content at runtime.
 * Combines statically defined children sections with dynamically registered sections and content.
 * @param props The accordion props including sections, section content, context, and an optional imperative ref.
 * @returns The extensible accordion component.
 */
export function ExtensibleAccordion<ContextT = unknown>(props: PropsWithChildren<{
    sections: readonly DynamicAccordionSection[];
    sectionContent: readonly DynamicAccordionSectionContent<ContextT>[];
    context: ContextT;
    sectionsRef?: Ref<SectionsImperativeRef>;
} & AccordionProps>): import("react").JSX.Element;

}
declare module "@babylonjs/node-particle-editor/modularTool/components/errorBoundary" {
import { ErrorInfo, ReactNode, Component } from "react";
/**
 * Props for the {@link ErrorBoundary} component.
 */
type ErrorBoundaryProps = {
    /** Child components to render */
    children: ReactNode;
    /** Optional fallback UI to show on error */
    fallback?: ReactNode;
    /** Optional callback when an error occurs */
    onError?: (error: Error, errorInfo: ErrorInfo) => void;
    /** Optional name for identifying this boundary in logs */
    name?: string;
};
type ErrorBoundaryState = {
    hasError: boolean;
    error: Error | null;
    errorInfo: ErrorInfo | null;
};
/**
 * Error boundary component that catches JavaScript errors in child components
 * and displays a fallback UI instead of crashing the entire application.
 */
export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
    constructor(props: ErrorBoundaryProps);
    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
    private _handleRetry;
    render(): string | number | boolean | Iterable<ReactNode> | import("react").JSX.Element | null | undefined;
}
export {};

}
declare module "@babylonjs/node-particle-editor/mcp/mcpEditorSessionConnection" {
/**
 * Options used to open an MCP editor session event stream.
 */
export interface IMcpEditorSessionEventSourceOptions {
    /** Base session URL, such as `http://localhost:3001/session/<id>`. */
    sessionUrl: string;
    /** Called whenever the server sends a document update. */
    onDocument: (document: unknown) => void;
    /** Called when the server explicitly closes the session. */
    onSessionClosed: (reason: string) => void;
    /** Called when the EventSource reports a connection error. */
    onConnectionError: () => void;
}
/**
 * Normalize a user-provided MCP editor session URL.
 * @param sessionUrl - The URL entered by the user or returned by an MCP tool.
 * @returns The URL without trailing slash characters.
 */
export function NormalizeMcpEditorSessionUrl(sessionUrl: string): string;
/**
 * Open an EventSource for server-to-editor MCP session updates.
 * @param options - Event stream options and callbacks.
 * @returns The opened EventSource. Call `CloseMcpEditorSessionEventSource` to disconnect it.
 */
export function OpenMcpEditorSessionEventSource(options: IMcpEditorSessionEventSourceOptions): EventSource;
/**
 * Close an MCP editor session EventSource if one is active.
 * @param eventSource - EventSource to close.
 */
export function CloseMcpEditorSessionEventSource(eventSource: EventSource | null | undefined): void;
/**
 * Post a document JSON payload to an MCP editor session.
 * @param sessionUrl - Base session URL, such as `http://localhost:3001/session/<id>`.
 * @param document - Serialized JSON document to send to the MCP server.
 * @param legacyDocumentRoute - Optional compatibility route to try when `/document` is unavailable.
 * @returns The final fetch response from the standard or compatibility route.
 */
export function PostMcpEditorSessionDocumentAsync(sessionUrl: string, document: string, legacyDocumentRoute?: string): Promise<Response>;

}
declare module "@babylonjs/node-particle-editor/lite/index" {
export * from "@babylonjs/node-particle-editor/lite/fluent/hoc/propertyLines/colorPropertyLine";
export * from "@babylonjs/node-particle-editor/lite/fluent/hoc/propertyLines/vectorPropertyLine";

}
declare module "@babylonjs/node-particle-editor/lite/fluent/hoc/propertyLines/vectorPropertyLine" {

import { FunctionComponent } from "react";
import { TensorPropertyLineProps as RuntimeNeutralTensorPropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/vectorPropertyLineCore";
export type Vector2Value = Vec2 | readonly [number, number];
export type Vector3Value = Vec3 | readonly [number, number, number];
export type Vector4Value = Vec4 | readonly [number, number, number, number];
export type QuaternionValue = Quat | readonly [number, number, number, number];
export type TensorPropertyLineProps<ValueT extends Vector2Value | Vector3Value | Vector4Value | QuaternionValue> = RuntimeNeutralTensorPropertyLineProps<ValueT>;
/**
 * Converts a Lite Euler value to a quaternion while preserving tuple versus structural representation.
 * @param value The Euler value in radians.
 * @param source The source quaternion whose representation should be preserved.
 * @returns The converted quaternion.
 */
export function CreateQuaternionFromEuler(value: Vector3Value, source: QuaternionValue): QuaternionValue;
type RotationVectorPropertyLineProps = TensorPropertyLineProps<Vector3Value> & {
    useDegrees?: boolean;
};
type QuaternionPropertyLineProps = TensorPropertyLineProps<QuaternionValue> & {
    useDegrees?: boolean;
    useEuler?: boolean;
};
export const Vector2PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector2Value>>;
export const Vector3PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector3Value>>;
export const Vector4PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector4Value>>;
export const RotationVectorPropertyLine: FunctionComponent<RotationVectorPropertyLineProps>;
export const QuaternionPropertyLine: FunctionComponent<QuaternionPropertyLineProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/lite/fluent/hoc/propertyLines/colorPropertyLine" {

import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { StructuralColorPickerProps } from "@babylonjs/node-particle-editor/fluent/primitives/structuralColorPicker";
export type Color3Value = Color3 | readonly [number, number, number];
export type Color4Value = Color4 | readonly [number, number, number, number];
export type ColorPickerProps<ValueT extends Color3Value | Color4Value> = Omit<StructuralColorPickerProps<ValueT>, "adapter">;
export type ColorPropertyLineProps<ValueT extends Color3Value | Color4Value> = ColorPickerProps<ValueT> & PropertyLineProps<ValueT>;
export const Color3PropertyLine: FunctionComponent<ColorPropertyLineProps<Color3Value>>;
export const Color4PropertyLine: FunctionComponent<ColorPropertyLineProps<Color4Value>>;

}
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;
    render(): React.JSX.Element;
}
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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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);
    render(): React.JSX.Element;
}
export {};

}
declare module "@babylonjs/node-particle-editor/lines/unitButton" {
interface IUnitButtonProps {
    unit: string;
    locked?: boolean;
    onClick?: (unit: string) => void;
}
export function UnitButton(props: IUnitButtonProps): import("react").JSX.Element;
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;
    render(): React.JSX.Element;
}
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;
    renderContent(isLink: boolean, tooltip: string): React.JSX.Element | null;
    renderOriginal(isLink: boolean, tooltip: string): React.JSX.Element;
    renderFluent(isLink: boolean, tooltip: string): React.JSX.Element;
    render(): React.JSX.Element;
}
export {};

}
declare module "@babylonjs/node-particle-editor/lines/textInputLineComponent" {
import { ReactNode, KeyboardEvent, 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;
    renderFluent(value: string, placeholder: string, step: number): import("react").JSX.Element;
    renderOriginal(value: string, placeholder: string, step: number): import("react").JSX.Element;
    render(): import("react").JSX.Element;
}

}
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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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: readonly 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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}
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);
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
export {};

}
declare module "@babylonjs/node-particle-editor/lines/matrixLineComponent" {
import * as React from "react";
import { Vector3, Vector4, 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;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
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;
    renderHeader(): React.JSX.Element;
    componentDidMount(): void;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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;
    renderContent(): React.JSX.Element;
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}
export {};

}
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;
    onCopyClick(): void;
    render(): React.JSX.Element;
}
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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}
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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
export {};

}
declare module "@babylonjs/node-particle-editor/lines/draggableLineWithButtonComponent" {
export type DraggableLineWithButtonProps = {
    format: string;
    data: string;
    tooltip: string;
    iconImage: any;
    onIconClick: (value: string) => void;
    iconTitle: string;
    lenSuffixToRemove?: number;
};
export const DraggableLineWithButtonComponent: React.FunctionComponent<DraggableLineWithButtonProps>;

}
declare module "@babylonjs/node-particle-editor/lines/draggableLineComponent" {
import { DraggableLineProps } from "@babylonjs/node-particle-editor/fluent/primitives/draggable";
type DraggableLineComponentProps = Omit<DraggableLineProps, "label">;
export const DraggableLineComponent: React.FunctionComponent<DraggableLineComponentProps>;
export {};

}
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;
    render(): React.JSX.Element;
}
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;
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}
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> {
    render(): React.JSX.Element;
}

}
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> {
    render(): React.JSX.Element;
}

}
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;
    renderOriginal(): React.JSX.Element;
    renderFluent(): React.JSX.Element;
    render(): React.JSX.Element;
}

}
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);
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}

}
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);
    renderFluent(): React.JSX.Element;
    renderOriginal(): React.JSX.Element;
    render(): React.JSX.Element;
}

}
declare module "@babylonjs/node-particle-editor/fluent/icons" {









}
declare module "@babylonjs/node-particle-editor/fluent/primitives/utils" {

import { KeyboardEvent, FocusEvent } from "react";
export const TokenMap: {
    px2: string;
    px4: string;
    px6: string;
    px8: string;
    px10: string;
    px12: string;
    px14: string;
    px16: string;
    px20: string;
    px24: string;
    px28: string;
    px32: string;
    px36: string;
    px40: string;
};
export const CustomTokens: {
    valueWidth: string;
    lineHeight: string;
    lineHeightSmall: string;
    dividerGap: string;
    dividerGapSmall: string;
    labelMinWidth: string;
    sliderMinWidth: string;
    sliderMaxWidth: string;
    rightAlignOffset: string;
};
export const UniformWidthStyling: any;
export const useInputStyles: () => Record<"invalid" | "container" | "inputSlot" | "inputFill", string>;
export function HandleOnBlur(event: FocusEvent<HTMLInputElement>): void;
export function HandleKeyDown(event: KeyboardEvent<HTMLInputElement>): void;
/**
 * Fluent's CalculatePrecision function
 * https://github.com/microsoft/fluentui/blob/dcbf775d37938eacffa37922fc0b43a3cdd5753f/packages/utilities/src/math.ts#L91C1
 *
 * Calculates a number's precision based on the number of trailing
 * zeros if the number does not have a decimal indicated by a negative
 * precision. Otherwise, it calculates the number of digits after
 * the decimal point indicated by a positive precision.
 *
 * @param value - the value to determine the precision of
 * @returns the calculated precision
 */
export function CalculatePrecision(value: number): number;
export function ValidateColorHex(val: string): boolean;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/uploadButton" {
import { FunctionComponent } from "react";
import { ButtonProps } from "@babylonjs/node-particle-editor/fluent/primitives/button";
type UploadButtonProps = Omit<ButtonProps, "onClick" | "icon"> & {
    /**
     * Callback when files are selected
     */
    onUpload: (files: FileList) => void;
    /**
     * File types to accept (e.g., ".jpg, .png, .dds")
     */
    accept?: string;
    /**
     * Text label to display on the button (optional)
     */
    label?: string;
};
/**
 * A button that triggers a file upload dialog.
 * Combines a Button with a hidden file input.
 * @param props UploadButtonProps
 * @returns UploadButton component
 */
export const UploadButton: FunctionComponent<UploadButtonProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/tooltip" {
import { Nullable } from "@babylonjs/core/index";
import { ReactElement } from "react";

/**
 * Props for the Tooltip primitive.
 */
export type TooltipProps = {
    /** The tooltip content. If null/empty, the tooltip is not rendered. */
    content?: Nullable<string | ReactElement>;
    /** Optional positioning passed through to the underlying FluentTooltip. */
    positioning?: any["positioning"];
    /** The element that the tooltip is attached to. */
    children: ReactElement;
};
export const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<HTMLElement>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/toggleButton" {

import { ButtonProps } from "@babylonjs/node-particle-editor/fluent/primitives/button";
import { FunctionComponent } from "react";

type ToggleButtonProps = Omit<ButtonProps, "icon" | "onClick"> & {
    /** The checked state supplied by the parent. */
    value: boolean;
    checkedIcon: any;
    uncheckedIcon?: any;
    /** Requests a new checked state. The parent must update value to accept the change. */
    onChange: (checked: boolean) => void;
    titlePositioning?: any["positioning"];
};
/**
 * Displays a controlled toggle button with icons.
 * The parent supplies the checked state through value; clicks request the opposite value through onChange.
 * If no uncheckedIcon is provided, the same icon is used for both states.
 *
 * @param props The controlled state, change callback, icons, and button presentation.
 * @returns The toggle button.
 */
export const ToggleButton: FunctionComponent<ToggleButtonProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/toast" {
import { FunctionComponent, PropsWithChildren, Ref } from "react";

/**
 * Options for showing a toast notification.
 */
export type ToastOptions = {
    /**
     * The intent of the toast notification. Defaults to "info".
     */
    intent?: any;
};
type ToastContextType = {
    showToast: (message: string, options?: ToastOptions) => void;
};
/**
 * Imperative handle exposed by {@link ToastProvider} via its `imperativeRef` prop.
 */
export type ToastHandle = {
    /**
     * Shows a toast notification with the given message.
     * @param message The message to display.
     * @param options Optional toast configuration.
     */
    showToast: (message: string, options?: ToastOptions) => void;
};
export type ToastProviderProps = PropsWithChildren<{
    /**
     * A ref that exposes the {@link ToastHandle} imperative API.
     */
    imperativeRef?: Ref<ToastHandle>;
}>;
/**
 * Provides toast notification functionality to child components via context and an optional imperative ref.
 * @returns The toast provider component tree.
 */
export const ToastProvider: FunctionComponent<ToastProviderProps>;
/**
 * Hook to show toast notifications.
 * @returns Object with showToast function that accepts a message string
 */
export function useToast(): ToastContextType;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/textureSelector" {
import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
import { Scene } from "@babylonjs/core/scene";
import { Nullable } from "@babylonjs/core/types";
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/entitySelector";
export type TextureSelectorProps = PrimitiveProps<Nullable<BaseTexture>> & {
    /**
     * The scene to get textures from
     */
    scene: Scene;
    /**
     * File types to accept for upload
     */
    accept?: string;
    /**
     * Whether to only allow cube textures
     */
    cubeOnly?: boolean;
} & Omit<EntitySelectorProps<BaseTexture>, "getEntities" | "getName">;
/**
 * A primitive component with a ComboBox for selecting from existing scene textures
 * and a button for uploading new texture files.
 * @param props TextureSelectorProps
 * @returns TextureSelector component
 */
export const TextureSelector: FunctionComponent<TextureSelectorProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/textarea" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type TextareaProps = PrimitiveProps<string> & {
    placeholder?: string;
};
/**
 * This is a texarea box that stops propagation of change/keydown events
 * @param props
 * @returns
 */
export const Textarea: FunctionComponent<TextareaProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/textInput" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type TextInputProps = PrimitiveProps<string> & {
    validator?: (value: string) => boolean;
    validateOnlyOnBlur?: boolean;
};
export const TextInput: FunctionComponent<TextInputProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/syncedSlider" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type SyncedSliderProps = PrimitiveProps<number> & {
    /** Minimum value for the slider */
    min?: number;
    /** Maximum value for the slider */
    max?: number;
    /** Step size for the slider */
    step?: number;
    /** Optional fixed precision (number of decimal digits). Overrides the automatically computed display precision. */
    precision?: number;
    /** Displayed in the ux to indicate unit of measurement */
    unit?: string;
    /** When true, onChange is only called when the user releases the slider, not during drag */
    notifyOnlyOnRelease?: boolean;
    /** When true, slider grows to fill space and SpinButton is fixed at 65px */
    compact?: boolean;
    /** When true, slider grows to fill all available space (no maxWidth constraint) */
    growSlider?: boolean;
};
/**
 * Component which synchronizes a slider and an input field, allowing the user to change the 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 { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type SwitchProps = PrimitiveProps<boolean> & {
    /**
     * Accessible name for switches whose visible label is rendered separately.
     */
    ariaLabel?: string;
    /**
     * When true, value controls the checked state without optimistic local updates. Defaults to false.
     */
    controlled?: 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/structuralColorPicker" {
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type StructuralColor = Readonly<{
    r: number;
    g: number;
    b: number;
    a?: number;
}>;
export type StructuralColorAdapter<ValueT> = Readonly<{
    getColor: (value: ValueT) => StructuralColor;
    createColor: (color: StructuralColor, source: ValueT) => ValueT;
}>;
export type StructuralColorPickerProps<ValueT> = PrimitiveProps<ValueT> & Readonly<{
    adapter: StructuralColorAdapter<ValueT>;
    isLinearMode?: boolean;
}>;
/**
 * Runtime-neutral color picker for structural RGB and RGBA values.
 * @param props The controlled value, adapter, color-space mode, and change callback.
 * @returns A color swatch that opens the Fluent color picker.
 */
export const StructuralColorPickerPopup: <ValueT>(props: StructuralColorPickerProps<ValueT>) => import("react").JSX.Element;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/spinButton" {
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type SpinButtonProps = PrimitiveProps<number> & {
    min?: number;
    max?: number;
    /** Determines how much the spinbutton increments with the arrow keys. Note this also determines the precision value (# of decimals in display value)
     * i.e. if step = 1, precision = 0. step = 0.0089, precision = 4. step = 300, precision = 2. step = 23.00, precision = 2. */
    step?: number;
    unit?: string;
    forceInt?: boolean;
    validator?: (value: number) => boolean;
    /** Optional fixed precision (number of decimal digits). Overrides the automatically computed display precision. */
    precision?: number;
    /** Optional className for the input element */
    inputClassName?: string;
    /** When true, hides the drag-to-scrub button */
    disableDragButton?: boolean;
};
/**
 * A numeric input with a vertical drag-to-scrub icon (ArrowsBidirectionalRegular rotated 90°).
 * Click-and-drag up/down on the icon to increment/decrement the value.
 */
export const SpinButton: import("react").ForwardRefExoticComponent<import("@babylonjs/node-particle-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: number;
    infoLabel?: import("@babylonjs/node-particle-editor/fluent/primitives/infoLabel").InfoLabelParentProps;
} & {
    onChange: (value: number) => void;
} & {
    min?: number;
    max?: number;
    /** Determines how much the spinbutton increments with the arrow keys. Note this also determines the precision value (# of decimals in display value)
     * i.e. if step = 1, precision = 0. step = 0.0089, precision = 4. step = 300, precision = 2. step = 23.00, precision = 2. */
    step?: number;
    unit?: string;
    forceInt?: boolean;
    validator?: (value: number) => boolean;
    /** Optional fixed precision (number of decimal digits). Overrides the automatically computed display precision. */
    precision?: number;
    /** Optional className for the input element */
    inputClassName?: string;
    /** When true, hides the drag-to-scrub button */
    disableDragButton?: boolean;
} & import("react").RefAttributes<HTMLInputElement>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/slider" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type SliderProps = PrimitiveProps<number> & {
    /** Minimum value for the slider */
    min?: number;
    /** Maximum value for the slider */
    max?: number;
    /** Step size for the slider */
    step?: number;
    /** When true, onChange is only called when the user releases the slider, not during drag */
    notifyOnlyOnRelease?: boolean;
    /** Optional pointer down handler */
    onPointerDown?: () => void;
    /** Optional pointer up handler */
    onPointerUp?: () => void;
};
/**
 * A slider primitive that wraps the Fluent UI Slider with step scaling, drag tracking, and optional notify-on-release behavior.
 * Follows the same pattern as other primitives (e.g. Switch) — no wrapper divs, just the Fluent component with logic.
 * @param props
 * @returns Slider component
 */
export const Slider: FunctionComponent<SliderProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/skeletonSelector" {
import { FunctionComponent } from "react";
import { Scene } from "@babylonjs/core/scene";
import { Nullable } from "@babylonjs/core/types";
import { Skeleton } from "@babylonjs/core/Bones/skeleton";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/entitySelector";
export type SkeletonSelectorProps = PrimitiveProps<Nullable<Skeleton>> & {
    /**
     * The scene to get skeletons from
     */
    scene: Scene;
    /**
     * Optional filter function to filter which skeletons are shown
     */
    filter?: (skeleton: Skeleton) => boolean;
} & Omit<EntitySelectorProps<Skeleton>, "getEntities" | "getName">;
/**
 * A primitive component with a ComboBox for selecting from existing scene skeletons.
 * @param props SkeletonSelectorProps
 * @returns SkeletonSelector component
 */
export const SkeletonSelector: FunctionComponent<SkeletonSelectorProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/searchBox" {
import { FunctionComponent } from "react";
type SearchBoxProps = {
    items: string[];
    onItemSelected: (item: string) => void;
    title?: string;
};
/**
 * SearchBox component that displays a popup with search functionality
 * @param props - The component props
 * @returns The search box component
 */
export const SearchBox: FunctionComponent<SearchBoxProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/searchBar" {
type SearchProps = {
    onChange: (val: string) => void;
    placeholder?: string;
};
export const SearchBar: import("react").ForwardRefExoticComponent<SearchProps & import("react").RefAttributes<HTMLInputElement>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/resourceSelector" {
/**
 * Runtime-neutral selection and navigation for an optionally linked resource.
 * The caller supplies stable IDs and only the mutation callbacks its runtime supports.
 */
export type ResourceSelectorProps<T> = {
    /** Currently linked resource, or null when unlinked. */
    value: T | null;
    /** Returns candidate resources for selection. */
    getEntities: () => readonly T[];
    /** Returns the resource's display name. */
    getName: (entity: T) => string;
    /** Returns a stable identity for each candidate, including duplicate display names. */
    getId: (entity: T) => string;
    /** Restricts the selectable candidates. */
    filter?: (entity: T) => boolean;
    /** Assigns a selected resource; receives null if an option became stale. */
    onSelect?: (entity: T | null) => void;
    /** Clears the current link, when supported. Takes precedence over the edit action. */
    onClear?: () => void;
    /** Navigates to the linked resource, when supported. */
    onLink?: (entity: T) => void;
    /** Disables link mutations and selection while an operation is pending. */
    disabled?: boolean;
    /** Accessible name when the visible label is supplied by a containing property line. */
    ariaLabel?: string;
    /** Keeps the Babylon entity selector visible even when its immutable value is empty. */
    showEmptySelector?: boolean;
};
/**
 * Displays a linked resource with one unlink-or-edit action, or a selector when unlinked.
 * @param props Resource identity, selection, navigation, and supported actions.
 * @returns The linked value or its replacement selector.
 */
export function ResourceSelector<T>(props: ResourceSelectorProps<T>): JSX.Element;
export namespace ResourceSelector {
    var displayName: string;
}

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/primitive" {
import { InfoLabelParentProps } from "@babylonjs/node-particle-editor/fluent/primitives/infoLabel";
export type BasePrimitiveProps = {
    /**
     * Optional flag to disable the component, preventing any interaction.
     */
    disabled?: boolean;
    /**
     * Optional class name to apply custom styles to the component.
     */
    className?: string;
    /**
     * Optional style object to apply custom inline styles to the top-level HTML element.
     */
    style?: React.CSSProperties;
    /**
     * Optional title for the component, used for tooltips or accessibility.
     */
    title?: string;
};
export type ImmutablePrimitiveProps<ValueT> = BasePrimitiveProps & {
    /**
     * The value of the property to be displayed and modified.
     */
    value: ValueT;
    /**
     * Optional information to display as an infoLabel popup aside the component.
     */
    infoLabel?: InfoLabelParentProps;
};
export type PrimitiveProps<T> = ImmutablePrimitiveProps<T> & {
    /**
     * Called when the primitive value changes
     */
    onChange: (value: T) => void;
};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/positionedPopover" {
import { FunctionComponent, PropsWithChildren } from "react";
type PositionedPopoverProps = {
    x: number;
    y: number;
    visible: boolean;
    hide: () => void;
};
/**
 * PositionedPopover component that shows a popover at specific coordinates
 * @param props - The component props
 * @returns The positioned popover component
 */
export const PositionedPopover: FunctionComponent<PropsWithChildren<PositionedPopoverProps>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/popover" {
import { PropsWithChildren, ReactElement } from "react";


type PopoverWithIconProps = {
    icon: any;
    trigger?: never;
};
type PopoverWithTriggerProps = {
    icon?: never;
    trigger: ReactElement;
};
type PopoverBaseProps = {
    /** Controlled open state */
    open?: boolean;
    /** Callback when open state changes */
    onOpenChange?: (open: boolean) => void;
    /** Positioning of the popover */
    positioning?: any;
    /** Custom class for the surface */
    surfaceClassName?: string;
};
type PopoverProps = PopoverBaseProps & (PopoverWithIconProps | PopoverWithTriggerProps);
export const Popover: import("react").ForwardRefExoticComponent<PropsWithChildren<PopoverProps> & import("react").RefAttributes<HTMLButtonElement>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/nodeSelector" {
import { FunctionComponent } from "react";
import { Scene } from "@babylonjs/core/scene";
import { Nullable } from "@babylonjs/core/types";
import { Node } from "@babylonjs/core/node";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/entitySelector";
export type NodeSelectorProps = PrimitiveProps<Nullable<Node>> & {
    /**
     * The scene to get nodes from
     */
    scene: Scene;
    /**
     * Optional filter function to filter which nodes are shown
     */
    filter?: (node: Node) => boolean;
} & Omit<EntitySelectorProps<Node>, "getEntities" | "getName">;
/**
 * A primitive component with a ComboBox for selecting from existing scene nodes.
 * @param props NodeSelectorProps
 * @returns NodeSelector component
 */
export const NodeSelector: FunctionComponent<NodeSelectorProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/messageBar" {
import { FunctionComponent } from "react";
type MessageBarProps = {
    message: string;
    title?: string;
    docLink?: string;
    intent: "info" | "success" | "warning" | "error";
    staticItem?: boolean;
};
export const MessageBar: FunctionComponent<MessageBarProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/materialSelector" {
import { FunctionComponent } from "react";
import { Scene } from "@babylonjs/core/scene";
import { Nullable } from "@babylonjs/core/types";
import { Material } from "@babylonjs/core/Materials/material";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/entitySelector";
export type MaterialSelectorProps = PrimitiveProps<Nullable<Material>> & {
    /**
     * The scene to get materials from
     */
    scene: Scene;
    /**
     * Optional filter function to filter which materials are shown
     */
    filter?: (material: Material) => boolean;
} & Omit<EntitySelectorProps<Material>, "getEntities" | "getName">;
/**
 * A primitive component with a ComboBox for selecting from existing scene materials.
 * @param props MaterialSelectorProps
 * @returns MaterialSelector component
 */
export const MaterialSelector: FunctionComponent<MaterialSelectorProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/list" {
import { ReactElement, ReactNode } from "react";
/**
 * Represents an item in a list
 */
export type ListItem<T> = {
    /** Unique identifier for the item */
    id: number;
    /** The data associated with the item */
    data: T;
    /** Value to use for sorting the list */
    sortBy: number;
};
type ListProps<T> = {
    items: ListItem<T>[];
    renderItem: (item: ListItem<T>, index: number) => ReactNode;
    onDelete?: (item: ListItem<T>, index: number) => void;
    onAdd?: (item?: ListItem<T>) => void;
    addButtonLabel?: string;
};
/**
 * For cases where you may want to add / remove items from a list via a trash can button / copy button, this HOC can be used
 * @returns A React component that renders a list of items with add/delete functionality
 * @param props - The properties for the List component
 */
export function List<T>(props: ListProps<T>): ReactElement;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/link" {
import { ImmutablePrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type LinkProps = ImmutablePrimitiveProps<string> & {
    /**
     * Used if you want to handle the link click yourself
     */
    onLink?: () => void;
    /**
     * The URL the link points to
     */
    url?: string;
    /**
     * Defines whether to open the link in current tab or new tab. Default is new
     */
    target?: "current" | "new";
    /**Force link size */
    size?: "small" | "medium";
};
export const Link: import("react").ForwardRefExoticComponent<import("@babylonjs/node-particle-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: string;
    infoLabel?: import("@babylonjs/node-particle-editor/fluent/primitives/infoLabel").InfoLabelParentProps;
} & {
    /**
     * Used if you want to handle the link click yourself
     */
    onLink?: () => void;
    /**
     * The URL the link points to
     */
    url?: string;
    /**
     * Defines whether to open the link in current tab or new tab. Default is new
     */
    target?: "current" | "new";
    /**Force link size */
    size?: "small" | "medium";
} & {
    children?: import("react").ReactNode | undefined;
} & import("react").RefAttributes<HTMLAnchorElement>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/lazyComponent" {

import { ComponentProps, ComponentType, ElementRef } from "react";
type LazyComponentProps = {
    spinnerSize?: any["size"];
    spinnerLabel?: string;
};
/**
 * Creates a lazy component wrapper that only calls the async function to get the underlying component when the lazy component is actually mounted.
 * This allows deferring imports until they are needed. While the underlying component is being loaded, a spinner is displayed.
 * @param getComponentAsync A function that returns a promise resolving to the component.
 * @param defaultProps Options for the loading spinner.
 * @returns A React component that displays a spinner while loading the async component.
 */

export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/infoLabel" {
import { FunctionComponent, MouseEventHandler } from "react";
export type InfoLabelProps = {
    htmlFor: string;
    info?: JSX.Element;
    label: string;
    className?: string;
    /**
     * When true, applies flex layout styling to the label slot for proper truncation in flex containers
     */
    flexLabel?: boolean;
    /**
     * Handler for right-click context menu. Also triggers on Ctrl+click.
     */
    onContextMenu?: MouseEventHandler;
};
export type InfoLabelParentProps = Omit<InfoLabelProps, "htmlFor">;
/**
 * Renders a label with an optional popup containing more info
 * @param props
 * @returns
 */
export const InfoLabel: FunctionComponent<InfoLabelProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/gradient" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { Color3Gradient, ColorGradient as Color4Gradient, FactorGradient } from "@babylonjs/core/Misc/gradients";
import { GradientBlockColorStep } from "@babylonjs/core/Materials/Node/Blocks/gradientBlock";
/**
 * Component wrapper for FactorGradient that provides slider inputs for factor1, factor2, and gradient step
 * @param props - Component props containing FactorGradient value and change handler
 * @returns A React component
 */
export const FactorGradientComponent: FunctionComponent<PrimitiveProps<FactorGradient>>;
/**
 * Component wrapper for Color3Gradient that provides color picker and gradient step slider
 * @param props - Component props containing Color3Gradient value and change handler
 * @returns A React component
 */
export const Color3GradientComponent: FunctionComponent<PrimitiveProps<Color3Gradient>>;
/**
 * Component wrapper for Color4Gradient that provides color pickers for color1, color2, and gradient step slider
 * @param props - Component props containing Color4Gradient value and change handler
 * @returns A React component
 */
export const Color4GradientComponent: FunctionComponent<PrimitiveProps<Color4Gradient>>;
/**
 * Component wrapper for GradientBlockColorStep that provides color picker and step slider
 * @param props - Component props containing GradientBlockColorStep value and change handler
 * @returns A React component
 */
export const ColorStepGradientComponent: FunctionComponent<PrimitiveProps<GradientBlockColorStep>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/entitySelector" {
import { Nullable } from "@babylonjs/core/types";
import { ImmutablePrimitiveProps, PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
type Entity = {
    uniqueId: number;
};
/**
 * Props for the EntitySelector component
 */
export type EntitySelectorProps<T extends Entity> = (PrimitiveProps<Nullable<T>> | ImmutablePrimitiveProps<Nullable<T>>) & {
    /**
     * Function to get the list of entities to choose from
     */
    getEntities: () => T[];
    /**
     * Function to get the display name from an entity
     */
    getName: (entity: T) => string;
    /**
     * Optional filter function to filter which entities are shown
     */
    filter?: (entity: T) => boolean;
    /**
     * Callback when the entity link is clicked
     */
    onLink: (entity: T) => void;
    /**
     * Optional default value that enables clearing the current linked entity
     */
    defaultValue?: Nullable<T>;
};
/**
 * A generic primitive component with a ComboBox for selecting from a list of entities.
 * Supports entities with duplicate names by using uniqueId for identity.
 * @param props ChooseEntityProps
 * @returns EntitySelector component
 */
export function EntitySelector<T extends Entity>(props: EntitySelectorProps<T>): JSX.Element;
export namespace EntitySelector {
    var displayName: string;
}
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/dropdown" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type AcceptedDropdownValue = string | number;
export type DropdownOption<T extends AcceptedDropdownValue> = {
    /**
     * Defines the visible part of the option
     */
    label: string;
    /**
     * Defines the value part of the option
     */
    value: T;
};
export type DropdownProps<V extends AcceptedDropdownValue> = PrimitiveProps<V> & {
    options: readonly DropdownOption<V>[];
};
/**
 * Renders a fluent UI dropdown component for the options passed in, and an additional 'Not Defined' option if null is set to true
 * This component can handle both null and undefined values
 * @param props
 * @returns dropdown component
 */
export const Dropdown: FunctionComponent<DropdownProps<AcceptedDropdownValue>>;
export const NumberDropdown: FunctionComponent<DropdownProps<number>>;
export const StringDropdown: FunctionComponent<DropdownProps<string>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/draggable" {
export type DraggableLineProps = {
    format: string;
    data: string;
    tooltip: string;
    label: string;
    onDelete?: () => void;
};
export const DraggableLine: React.FunctionComponent<DraggableLineProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/dialog" {
import { ReactNode, FC } from "react";
/**
 * Props for an action button in the dialog footer.
 */
export type DialogActionProps = {
    /** Button label text. */
    label: string;
    /** Click handler. */
    onClick: () => void;
    /** Button appearance. Defaults to "secondary". */
    appearance?: "primary" | "secondary";
};
/**
 * Props for the shared Dialog primitive.
 */
export type DialogProps = {
    /** Whether the dialog is open. */
    open: boolean;
    /** Dialog title. */
    title: string;
    /** Dialog content (body). */
    children: ReactNode;
    /** Action buttons rendered in the footer. */
    actions?: DialogActionProps[];
    /** Called when the dialog is dismissed via the close button. */
    onDismiss?: () => void;
};
/**
 * A shared dialog component wrapping Fluent UI Dialog with Babylon conventions.
 *
 * @example
 * ```tsx
 * <Dialog
 *     open={isOpen}
 *     title="Confirm Action"
 *     onDismiss={() => setIsOpen(false)}
 *     actions={[
 *         { label: "Cancel", onClick: () => setIsOpen(false) },
 *         { label: "Confirm", onClick: handleConfirm, appearance: "primary" },
 *     ]}
 * >
 *     <Text>Are you sure you want to proceed?</Text>
 * </Dialog>
 * ```
 *
 * @param props - The dialog props.
 * @returns The dialog element.
 */
export const Dialog: FC<DialogProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/contextMenu" {
import { ReactElement } from "react";


import { BasePrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
/**
 * Represents a single menu item in the context menu.
 */
export type ContextMenuItemProps = {
    /**
     * Unique key for the menu item.
     */
    key: string;
    /**
     * The text label displayed for the menu item.
     */
    label: string;
    /**
     * Optional icon to display alongside the menu item.
     */
    icon?: any;
    /**
     * Called when the menu item is clicked.
     */
    onClick?: () => void;
    /**
     * Whether the menu item is disabled.
     */
    disabled?: boolean;
    /**
     * Optional secondary text displayed alongside the label.
     */
    secondaryContent?: string;
};
/**
 * Represents a divider in the context menu.
 */
export type ContextMenuDividerProps = {
    /**
     * Unique key for the divider.
     */
    key: string;
    /**
     * Indicates this is a divider item.
     */
    type: "divider";
};
/**
 * Represents a group of menu items with an optional header.
 */
export type ContextMenuGroupProps = {
    /**
     * Unique key for the group.
     */
    key: string;
    /**
     * Indicates this is a group item.
     */
    type: "group";
    /**
     * Optional header text for the group.
     */
    header?: string;
    /**
     * The menu items within the group.
     */
    items: ContextMenuItem[];
};
/**
 * Union type representing all possible menu items.
 */
export type ContextMenuItem = ContextMenuItemProps | ContextMenuDividerProps | ContextMenuGroupProps;
type ContextMenuWithIconProps = {
    /**
     * Icon to use as the trigger button.
     */
    icon: any;
    trigger?: never;
};
type ContextMenuWithTriggerProps = {
    icon?: never;
    /**
     * Custom trigger element for opening the menu.
     */
    trigger: ReactElement;
};
export type ContextMenuProps = BasePrimitiveProps & (ContextMenuWithIconProps | ContextMenuWithTriggerProps) & {
    /**
     * Array of menu items to display.
     */
    items: ContextMenuItem[];
    /**
     * Positioning of the menu relative to the trigger.
     */
    positioning?: any["positioning"];
    /**
     * Called when the menu open state changes.
     */
    onOpenChange?: (open: boolean) => void;
};
/**
 * A wrapper around Fluent UI's Menu component providing a simplified API for context menus.
 * Supports menu items with icons, dividers, and grouped items.
 */
export const ContextMenu: import("react").ForwardRefExoticComponent<ContextMenuProps & import("react").RefAttributes<HTMLButtonElement>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/comboBox" {
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
/**
 * An option object for the ComboBox with separate label and value.
 */
export type ComboBoxOption = {
    /**
     * Defines the visible part of the option
     */
    label: string;
    /**
     * Defines the value part of the option
     */
    value: string;
};
export type ComboBoxProps = PrimitiveProps<string> & {
    /**
     * Label for the ComboBox
     */
    label: string;
    /**
     * Accessible name used when the visible label is supplied by a containing property line.
     */
    ariaLabel?: string;
    /**
     * Options to display as label/value pairs
     */
    options: ComboBoxOption[];
    /**
     * The default open state when open is uncontrolled
     */
    defaultOpen?: boolean;
};
/**
 * Wrapper around a Fluent ComboBox that allows for filtering options.
 * @param props
 * @returns
 */
export const ComboBox: import("react").ForwardRefExoticComponent<import("@babylonjs/node-particle-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: string;
    infoLabel?: import("@babylonjs/node-particle-editor/fluent/primitives/infoLabel").InfoLabelParentProps;
} & {
    onChange: (value: string) => void;
} & {
    /**
     * Label for the ComboBox
     */
    label: string;
    /**
     * Accessible name used when the visible label is supplied by a containing property line.
     */
    ariaLabel?: string;
    /**
     * Options to display as label/value pairs
     */
    options: ComboBoxOption[];
    /**
     * The default open state when open is uncontrolled
     */
    defaultOpen?: boolean;
} & import("react").RefAttributes<HTMLInputElement>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/colorPicker" {
import { FunctionComponent } from "react";
import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type ColorPickerProps<C extends Color3 | Color4> = {
    isLinearMode?: boolean;
} & PrimitiveProps<C>;
export const ColorPickerPopup: import("react").ForwardRefExoticComponent<{
    isLinearMode?: boolean;
} & import("@babylonjs/node-particle-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: Color3 | Color4;
    infoLabel?: import("@babylonjs/node-particle-editor/fluent/primitives/infoLabel").InfoLabelParentProps;
} & {
    onChange: (value: Color3 | Color4) => void;
} & import("react").RefAttributes<HTMLButtonElement>>;
export type InputHexProps = PrimitiveProps<Color3 | Color4> & {
    isLinear?: boolean;
    isPropertyLinear?: boolean;
};
/**
 * Component which displays the passed in color's HEX value in the currently selected color space.
 * When the hex color is changed by user, component calculates the new Color3/4 value and calls onChange.
 * @param props - The properties for the InputHexField component.
 * @returns
 */
export const InputHexField: FunctionComponent<InputHexProps>;
type HsvKey = "h" | "s" | "v";
type InputHsvFieldProps = PrimitiveProps<Color3 | Color4> & {
    hsvKey: HsvKey;
    isFloat: boolean;
};
/**
 * 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/collapse" {
import { FunctionComponent, PropsWithChildren } from "react";
type CollapseProps = {
    visible: boolean;
    orientation?: "horizontal" | "vertical";
};
/**
 * Wraps the passed in children with a fluent collapse component, handling smooth animation when visible prop changes
 * NOTE: When passing in children, prefer react fragment over empty div to avoid bloating the react tree with an unnecessary div
 * @param props
 * @returns
 */
export const Collapse: FunctionComponent<PropsWithChildren<CollapseProps>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/clusteredLightContainerSelector" {
import { FunctionComponent } from "react";
import { Scene } from "@babylonjs/core/scene";
import { Nullable } from "@babylonjs/core/types";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/entitySelector";
import { ClusteredLightContainer } from "@babylonjs/core/Lights/Clustered/clusteredLightContainer";
export type ClusteredLightContainerSelectorProps = PrimitiveProps<Nullable<ClusteredLightContainer>> & {
    /**
     * The scene to get clustered light containers from
     */
    scene: Scene;
    /**
     * Optional filter function to filter which clustered light containers are shown
     */
    filter?: (container: ClusteredLightContainer) => boolean;
} & Omit<EntitySelectorProps<ClusteredLightContainer>, "getEntities" | "getName">;
/**
 * A primitive component with a ComboBox for selecting from existing scene clustered light containers.
 * @param props ClusteredLightContainerSelectorProps
 * @returns ClusteredLightContainerSelector component
 */
export const ClusteredLightContainerSelector: FunctionComponent<ClusteredLightContainerSelectorProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/checkbox" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
/**
 * This is a primitive fluent checkbox that can both read and write checked state
 * @param props
 * @returns Checkbox component
 */
export const Checkbox: FunctionComponent<PrimitiveProps<boolean>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/button" {
import { MouseEvent } from "react";

import { BasePrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
export type ButtonProps = BasePrimitiveProps & {
    /** Callback invoked when the button is clicked. */
    onClick?: (e?: MouseEvent<HTMLButtonElement>) => unknown | Promise<unknown>;
    /** Optional icon rendered inside the button. */
    icon?: any;
    /** Fluent button appearance. */
    appearance?: "subtle" | "transparent" | "primary" | "secondary";
    /** Optional visible button label. */
    label?: string;
    /** Optional accessible label when the visible label is absent or insufficient. */
    ariaLabel?: string;
};
export const Button: import("react").ForwardRefExoticComponent<BasePrimitiveProps & {
    /** Callback invoked when the button is clicked. */
    onClick?: (e?: MouseEvent<HTMLButtonElement>) => unknown | Promise<unknown>;
    /** Optional icon rendered inside the button. */
    icon?: any;
    /** Fluent button appearance. */
    appearance?: "subtle" | "transparent" | "primary" | "secondary";
    /** Optional visible button label. */
    label?: string;
    /** Optional accessible label when the visible label is absent or insufficient. */
    ariaLabel?: string;
} & import("react").RefAttributes<HTMLButtonElement>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/accordion" {
import { ForwardRefExoticComponent, FunctionComponent, PropsWithChildren, RefAttributes } from "react";
/**
 * Props: `AccordionSectionBlock`.
 */
export type AccordionSectionBlockProps = {
    /** The ID of the `AccordionSectionBlock`, unique within the `Accordion` instance. */
    sectionId: string;
};
/**
 * Props: `AccordionSectionItem`.
 */
export type AccordionSectionItemProps = {
    /** The ID of the `AccordionSectionItem`, unique within the `AccordionSectionBlock` instance. */
    uniqueId: string;
    /** The searchable text label for the item. */
    label?: string;
    /** Whether the item is not interactable. */
    staticItem?: boolean;
};
/**
 * Wrapper component that must encapsulate individual items.
 * - Renders the pin button and tracks the pinned state of the item.
 * - Renders the hide button and tracks the hidden state of the item.
 * - Filters items based on the current search term.
 *
 * @param props - `AccordionSectionItemProps`
 * @returns `Portal` if pinned; `null` if hidden/filtered; `children` otherwise.
 */
export const AccordionSectionItem: FunctionComponent<PropsWithChildren<AccordionSectionItemProps>>;
/**
 * Props: `AccordionSection`.
 */
export type AccordionSectionProps = {
    /** The text label shown in the section header. */
    title: string;
    /** Indicates whether the `AccordionSection` is initially collapsed. */
    collapseByDefault?: boolean;
};
/**
 * Wrapper component that must encapsulate the section body.
 *
 * @param props - `AccordionSectionProps`
 * @returns `div`
 */
export const AccordionSection: FunctionComponent<PropsWithChildren<AccordionSectionProps>>;
/**
 * Props: `Accordion`.
 */
export type AccordionProps = {
    /** The unique ID of the `Accordion` instance. */
    uniqueId?: string;
    /** The list of sections to be highlighted. */
    highlightSections?: readonly string[];
    /** Enables the pinned items feature. */
    enablePinnedItems?: boolean;
    /** Enables the hidden items feature. */
    enableHiddenItems?: boolean;
    /** Enables the search items feature. */
    enableSearchItems?: boolean;
};
export const Accordion: ForwardRefExoticComponent<AccordionProps & {
    children?: import("react").ReactNode | undefined;
} & RefAttributes<HTMLDivElement>>;

}
declare module "@babylonjs/node-particle-editor/fluent/primitives/accordion.contexts" {
import { RefObject } from "react";
import { AccordionProps, AccordionSectionBlockProps, AccordionSectionItemProps } from "@babylonjs/node-particle-editor/fluent/primitives/accordion";
/**
 * Immutable state for the Accordion.
 */
export type AccordionState = {
    /** IDs of pinned items (persisted to localStorage). */
    pinnedIds: string[];
    /** IDs of hidden items (persisted to localStorage). */
    hiddenIds: string[];
    /** Current search/filter term. */
    searchTerm: string;
    /** Whether edit mode is active (shows pin/hide controls). */
    editMode: boolean;
};
/**
 * Actions that can be dispatched to update accordion state.
 */
export type AccordionAction = {
    type: "SET_SEARCH_TERM";
    term: string;
} | {
    type: "SET_EDIT_MODE";
    enabled: boolean;
} | {
    type: "TOGGLE_PINNED";
    itemId: string;
} | {
    type: "TOGGLE_HIDDEN";
    itemId: string;
} | {
    type: "MOVE_PINNED_UP";
    itemId: string;
} | {
    type: "REMOVE_STALE_IDS";
    activeIds: Set<string>;
} | {
    type: "SHOW_ALL";
} | {
    type: "HIDE_ALL_VISIBLE";
    visibleItemIds: string[];
};
/**
 * Feature flags for the Accordion (immutable after initialization).
 */
export type AccordionFeatures = {
    /** Whether pinning is enabled. */
    pinning: boolean;
    /** Whether hiding is enabled. */
    hiding: boolean;
    /** Whether search is enabled. */
    search: boolean;
};
/**
 * Context value for the Accordion component.
 */
export type AccordionContextValue = {
    /** The unique ID of the Accordion instance. */
    accordionId: string;
    /** State for the Accordion, managed via dispatch function. */
    state: AccordionState;
    /** Dispatch function to update state. */
    dispatch: React.Dispatch<AccordionAction>;
    /** Feature flags. */
    features: AccordionFeatures;
    /** Ref for the pinned items portal container. */
    pinnedContainerRef: RefObject<HTMLDivElement>;
    /** Map of registered item IDs to labels (for duplicate detection and section empty checks). */
    registeredItemIds: Map<string, string>;
};
export const AccordionContext: import("react").Context<AccordionContextValue | undefined>;
/**
 * Hook to create and manage the AccordionContext value.
 *
 * @param props - AccordionProps
 * @returns AccordionContextValue, or undefined if no features are enabled or no uniqueId is provided.
 */
export function useAccordionContext(props: AccordionProps): AccordionContextValue | undefined;
/**
 * Context value for an AccordionSectionBlock.
 */
export type AccordionSectionBlockContextValue = {
    /** The section ID. */
    sectionId: string;
};
export const AccordionSectionBlockContext: import("react").Context<AccordionSectionBlockContextValue | undefined>;
/**
 * Hook to create the AccordionSectionBlockContext value.
 *
 * @param props - AccordionSectionBlockProps
 * @returns AccordionSectionBlockContextValue and isEmpty state
 */
export function useAccordionSectionBlockContext(props: AccordionSectionBlockProps): {
    context: AccordionSectionBlockContextValue;
    isEmpty: boolean;
};
/**
 * Context to track whether we're inside an AccordionSectionItem.
 * Used to prevent nested items from being individually manageable.
 */
export const AccordionItemDepthContext: import("react").Context<boolean>;
/**
 * Derived item state, computed from the accordion state during render.
 */
export type AccordionItemState = {
    /** The globally unique item ID. */
    itemUniqueId: string;
    /** Whether this item is nested inside another AccordionSectionItem. */
    isNested: boolean;
    /** Whether this item is pinned. */
    isPinned: boolean;
    /** Whether this item is hidden. */
    isHidden: boolean;
    /** Whether this item matches the current search term. */
    isMatch: boolean;
    /** The index of this item in the pinned list (for ordering). */
    pinnedIndex: number;
    /** Whether this pinned item can be moved up (is not first in the pinned list). */
    canMoveUp: boolean;
    /** Whether edit mode is active. */
    inEditMode: boolean;
    /** Callbacks to modify state. */
    actions: {
        togglePinned: () => void;
        toggleHidden: () => void;
        movePinnedUp: () => void;
    };
};
/**
 * Hook to compute item state from accordion context.
 *
 * @param props - AccordionSectionItemProps
 * @returns AccordionItemState, or undefined if no accordion context or nested item.
 */
export function useAccordionSectionItemState(props: AccordionSectionItemProps): AccordionItemState | undefined;

}
declare module "@babylonjs/node-particle-editor/fluent/hooks/transientStateHooks" {
/**
 * A hook that provides a transient state value and a "pulse" function to set it.
 * The transient value is meant to be consumed immediately after being set, and will be cleared on the next render.
 * @typeParam T The type of the transient value.
 * @returns A tuple containing the transient value and a function to "pulse" the state.
 */
export function useImpulse<T>(): [T | undefined, (value: T) => void];

}
declare module "@babylonjs/node-particle-editor/fluent/hooks/keyboardHooks" {
import { WindowOptions } from "@babylonjs/node-particle-editor/fluent/hooks/eventHooks";
type KeyCallbacks = {
    onKeyDown?: (e: KeyboardEvent) => void;
    onKeyUp?: (e: KeyboardEvent) => void;
};
export function useKeyListener(callbacks: KeyCallbacks, options?: WindowOptions): void;
type KeyStateOptions = WindowOptions & {
    preventDefault?: boolean;
};
export function useKeyState(key: string, options?: KeyStateOptions): boolean;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hooks/eventHooks" {
export type WindowOptions = {
    current?: boolean;
    primary?: boolean;
};
export function useEventListener<EventT extends keyof DocumentEventMap>(source: "document", eventName: EventT, handler: (e: DocumentEventMap[EventT]) => void, options?: WindowOptions): void;
export function useEventListener<EventT extends keyof WindowEventMap>(source: "window", eventName: EventT, handler: (e: WindowEventMap[EventT]) => void, options?: WindowOptions): void;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/textureUpload" {
import { FunctionComponent } from "react";
import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
import { Scene } from "@babylonjs/core/scene";
type TextureUploadUpdateProps = {
    /**
     * Existing texture to update via updateURL
     */
    texture: BaseTexture;
    /**
     * Callback after texture is updated
     */
    onChange?: (texture: BaseTexture) => void;
    scene?: never;
    cubeOnly?: never;
};
type TextureUploadCreateProps = {
    /**
     * The scene to create the texture in
     */
    scene: Scene;
    /**
     * Callback when a new texture is created
     */
    onChange: (texture: BaseTexture) => void;
    /**
     * Whether to create cube textures
     */
    cubeOnly?: boolean;
    texture?: never;
};
type TextureUploadProps = TextureUploadUpdateProps | TextureUploadCreateProps;
/**
 * A button that uploads a file and either:
 * - Updates an existing Texture or CubeTexture via updateURL (if texture prop is provided)
 * - Creates a new Texture or CubeTexture (if scene/onChange props are provided)
 * @param props TextureUploadProps
 * @returns UploadButton component that handles texture upload
 */
export const TextureUpload: FunctionComponent<TextureUploadProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/popupWindow" {
/**
 * Options for opening a popup browser window via {@link OpenPopupWindow}.
 */
export type PopupWindowOptions = {
    /**
     * Title set on the popup document.
     */
    title?: string;
    /**
     * Default width of the popup in pixels.
     * @remarks Ignored if `id` is provided and a previously saved width exists.
     */
    defaultWidth?: number;
    /**
     * Default height of the popup in pixels.
     * @remarks Ignored if `id` is provided and a previously saved height exists.
     */
    defaultHeight?: number;
    /**
     * Default screen-X position of the popup in pixels.
     * @remarks Ignored if `id` is provided and a previously saved position exists.
     */
    defaultLeft?: number;
    /**
     * Default screen-Y position of the popup in pixels.
     * @remarks Ignored if `id` is provided and a previously saved position exists.
     */
    defaultTop?: number;
    /**
     * Optional unique identity. When provided, the popup's bounds are saved to and
     * restored from `localStorage` under the key `Babylon/Settings/PopupWindow/{id}/Bounds`.
     */
    id?: string;
    /**
     * Optional callback invoked when the popup is closed externally — e.g. the user dismisses
     * the popup, or the browser tab/window itself is unloaded. NOT called when the consumer
     * closes the popup via {@link PopupWindowHandle.dispose} (the consumer already knows about
     * that closure).
     */
    onClose?: () => void;
};
/**
 * Handle returned from {@link OpenPopupWindow}.
 */
export type PopupWindowHandle = {
    /**
     * The popup `Window` object. May become `closed` if the user dismisses the popup.
     */
    readonly popupWindow: Window;
    /**
     * A flex container element appended to the popup body. Render the tool into this element.
     */
    readonly hostElement: HTMLDivElement;
    /**
     * Closes the popup window and removes any listeners installed on the parent.
     * Safe to call multiple times.
     */
    dispose: () => void;
};
/**
 * Opens a new browser popup window suitable for hosting a Fluent-based modular tool.
 *
 * The popup body is configured for full-bleed flex layout and a host `<div>` is appended
 * for the tool to render into. Fluent style targeting (Griffel `RendererProvider`,
 * `FluentProvider` with `targetDocument`) is the caller's responsibility — typically wired
 * up by `MakeModularTool`, which derives `targetDocument` from `containerElement.ownerDocument`.
 *
 * **Must be called synchronously in response to a user interaction** (e.g. button click) —
 * otherwise the browser will block the popup as a scripted popup.
 *
 * @param options Window options. See {@link PopupWindowOptions}.
 * @returns A handle to the popup window and its host element, plus a `dispose` to close it.
 *          `null` if the popup was blocked by the browser.
 */
export function OpenPopupWindow(options?: PopupWindowOptions): PopupWindowHandle | null;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/pane" {

import { FunctionComponent, PropsWithChildren } from "react";
export type PaneProps = {
    title: string;
    icon?: any;
};
export const Pane: FunctionComponent<PropsWithChildren<PaneProps>>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/gradientList" {
import { FunctionComponent } from "react";
import { Color3Gradient, ColorGradient as Color4Gradient, FactorGradient } from "@babylonjs/core/Misc/gradients";
import { Nullable } from "@babylonjs/core/types";
type GradientListProps<T extends FactorGradient | Color3Gradient | Color4Gradient> = {
    label: string;
    gradients: Nullable<Array<T>>;
    addGradient: (step?: T) => void;
    removeGradient: (step: T, index: number) => void;
    onChange: (newGradient: T, index: number) => void;
};
export const FactorGradientList: FunctionComponent<GradientListProps<FactorGradient>>;
export const Color3GradientList: FunctionComponent<GradientListProps<Color3Gradient>>;
export const Color4GradientList: FunctionComponent<GradientListProps<Color4Gradient>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/fluentToolWrapper" {
import { PropsWithChildren, FunctionComponent } from "react";

export type UiSize = "small" | "medium";
export type ToolHostProps = {
    /**
     * Will ensure all of the controls within the tool are of the same scale
     */
    size?: UiSize;
    /**
     * 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;
    /**
     * Name of the tool displayed in the UX
     */
    toolName: string;
    /**
     * Override the qsp detection for fluent
     */
    useFluent?: boolean;
};
export const ToolContext: import("react").Context<{
    readonly useFluent: boolean;
    readonly disableCopy: boolean;
    readonly toolName: string;
    readonly size: UiSize | undefined;
}>;
/**
 * 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 { ButtonProps } from "@babylonjs/node-particle-editor/fluent/primitives/button";
type FileUploadLineProps = Omit<ButtonProps, "onClick" | "label"> & {
    onClick: (files: FileList) => void;
    label: string;
    accept: string;
};
/**
 * A full-width line with an upload button.
 * For just the button without the line wrapper, use UploadButton directly.
 * @returns An UploadButton wrapped in a LineContainer
 */
export const FileUploadLine: FunctionComponent<FileUploadLineProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/childWindow" {
import { FunctionComponent, PropsWithChildren, Ref } from "react";
export type ChildWindowOptions = {
    /**
     * The default width of the child window in pixels.
     * @remarks Ignored if the ChildWindow was passed an id and previous bounds were saved.
     */
    defaultWidth?: number;
    /**
     * The default height of the child window in pixels.
     * @remarks Ignored if the ChildWindow was passed an id and previous bounds were saved.
     */
    defaultHeight?: number;
    /**
     * The default left position of the child window in pixels.
     * @remarks Ignored if the ChildWindow was passed an id and previous bounds were saved.
     */
    defaultLeft?: number;
    /**
     * The default top position of the child window in pixels.
     * @remarks Ignored if the ChildWindow was passed an id and previous bounds were saved.
     */
    defaultTop?: number;
    /**
     * The title of the child window.
     * @remarks If not provided, the id will be used instead (if any).
     */
    title?: string;
};
export type ChildWindow = {
    /**
     * Opens the child window.
     * @param options Options for opening the child window.
     */
    open: (options?: ChildWindowOptions) => void;
    /**
     * Closes the child window.
     */
    close: () => void;
};
export type ChildWindowProps = {
    /**
     * An optional unique identity for the child window.
     * @remarks If provided, the child window's bounds will be saved/restored using this identity.
     */
    id?: string;
    /**
     * Called when the open state of the child window changes.
     * @param isOpen Whether the child window is open.
     */
    onOpenChange?: (isOpen: boolean) => void;
    /**
     * A ref that exposes the ChildWindow imperative API.
     */
    imperativeRef?: Ref<ChildWindow>;
};
/**
 * Allows displaying a child window that can contain child components.
 * @param props Props for the child window.
 * @returns The child window component.
 */
export const ChildWindow: FunctionComponent<PropsWithChildren<ChildWindowProps>>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/buttonLine" {
import { FunctionComponent } from "react";
import { ButtonProps } from "@babylonjs/node-particle-editor/fluent/primitives/button";
type ButtonLineProps = Omit<ButtonProps, "label"> & {
    label: string;
    uniqueId?: 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>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/vectorPropertyLineCore" {
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
export type TensorComponent = "x" | "y" | "z" | "w";
export type TensorValue2 = Readonly<{
    x: number;
    y: number;
}>;
export type TensorValue3 = TensorValue2 & Readonly<{
    z: number;
}>;
export type TensorValue4 = TensorValue3 & Readonly<{
    w: number;
}>;
export type TensorPropertyLineProps<ValueT> = PropertyLineProps<ValueT> & PrimitiveProps<ValueT> & {
    min?: number;
    max?: number;
    unit?: string;
    step?: number;
    precision?: number;
    valueConverter?: {
        from: (value: number) => number;
        to: (value: number) => number;
    };
};
export type TensorValueAdapter<ValueT> = Readonly<{
    components: readonly TensorComponent[];
    getComponent: (value: ValueT, component: TensorComponent) => number;
    withComponent: (value: ValueT, component: TensorComponent, componentValue: number) => ValueT;
}>;
type ControlledTensorPropertyLineProps<ValueT> = TensorPropertyLineProps<ValueT> & Readonly<{
    adapter: TensorValueAdapter<ValueT>;
}>;
/**
 * Runtime-neutral controlled editor for two-, three-, and four-component numeric values.
 * @param props The value, change callback, component adapter, and property-line presentation.
 * @returns The tensor property line.
 */
export const ControlledTensorPropertyLine: <ValueT>(props: ControlledTensorPropertyLineProps<ValueT>) => import("react").JSX.Element;
export const RadiansToDegreesConverter: {
    from: (value: number) => number;
    to: (value: number) => number;
};
type ControlledRotationVectorPropertyLineProps<ValueT> = TensorPropertyLineProps<ValueT> & Readonly<{
    adapter: TensorValueAdapter<ValueT>;
    useDegrees?: boolean;
}>;
/**
 * Runtime-neutral controlled Euler rotation editor.
 * @param props The rotation value, runtime adapter, and display options.
 * @returns The rotation property line.
 */
export const ControlledRotationVectorPropertyLine: <ValueT>(props: ControlledRotationVectorPropertyLineProps<ValueT>) => import("react").JSX.Element;
export type QuaternionValueAdapter<QuaternionT, EulerT> = Readonly<{
    quaternion: TensorValueAdapter<QuaternionT>;
    euler: TensorValueAdapter<EulerT>;
    fromEuler: (value: EulerT, source: QuaternionT) => QuaternionT;
    toEuler: (value: QuaternionT) => EulerT;
}>;
type ControlledQuaternionPropertyLineProps<QuaternionT, EulerT> = TensorPropertyLineProps<QuaternionT> & Readonly<{
    adapter: QuaternionValueAdapter<QuaternionT, EulerT>;
    useDegrees?: boolean;
    useEuler?: boolean;
}>;
/**
 * Runtime-neutral controlled quaternion editor with optional Euler presentation.
 * @param props The quaternion value, runtime conversion adapter, and display options.
 * @returns The quaternion or Euler property line.
 */
export const ControlledQuaternionPropertyLine: <QuaternionT, EulerT>(props: ControlledQuaternionPropertyLineProps<QuaternionT, EulerT>) => import("react").JSX.Element;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/vectorPropertyLine" {
import { FunctionComponent } from "react";
import { Quaternion, Vector2, Vector3, Vector4 } from "@babylonjs/core/Maths/math.vector";
import { TensorPropertyLineProps as RuntimeNeutralTensorPropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/vectorPropertyLineCore";
export type TensorPropertyLineProps<ValueT extends Vector2 | Vector3 | Vector4 | Quaternion> = RuntimeNeutralTensorPropertyLineProps<ValueT>;
type RotationVectorPropertyLineProps = TensorPropertyLineProps<Vector3> & {
    useDegrees?: boolean;
};
type QuaternionPropertyLineProps = TensorPropertyLineProps<Quaternion> & {
    useDegrees?: boolean;
    useEuler?: boolean;
};
/**
 * Edits a Babylon.js Vector2 value.
 * @param props The controlled vector and property-line presentation.
 * @returns The Vector2 property line.
 */
export const Vector2PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector2>>;
/**
 * Edits a Babylon.js Vector3 value.
 * @param props The controlled vector and property-line presentation.
 * @returns The Vector3 property line.
 */
export const Vector3PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector3>>;
/**
 * Edits a Babylon.js Vector4 value.
 * @param props The controlled vector and property-line presentation.
 * @returns The Vector4 property line.
 */
export const Vector4PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector4>>;
/**
 * Edits a Babylon.js Euler rotation value.
 * @param props The controlled rotation and property-line presentation.
 * @returns The Euler rotation property line.
 */
export const RotationVectorPropertyLine: FunctionComponent<RotationVectorPropertyLineProps>;
/**
 * Edits a Babylon.js Quaternion value with optional Euler presentation.
 * @param props The controlled quaternion and property-line presentation.
 * @returns The quaternion property line.
 */
export const QuaternionPropertyLine: FunctionComponent<QuaternionPropertyLineProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/textPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { ImmutablePrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { FunctionComponent } from "react";
/**
 * Wraps text in a property line
 * @param props - PropertyLineProps and TextProps
 * @returns property-line wrapped text
 */
export const TextPropertyLine: FunctionComponent<PropertyLineProps<string> & ImmutablePrimitiveProps<string>>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/textAreaPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { TextareaProps } from "@babylonjs/node-particle-editor/fluent/primitives/textarea";
/**
 * Wraps textarea in a property line
 * @param props - PropertyLineProps and TextProps
 * @returns property-line wrapped text
 */
export const TextAreaPropertyLine: FunctionComponent<PropertyLineProps<string> & TextareaProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/syncedSliderPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { SyncedSliderProps } from "@babylonjs/node-particle-editor/fluent/primitives/syncedSlider";
type SyncedSliderPropertyProps = SyncedSliderProps & PropertyLineProps<number>;
/**
 * Renders a simple wrapper around the SyncedSliderInput
 * @param props
 * @returns
 */
export const SyncedSliderPropertyLine: import("react").ForwardRefExoticComponent<SyncedSliderPropertyProps & import("react").RefAttributes<HTMLDivElement>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/switchPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/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<boolean> & SwitchProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/stringifiedPropertyLine" {
import { ImmutablePrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
type StringifiedPropertyLineProps = PropertyLineProps<number> & ImmutablePrimitiveProps<number> & {
    precision?: number;
    units?: string;
};
/**
 * Expects a numerical value and converts it toFixed(if precision is supplied) or toLocaleString
 * Can pass optional units to be appending to the end of the string
 * @param props
 * @returns
 */
export const StringifiedPropertyLine: FunctionComponent<StringifiedPropertyLineProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/spinButtonPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { SpinButtonProps } from "@babylonjs/node-particle-editor/fluent/primitives/spinButton";
export const SpinButtonPropertyLine: FunctionComponent<PropertyLineProps<number> & SpinButtonProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine" {
import { FunctionComponent, HTMLProps, PropsWithChildren } from "react";
import { AccordionSectionItemProps } from "@babylonjs/node-particle-editor/fluent/primitives/accordion";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
type BasePropertyLineProps = {
    /**
     * The name of the property to display in the property line.
     */
    label: string;
    /**
     * The ID of the property line to be used when the label cannot be used as a persistent ID.
     *
     * Note that when a property line is used within an accordion section, this ID must be unique within that section in order
     * for property pinning and filtering to work correctly. If not, error will be shown in console.
     */
    uniqueId?: 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;
    /**
     * Link to the documentation for this property, available from the info icon either linked from the description (if provided) or default 'docs' text
     */
    docLink?: string;
};
type NullableProperty<ValueT> = {
    nullable: true;
    ignoreNullable: false;
    value: ValueT;
    onChange: (value: ValueT) => void;
    defaultValue?: ValueT;
};
type IgnoreNullable<ValueT> = {
    ignoreNullable: true;
    nullable: false;
    value: ValueT;
    onChange: (value: ValueT) => void;
    defaultValue: ValueT;
};
type NonNullableProperty = {
    nullable?: false;
    ignoreNullable?: false;
};
type ExpandableProperty = {
    /**
     * If supplied, an 'expand' icon will be shown which, when clicked, renders this component within the property line.
     */
    expandedContent: JSX.Element;
    /**
     * If true, the expanded content will be shown by default.
     */
    expandByDefault?: boolean;
};
type NonExpandableProperty = {
    expandedContent?: undefined;
};
export type PropertyLineProps<ValueT> = BasePropertyLineProps & (NullableProperty<ValueT> | NonNullableProperty | IgnoreNullable<ValueT>) & (ExpandableProperty | NonExpandableProperty);
/**
 * 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<PropsWithChildren<PropertyLineProps<any>> & import("react").RefAttributes<HTMLDivElement>>;
export const LineContainer: import("react").ForwardRefExoticComponent<Omit<PropsWithChildren<HTMLProps<HTMLDivElement> & AccordionSectionItemProps>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
export const PlaceholderPropertyLine: FunctionComponent<PrimitiveProps<any> & PropertyLineProps<any>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/materialTextureBindingPropertyLine" {
import { ReactElement } from "react";
/** Directional mutations supported by a texture binding. */
export type TextureBindingWriteCapabilities<TextureT> = Readonly<{
    assign?: (texture: TextureT) => void;
    clear?: () => void;
}>;
/** Runtime-neutral presentation and mutation props for a material texture binding. */
export type MaterialTextureBindingProps<TextureT> = Readonly<{
    id: string;
    label: string;
    value: TextureT | null;
    candidates: readonly TextureT[];
    getDisplayName: (texture: TextureT) => string;
    getKind: (texture: TextureT) => string;
    acceptedKinds: readonly string[];
    isCandidateAccepted?: (texture: TextureT) => boolean;
    getId?: (texture: TextureT) => string;
    write?: TextureBindingWriteCapabilities<TextureT>;
    navigate?: (texture: TextureT) => void;
    pending?: boolean;
    error?: string;
    expandedContent?: ReactElement;
}>;
/**
 * Displays a runtime-neutral, direction-aware material texture binding.
 * @param props The binding props. Missing assign, clear, or navigation callbacks remove those actions.
 * @returns A texture binding property line.
 */
export const MaterialTextureBindingPropertyLine: <TextureT>(props: MaterialTextureBindingProps<TextureT>) => JSX.Element;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/linkPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { LinkProps } from "@babylonjs/node-particle-editor/fluent/primitives/link";
import { FunctionComponent } from "react";
/**
 * Wraps a link in a property line
 * @param props - PropertyLineProps and LinkProps
 * @returns property-line wrapped link
 */
export const LinkPropertyLine: FunctionComponent<PropertyLineProps<string> & LinkProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/inputPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { TextInputProps } from "@babylonjs/node-particle-editor/fluent/primitives/textInput";
import { SpinButtonProps } from "@babylonjs/node-particle-editor/fluent/primitives/spinButton";
/**
 * Wraps a text input in a property line
 * @param props - PropertyLineProps and InputProps
 * @returns property-line wrapped input component
 */
export const TextInputPropertyLine: FunctionComponent<TextInputProps & PropertyLineProps<string>>;
export type NumberInputPropertyLineProps = SpinButtonProps & PropertyLineProps<number>;
/**
 * Wraps a number input in a property line
 * To force integer values, use forceInt param (this is distinct from the 'step' param, which will still allow submitting an integer value. forceInt will not)
 * @param props - PropertyLineProps and InputProps
 * @returns property-line wrapped input component
 */
export const NumberInputPropertyLine: FunctionComponent<NumberInputPropertyLineProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/hexPropertyLine" {
import { FunctionComponent } from "react";
import { NumberInputPropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/inputPropertyLine";
export type HexPropertyLineProps = NumberInputPropertyLineProps & {
    numBits?: 32 | 24 | 16 | 8;
};
/**
 * Takes a number representing a Hex value and converts it to a hex string then wraps the TextInput in a PropertyLine
 * @param props - PropertyLineProps
 * @returns property-line wrapped textbox that converts to/from hex number representation
 */
export const HexPropertyLine: FunctionComponent<HexPropertyLineProps>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/entitySelectorPropertyLine" {
import { Skeleton } from "@babylonjs/core/Bones/skeleton";
import { ClusteredLightContainer } from "@babylonjs/core/Lights/Clustered/clusteredLightContainer";
import { Material } from "@babylonjs/core/Materials/material";
import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
import { Node } from "@babylonjs/core/node";
import { Nullable } from "@babylonjs/core/types";
import { ClusteredLightContainerSelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/clusteredLightContainerSelector";
import { MaterialSelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/materialSelector";
import { NodeSelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/nodeSelector";
import { SkeletonSelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/skeletonSelector";
import { TextureSelectorProps } from "@babylonjs/node-particle-editor/fluent/primitives/textureSelector";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
type NodeSelectorPropertyLineProps = PropertyLineProps<Nullable<Node>> & NodeSelectorProps;
type MaterialSelectorPropertyLineProps = PropertyLineProps<Nullable<Material>> & MaterialSelectorProps;
type TextureSelectorPropertyLineProps = PropertyLineProps<Nullable<BaseTexture>> & TextureSelectorProps;
type SkeletonSelectorPropertyLineProps = PropertyLineProps<Nullable<Skeleton>> & SkeletonSelectorProps;
type ClusteredLightContainerSelectorPropertyLineProps = PropertyLineProps<Nullable<ClusteredLightContainer>> & ClusteredLightContainerSelectorProps;
export const NodeSelectorPropertyLine: (props: NodeSelectorPropertyLineProps) => import("react").JSX.Element;
export const MaterialSelectorPropertyLine: (props: MaterialSelectorPropertyLineProps) => import("react").JSX.Element;
export const TextureSelectorPropertyLine: (props: TextureSelectorPropertyLineProps) => import("react").JSX.Element;
export const SkeletonSelectorPropertyLine: (props: SkeletonSelectorPropertyLineProps) => import("react").JSX.Element;
export const ClusteredLightContainerSelectorPropertyLine: (props: ClusteredLightContainerSelectorPropertyLineProps) => import("react").JSX.Element;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/dropdownPropertyLine" {
import { AcceptedDropdownValue, DropdownProps } from "@babylonjs/node-particle-editor/fluent/primitives/dropdown";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
type DropdownPropertyLineProps<V extends AcceptedDropdownValue> = DropdownProps<V> & PropertyLineProps<V>;
/**
 * Wraps a dropdown in a property line
 * @param props - PropertyLineProps and DropdownProps
 * @returns property-line wrapped dropdown
 */
export const DropdownPropertyLine: import("react").ForwardRefExoticComponent<DropdownPropertyLineProps<AcceptedDropdownValue> & import("react").RefAttributes<HTMLDivElement>>;
/**
 * Dropdown component for number values.
 */
export const NumberDropdownPropertyLine: FunctionComponent<DropdownPropertyLineProps<number>>;
/**
 * Dropdown component for string values
 */
export const StringDropdownPropertyLine: FunctionComponent<DropdownPropertyLineProps<string>>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/comboBoxPropertyLine" {
import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { ComboBoxProps } from "@babylonjs/node-particle-editor/fluent/primitives/comboBox";
type ComboBoxPropertyLineProps = ComboBoxProps & PropertyLineProps<string>;
/**
 * A property line with a filterable ComboBox
 * @param props - ComboBoxProps & PropertyLineProps
 * @returns property-line wrapped ComboBox component
 */
export const ComboBoxPropertyLine: FunctionComponent<ComboBoxPropertyLineProps>;
export {};

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/colorPropertyLineCore" {
import { ComponentType, Ref } from "react";
import { StructuralColorAdapter } from "@babylonjs/node-particle-editor/fluent/primitives/structuralColorPicker";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
export type ColorPropertyLineAdapter<ValueT> = StructuralColorAdapter<ValueT> & Readonly<{
    picker: ComponentType<PrimitiveProps<ValueT> & {
        isLinearMode?: boolean;
    }>;
}>;
export type ControlledColorPropertyLineProps<ValueT> = PrimitiveProps<ValueT> & PropertyLineProps<ValueT> & Readonly<{
    adapter: ColorPropertyLineAdapter<ValueT>;
    isLinearMode?: boolean;
    propertyLineRef?: Ref<HTMLDivElement>;
}>;
/**
 * Runtime-neutral controlled color editor with RGB or RGBA sliders and an injected picker.
 * @param props The controlled color, runtime adapter, and property-line presentation.
 * @returns The color property line.
 */
export const ControlledColorPropertyLine: <ValueT>(props: ControlledColorPropertyLineProps<ValueT>) => import("react").JSX.Element;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/colorPropertyLine" {
import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
import { ColorPickerProps } from "@babylonjs/node-particle-editor/fluent/primitives/colorPicker";
export type ColorPropertyLineProps = ColorPickerProps<Color3 | Color4> & PropertyLineProps<Color3 | Color4>;
/**
 * Edits a Babylon.js Color3 value.
 * @param props The controlled color and property-line presentation.
 * @returns The Color3 property line.
 */
export const Color3PropertyLine: FunctionComponent<ColorPickerProps<Color3> & PropertyLineProps<Color3>>;
/**
 * Edits a Babylon.js Color4 value.
 * @param props The controlled color and property-line presentation.
 * @returns The Color4 property line.
 */
export const Color4PropertyLine: FunctionComponent<ColorPickerProps<Color4> & PropertyLineProps<Color4>>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/checkboxPropertyLine" {
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { PrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
import { FunctionComponent } from "react";
/**
 * Wraps a checkbox in a property line
 * @param props - PropertyLineProps and CheckboxProps
 * @returns property-line wrapped checkbox
 */
export const CheckboxPropertyLine: FunctionComponent<PropertyLineProps<boolean> & PrimitiveProps<boolean>>;

}
declare module "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/booleanBadgePropertyLine" {
import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/node-particle-editor/fluent/hoc/propertyLines/propertyLine";
import { ImmutablePrimitiveProps } from "@babylonjs/node-particle-editor/fluent/primitives/primitive";
/**
 * Displays an icon indicating enabled (green check) or disabled (red cross) state
 * @param props - The properties for the PropertyLine, including the boolean value to display.
 * @returns A PropertyLine component with a PresenceBadge indicating the boolean state.
 */
export const BooleanBadgePropertyLine: FunctionComponent<PropertyLineProps<boolean> & ImmutablePrimitiveProps<boolean>>;

}
declare module "@babylonjs/node-particle-editor/components/propertyTabComponentBase" {
import { FunctionComponent, PropsWithChildren } from "react";
/**
 * A wrapper component for the property tab that provides a consistent layout and styling.
 * It uses a Pane and an Accordion to organize the content, so its direct children
 * must have 'title' props to be compatible with the Accordion structure.
 * @param props The props to pass to the component.
 * @returns The rendered component.
 */
export const PropertyTabComponentBase: FunctionComponent<PropsWithChildren>;

}
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
 */
export const TextInputWithSubmit: (props: ITextInputProps) => import("react").JSX.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 ButtonComponentProps = {
    disabled?: boolean;
    active?: boolean;
    onClick?: () => void;
    color: "light" | "dark";
    size: "default" | "small" | "wide" | "smaller";
    title?: string;
    backgroundColor?: string;
};
export const ButtonComponent: React.FC<PropsWithChildren<ButtonComponentProps>>;

}
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
 */
export const NodeRenderer: (props: PropsWithChildren<INodeRendererProps>) => import("react").JSX.Element;

}
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;
}
export const OptionsLineComponent: (props: IOptionsLineComponentProps) => import("react").JSX.Element;

}
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;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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);
    render(): React.JSX.Element;
}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}
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;
    render(): React.JSX.Element;
}

}

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