babylonjs-gui-editor 5.12.1 → 5.13.0

package/babylon.guiEditor.d.ts

@@ -1240,6 +1240,7 @@ declare module BABYLON.GuiEditor.SharedUIComponents {
         onClick: () => void;
         icon?: string;
         iconLabel?: string;
+        isDisabled?: boolean;
     }
     export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
         constructor(props: IButtonLineComponentProps);
@@ -1302,7 +1303,7 @@ declare module BABYLON.GuiEditor.SharedUIComponents {
         icon?: string;
         lockObject?: BABYLON.GuiEditor.SharedUIComponents.LockObject;
         iconLabel?: string;
-        onValueChange?: (value: string) => void;
+        onChange?: () => void;
     }
     export class Color3LineComponent extends React.Component<IColor3LineComponentProps> {
         render(): JSX.Element;
@@ -1697,6 +1698,42 @@ declare module BABYLON.GuiEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        interface IMatrixLineComponentProps {
+        label: string;
+        target: any;
+        propertyName: string;
+        step?: number;
+        onChange?: (newValue: Matrix) => void;
+        onModeChange?: (mode: number) => void;
+        onPropertyChangedObservable?: Observable<BABYLON.GuiEditor.SharedUIComponents.PropertyChangedEvent>;
+        mode?: number;
+    }
+    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(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON {
 
@@ -1758,24 +1795,29 @@ declare module BABYLON.GuiEditor.SharedUIComponents {
         propertyName: string;
         options: IInspectableOptions[];
         noDirectUpdate?: boolean;
-        onSelect?: (value: number) => void;
-        extractValue?: () => number;
+        onSelect?: (value: number | string) => void;
+        extractValue?: (target: any) => number | string;
         onPropertyChangedObservable?: Observable<BABYLON.GuiEditor.SharedUIComponents.PropertyChangedEvent>;
         allowNullValue?: boolean;
         icon?: string;
         iconLabel?: string;
+        className?: string;
+        valuesAreStrings?: boolean;
+        defaultIfNull?: number;
     }
     export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
-        value: number;
+        value: number | string;
     }> {
         private _localChange;
         private _remapValueIn;
         private _remapValueOut;
+        private _getValue;
         constructor(props: IOptionsLineComponentProps);
         shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
             value: number;
         }): boolean;
         raiseOnPropertyChanged(newValue: number, previousValue: number): void;
+        setValue(value: string | number): void;
         updateValue(valueString: string): void;
         render(): JSX.Element;
     }
@@ -1904,6 +1946,8 @@ declare module BABYLON.GuiEditor.SharedUIComponents {
         max?: number;
         placeholder?: string;
         unit?: React.ReactNode;
+        validator?: (value: string) => boolean;
+        multilines?: boolean;
     }
     export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
         value: string;
