declare module "@babylonjs/gui-editor/workbenchEditor" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { Control } from "@babylonjs/gui/2D/controls/control";
import "@babylonjs/gui-editor/main.scss";
import "@babylonjs/gui-editor/scss/header.scss";
interface IGraphEditorProps {
    globalState: GlobalState;
    onReady?: () => Promise<void>;
}
interface IGraphEditorState {
    showPreviewPopUp: boolean;
    toolbarExpand: boolean;
    message: string;
}
export class WorkbenchEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
    private _moveInProgress;
    private _leftWidth;
    private _rightWidth;
    private _popUpWindow;
    private _draggedItem;
    private _rootRef;
    private _onErrorMessageObserver;
    private _workbenchRef;
    componentDidMount(): void;
    componentWillUnmount(): void;
    addToolControls: (evt: KeyboardEvent) => void;
    removePressToolControls: (evt: KeyboardEvent) => void;
    constructor(props: IGraphEditorProps);
    showWaitScreen(): void;
    hideWaitScreen(): void;
    onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
    onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
    resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
    buildColumnLayout(): string;
    handlePopUp: () => void;
    handleClosingPopUp: () => void;
    switchExpandedState(): void;
    render(): import("react/jsx-runtime").JSX.Element;
    onCreate(value: string): Control;
    createBlackLine(): import("react/jsx-runtime").JSX.Element;
    createToolbarHelper(ct: {
        className: string;
        icon: string;
    }[]): import("react/jsx-runtime").JSX.Element[];
    createToolbar(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tools" {
import { Control } from "@babylonjs/gui/2D/controls/control";
import { Grid } from "@babylonjs/gui/2D/controls/grid";
import { Vector2 } from "@babylonjs/core/Maths/math";
export class Tools {
    static LookForItems(item: any, selectedEntities: any[], firstIteration?: boolean): boolean;
    private static _RecursiveRemoveHiddenMeshesAndHoistChildren;
    static SortAndFilter(parent: any, items: any[]): any[];
    static GetCellInfo(grid: Grid, control: Control): Vector2;
    static ReorderGrid(grid: Grid, index: number, control: Control, cell: Vector2): void;
}

}
declare module "@babylonjs/gui-editor/portal" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-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/gui-editor/nodeLocationInfo" {
export interface INodeLocationInfo {
    blockId: number;
    x: number;
    y: number;
}
export interface IFrameData {
    x: number;
    y: number;
    width: number;
    height: number;
    color: number[];
    name: string;
    isCollapsed: boolean;
    blocks: number[];
    comments: string;
}
export interface IEditorData {
    locations: INodeLocationInfo[];
    x: number;
    y: number;
    zoom: number;
    frames?: IFrameData[];
    map?: {
        [key: number]: number;
    };
}

}
declare module "@babylonjs/gui-editor/main" {
/**
 * Vite dev server entry point for the GUI Editor.
 *
 * Uses dynamic import so the editor module graph (which contains
 * `const { X } = window.BABYLON ?? {}` bindings) loads only after
 * the CDN bootstrap has set window.BABYLON.
 */
type ShowArgs = Parameters<(typeof import("@babylonjs/gui-editor/guiEditor"))["GUIEditor"]["Show"]>;
function StartEditor(args: ShowArgs): Promise<void>;
const Win: Record<string, unknown>;

}
declare module "@babylonjs/gui-editor/keyboardManager" {
import { Observable } from "@babylonjs/core/Misc/observable";
type Key = "control" | "shift" | "alt" | "space" | "meta";
export class KeyboardManager {
    private _hostElement;
    private _kdListener;
    private _kuListener;
    private _moveListener;
    private _focusOutListener;
    private _keys;
    onKeyPressedObservable: Observable<Key>;
    constructor(hostElement: HTMLElement | HTMLDocument);
    private _keyEvent;
    private _updateModifierKeys;
    private _setKeyDown;
    private _clearKeys;
    isKeyDown(key: Key): boolean;
    dispose(): void;
}
export {};

}
declare module "@babylonjs/gui-editor/index" {
export * from "@babylonjs/gui-editor/guiEditor";

}
declare module "@babylonjs/gui-editor/guiNodeTools" {
import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
import { Line } from "@babylonjs/gui/2D/controls/line";
import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
import { Image } from "@babylonjs/gui/2D/controls/image";
import { InputText } from "@babylonjs/gui/2D/controls/inputText";
import { Grid } from "@babylonjs/gui/2D/controls/grid";
import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
export class GUINodeTools {
    static ImageControlDefaultUrl: string;
    static CreateControlFromString(data: string): Grid | Rectangle | StackPanel | Line | TextBlock | Image | Slider | ImageBasedSlider | RadioButton | InputText | ColorPicker | Ellipse | Checkbox | DisplayGrid;
}

}
declare module "@babylonjs/gui-editor/guiEditor" {
import { Observable } from "@babylonjs/core/Misc/observable";
import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
/**
 * Interface used to specify creation options for the gui editor
 */
export interface IGUIEditorOptions {
    liveGuiTexture?: AdvancedDynamicTexture;
    customLoad?: {
        label: string;
        action: (data: string) => Promise<string>;
    } | undefined;
    hostElement?: HTMLElement;
    customSave?: {
        label: string;
        action: (data: string) => Promise<string>;
    };
    currentSnippetToken?: string;
    customLoadObservable?: Observable<any>;
}
/**
 * Class used to create a gui editor
 */
export class GUIEditor {
    private static _CurrentState;
    /** @internal */
    static _PopupWindow: Window | null;
    /**
     * Show the gui editor
     * @param options defines the options to use to configure the gui editor
     * @param embed defines whether editor is being opened from the Playground
     */
    static Show(options: IGUIEditorOptions, embed?: boolean): Promise<void>;
}

}
declare module "@babylonjs/gui-editor/globalState" {
import { Nullable } from "@babylonjs/core/types";
import { Observable } from "@babylonjs/core/Misc/observable";
import { LogEntry } from "@babylonjs/gui-editor/components/log/logComponent";
import { Color3 } from "@babylonjs/core/Maths/math.color";
import { WorkbenchComponent } from "@babylonjs/gui-editor/diagram/workbench";
import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Scene } from "@babylonjs/core/scene";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { ISize } from "@babylonjs/core/Maths/math";
import { KeyboardManager } from "@babylonjs/gui-editor/keyboardManager";
export enum DragOverLocation {
    ABOVE = 0,
    BELOW = 1,
    CENTER = 2,
    NONE = 3
}
export enum GUIEditorTool {
    SELECT = 0,
    PAN = 1,
    ZOOM = 2
}
export class GlobalState {
    liveGuiTexture: Nullable<AdvancedDynamicTexture>;
    guiTexture: AdvancedDynamicTexture;
    hostElement: HTMLElement;
    hostDocument: HTMLDocument;
    hostWindow: Window;
    selectedControls: Control[];
    onSelectionChangedObservable: Observable<void>;
    onResizeObservable: Observable<ISize>;
    onBuiltObservable: Observable<void>;
    onResetRequiredObservable: Observable<void>;
    onUpdateRequiredObservable: Observable<void>;
    onLogRequiredObservable: Observable<LogEntry>;
    onErrorMessageDialogRequiredObservable: Observable<string>;
    onIsLoadingChanged: Observable<boolean>;
    onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
    onNewSceneObservable: Observable<Nullable<Scene>>;
    onGuiNodeRemovalObservable: Observable<Control>;
    onPopupClosedObservable: Observable<void>;
    private _backgroundColor;
    private _outlines;
    keys: KeyboardManager;
    private _fromPg;
    /** DO NOT USE: in the process of removing */
    blockKeyboardEvents: boolean;
    onOutlineChangedObservable: Observable<void>;
    controlCamera: boolean;
    selectionLock: boolean;
    workbench: WorkbenchComponent;
    onPropertyChangedObservable: Observable<PropertyChangedEvent>;
    private _tool;
    private _usePrevSelected;
    private _prevTool;
    onToolChangeObservable: Observable<void>;
    get tool(): GUIEditorTool;
    set tool(newTool: GUIEditorTool);
    get usePrevSelected(): boolean;
    set usePrevSelected(val: boolean);
    restorePreviousTool(): void;
    onFitControlsToWindowObservable: Observable<void>;
    onReframeWindowObservable: Observable<void>;
    onLoadObservable: Observable<File>;
    onSaveObservable: Observable<void>;
    onSaveSelectedControl: Observable<void>;
    onSnippetLoadObservable: Observable<void>;
    onSnippetSaveObservable: Observable<void>;
    onControlLoadObservable: Observable<File>;
    onResponsiveChangeObservable: Observable<boolean>;
    onParentingChangeObservable: Observable<Nullable<Control>>;
    onDropObservable: Observable<void>;
    onPropertyGridUpdateRequiredObservable: Observable<void>;
    onDraggingEndObservable: Observable<void>;
    onDraggingStartObservable: Observable<void>;
    onWindowResizeObservable: Observable<void>;
    onGizmoUpdateRequireObservable: Observable<void>;
    onArtBoardUpdateRequiredObservable: Observable<void>;
    onBackgroundColorChangeObservable: Observable<void>;
    onFontsParsedObservable: Observable<void>;
    onPointerMoveObservable: Observable<import("react").PointerEvent<HTMLCanvasElement>>;
    onPointerUpObservable: Observable<Nullable<PointerEvent | import("react").PointerEvent<HTMLCanvasElement>>>;
    draggedControl: Nullable<Control>;
    draggedControlDirection: DragOverLocation;
    onCopyObservable: Observable<(content: string) => void>;
    onCutObservable: Observable<(content: string) => void>;
    onPasteObservable: Observable<string>;
    isSaving: boolean;
    lockObject: LockObject;
    storeEditorData: (serializationObject: any) => void;
    shiftKeyPressed: boolean;
    mcpSessionUrl: string | null;
    mcpSessionConnected: boolean;
    mcpEventSource: EventSource | null;
    onMcpSessionStateChangedObservable: Observable<boolean>;
    customSave?: {
        label: string;
        action: (data: string) => Promise<string>;
    };
    customLoad?: {
        label: string;
        action: (data: string) => Promise<string>;
    };
    constructor();
    /** adds copy, cut and paste listeners to the host window */
    registerEventListeners(): void;
    get backgroundColor(): Color3;
    get fromPG(): boolean;
    set fromPG(value: boolean);
    set backgroundColor(value: Color3);
    get outlines(): boolean;
    set outlines(value: boolean);
    select(control: Control): void;
    setSelection(controls: Control[]): void;
    private _findParentControlInTexture;
    deleteSelectedNodes(): void;
    isMultiSelectable(control: Control): boolean;
    dispose(): void;
}

}
declare module "@babylonjs/gui-editor/controlTypes" {
export const ControlTypes: {
    className: string;
    icon: string;
}[];

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

}
declare module "@babylonjs/gui-editor/diagram/workbench" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
import { Scene } from "@babylonjs/core/scene";
import { Container } from "@babylonjs/gui/2D/controls/container";
import { ISize } from "@babylonjs/core/Maths/math";
import "@babylonjs/gui-editor/diagram/workbenchCanvas.scss";
export interface IWorkbenchComponentProps {
    globalState: GlobalState;
}
export enum ConstraintDirection {
    NONE = 0,
    X = 2,// Horizontal constraint
    Y = 3
}
export class WorkbenchComponent extends React.Component<IWorkbenchComponentProps> {
    private _mouseDown;
    private _rootContainer;
    private _setConstraintDirection;
    private _mouseStartPoint;
    _scene: Scene;
    private _constraintDirection;
    private _panning;
    private _isOverGUINode;
    private _engine;
    private _guiRenderObserver;
    private _doubleClick;
    private _currLeft;
    private _currTop;
    private _controlsHit;
    private _pointerTravelDistance;
    private _processSelectionOnUp;
    private _visibleRegionContainer;
    private _centerZoomMousePosition;
    private _hasPerformedDragZoom;
    private static _addedFonts;
    static get addedFonts(): string[];
    get visibleRegionContainer(): Container;
    private _panAndZoomContainer;
    get panAndZoomContainer(): Container;
    private _trueRootContainer;
    set trueRootContainer(value: Container);
    get trueRootContainer(): Container;
    private _defaultGUISize;
    private _initialPanningOffset;
    private _panningOffset;
    private _zoomFactor;
    private _zoomModeIncrement;
    private _guiSize;
    private _pasteDisabled;
    get guiSize(): ISize;
    get pasteDisabled(): boolean;
    set guiSize(value: ISize);
    applyEditorTransformation(): void;
    removeEditorTransformation(): void;
    private _reframeWindow;
    constructor(props: IWorkbenchComponentProps);
    keyEvent: (evt: KeyboardEvent) => void;
    copyToClipboard(copyFn: (content: string) => void): void;
    cutToClipboard(copyFn: (content: string) => void): void;
    pasteFromClipboard(clipboardContents: string): boolean;
    CopyGUIControl(original: Control): void;
    blurEvent: () => void;
    /**
     * Adds editor observers to control and stores old data in metadata
     * @param guiControl
     */
    addEditorBehavior(guiControl: Control): void;
    /**
     * Removes editor behavior (observables, metadata) from control
     * @param control
     */
    removeEditorBehavior(control: Control): void;
    dispose(): void;
    loadFromJson(serializationObject: any): void;
    /**
     * Load Control from Json then select loaded Control
     * @param serializationObject
     */
    loadControlFromJson(serializationObject: any): void;
    loadFromSnippet(snippetId: string): Promise<void>;
    loadToEditor(): void;
    updateNodeOutlines(): void;
    appendBlock(guiElement: Control): Control;
    private parent;
    private _canClone;
    private _controlToLinkedMeshMap;
    private _observersMap;
    private _saveObservables;
    private _restoreObservables;
    private _copyEditorGUIToLiveGUI;
    private _reorderGrid;
    private _isNotChildInsert;
    private _adjustParentingIndex;
    isSelected(value: boolean, guiNode: Control): void;
    clicked: boolean;
    _onMove(guiControl: Control, evt: Vector2, startPos: Vector2): void;
    onMove(evt: React.PointerEvent): void;
    private _screenToTexturePosition;
    private getScaledPointerPosition;
    startPanning(): void;
    endPanning(): void;
    processSelection(): void;
    onDown(evt: React.PointerEvent<HTMLElement>): void;
    onUp(evt: React.PointerEvent): void;
    private _syncConnectedLines;
    private _copyLiveGUIToEditorGUI;
    createGUICanvas(embed?: boolean): void;
    synchronizeLiveGUI(): void;
    addControls(scene: Scene): void;
    panning(): void;
    moveControls(moveHorizontal: boolean, amount: number): void;
    zoomWheel(event: React.WheelEvent): void;
    private _panZoomToCenter;
    zoomDrag(event: React.MouseEvent): void;
    zooming(delta: number): void;
    zeroIfClose(vec: Vector3): void;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/diagram/gizmoWrapper" {
import { Nullable } from "@babylonjs/core/types";
import { Observer } from "@babylonjs/core/Misc/observable";
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
export interface IGizmoWrapperProps {
    globalState: GlobalState;
}
export class GizmoWrapper extends React.Component<IGizmoWrapperProps> {
    observer: Nullable<Observer<void>>;
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/diagram/gizmoScalePoint" {
import { Vector2 } from "@babylonjs/core/Maths/math";
import * as React from "react";
export enum ScalePointPosition {
    Top = -1,
    Left = -1,
    Center = 0,
    Right = 1,
    Bottom = 1
}
export interface IScalePoint {
    position: Vector2;
    horizontalPosition: ScalePointPosition;
    verticalPosition: ScalePointPosition;
    rotation: number;
    isPivot: boolean;
    defaultRotation: number;
    id?: number;
}
interface IGizmoScalePointProps {
    scalePoint: IScalePoint;
    clickable: boolean;
    key: number;
    onDrag: (event?: React.PointerEvent<HTMLDivElement>, scalePoint?: IScalePoint) => void;
    onRotate: (event?: React.PointerEvent<HTMLDivElement>, scalePoint?: IScalePoint) => void;
    onUp: () => void;
    overrideCursor?: string;
    canRotate: boolean;
    allowClickOnPivot?: boolean;
}
export function GizmoScalePoint(props: IGizmoScalePointProps): import("react/jsx-runtime").JSX.Element;
export {};

}
declare module "@babylonjs/gui-editor/diagram/gizmoLine" {
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { Line } from "@babylonjs/gui/2D/controls/line";
interface IGizmoLineProps {
    globalState: GlobalState;
    control: Line;
}
/**
 * This class represents the gizmo drawn on a line Control.
 * It is used to scale and rotate the control around a pivot point
 * @param props the properties of the gizmo
 * @returns a gizmo line
 */
export function GizmoLine(props: IGizmoLineProps): import("react/jsx-runtime").JSX.Element;
export {};

}
declare module "@babylonjs/gui-editor/diagram/gizmoGeneric" {
import { Control } from "@babylonjs/gui/2D/controls/control";
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { Rect } from "@babylonjs/gui-editor/diagram/coordinateHelper";
import { IScalePoint } from "@babylonjs/gui-editor/diagram/gizmoScalePoint";
export interface IGuiGizmoProps {
    globalState: GlobalState;
    control: Control;
}
interface IGuiGizmoState {
    canvasBounds: Rect;
    scalePoints: IScalePoint[];
    scalePointDragging: number;
    isRotating: boolean;
}
export class GizmoGeneric extends React.Component<IGuiGizmoProps, IGuiGizmoState> {
    private _storedValues;
    private _localBounds;
    private _rotation;
    private _gizmoUpdateObserver;
    private _pointerUpObserver;
    private _pointerMoveObserver;
    constructor(props: IGuiGizmoProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    /**
     * Update the gizmo's positions
     */
    updateGizmo(): void;
    private _onUp;
    private _onMove;
    private _rotate;
    private _dragLocalBounds;
    private _updateNodeFromLocalBounds;
    private _beginDraggingScalePoint;
    private _beginRotate;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/diagram/coordinateHelper" {
import { Control } from "@babylonjs/gui/2D/controls/control";
import { Matrix2D } from "@babylonjs/gui/2D/math2D";
import { Vector2 } from "@babylonjs/core/Maths/math.vector";
import { Observable } from "@babylonjs/core/Misc/observable";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Measure } from "@babylonjs/gui/2D/measure";
export type DimensionProperties = "width" | "left" | "height" | "top" | "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom" | "fontSize" | "linkOffsetX" | "linkOffsetY";
export class Rect {
    top: number;
    left: number;
    right: number;
    bottom: number;
    constructor(left: number, top: number, right: number, bottom: number);
    clone(): Rect;
    get center(): Vector2;
    get width(): number;
    get height(): number;
}
export class CoordinateHelper {
    private static _MatrixCache;
    static GlobalState: GlobalState;
    /**
     * Get the scaling of a specific GUI control
     * @param node the node for which we are getting the scaling
     * @param relative should we return only the relative scaling (relative to the parent)
     * @returns an X,Y vector of the scaling
     */
    static GetScale(node: Control, relative?: boolean): Vector2;
    static GetRotation(node: Control, relative?: boolean): number;
    static GetParentSizes(guiControl: Control): Measure;
    /**
     * This function calculates a local matrix for a node, including it's full transformation and pivot point
     *
     * @param node the node to calculate the matrix for
     * @param storedValues should the stored (cached) values be used to calculate the matrix
     * @returns a new matrix for the control
     */
    static GetNodeMatrix(node: Control, storedValues?: Rect): Matrix2D;
    /**
     * Using the node's tree, calculate its world matrix and return it
     * @param node the node to calculate the matrix for
     * @param storedValues used stored valued (cached when pointer down is clicked)
     * @param stopAt stop looking when this node is found
     * @returns the world matrix for this node
     */
    static NodeToRTTWorldMatrix(node: Control, storedValues?: Rect, stopAt?: Control): Matrix2D;
    static NodeToRTTSpace(node: Control, x: number, y: number, reference?: Vector2, storedValues?: Rect, stopAt?: Control): Vector2;
    static RttToLocalNodeSpace(node: Control, x: number, y: number, reference?: Vector2, storedValues?: Rect): Vector2;
    static RttToCanvasSpace(x: number, y: number): Vector2;
    static MousePointerToRTTSpace(_node?: Control, x?: number, y?: number): Vector2;
    private static _ResetMatrixArray;
    static ComputeLocalBounds(node: Control): Rect;
    /**
     * converts a node's dimensions to percentage, properties can be specified as a list, or can convert all
     * @param guiControl
     * @param properties
     * @param onPropertyChangedObservable
     */
    static ConvertToPercentage(guiControl: Control, properties?: DimensionProperties[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>): void;
    static Round(value: number): number;
    static ConvertToPixels(guiControl: Control, properties?: DimensionProperties[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>): void;
}

}
declare module "@babylonjs/gui-editor/diagram/artBoard" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { Rect } from "@babylonjs/gui-editor/diagram/coordinateHelper";
interface IArtBoardProps {
    globalState: GlobalState;
}
interface IArtBoardState {
    bounds: Rect;
}
export class ArtBoardComponent extends React.Component<IArtBoardProps, IArtBoardState> {
    constructor(props: IArtBoardProps);
    update(): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/parentingPropertyGridComponent" {
import * as React from "react";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Observable } from "@babylonjs/core/Misc/observable";
interface IParentingPropertyGridComponentProps {
    control: Control;
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class ParentingPropertyGridComponent extends React.Component<IParentingPropertyGridComponentProps> {
    constructor(props: IParentingPropertyGridComponentProps);
    private _columnNumber;
    private _rowNumber;
    updateGridPosition(): void;
    getCellInfo(): void;
    private _changeCell;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/commandDropdownComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface ICommandDropdownComponentProps {
    globalState: GlobalState;
    icon?: string;
    tooltip: string;
    defaultValue?: string;
    items: {
        label: string;
        icon?: string;
        fileButton?: boolean;
        loadControlButton?: 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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/commandButtonComponent" {
import * as React from "react";
interface ICommandButtonComponentProps {
    tooltip: string;
    shortcut?: string;
    icon: string;
    iconLabel?: string;
    isActive: boolean;
    copyDeleteDisabled?: boolean;
    pasteDisabled?: boolean;
    onClick: () => void;
    altStyle?: boolean;
    disabled?: boolean;
}
export class CommandButtonComponent extends React.Component<ICommandButtonComponentProps> {
    constructor(props: ICommandButtonComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/commandBarComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import "@babylonjs/gui-editor/scss/commandBar.scss";
interface ICommandBarComponentProps {
    globalState: GlobalState;
}
export class CommandBarComponent extends React.Component<ICommandBarComponentProps> {
    private _sizeOption;
    private _stopUpdating;
    private _lockObject;
    constructor(props: ICommandBarComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemSelectableComponent" {
import { Nullable } from "@babylonjs/core/types";
import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
import * as React from "react";
import { GlobalState, DragOverLocation } from "@babylonjs/gui-editor/globalState";
export interface ITreeItemSelectableComponentProps {
    entity: any;
    selectedEntities: any[];
    mustExpand?: boolean;
    offset: number;
    globalState: GlobalState;
    extensibilityGroups?: IExplorerExtensibilityGroup[];
    filter: Nullable<string>;
}
export interface ITreeItemSelectableComponentState {
    expand: boolean;
    dragOver: boolean;
    isSelected: boolean;
    isHovered: boolean;
    dragOverLocation: DragOverLocation;
    blockDrag: boolean;
}
export class TreeItemSelectableComponent extends React.Component<ITreeItemSelectableComponentProps, ITreeItemSelectableComponentState> {
    private _onSelectionChangedObservable;
    private _onDraggingEndObservable;
    private _onDraggingStartObservable;
    private _thisRef;
    /** flag flipped onDragEnter if dragOver is already true
     * prevents dragLeave from immediately setting dragOver to false
     * required to make dragging work as expected
     * see: see: https://github.com/transformation-dev/matrx/tree/master/packages/dragster
     */
    private _secondDragEnter;
    constructor(props: ITreeItemSelectableComponentProps);
    switchExpandedState(): void;
    shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: {
        isSelected: boolean;
    }): boolean;
    scrollIntoView(): void;
    componentWillUnmount(): void;
    onSelect(): void;
    renderChildren(isExpanded: boolean, offset?: boolean): (import("react/jsx-runtime").JSX.Element | null)[] | null;
    render(): import("react/jsx-runtime").JSX.Element | (import("react/jsx-runtime").JSX.Element | null)[] | null;
    dragOver(event: React.DragEvent<HTMLDivElement>): void;
    updateDragOverLocation(event: React.DragEvent<HTMLDivElement>): void;
    drop(): void;
}

}
declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemLabelComponent" {
import * as React from "react";
interface ITreeItemLabelComponentProps {
    label?: string;
    onClick?: () => void;
    onChange: (newValue: string) => void;
    bracket: string;
    renaming: boolean;
    setRenaming: (renaming: boolean) => void;
}
interface ITreeItemLabelState {
    value: string;
}
export class TreeItemLabelComponent extends React.Component<ITreeItemLabelComponentProps, ITreeItemLabelState> {
    constructor(props: ITreeItemLabelComponentProps);
    onClick(): void;
    onBlur(): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemComponent" {
import * as React from "react";
import { Nullable } from "@babylonjs/core/types";
import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
export interface ITreeItemComponentProps {
    items?: Nullable<any[]>;
    label: string;
    offset: number;
    filter: Nullable<string>;
    forceSubitems?: boolean;
    globalState: GlobalState;
    entity?: any;
    selectedEntities: any[];
    extensibilityGroups?: IExplorerExtensibilityGroup[];
    contextMenuItems?: {
        label: string;
        action: () => void;
    }[];
}
export class TreeItemComponent extends React.Component<ITreeItemComponentProps, {
    isExpanded: boolean;
    mustExpand: boolean;
}> {
    static _ContextMenuUniqueIdGenerator: number;
    constructor(props: ITreeItemComponentProps);
    switchExpandedState(): void;
    shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: {
        isExpanded: boolean;
    }): boolean;
    expandAll(expand: boolean): void;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorerComponent" {
import * as React from "react";
import { Nullable } from "@babylonjs/core/types";
import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
import { Scene } from "@babylonjs/core/scene";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorer.scss";
import { PropsWithChildren } from "react";
interface ISceneExplorerFilterComponentProps {
    onFilter: (filter: string) => void;
}
export class SceneExplorerFilterComponent extends React.Component<ISceneExplorerFilterComponentProps> {
    constructor(props: ISceneExplorerFilterComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
interface ISceneExplorerComponentProps {
    scene?: Scene;
    noCommands?: boolean;
    noHeader?: boolean;
    noExpand?: boolean;
    noClose?: boolean;
    extensibilityGroups?: IExplorerExtensibilityGroup[];
    globalState: GlobalState;
    popupMode?: boolean;
    onPopup?: () => void;
    onClose?: () => void;
}
export class SceneExplorerComponent extends React.Component<PropsWithChildren<ISceneExplorerComponentProps>, {
    filter: Nullable<string>;
    selectedEntity: any;
    scene: Nullable<Scene>;
}> {
    private _onSelectionChangeObserver;
    private _onParrentingChangeObserver;
    private _onNewSceneObserver;
    private _onPropertyChangedObservable;
    private _onUpdateRequiredObserver;
    constructor(props: ISceneExplorerComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    filterContent(filter: string): void;
    findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: {
        previousOne?: any;
        found?: boolean;
    }): boolean;
    processKeys(keyEvent: React.KeyboardEvent<HTMLDivElement>): void;
    renderContent(): import("react/jsx-runtime").JSX.Element | null;
    onClose(): void;
    onPopup(): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/sceneExplorer/extensionsComponent" {
import * as React from "react";
import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
interface IExtensionsComponentProps {
    target: any;
    extensibilityGroups?: IExplorerExtensibilityGroup[];
}
export class ExtensionsComponent extends React.Component<IExtensionsComponentProps, {
    popupVisible: boolean;
}> {
    private _popup;
    private _extensionRef;
    constructor(props: IExtensionsComponentProps);
    showPopup(): void;
    componentDidMount(): void;
    componentDidUpdate(): void;
    render(): import("react/jsx-runtime").JSX.Element | null;
}
export {};

}
declare module "@babylonjs/gui-editor/components/sceneExplorer/entities/gui/controlTreeItemComponent" {
import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
import { Control } from "@babylonjs/gui/2D/controls/control";
import * as React from "react";
import { GlobalState, DragOverLocation } from "@babylonjs/gui-editor/globalState";
interface IControlTreeItemComponentProps {
    control: Control;
    extensibilityGroups?: IExplorerExtensibilityGroup[];
    onClick: () => void;
    globalState: GlobalState;
    isHovered: boolean;
    isDragOver: boolean;
    dragOverLocation: DragOverLocation;
    onRenamingStateChanged: (renaming: boolean) => void;
}
export class ControlTreeItemComponent extends React.Component<IControlTreeItemComponentProps, {
    isActive: boolean;
    isVisible: boolean;
    isRenaming: boolean;
}> {
    private _onIsVisibleChangedObserver;
    constructor(props: IControlTreeItemComponentProps);
    componentWillUnmount(): void;
    highlight(): void;
    switchVisibility(): void;
    onRename(name: string): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
import "@babylonjs/gui-editor/components/propertyTab/propertyTab.scss";
interface IPropertyTabComponentProps {
    globalState: GlobalState;
}
export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps> {
    private _onBuiltObserver;
    private _timerIntervalId;
    private _lockObject;
    constructor(props: IPropertyTabComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    load(file: File): void;
    /**
     * Read loaded file
     * @param file
     */
    loadControl(file: File): void;
    save(saveCallback: () => void): void;
    saveLocally: () => void;
    /**
     * Save the selected control as Json with file name of guiControl
     */
    saveSelectedControlLocally: () => void;
    saveToSnippetServerHelper: (content: string, adt: AdvancedDynamicTexture) => Promise<string>;
    saveToSnippetServer: () => Promise<void>;
    loadFromSnippet(): void;
    renderNode(nodes: Control[]): import("react/jsx-runtime").JSX.Element;
    /**
     * returns the class name of a list of controls if they share a class, or an empty string if not
     * @param nodes the list of controls to check
     * @returns the class name of a list of controls if they share a class, or an empty string if not
     */
    getControlsCommonClassName(nodes: Control[]): string;
    renderProperties(nodes: Control[]): import("react/jsx-runtime").JSX.Element | undefined;
    renderControlIcon(nodes: Control[]): string;
    render(): import("react/jsx-runtime").JSX.Element | null;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/textBlockPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface ITextBlockPropertyGridComponentProps {
    textBlocks: TextBlock[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
    constructor(props: ITextBlockPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/stackPanelPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IStackPanelPropertyGridComponentProps {
    stackPanels: StackPanel[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
    constructor(props: IStackPanelPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
interface ISliderPropertyGridComponentProps {
    sliders: (Slider | ImageBasedSlider)[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
    constructor(props: ISliderPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderGenericPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface ISliderGenericPropertyGridComponentProps {
    sliders: Slider[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class SliderGenericPropertyGridComponent extends React.Component<ISliderGenericPropertyGridComponentProps> {
    constructor(props: ISliderGenericPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/scrollViewerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IScrollViewerPropertyGridComponentProps {
    scrollViewers: ScrollViewer[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
    constructor(props: IScrollViewerPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/rectanglePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IRectanglePropertyGridComponentProps {
    rectangles: Rectangle[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
    constructor(props: IRectanglePropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/radioButtonPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IRadioButtonPropertyGridComponentProps {
    radioButtons: RadioButton[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
    constructor(props: IRadioButtonPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/linePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Line } from "@babylonjs/gui/2D/controls/line";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface ILinePropertyGridComponentProps {
    lines: Line[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
    constructor(props: ILinePropertyGridComponentProps);
    onDashChange(value: string): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/inputTextPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { InputText } from "@babylonjs/gui/2D/controls/inputText";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IInputTextPropertyGridComponentProps {
    inputTexts: InputText[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
    constructor(props: IInputTextPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imagePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Image } from "@babylonjs/gui/2D/controls/image";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IImagePropertyGridComponentProps {
    images: Image[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
    private _observers;
    constructor(props: IImagePropertyGridComponentProps);
    shouldComponentUpdate(nextProps: IImagePropertyGridComponentProps): boolean;
    updateObservers(oldImages: Image[], newImages: Image[]): void;
    componentWillUnmount(): void;
    toggleAnimations(on: boolean): void;
    getMaxCells(): number;
    updateCellSize(): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IImageBasedSliderPropertyGridComponentProps {
    imageBasedSliders: ImageBasedSlider[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
    constructor(props: IImageBasedSliderPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/gridPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Grid } from "@babylonjs/gui/2D/controls/grid";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IGridPropertyGridComponentProps {
    grids: Grid[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
    onUpdateRequiredObservable?: Observable<void>;
}
interface IGridPropertyComponentState {
    removingColumn: boolean;
    removingRow: boolean;
}
export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps, IGridPropertyComponentState> {
    constructor(props: IGridPropertyGridComponentProps);
    private _previousGrid;
    private _rowDefinitions;
    private _rowEditFlags;
    private _columnEditFlags;
    private _columnDefinitions;
    private _editedRow;
    private _editedColumn;
    private _rowChild;
    private _columnChild;
    renderRows(): import("react/jsx-runtime").JSX.Element[];
    setRowValues(): void;
    setColumnValues(): void;
    renderColumns(): import("react/jsx-runtime").JSX.Element[];
    parsePercentage(value: string): number;
    isCloseTo(value: number, expected: number, epsilon?: number): boolean;
    adjustPercentages(definitions: string[], editFlags: boolean[]): string[];
    resizeRow(): void;
    resizeColumn(): void;
    checkValue(value: string, percent: boolean): string;
    checkPercentage(value: string): boolean;
    resetValues(): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/ellipsePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IEllipsePropertyGridComponentProps {
    ellipses: Ellipse[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
    constructor(props: IEllipsePropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/displayGridPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IDisplayGridPropertyGridComponentProps {
    displayGrids: DisplayGrid[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class DisplayGridPropertyGridComponent extends React.Component<IDisplayGridPropertyGridComponentProps> {
    constructor(props: IDisplayGridPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/controlPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IControlPropertyGridComponentProps {
    controls: Control[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
    constructor(props: IControlPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/containerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Container } from "@babylonjs/gui/2D/controls/container";
interface IContainerPropertyGridComponentProps {
    containers: Container[];
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class ContainerPropertyGridComponent extends React.Component<IContainerPropertyGridComponentProps> {
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/commonControlPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { IInspectableOptions } from "@babylonjs/core/Misc/iInspectable";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface ICommonControlPropertyGridComponentProps {
    controls: Control[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    hideDimensions?: boolean;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
interface ICommonControlPropertyGridComponentState {
    fontFamilyOptions: IInspectableOptions[];
}
export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps, ICommonControlPropertyGridComponentState> {
    private _onPropertyChangedObserver;
    private _onFontsParsedObserver;
    private _onControlVisibilityChangedObservers;
    constructor(props: ICommonControlPropertyGridComponentProps);
    componentDidMount(): void;
    private _checkFontsInLayout;
    private _addFont;
    private _getTransformedReferenceCoordinate;
    private _updateAlignment;
    private _checkAndUpdateValues;
    private _addOrUpdateMetadata;
    private _removeFromMetadata;
    private _getCommonPropertyKeys;
    private _markChildrenAsDirty;
    componentWillUnmount(): void;
    _filterFontDuplicates(array: {
        label: string;
        value: string;
        id: string;
    }[]): {
        label: string;
        value: string;
        id: string;
    }[];
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/colorPickerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IColorPickerPropertyGridComponentProps {
    colorPickers: ColorPicker[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
    constructor(props: IColorPickerPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/checkboxPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface ICheckboxPropertyGridComponentProps {
    checkboxes: Checkbox[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
    constructor(props: ICheckboxPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/buttonPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IButtonPropertyGridComponentProps {
    rectangles: Rectangle[];
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    onAddComponent: (newComponent: string) => void;
    onFontsParsedObservable?: Observable<void>;
    globalState?: GlobalState;
}
export class ButtonPropertyGridComponent extends React.Component<IButtonPropertyGridComponentProps> {
    constructor(props: IButtonPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/mcpSession/mcpSessionComponent" {
import { FunctionComponent } from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
interface IMcpSessionComponentProps {
    globalState: GlobalState;
}
/**
 * Panel that connects to a live MCP session for bidirectional GUI sync.
 * @param props - Component props.
 * @returns The React element.
 */
export const McpSessionComponent: FunctionComponent<IMcpSessionComponentProps>;
export {};

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

}
declare module "@babylonjs/gui-editor/components/guiList/guiListComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/gui-editor/globalState";
import "@babylonjs/gui-editor/components/guiList/guiList.scss";
interface IGuiListComponentProps {
    globalState: GlobalState;
}
export class GuiListComponent extends React.Component<IGuiListComponentProps, {
    filter: string;
}> {
    private _onResetRequiredObserver;
    private static _Tooltips;
    constructor(props: IGuiListComponentProps);
    componentWillUnmount(): void;
    filterContent(filter: string): void;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/propertyChangedEvent" {
export class PropertyChangedEvent {
    object: any;
    property: string;
    value: any;
    initialValue: any;
    allowNullValue?: boolean;
}

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/copyCommandToClipboard" {
export function copyCommandToClipboard(strCommand: string): void;
export function getClassNameWithNamespace(obj: any): {
    className: string;
    babylonNamespace: string;
};

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
interface ITextBlockPropertyGridComponentProps {
    textBlock: TextBlock;
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
    constructor(props: ITextBlockPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/linePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { InputText } from "@babylonjs/gui/2D/controls/inputText";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
interface IInputTextPropertyGridComponentProps {
    inputText: InputText;
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
    constructor(props: IInputTextPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/imagePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/gridPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element[];
    renderColumns(): import("react/jsx-runtime").JSX.Element[];
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/controlPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
interface IControlPropertyGridComponentProps {
    control: Control;
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
    constructor(props: IControlPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { Control } from "@babylonjs/gui/2D/controls/control";
import { LockObject } from "@babylonjs/gui-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): import("react/jsx-runtime").JSX.Element | null;
    render(): import("react/jsx-runtime").JSX.Element | undefined;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
interface IColorPickerPropertyGridComponentProps {
    colorPicker: ColorPicker;
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
    constructor(props: IColorPickerPropertyGridComponentProps);
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/split/splitter" {
import { ControlledSize } from "@babylonjs/gui-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/gui-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/gui-editor/split/splitContainer" {
import { PropsWithChildren } from "react";
import { SplitDirection } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/typeLedger" {
import { INodeContainer } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeContainer";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
export class TypeLedger {
    static PortDataBuilder: (port: NodePort, nodeContainer: INodeContainer) => IPortData;
    static NodeDataBuilder: (data: any, nodeContainer: INodeContainer) => INodeData;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/tools" {
import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
import { FramePortData } from "@babylonjs/gui-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/gui-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/gui-editor/nodeGraphSystem/frameNodePort";
import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { INodeContainer } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeContainer";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
import { ISelectionChangedOptions } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/selectionChangedOptions";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
import { HistoryStack } from "@babylonjs/gui-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;
    }>;
    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/gui-editor/nodeGraphSystem/searchBox" {
import * as React from "react";
import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
import "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element | null;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/propertyLedger" {
import { ComponentClass } from "react";
import { IPropertyComponentProps } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export class PropertyLedger {
    static DefaultControl: ComponentClass<IPropertyComponentProps>;
    static RegisteredControls: {
        [key: string]: ComponentClass<IPropertyComponentProps>;
    };
}

}
declare module "@babylonjs/gui-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/gui-editor/nodeGraphSystem/graphNode";
import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
import { ISelectionChangedOptions } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/selectionChangedOptions";
import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
import { IDisplayManager } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/displayManager";
import { IPortData } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/nodeLink" {
import { Observable } from "@babylonjs/core/Misc/observable";
import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { GraphCanvasComponent } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/nodeLedger" {
export class NodeLedger {
    static RegisteredNodeNames: string[];
    static NameFormatter: (name: string) => string;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/graphStickyNote" {
import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
import { IStickyNoteData } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/graphSearch" {
import * as React from "react";
import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element | null;
}
export {};

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/graphNode" {
import { Nullable } from "@babylonjs/core/types";
import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/graphMinimap" {
import * as React from "react";
import { GraphCanvasComponent } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/graphFrame" {
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { GraphCanvasComponent } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/frameNodePort";
import { IFrameData } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/graphCanvas" {
import * as React from "react";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { Nullable } from "@babylonjs/core/types";
import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
import { GraphStickyNote } from "@babylonjs/gui-editor/nodeGraphSystem/graphStickyNote";
import { IEditorData, IFrameData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
import { INodeContainer } from "@babylonjs/gui-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;
    _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;
    /**
     * Pans the canvas so the given node is visible and roughly centered.
     * @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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort" {
import { IDisplayManager } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/displayManager";
import { Observable } from "@babylonjs/core/Misc/observable";
import { Nullable } from "@babylonjs/core/types";
import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { FramePortPosition } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
import { StateManager } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/displayLedger" {
export class DisplayLedger {
    static RegisteredControls: {
        [key: string]: any;
    };
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/automaticProperties" {
import { IEditablePropertyOption } from "@babylonjs/core/Decorators/nodeDecorator";
import { StateManager } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/types/framePortData" {
import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
export type FramePortData = {
    frame: GraphFrame;
    port: FrameNodePort;
};

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/selectionChangedOptions" {
import { Nullable } from "@babylonjs/core/types";
import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { GraphStickyNote } from "@babylonjs/gui-editor/nodeGraphSystem/graphStickyNote";
import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
import { FramePortData } from "@babylonjs/gui-editor/nodeGraphSystem/types/framePortData";
export interface ISelectionChangedOptions {
    selection: Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData | GraphStickyNote>;
    forceKeepSelection?: boolean;
    marqueeSelection?: boolean;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/propertyComponentProps" {
import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
export interface IPropertyComponentProps {
    stateManager: StateManager;
    nodeData: INodeData;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData" {
import { Nullable } from "@babylonjs/core/types";
import { GraphNode } from "@babylonjs/gui-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/gui-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/gui-editor/nodeGraphSystem/interfaces/nodeData" {
import { Nullable } from "@babylonjs/core/types";
import { IPortData } from "@babylonjs/gui-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/gui-editor/nodeGraphSystem/interfaces/nodeContainer" {
import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
export interface INodeContainer {
    nodes: GraphNode[];
    appendNode(data: INodeData): GraphNode;
}

}
declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/displayManager" {
import { Nullable } from "@babylonjs/core/types";
import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/gui-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/gui-editor/modularTool/modularTool" {
import { IExtensionFeed } from "@babylonjs/gui-editor/modularTool/extensibility/extensionFeed";
import { WeaklyTypedServiceDefinition, ServiceContainer } from "@babylonjs/gui-editor/modularTool/modularity/serviceContainer";
import { ShellServiceOptions } from "@babylonjs/gui-editor/modularTool/services/shellService";
import { ThemeMode } from "@babylonjs/gui-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/gui-editor/modularTool/modularBridge" {
import { IDisposable } from "@babylonjs/core/index";
import { WeaklyTypedServiceDefinition, ServiceContainer } from "@babylonjs/gui-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/gui-editor/modularTool/themes/babylonTheme" {

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

}
declare module "@babylonjs/gui-editor/modularTool/services/toastService" {
import { IService } from "@babylonjs/gui-editor/modularTool/modularity/serviceDefinition";
import { ToastOptions } from "@babylonjs/gui-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/gui-editor/modularTool/services/themeService" {

import { IDisposable, IReadonlyObservable } from "@babylonjs/core/index";
import { IService, ServiceDefinition } from "@babylonjs/gui-editor/modularTool/modularity/serviceDefinition";
import { ISettingsStore, SettingDescriptor } from "@babylonjs/gui-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/gui-editor/modularTool/services/themeSelectorService" {
import { ServiceDefinition } from "@babylonjs/gui-editor/modularTool/modularity/serviceDefinition";
import { IShellService } from "@babylonjs/gui-editor/modularTool/services/shellService";
export const ThemeSelectorServiceDefinition: ServiceDefinition<[], [IShellService]>;

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

}
declare module "@babylonjs/gui-editor/modularTool/services/shellService" {
import { ComponentType } from "react";
import { IDisposable, Nullable } from "@babylonjs/core/index";
import { IService, ServiceDefinition } from "@babylonjs/gui-editor/modularTool/modularity/serviceDefinition";
import { SettingDescriptor } from "@babylonjs/gui-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/gui-editor/modularTool/services/settingsStore" {
import { IReadonlyObservable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/gui-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/gui-editor/modularTool/services/settingsService" {
import { IDisposable } from "@babylonjs/core/index";
import { DynamicAccordionSection, DynamicAccordionSectionContent } from "@babylonjs/gui-editor/modularTool/components/extensibleAccordion";
import { IService, ServiceDefinition } from "@babylonjs/gui-editor/modularTool/modularity/serviceDefinition";
import { IShellService } from "@babylonjs/gui-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/gui-editor/modularTool/services/reactContextService" {
import { Context } from "react";
import { IDisposable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/gui-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/gui-editor/modularTool/services/globalSettings" {
import { SettingDescriptor } from "@babylonjs/gui-editor/modularTool/services/settingsStore";
export const CompactModeSettingDescriptor: SettingDescriptor<boolean>;
export const DisableCopySettingDescriptor: SettingDescriptor<boolean>;

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

}
declare module "@babylonjs/gui-editor/modularTool/services/dialogService" {
import { IService } from "@babylonjs/gui-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/gui-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/gui-editor/modularTool/services/cli/bridgeService" {
import { ServiceDefinition } from "@babylonjs/gui-editor/modularTool/modularity/serviceDefinition";
import { ICliConnectionStatus } from "@babylonjs/gui-editor/modularTool/services/cli/bridgeConnectionStatus";
import { IBridgeCommandRegistry } from "@babylonjs/gui-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/gui-editor/modularTool/services/cli/bridgeConnectionStatus" {
import { IReadonlyObservable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/gui-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/gui-editor/modularTool/services/cli/bridgeCommandRegistry" {
import { IDisposable } from "@babylonjs/core/index";
import { IService } from "@babylonjs/gui-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/gui-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/gui-editor/modularTool/modularity/serviceContainer" {
import { IDisposable } from "@babylonjs/core/index";
import { IService, ServiceDefinition } from "@babylonjs/gui-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/gui-editor/modularTool/misc/observableCollection" {
import { IDisposable, IReadonlyObservable } from "@babylonjs/core/index";
/**
 * A collection of items that can be observed for changes.
 */
export class ObservableCollection<T> {
    private readonly _items;
    private readonly _keys;
    private readonly _observable;
    /**
     * 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;
}

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/modularTool/hooks/themeHooks" {
import { ThemeMode } from "@babylonjs/gui-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/gui-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/gui-editor/modularTool/hooks/settingsHooks" {
import { Dispatch, SetStateAction } from "react";
import { SettingDescriptor } from "@babylonjs/gui-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/gui-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/gui-editor/modularTool/hooks/observableHooks" {
import { IReadonlyObservable } from "@babylonjs/core/index";
import { ObservableCollection } from "@babylonjs/gui-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 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: ObservableCollection<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: ObservableCollection<T>): T[];

}
declare module "@babylonjs/gui-editor/modularTool/extensibility/extensionManager" {
import { IDisposable } from "@babylonjs/core/index";
import { ServiceContainer } from "@babylonjs/gui-editor/modularTool/modularity/serviceContainer";
import { IExtensionFeed, ExtensionMetadata } from "@babylonjs/gui-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/gui-editor/modularTool/extensibility/extensionFeed" {
import { WeaklyTypedServiceDefinition } from "@babylonjs/gui-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/gui-editor/modularTool/extensibility/builtInsExtensionFeed" {
import { IExtensionFeed, ExtensionMetadata, IExtensionMetadataQuery, ExtensionModule } from "@babylonjs/gui-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/gui-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/gui-editor/modularTool/contexts/settingsContext" {
import { ISettingsStore } from "@babylonjs/gui-editor/modularTool/services/settingsStore";
export const SettingsStoreContext: import("react").Context<ISettingsStore | undefined>;
export function useSettingsStore(): ISettingsStore | undefined;

}
declare module "@babylonjs/gui-editor/modularTool/contexts/extensionManagerContext" {
import { ExtensionManager } from "@babylonjs/gui-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/gui-editor/modularTool/contexts/dialogContext" {
import { DialogOptions } from "@babylonjs/gui-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/gui-editor/modularTool/components/uxContextProvider" {
import { FunctionComponent, PropsWithChildren } from "react";
export const UXContextProvider: FunctionComponent<PropsWithChildren>;

}
declare module "@babylonjs/gui-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/gui-editor/modularTool/components/teachingMoment" {
import { FunctionComponent } from "react";
import { MakePopoverTeachingMoment } from "@babylonjs/gui-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/gui-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/gui-editor/modularTool/components/extensibleAccordion" {
import { ComponentType, PropsWithChildren, Ref } from "react";
import { AccordionProps } from "@babylonjs/gui-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-runtime").JSX.Element;

}
declare module "@babylonjs/gui-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-runtime").JSX.Element | null | undefined;
}
export {};

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/unitButton" {
interface IUnitButtonProps {
    unit: string;
    locked?: boolean;
    onClick?: (unit: string) => void;
}
export function UnitButton(props: IUnitButtonProps): import("react/jsx-runtime").JSX.Element;
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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): import("react/jsx-runtime").JSX.Element | null;
    renderOriginal(isLink: boolean, tooltip: string): import("react/jsx-runtime").JSX.Element;
    renderFluent(isLink: boolean, tooltip: string): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/textInputLineComponent" {
import { ReactNode, KeyboardEvent, Component } from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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-runtime").JSX.Element;
    renderOriginal(value: string, placeholder: string, step: number): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/lines/targetsProxy" {
import { PropertyChangedEvent } from "@babylonjs/gui-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/gui-editor/lines/sliderLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/optionsLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/lines/numericInputComponent" {
import * as React from "react";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/lineContainerComponent" {
import * as React from "react";
import { ISelectedLineContainer } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    componentDidMount(): void;
    renderFluent(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/iconComponent" {
import * as React from "react";
interface IIconComponentProps {
    icon: string;
    label?: string;
}
export class IconComponent extends React.Component<IIconComponentProps> {
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/iSelectedLineContainer" {
export interface ISelectedLineContainer {
    selectedLineContainerTitles: Array<string>;
    selectedLineContainerTitlesNoFocus: Array<string>;
}

}
declare module "@babylonjs/gui-editor/lines/hexLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/floatLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

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

}
declare module "@babylonjs/gui-editor/lines/colorPickerComponent" {
import * as React from "react";
import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/lines/color4LineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/lines/color3LineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/lines/checkBoxLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderFluent(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
    renderOriginal(): import("react/jsx-runtime").JSX.Element;
    render(): import("react/jsx-runtime").JSX.Element;
}

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









}
declare module "@babylonjs/gui-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/gui-editor/fluent/primitives/uploadButton" {
import { FunctionComponent } from "react";
import { ButtonProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/toggleButton" {

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

type ToggleButtonProps = Omit<ButtonProps, "icon" | "onClick"> & {
    value: boolean;
    checkedIcon: any;
    uncheckedIcon?: any;
    onChange: (checked: boolean) => void;
    titlePositioning?: any["positioning"];
};
/**
 * Toggles between two states using a button with icons.
 * If no disabledIcon is provided, the button will toggle between visual enabled/disabled states without an icon change
 *
 * @param props
 * @returns
 */
export const ToggleButton: FunctionComponent<ToggleButtonProps>;
export {};

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/textarea" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/textInput" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-editor/fluent/primitives/primitive";
export type TextInputProps = PrimitiveProps<string> & {
    validator?: (value: string) => boolean;
    validateOnlyOnBlur?: boolean;
};
export const TextInput: FunctionComponent<TextInputProps>;

}
declare module "@babylonjs/gui-editor/fluent/primitives/syncedSlider" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/switch" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-editor/fluent/primitives/primitive";
export type SwitchProps = PrimitiveProps<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/gui-editor/fluent/primitives/spinButton" {
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: number;
    infoLabel?: import("@babylonjs/gui-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/gui-editor/fluent/primitives/slider" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/gui-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/gui-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/gui-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/gui-editor/fluent/primitives/primitive" {
import { InfoLabelParentProps } from "@babylonjs/gui-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/gui-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/gui-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/gui-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/gui-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/gui-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/gui-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/gui-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/gui-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/link" {
import { ImmutablePrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: string;
    infoLabel?: import("@babylonjs/gui-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/gui-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/gui-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/gui-editor/fluent/primitives/gradient" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/entitySelector" {
import { Nullable } from "@babylonjs/core/types";
import { ImmutablePrimitiveProps, PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/dropdown" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-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/gui-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/gui-editor/fluent/primitives/contextMenu" {
import { ReactElement } from "react";


import { BasePrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/comboBox" {
import { PrimitiveProps } from "@babylonjs/gui-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;
    /**
     * 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/gui-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: string;
    infoLabel?: import("@babylonjs/gui-editor/fluent/primitives/infoLabel").InfoLabelParentProps;
} & {
    onChange: (value: string) => void;
} & {
    /**
     * Label for the ComboBox
     */
    label: 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/gui-editor/fluent/primitives/colorPicker" {
import { FunctionComponent } from "react";
import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/primitive").BasePrimitiveProps & {
    value: Color3 | Color4;
    infoLabel?: import("@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/clusteredLightContainerSelector" {
import { FunctionComponent } from "react";
import { Scene } from "@babylonjs/core/scene";
import { Nullable } from "@babylonjs/core/types";
import { PrimitiveProps } from "@babylonjs/gui-editor/fluent/primitives/primitive";
import { EntitySelectorProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/checkbox" {
import { FunctionComponent } from "react";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/primitives/button" {
import { MouseEvent } from "react";

import { BasePrimitiveProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/accordion.contexts" {
import { RefObject } from "react";
import { AccordionProps, AccordionSectionBlockProps, AccordionSectionItemProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/hooks/keyboardHooks" {
import { WindowOptions } from "@babylonjs/gui-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/gui-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/gui-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/gui-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/gui-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/gui-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/gui-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/gui-editor/fluent/hoc/fileUploadLine" {
import { FunctionComponent } from "react";
import { ButtonProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/hoc/buttonLine" {
import { FunctionComponent } from "react";
import { ButtonProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/vectorPropertyLine" {
import { FunctionComponent } from "react";
import { Vector3, Quaternion, Vector2, Vector4 } from "@babylonjs/core/Maths/math.vector";
import { PrimitiveProps } from "@babylonjs/gui-editor/fluent/primitives/primitive";
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
export type TensorPropertyLineProps<V extends Vector2 | Vector3 | Vector4 | Quaternion> = PropertyLineProps<V> & PrimitiveProps<V> & {
    /**
     * If passed, all sliders will use this for the min value
     */
    min?: number;
    /**
     * If passed, all sliders will use this for the max value
     */
    max?: number;
    /**
     * Will be displayed in the input UI to indicate the unit of measurement
     */
    unit?: string;
    /**
     * Internal spinbutton's step
     */
    step?: number;
    /** Optional fixed precision (number of decimal digits). Overrides the automatically computed display precision. */
    precision?: number;
    /**
     * If passed, the UX will use the conversion functions to display/update values
     */
    valueConverter?: {
        /**
         * Will call from(val) before displaying in the UX
         */
        from: (val: number) => number;
        /**
         * Will call to(val) before calling onChange
         */
        to: (val: number) => number;
    };
};
type RotationVectorPropertyLineProps = TensorPropertyLineProps<Vector3> & {
    /**
     * Display angles as degrees instead of radians
     */
    useDegrees?: boolean;
};
export const RotationVectorPropertyLine: FunctionComponent<RotationVectorPropertyLineProps>;
type QuaternionPropertyLineProps = TensorPropertyLineProps<Quaternion> & {
    /**
     * Display angles as degrees instead of radians
     */
    useDegrees?: boolean;
    /**
     * Display angles as Euler angles instead of quaternions
     */
    useEuler?: boolean;
};
export const QuaternionPropertyLine: FunctionComponent<QuaternionPropertyLineProps>;
export const Vector2PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector2>>;
export const Vector3PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector3>>;
export const Vector4PropertyLine: FunctionComponent<TensorPropertyLineProps<Vector4>>;
export {};

}
declare module "@babylonjs/gui-editor/fluent/hoc/propertyLines/textPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { ImmutablePrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/textAreaPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { TextareaProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/syncedSliderPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { SyncedSliderProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/switchPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { SwitchProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/stringifiedPropertyLine" {
import { ImmutablePrimitiveProps } from "@babylonjs/gui-editor/fluent/primitives/primitive";
import { PropertyLineProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/spinButtonPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { SpinButtonProps } from "@babylonjs/gui-editor/fluent/primitives/spinButton";
export const SpinButtonPropertyLine: FunctionComponent<PropertyLineProps<number> & SpinButtonProps>;

}
declare module "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine" {
import { FunctionComponent, HTMLProps, PropsWithChildren } from "react";
import { AccordionSectionItemProps } from "@babylonjs/gui-editor/fluent/primitives/accordion";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/linkPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { LinkProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/inputPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { FunctionComponent } from "react";
import { TextInputProps } from "@babylonjs/gui-editor/fluent/primitives/textInput";
import { SpinButtonProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/hexPropertyLine" {
import { FunctionComponent } from "react";
import { NumberInputPropertyLineProps } from "@babylonjs/gui-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/gui-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/gui-editor/fluent/primitives/clusteredLightContainerSelector";
import { MaterialSelectorProps } from "@babylonjs/gui-editor/fluent/primitives/materialSelector";
import { NodeSelectorProps } from "@babylonjs/gui-editor/fluent/primitives/nodeSelector";
import { SkeletonSelectorProps } from "@babylonjs/gui-editor/fluent/primitives/skeletonSelector";
import { TextureSelectorProps } from "@babylonjs/gui-editor/fluent/primitives/textureSelector";
import { PropertyLineProps } from "@babylonjs/gui-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-runtime").JSX.Element;
export const MaterialSelectorPropertyLine: (props: MaterialSelectorPropertyLineProps) => import("react/jsx-runtime").JSX.Element;
export const TextureSelectorPropertyLine: (props: TextureSelectorPropertyLineProps) => import("react/jsx-runtime").JSX.Element;
export const SkeletonSelectorPropertyLine: (props: SkeletonSelectorPropertyLineProps) => import("react/jsx-runtime").JSX.Element;
export const ClusteredLightContainerSelectorPropertyLine: (props: ClusteredLightContainerSelectorPropertyLineProps) => import("react/jsx-runtime").JSX.Element;
export {};

}
declare module "@babylonjs/gui-editor/fluent/hoc/propertyLines/dropdownPropertyLine" {
import { AcceptedDropdownValue, DropdownProps } from "@babylonjs/gui-editor/fluent/primitives/dropdown";
import { PropertyLineProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/comboBoxPropertyLine" {
import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { ComboBoxProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/colorPropertyLine" {
import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
import { ColorPickerProps } from "@babylonjs/gui-editor/fluent/primitives/colorPicker";
export type ColorPropertyLineProps = ColorPickerProps<Color3 | Color4> & PropertyLineProps<Color3 | Color4>;
export const Color3PropertyLine: FunctionComponent<ColorPickerProps<Color3> & PropertyLineProps<Color3>>;
export const Color4PropertyLine: FunctionComponent<ColorPickerProps<Color4> & PropertyLineProps<Color4>>;

}
declare module "@babylonjs/gui-editor/fluent/hoc/propertyLines/checkboxPropertyLine" {
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { PrimitiveProps } from "@babylonjs/gui-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/gui-editor/fluent/hoc/propertyLines/booleanBadgePropertyLine" {
import { FunctionComponent } from "react";
import { PropertyLineProps } from "@babylonjs/gui-editor/fluent/hoc/propertyLines/propertyLine";
import { ImmutablePrimitiveProps } from "@babylonjs/gui-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/gui-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/gui-editor/components/classNames" {
export function ClassNames(names: any, styleObject: any): string;
export function JoinClassNames(styleObject: any, ...names: string[]): string;

}
declare module "@babylonjs/gui-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/gui-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-runtime").JSX.Element;

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/components/Icon" {
export type IconProps = {
    color?: "dark" | "light";
    icon: string;
};
export const Icon: React.FC<IconProps>;

}
declare module "@babylonjs/gui-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/gui-editor/components/reactGraphSystem/useGraphContext" {
/**
 * utility hook to assist using the graph context
 * @returns
 */
export const useGraphContext: () => import("@babylonjs/gui-editor/components/reactGraphSystem/GraphContextManager").IGraphContext;

}
declare module "@babylonjs/gui-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-runtime").JSX.Element;

}
declare module "@babylonjs/gui-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/gui-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/gui-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/gui-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/gui-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/gui-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/gui-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/gui-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-runtime").JSX.Element;

}
declare module "@babylonjs/gui-editor/components/lines/NumericInputComponent" {
import * as React from "react";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/components/lines/ColorPickerLineComponent" {
import * as React from "react";
import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-editor/components/layout/utils" {
import { Layout, LayoutColumn, LayoutTabsRow } from "@babylonjs/gui-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/gui-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/gui-editor/components/layout/LayoutContext" {
import { Layout } from "@babylonjs/gui-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/gui-editor/components/layout/FlexibleTabsContainer" {
import { FC } from "react";
import { LayoutTab } from "@babylonjs/gui-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/gui-editor/components/layout/FlexibleTab" {
import { FC } from "react";
import { TabDrag } from "@babylonjs/gui-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/gui-editor/components/layout/FlexibleResizeBar" {
import { FC } from "react";
import { ResizeDirections } from "@babylonjs/gui-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/gui-editor/components/layout/FlexibleGridLayout" {
import { FC } from "react";
import { Layout } from "@babylonjs/gui-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/gui-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/gui-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/gui-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/gui-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/gui-editor/components/layout/DraggableIcon" {
import { FC } from "react";
import { ElementTypes, TabDrag } from "@babylonjs/gui-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/gui-editor/components/colorPicker/HexColor" {
import * as React from "react";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/components/colorPicker/ColorPicker" {
import * as React from "react";
import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/components/colorPicker/ColorComponentEntry" {
import * as React from "react";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}
export {};

}
declare module "@babylonjs/gui-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/gui-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/gui-editor/colorPicker/hexColor" {
import * as React from "react";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/colorPicker/colorPicker" {
import * as React from "react";
import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
import { LockObject } from "@babylonjs/gui-editor/tabs/propertyGrids/lockObject";
import "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}
declare module "@babylonjs/gui-editor/colorPicker/colorComponentEntry" {
import * as React from "react";
import { LockObject } from "@babylonjs/gui-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(): import("react/jsx-runtime").JSX.Element;
}

}

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