@@ -2075,14 +2119,15 @@ declare module BABYLON {
 declare module BABYLON.GuiEditor.SharedUIComponents {
         interface IVector4LineComponentProps {
         label: string;
-        target: any;
-        propertyName: string;
+        target?: any;
+        propertyName?: string;
         step?: number;
         onChange?: (newvalue: Vector4) => void;
         useEuler?: boolean;
         onPropertyChangedObservable?: Observable<BABYLON.GuiEditor.SharedUIComponents.PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
+        value?: Vector4;
     }
     export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
         isExpanded: boolean;
@@ -2110,6 +2155,666 @@ declare module BABYLON.GuiEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class DisplayLedger {
+        static RegisteredControls: {
+            [key: string]: any;
+        };
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class FrameNodePort extends BABYLON.GuiEditor.SharedUIComponents.NodePort {
+        portData: BABYLON.GuiEditor.SharedUIComponents.IPortData;
+        node: BABYLON.GuiEditor.SharedUIComponents.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(): BABYLON.GuiEditor.SharedUIComponents.FramePortPosition;
+        set framePortPosition(position: BABYLON.GuiEditor.SharedUIComponents.FramePortPosition);
+        constructor(portContainer: HTMLElement, portData: BABYLON.GuiEditor.SharedUIComponents.IPortData, node: BABYLON.GuiEditor.SharedUIComponents.GraphNode, stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager, isInput: boolean, framePortId: number, parentFrameId: number);
+        static CreateFrameNodePortElement(portData: BABYLON.GuiEditor.SharedUIComponents.IPortData, node: BABYLON.GuiEditor.SharedUIComponents.GraphNode, root: HTMLElement, displayManager: Nullable<BABYLON.GuiEditor.SharedUIComponents.IDisplayManager>, stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export interface IGraphCanvasComponentProps {
+        stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager;
+        onEmitNewNode: (nodeData: BABYLON.GuiEditor.SharedUIComponents.INodeData) => BABYLON.GuiEditor.SharedUIComponents.GraphNode;
+    }
+    export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> implements BABYLON.GuiEditor.SharedUIComponents.INodeContainer {
+        private readonly _minZoom;
+        private readonly _maxZoom;
+        private _hostCanvas;
+        private _graphCanvas;
+        private _selectionContainer;
+        private _frameContainer;
+        private _svgCanvas;
+        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 _zoom;
+        private _selectedNodes;
+        private _selectedLink;
+        private _selectedPort;
+        private _candidateLink;
+        private _candidatePort;
+        private _gridSize;
+        private _selectionBox;
+        private _selectedFrames;
+        private _frameCandidate;
+        private _frames;
+        private _nodeDataContentList;
+        private _altKeyIsPressed;
+        private _multiKeyIsPressed;
+        private _oldY;
+        _frameIsMoving: boolean;
+        _isLoading: boolean;
+        get gridSize(): number;
+        set gridSize(value: number);
+        get stateManager(): BABYLON.GuiEditor.SharedUIComponents.StateManager;
+        get nodes(): BABYLON.GuiEditor.SharedUIComponents.GraphNode[];
+        get links(): BABYLON.GuiEditor.SharedUIComponents.NodeLink[];
+        get frames(): BABYLON.GuiEditor.SharedUIComponents.GraphFrame[];
+        get zoom(): number;
+        set zoom(value: number);
+        get x(): number;
+        set x(value: number);
+        get y(): number;
+        set y(value: number);
+        get selectedNodes(): BABYLON.GuiEditor.SharedUIComponents.GraphNode[];
+        get selectedLink(): Nullable<BABYLON.GuiEditor.SharedUIComponents.NodeLink>;
+        get selectedFrames(): BABYLON.GuiEditor.SharedUIComponents.GraphFrame[];
+        get selectedPort(): Nullable<BABYLON.GuiEditor.SharedUIComponents.NodePort>;
+        get canvasContainer(): HTMLDivElement;
+        get hostCanvas(): HTMLDivElement;
+        get svgCanvas(): HTMLElement;
+        get selectionContainer(): HTMLDivElement;
+        get frameContainer(): HTMLDivElement;
+        private _selectedFrameAndNodesConflict;
+        constructor(props: IGraphCanvasComponentProps);
+        getCachedData(): any[];
+        removeDataFromCache(data: any): void;
+        createNodeFromObject(nodeData: BABYLON.GuiEditor.SharedUIComponents.INodeData, onNodeCreated: (data: any) => void, recursion?: boolean): BABYLON.GuiEditor.SharedUIComponents.GraphNode;
+        getGridPosition(position: number, useCeil?: boolean): number;
+        getGridPositionCeil(position: number): number;
+        updateTransform(): void;
+        onKeyUp(): void;
+        findNodeFromData(data: any): BABYLON.GuiEditor.SharedUIComponents.GraphNode;
+        reset(): void;
+        connectPorts(pointA: BABYLON.GuiEditor.SharedUIComponents.IPortData, pointB: BABYLON.GuiEditor.SharedUIComponents.IPortData): void;
+        removeLink(link: BABYLON.GuiEditor.SharedUIComponents.NodeLink): void;
+        appendNode(data: BABYLON.GuiEditor.SharedUIComponents.INodeData): BABYLON.GuiEditor.SharedUIComponents.GraphNode;
+        distributeGraph(): void;
+        componentDidMount(): void;
+        onMove(evt: React.PointerEvent): void;
+        onDown(evt: React.PointerEvent<HTMLElement>): void;
+        onUp(evt: React.PointerEvent): void;
+        onWheel(evt: React.WheelEvent): void;
+        zoomToFit(): void;
+        processCandidatePort(): void;
+        connectNodes(nodeA: BABYLON.GuiEditor.SharedUIComponents.GraphNode, pointA: BABYLON.GuiEditor.SharedUIComponents.IPortData, nodeB: BABYLON.GuiEditor.SharedUIComponents.GraphNode, pointB: BABYLON.GuiEditor.SharedUIComponents.IPortData): void;
+        processEditorData(editorData: BABYLON.GuiEditor.SharedUIComponents.IEditorData): void;
+        reOrganize(editorData?: Nullable<BABYLON.GuiEditor.SharedUIComponents.IEditorData>, isImportingAFrame?: boolean): void;
+        addFrame(frameData: BABYLON.GuiEditor.SharedUIComponents.IFrameData): void;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        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(): BABYLON.GuiEditor.SharedUIComponents.GraphNode[];
+        get ports(): BABYLON.GuiEditor.SharedUIComponents.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: BABYLON.GuiEditor.SharedUIComponents.GraphCanvasComponent, doNotCaptureNodes?: boolean);
+        refresh(): void;
+        addNode(node: BABYLON.GuiEditor.SharedUIComponents.GraphNode): void;
+        removeNode(node: BABYLON.GuiEditor.SharedUIComponents.GraphNode): void;
+        syncNode(node: BABYLON.GuiEditor.SharedUIComponents.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: BABYLON.GuiEditor.SharedUIComponents.FrameNodePort): void;
+        private _movePortUp;
+        moveFramePortDown(nodePort: BABYLON.GuiEditor.SharedUIComponents.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): BABYLON.GuiEditor.SharedUIComponents.IFrameData;
+        export(): void;
+        adjustPorts(): void;
+        static Parse(serializationData: BABYLON.GuiEditor.SharedUIComponents.IFrameData, canvas: BABYLON.GuiEditor.SharedUIComponents.GraphCanvasComponent, map?: {
+            [key: number]: number;
+        }): GraphFrame;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        /// <reference types="react" />
+    export class GraphNode {
+        content: BABYLON.GuiEditor.SharedUIComponents.INodeData;
+        private _visual;
+        private _headerContainer;
+        private _warning;
+        private _header;
+        private _connections;
+        private _inputsContainer;
+        private _outputsContainer;
+        private _content;
+        private _comments;
+        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 _ownerCanvas;
+        private _isSelected;
+        private _displayManager;
+        private _isVisible;
+        private _enclosingFrameId;
+        get isVisible(): boolean;
+        set isVisible(value: boolean);
+        private _upateNodePortNames;
+        get outputPorts(): BABYLON.GuiEditor.SharedUIComponents.NodePort[];
+        get inputPorts(): BABYLON.GuiEditor.SharedUIComponents.NodePort[];
+        get links(): BABYLON.GuiEditor.SharedUIComponents.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 isSelected(): boolean;
+        get enclosingFrameId(): number;
+        set enclosingFrameId(value: number);
+        set isSelected(value: boolean);
+        setIsSelected(value: boolean, marqueeSelection: boolean): void;
+        constructor(content: BABYLON.GuiEditor.SharedUIComponents.INodeData, stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager);
+        isOverlappingFrame(frame: BABYLON.GuiEditor.SharedUIComponents.GraphFrame): boolean;
+        getPortForPortData(portData: BABYLON.GuiEditor.SharedUIComponents.IPortData): BABYLON.GuiEditor.SharedUIComponents.NodePort | null;
+        getPortDataForPortDataContent(data: any): BABYLON.GuiEditor.SharedUIComponents.IPortData | null;
+        getLinksForPortDataContent(data: any): BABYLON.GuiEditor.SharedUIComponents.NodeLink[];
+        getLinksForPortData(portData: BABYLON.GuiEditor.SharedUIComponents.IPortData): BABYLON.GuiEditor.SharedUIComponents.NodeLink[];
+        private _refreshFrames;
+        _refreshLinks(): void;
+        refresh(): void;
+        private _onDown;
+        cleanAccumulation(useCeil?: boolean): void;
+        private _onUp;
+        private _onMove;
+        renderProperties(): Nullable<JSX.Element>;
+        appendVisual(root: HTMLDivElement, owner: BABYLON.GuiEditor.SharedUIComponents.GraphCanvasComponent): void;
+        dispose(): void;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export interface IDisplayManager {
+        getHeaderClass(data: BABYLON.GuiEditor.SharedUIComponents.INodeData): string;
+        shouldDisplayPortLabels(data: BABYLON.GuiEditor.SharedUIComponents.IPortData): boolean;
+        updatePreviewContent(data: BABYLON.GuiEditor.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void;
+        getBackgroundColor(data: BABYLON.GuiEditor.SharedUIComponents.INodeData): string;
+        getHeaderText(data: BABYLON.GuiEditor.SharedUIComponents.INodeData): string;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export interface INodeContainer {
+        nodes: BABYLON.GuiEditor.SharedUIComponents.GraphNode[];
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export interface INodeData {
+        data: any;
+        name: string;
+        uniqueId: number;
+        isInput: boolean;
+        comments: string;
+        getWarningMessage: () => string;
+        getClassName: () => string;
+        dispose: () => void;
+        getPortByName: (name: string) => Nullable<BABYLON.GuiEditor.SharedUIComponents.IPortData>;
+        inputs: BABYLON.GuiEditor.SharedUIComponents.IPortData[];
+        outputs: BABYLON.GuiEditor.SharedUIComponents.IPortData[];
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        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 BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export enum PortDataDirection {
+        /** Input */
+        Input = 0,
+        /** Output */
+        Output = 1
+    }
+    export interface IPortData {
+        data: any;
+        name: string;
+        internalName: string;
+        isExposedOnFrame: boolean;
+        exposedPortPosition: number;
+        isConnected: boolean;
+        direction: PortDataDirection;
+        ownerData: any;
+        connectedPort: Nullable<IPortData>;
+        needDualDirectionValidation: boolean;
+        hasEndpoints: boolean;
+        endpoints: Nullable<IPortData[]>;
+        updateDisplayName: (newName: string) => void;
+        connectTo: (port: IPortData) => void;
+        disconnectFrom: (port: IPortData) => void;
+        checkCompatibilityState(port: IPortData): number;
+        getCompatibilityIssueMessage(issue: number, targetNode: BABYLON.GuiEditor.SharedUIComponents.GraphNode, targetPort: IPortData): string;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export interface IPropertyComponentProps {
+        stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager;
+        nodeData: BABYLON.GuiEditor.SharedUIComponents.INodeData;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export interface ISelectionChangedOptions {
+        selection: Nullable<BABYLON.GuiEditor.SharedUIComponents.GraphNode | BABYLON.GuiEditor.SharedUIComponents.NodeLink | BABYLON.GuiEditor.SharedUIComponents.GraphFrame | BABYLON.GuiEditor.SharedUIComponents.NodePort | BABYLON.GuiEditor.SharedUIComponents.FramePortData>;
+        forceKeepSelection?: boolean;
+        marqueeSelection?: boolean;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class NodeLink {
+        private _graphCanvas;
+        private _portA;
+        private _portB?;
+        private _nodeA;
+        private _nodeB?;
+        private _path;
+        private _selectionPath;
+        private _onSelectionChangedObserver;
+        private _isVisible;
+        onDisposedObservable: Observable<NodeLink>;
+        get isVisible(): boolean;
+        set isVisible(value: boolean);
+        get portA(): BABYLON.GuiEditor.SharedUIComponents.NodePort | BABYLON.GuiEditor.SharedUIComponents.FrameNodePort;
+        get portB(): BABYLON.GuiEditor.SharedUIComponents.NodePort | BABYLON.GuiEditor.SharedUIComponents.FrameNodePort | undefined;
+        get nodeA(): BABYLON.GuiEditor.SharedUIComponents.GraphNode;
+        get nodeB(): BABYLON.GuiEditor.SharedUIComponents.GraphNode | undefined;
+        update(endX?: number, endY?: number, straight?: boolean): void;
+        constructor(graphCanvas: BABYLON.GuiEditor.SharedUIComponents.GraphCanvasComponent, portA: BABYLON.GuiEditor.SharedUIComponents.NodePort, nodeA: BABYLON.GuiEditor.SharedUIComponents.GraphNode, portB?: BABYLON.GuiEditor.SharedUIComponents.NodePort, nodeB?: BABYLON.GuiEditor.SharedUIComponents.GraphNode);
+        onClick(evt: MouseEvent): void;
+        dispose(notify?: boolean): void;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class NodePort {
+        portData: BABYLON.GuiEditor.SharedUIComponents.IPortData;
+        node: BABYLON.GuiEditor.SharedUIComponents.GraphNode;
+        protected _element: HTMLDivElement;
+        protected _img: HTMLImageElement;
+        protected _stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager;
+        protected _portLabelElement: Element;
+        protected _onCandidateLinkMovedObserver: Nullable<Observer<Nullable<Vector2>>>;
+        protected _onSelectionChangedObserver: Nullable<Observer<Nullable<BABYLON.GuiEditor.SharedUIComponents.ISelectionChangedOptions>>>;
+        protected _exposedOnFrame: boolean;
+        delegatedPort: Nullable<BABYLON.GuiEditor.SharedUIComponents.FrameNodePort>;
+        get element(): HTMLDivElement;
+        get portName(): string;
+        set portName(newName: string);
+        get disabled(): boolean;
+        hasLabel(): boolean;
+        get exposedOnFrame(): boolean;
+        set exposedOnFrame(value: boolean);
+        get exposedPortPosition(): number;
+        set exposedPortPosition(value: number);
+        private _isConnectedToNodeOutsideOfFrame;
+        refresh(): void;
+        constructor(portContainer: HTMLElement, portData: BABYLON.GuiEditor.SharedUIComponents.IPortData, node: BABYLON.GuiEditor.SharedUIComponents.GraphNode, stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager);
+        dispose(): void;
+        static CreatePortElement(portData: BABYLON.GuiEditor.SharedUIComponents.IPortData, node: BABYLON.GuiEditor.SharedUIComponents.GraphNode, root: HTMLElement, displayManager: Nullable<BABYLON.GuiEditor.SharedUIComponents.IDisplayManager>, stateManager: BABYLON.GuiEditor.SharedUIComponents.StateManager): NodePort;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class PropertyLedger {
+        static DefaultControl: React.ComponentClass<BABYLON.GuiEditor.SharedUIComponents.IPropertyComponentProps>;
+        static RegisteredControls: {
+            [key: string]: React.ComponentClass<BABYLON.GuiEditor.SharedUIComponents.IPropertyComponentProps>;
+        };
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class StateManager {
+        data: any;
+        hostDocument: Document;
+        lockObject: any;
+        onSelectionChangedObservable: Observable<Nullable<BABYLON.GuiEditor.SharedUIComponents.ISelectionChangedOptions>>;
+        onFrameCreatedObservable: Observable<BABYLON.GuiEditor.SharedUIComponents.GraphFrame>;
+        onUpdateRequiredObservable: Observable<any>;
+        onGraphNodeRemovalObservable: Observable<BABYLON.GuiEditor.SharedUIComponents.GraphNode>;
+        onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
+        onCandidateLinkMoved: Observable<Nullable<Vector2>>;
+        onCandidatePortSelectedObservable: Observable<Nullable<BABYLON.GuiEditor.SharedUIComponents.NodePort | BABYLON.GuiEditor.SharedUIComponents.FrameNodePort>>;
+        onNewNodeCreatedObservable: Observable<BABYLON.GuiEditor.SharedUIComponents.GraphNode>;
+        onRebuildRequiredObservable: Observable<boolean>;
+        onErrorMessageDialogRequiredObservable: Observable<string>;
+        onExposePortOnFrameObservable: Observable<BABYLON.GuiEditor.SharedUIComponents.GraphNode>;
+        onGridSizeChanged: Observable<void>;
+        onNewBlockRequiredObservable: Observable<{
+            type: string;
+            targetX: number;
+            targetY: number;
+            needRepositioning?: boolean | undefined;
+        }>;
+        exportData: (data: any) => string;
+        isElbowConnectionAllowed: (nodeA: BABYLON.GuiEditor.SharedUIComponents.FrameNodePort | BABYLON.GuiEditor.SharedUIComponents.NodePort, nodeB: BABYLON.GuiEditor.SharedUIComponents.FrameNodePort | BABYLON.GuiEditor.SharedUIComponents.NodePort) => boolean;
+        applyNodePortDesign: (data: BABYLON.GuiEditor.SharedUIComponents.IPortData, element: HTMLElement, img: HTMLImageElement) => void;
+        storeEditorData: (serializationObject: any, frame?: Nullable<BABYLON.GuiEditor.SharedUIComponents.GraphFrame>) => void;
+        getEditorDataMap: () => {
+            [key: number]: number;
+        };
+        createDefaultInputData: (rootData: any, portData: BABYLON.GuiEditor.SharedUIComponents.IPortData, nodeContainer: BABYLON.GuiEditor.SharedUIComponents.INodeContainer) => {
+            data: BABYLON.GuiEditor.SharedUIComponents.INodeData;
+            name: string;
+        };
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export const IsFramePortData: (variableToCheck: any) => variableToCheck is BABYLON.GuiEditor.SharedUIComponents.FramePortData;
+    export const RefreshNode: (node: BABYLON.GuiEditor.SharedUIComponents.GraphNode, visitedNodes?: Set<BABYLON.GuiEditor.SharedUIComponents.GraphNode> | undefined, visitedLinks?: Set<BABYLON.GuiEditor.SharedUIComponents.NodeLink> | undefined) => void;
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export class TypeLedger {
+        static PortDataBuilder: (port: BABYLON.GuiEditor.SharedUIComponents.NodePort, nodeContainer: BABYLON.GuiEditor.SharedUIComponents.INodeContainer) => BABYLON.GuiEditor.SharedUIComponents.IPortData;
+        static NodeDataBuilder: (data: any, nodeContainer: BABYLON.GuiEditor.SharedUIComponents.INodeContainer) => BABYLON.GuiEditor.SharedUIComponents.INodeData;
+    }
+
+
+
+}
+declare module BABYLON {
+
+}
+declare module BABYLON.GuiEditor.SharedUIComponents {
+        export type FramePortData = {
+        frame: BABYLON.GuiEditor.SharedUIComponents.GraphFrame;
+        port: FrameNodePort;
+    };
+
+
+
 }
 declare module BABYLON {