@babylonjs/node-render-graph-editor/dist/babylon.nodeRenderGraphEditor.module.d.ts

Node Render Graph Editor es6

declare module "@babylonjs/node-render-graph-editor/serializationTools" {
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import { Nullable } from "@babylonjs/core/types";
import { GraphFrame } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphFrame";
import { NodeRenderGraph } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraph";
export class SerializationTools {
    static UpdateLocations(renderGraph: NodeRenderGraph, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
    static Serialize(renderGraph: NodeRenderGraph, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
    static Deserialize(serializationObject: any, globalState: GlobalState): void;
    static AddFrameToRenderGraph(serializationObject: any, globalState: GlobalState, currentRenderGraph: NodeRenderGraph): void;
}

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

}
declare module "@babylonjs/node-render-graph-editor/nodeRenderGraphEditor" {
import { NodeRenderGraph } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraph";
import { Observable } from "@babylonjs/core/Misc/observable";
import { Scene } from "@babylonjs/core/scene";
/**
 * Interface used to specify creation options for the node editor
 */
export interface INodeEditorOptions {
    nodeRenderGraph: NodeRenderGraph;
    hostScene?: Scene;
    hostElement?: HTMLElement;
    customSave?: {
        label: string;
        action: (data: string) => Promise<void>;
    };
    customLoadObservable?: Observable<any>;
}
/**
 * Class used to create a node editor
 */
export class NodeRenderGraphEditor {
    private static _CurrentState;
    private static _PopupWindow;
    /**
     * Show the node editor
     * @param options defines the options to use to configure the node editor
     */
    static Show(options: INodeEditorOptions): void;
}

}
declare module "@babylonjs/node-render-graph-editor/index" {
export * from "@babylonjs/node-render-graph-editor/nodeRenderGraphEditor";

}
declare module "@babylonjs/node-render-graph-editor/graphEditor" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import { Nullable } from "@babylonjs/core/types";
import { IInspectorOptions } from "@babylonjs/core/Debug/debugLayer";
import "@babylonjs/node-render-graph-editor/main.scss";
import { GraphNode } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphNode";
import { IEditorData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
import { NodeRenderGraphBlock } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraphBlock";
interface IGraphEditorProps {
    globalState: GlobalState;
}
interface IGraphEditorState {
    showPreviewPopUp: boolean;
    message: string;
    isError: boolean;
}
interface IInternalPreviewAreaOptions extends IInspectorOptions {
    popup: boolean;
    original: boolean;
    explorerWidth?: string;
    inspectorWidth?: string;
    embedHostWidth?: string;
}
export class GraphEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
    private _graphCanvasRef;
    private _diagramContainerRef;
    private _graphCanvas;
    private _previewManager;
    private _mouseLocationX;
    private _mouseLocationY;
    private _onWidgetKeyUpPointer;
    private _historyStack;
    private _previewHost;
    private _popUpWindow;
    private _externalTextures;
    appendBlock(dataToAppend: NodeRenderGraphBlock | INodeData, recursion?: boolean): GraphNode;
    addValueNode(type: string): GraphNode;
    prepareHistoryStack(): void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    constructor(props: IGraphEditorProps);
    zoomToFit(): void;
    private _setExternalInputs;
    buildRenderGraph(): void;
    build(ignoreEditorData?: boolean): void;
    loadGraph(): void;
    showWaitScreen(): void;
    hideWaitScreen(): void;
    reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
    onWheel: (evt: WheelEvent) => void;
    emitNewBlock(blockType: string, targetX: number, targetY: number): GraphNode | undefined;
    dropNewBlock(event: React.DragEvent<HTMLDivElement>): void;
    handlePopUp: () => void;
    handleClosingPopUp: () => void;
    initiatePreviewArea: (canvas?: HTMLCanvasElement) => void;
    createPopUp: () => void;
    createPreviewMeshControlHostAsync: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => Promise<unknown>;
    createPreviewHostAsync: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => Promise<unknown>;
    fixPopUpStyles: (document: Document) => void;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/globalState" {
import { NodeRenderGraph } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraph";
import { Observable } from "@babylonjs/core/Misc/observable";
import { LogEntry } from "@babylonjs/node-render-graph-editor/components/log/logComponent";
import { GraphNode } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphFrame";
import { Nullable } from "@babylonjs/core/types";
import { LockObject } from "@babylonjs/node-render-graph-editor/tabs/propertyGrids/lockObject";
import { StateManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/stateManager";
import { NodeRenderGraphBlock } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraphBlock";
import { FilesInput } from "@babylonjs/core/Misc/filesInput";
import { PreviewType } from "@babylonjs/node-render-graph-editor/components/preview/previewType";
import { Scene } from "@babylonjs/core/scene";
export class GlobalState {
    hostElement: HTMLElement;
    hostDocument: Document;
    hostWindow: Window;
    stateManager: StateManager;
    onClearUndoStack: Observable<void>;
    onBuiltObservable: Observable<void>;
    onResetRequiredObservable: Observable<boolean>;
    onZoomToFitRequiredObservable: Observable<void>;
    onReOrganizedRequiredObservable: Observable<void>;
    onLogRequiredObservable: Observable<LogEntry>;
    onIsLoadingChanged: Observable<boolean>;
    onLightUpdated: Observable<void>;
    onFrame: Observable<void>;
    onAnimationCommandActivated: Observable<void>;
    onImportFrameObservable: Observable<any>;
    onPopupClosedObservable: Observable<void>;
    onGetNodeFromBlock: (block: NodeRenderGraphBlock) => GraphNode;
    onDropEventReceivedObservable: Observable<DragEvent>;
    previewType: PreviewType;
    previewFile: File;
    envType: PreviewType;
    envFile: File;
    listOfCustomPreviewFiles: File[];
    rotatePreview: boolean;
    lockObject: LockObject;
    hemisphericLight: boolean;
    directionalLight0: boolean;
    directionalLight1: boolean;
    pointerOverCanvas: boolean;
    onRefreshPreviewMeshControlComponentRequiredObservable: Observable<void>;
    filesInput: FilesInput;
    scene: Scene;
    noAutoFillExternalInputs: boolean;
    _engine: number;
    customSave?: {
        label: string;
        action: (data: string) => Promise<void>;
    };
    private _nodeRenderGraph;
    /**
     * Gets the current node render graph
     */
    get nodeRenderGraph(): NodeRenderGraph;
    /**
     * Sets the current node material
     */
    set nodeRenderGraph(nodeRenderGraph: NodeRenderGraph);
    /** Gets the engine */
    get engine(): number;
    /** Sets the engine */
    set engine(e: number);
    constructor(scene: Scene);
    storeEditorData(serializationObject: any, frame?: Nullable<GraphFrame>): void;
}

}
declare module "@babylonjs/node-render-graph-editor/blockTools" {
import { Scene } from "@babylonjs/core/scene";
import { FrameGraph } from "@babylonjs/core/FrameGraph/frameGraph";
import { NodeRenderGraphBlockConnectionPointTypes } from "@babylonjs/core/FrameGraph/Node/Types/nodeRenderGraphTypes";
import { NodeRenderGraphOutputBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/outputBlock";
import { NodeRenderGraphInputBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/inputBlock";
import { NodeRenderGraphElbowBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/elbowBlock";
import { NodeRenderGraphTeleportInBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Teleport/teleportInBlock";
import { NodeRenderGraphTeleportOutBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Teleport/teleportOutBlock";
import { NodeRenderGraphBlackAndWhitePostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/blackAndWhitePostProcessBlock";
import { NodeRenderGraphBloomPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/bloomPostProcessBlock";
import { NodeRenderGraphBlurPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/blurPostProcessBlock";
import { NodeRenderGraphCircleOfConfusionPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/circleOfConfusionPostProcessBlock";
import { NodeRenderGraphDepthOfFieldPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/depthOfFieldPostProcessBlock";
import { NodeRenderGraphExtractHighlightsPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/extractHighlightsPostProcessBlock";
import { NodeRenderGraphClearBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Textures/clearBlock";
import { NodeRenderGraphCopyTextureBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Textures/copyTextureBlock";
import { NodeRenderGraphGenerateMipmapsBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Textures/generateMipmapsBlock";
import { NodeRenderGraphObjectRendererBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Rendering/objectRendererBlock";
import { NodeRenderGraphGeometryRendererBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Rendering/geometryRendererBlock";
import { NodeRenderGraphCullObjectsBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/cullObjectsBlock";
import { NodeRenderGraphGUIBlock } from "@babylonjs/gui/2D/FrameGraph/renderGraphGUIBlock";
import { NodeRenderGraphTAAObjectRendererBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Rendering/taaObjectRendererBlock";
import { NodeRenderGraphResourceContainerBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/resourceContainerBlock";
import { NodeRenderGraphShadowGeneratorBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Rendering/shadowGeneratorBlock";
import { NodeRenderGraphCascadedShadowGeneratorBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Rendering/csmShadowGeneratorBlock";
import { NodeRenderGraphExecuteBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/executeBlock";
import { NodeRenderGraphGlowLayerBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Layers/glowLayerBlock";
import { NodeRenderGraphHighlightLayerBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Layers/highlightLayerBlock";
import { NodeRenderGraphPassCubePostProcessBlock, NodeRenderGraphPassPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/passPostProcessBlock";
import { NodeRenderGraphUtilityLayerRendererBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Rendering/utilityLayerRendererBlock";
import { NodeRenderGraphSSRPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/ssrPostProcessBlock";
import { NodeRenderGraphAnaglyphPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/anaglyphPostProcessBlock";
import { NodeRenderGraphChromaticAberrationPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/chromaticAberrationPostProcessBlock";
import { NodeRenderGraphImageProcessingPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/imageProcessingPostProcessBlock";
import { NodeRenderGraphFXAAPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/fxaaPostProcessBlock";
import { NodeRenderGraphGrainPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/grainPostProcessBlock";
import { NodeRenderGraphMotionBlurPostProcessBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/PostProcesses/motionBlurPostProcessBlock";
/**
 * Static class for BlockTools
 */
export class BlockTools {
    static GetBlockFromString(data: string, frameGraph: FrameGraph, scene: Scene): NodeRenderGraphTeleportInBlock | NodeRenderGraphTeleportOutBlock | NodeRenderGraphOutputBlock | NodeRenderGraphElbowBlock | NodeRenderGraphResourceContainerBlock | NodeRenderGraphExecuteBlock | NodeRenderGraphUtilityLayerRendererBlock | NodeRenderGraphInputBlock | NodeRenderGraphClearBlock | NodeRenderGraphCopyTextureBlock | NodeRenderGraphGenerateMipmapsBlock | NodeRenderGraphBlackAndWhitePostProcessBlock | NodeRenderGraphBloomPostProcessBlock | NodeRenderGraphBlurPostProcessBlock | NodeRenderGraphPassPostProcessBlock | NodeRenderGraphPassCubePostProcessBlock | NodeRenderGraphGUIBlock | NodeRenderGraphObjectRendererBlock | NodeRenderGraphGeometryRendererBlock | NodeRenderGraphTAAObjectRendererBlock | NodeRenderGraphCullObjectsBlock | NodeRenderGraphCircleOfConfusionPostProcessBlock | NodeRenderGraphDepthOfFieldPostProcessBlock | NodeRenderGraphExtractHighlightsPostProcessBlock | NodeRenderGraphShadowGeneratorBlock | NodeRenderGraphCascadedShadowGeneratorBlock | NodeRenderGraphGlowLayerBlock | NodeRenderGraphHighlightLayerBlock | NodeRenderGraphSSRPostProcessBlock | NodeRenderGraphAnaglyphPostProcessBlock | NodeRenderGraphChromaticAberrationPostProcessBlock | NodeRenderGraphImageProcessingPostProcessBlock | NodeRenderGraphFXAAPostProcessBlock | NodeRenderGraphGrainPostProcessBlock | NodeRenderGraphMotionBlurPostProcessBlock | null;
    static GetColorFromConnectionNodeType(type: NodeRenderGraphBlockConnectionPointTypes): string;
    static GetConnectionNodeTypeFromString(type: string): NodeRenderGraphBlockConnectionPointTypes.Texture | NodeRenderGraphBlockConnectionPointTypes.TextureBackBuffer | NodeRenderGraphBlockConnectionPointTypes.TextureBackBufferDepthStencilAttachment | NodeRenderGraphBlockConnectionPointTypes.TextureDepthStencilAttachment | NodeRenderGraphBlockConnectionPointTypes.TextureViewDepth | NodeRenderGraphBlockConnectionPointTypes.TextureViewNormal | NodeRenderGraphBlockConnectionPointTypes.TextureAlbedo | NodeRenderGraphBlockConnectionPointTypes.TextureReflectivity | NodeRenderGraphBlockConnectionPointTypes.TextureWorldPosition | NodeRenderGraphBlockConnectionPointTypes.TextureVelocity | NodeRenderGraphBlockConnectionPointTypes.TextureScreenDepth | NodeRenderGraphBlockConnectionPointTypes.TextureWorldNormal | NodeRenderGraphBlockConnectionPointTypes.TextureLocalPosition | NodeRenderGraphBlockConnectionPointTypes.TextureLinearVelocity | NodeRenderGraphBlockConnectionPointTypes.TextureNormalizedViewDepth | NodeRenderGraphBlockConnectionPointTypes.ResourceContainer | NodeRenderGraphBlockConnectionPointTypes.ShadowGenerator | NodeRenderGraphBlockConnectionPointTypes.ShadowLight | NodeRenderGraphBlockConnectionPointTypes.Camera | NodeRenderGraphBlockConnectionPointTypes.ObjectList | NodeRenderGraphBlockConnectionPointTypes.AutoDetect;
    static GetStringFromConnectionNodeType(type: NodeRenderGraphBlockConnectionPointTypes): "" | "Texture" | "Camera" | "TextureBackBuffer" | "TextureBackBufferDepthStencilAttachment" | "TextureDepthStencilAttachment" | "ObjectList" | "TextureViewDepth" | "TextureNormalizedViewDepth" | "TextureNormal" | "TextureAlbedo" | "TextureReflectivity" | "TexturePosition" | "TextureVelocity" | "TextureScreenDepth" | "TextureLocalPosition" | "TextureWorldNormal" | "TextureLinearVelocity" | "ResourceContainer" | "ShadowGenerator" | "ShadowLight";
}

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/textureLineComponent" {
import * as React from "react";
import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture";
interface ITextureLineComponentProps {
    texture: BaseTexture;
    width: number;
    height: number;
    globalState?: any;
    hideChannelSelect?: boolean;
}
export interface ITextureLineComponentState {
    displayRed: boolean;
    displayGreen: boolean;
    displayBlue: boolean;
    displayAlpha: boolean;
    face: number;
}
export class TextureLineComponent extends React.Component<ITextureLineComponentProps, ITextureLineComponentState> {
    private _canvasRef;
    constructor(props: ITextureLineComponentProps);
    shouldComponentUpdate(): boolean;
    componentDidMount(): void;
    componentDidUpdate(): void;
    updatePreview(): void;
    static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/lineWithFileButtonComponent" {
import * as React from "react";
interface ILineWithFileButtonComponentProps {
    title: string;
    closed?: boolean;
    label: string;
    iconImage: any;
    onIconClick: (file: File) => void;
    accept: string;
    uploadName?: string;
}
export class LineWithFileButtonComponent extends React.Component<ILineWithFileButtonComponentProps, {
    isExpanded: boolean;
}> {
    private _uploadRef;
    constructor(props: ILineWithFileButtonComponentProps);
    onChange(evt: any): void;
    switchExpandedState(): void;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/lineContainerComponent" {
import * as React from "react";
interface ILineContainerComponentProps {
    title: string;
    children: any[] | any;
    closed?: boolean;
}
export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
    isExpanded: boolean;
}> {
    constructor(props: ILineContainerComponentProps);
    switchExpandedState(): void;


}
export {};

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/fileButtonLineComponent" {
import * as React from "react";
interface IFileButtonLineComponentProps {
    label: string;
    onClick: (file: File) => void;
    accept: string;
    uploadName?: string;
}
export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
    private _uploadRef;
    constructor(props: IFileButtonLineComponentProps);
    onChange(evt: any): void;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/draggableLineWithButtonComponent" {
import * as React from "react";
export interface IDraggableLineWithButtonComponent {
    data: string;
    tooltip: string;
    iconImage: any;
    onIconClick: (value: string) => void;
    iconTitle: string;
    lenSuffixToRemove?: number;
}
export class DraggableLineWithButtonComponent extends React.Component<IDraggableLineWithButtonComponent> {
    constructor(props: IDraggableLineWithButtonComponent);

}

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/draggableLineComponent" {
import * as React from "react";
export interface IButtonLineComponentProps {
    data: string;
    tooltip: string;
}
export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
    constructor(props: IButtonLineComponentProps);

}

}
declare module "@babylonjs/node-render-graph-editor/sharedComponents/checkBoxLineComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/node-render-graph-editor/propertyChangedEvent";
export interface ICheckBoxLineComponentProps {
    label: string;
    target?: any;
    propertyName?: string;
    isSelected?: () => boolean;
    onSelect?: (value: boolean) => void;
    onValueChanged?: () => void;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
    disabled?: boolean;
    extractValue?: (target: any) => boolean;
}
export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
    isSelected: boolean;
    isDisabled?: boolean;
}> {
    private static _UniqueIdSeed;
    private _uniqueId;
    private _localChange;
    constructor(props: ICheckBoxLineComponentProps);
    shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
        isSelected: boolean;
        isDisabled: boolean;
    }): boolean;
    onChange(): void;

}

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

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

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

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

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

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

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

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

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

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/connectionPointPortData" {
import { NodeRenderGraphBlock } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraphBlock";
import { NodeRenderGraphConnectionPoint } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraphBlockConnectionPoint";
import { NodeRenderGraphConnectionPointCompatibilityStates } from "@babylonjs/core/FrameGraph/Node/Types/nodeRenderGraphTypes";
import { Nullable } from "@babylonjs/core/types";
import { GraphNode } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphNode";
import { INodeContainer } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeContainer";
import { IPortData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/portData";
import { PortDataDirection } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/portData";
export class ConnectionPointPortData implements IPortData {
    private _connectedPort;
    private _nodeContainer;
    data: NodeRenderGraphConnectionPoint;
    get name(): string;
    get internalName(): string;
    get isExposedOnFrame(): boolean;
    set isExposedOnFrame(value: boolean);
    get exposedPortPosition(): number;
    set exposedPortPosition(value: number);
    get isConnected(): boolean;
    get isInactive(): boolean;
    get connectedPort(): Nullable<IPortData>;
    set connectedPort(value: Nullable<IPortData>);
    get direction(): PortDataDirection;
    get ownerData(): NodeRenderGraphBlock;
    get needDualDirectionValidation(): boolean;
    get hasEndpoints(): boolean;
    get endpoints(): IPortData[];
    constructor(connectionPoint: NodeRenderGraphConnectionPoint, nodeContainer: INodeContainer);
    updateDisplayName(newName: string): void;
    connectTo(port: IPortData): void;
    canConnectTo(port: IPortData): boolean;
    disconnectFrom(port: IPortData): void;
    checkCompatibilityState(port: IPortData): 0 | NodeRenderGraphConnectionPointCompatibilityStates.TypeIncompatible | NodeRenderGraphConnectionPointCompatibilityStates.HierarchyIssue;
    getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/blockNodeData" {
import { INodeContainer } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeContainer";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
import { IPortData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/portData";
import { NodeRenderGraphBlock } from "@babylonjs/core/FrameGraph/Node/nodeRenderGraphBlock";
import { NodeRenderGraphTeleportOutBlock } from "@babylonjs/core/FrameGraph/Node/Blocks/Teleport/teleportOutBlock";
export class BlockNodeData implements INodeData {
    data: NodeRenderGraphBlock;
    private _inputs;
    private _outputs;
    private _onBuildObserver;
    /**
     * Gets or sets a callback used to call node visual refresh
     */
    refreshCallback?: () => void;
    get uniqueId(): number;
    get name(): string;
    getClassName(): string;
    get isInput(): boolean;
    get inputs(): IPortData[];
    get outputs(): IPortData[];
    get comments(): string;
    set comments(value: string);
    get executionTime(): number;
    getPortByName(name: string): IPortData | null;
    isConnectedToOutput(): boolean;
    dispose(): void;
    prepareHeaderIcon(iconDiv: HTMLDivElement, img: HTMLImageElement): void;
    get invisibleEndpoints(): NodeRenderGraphTeleportOutBlock[] | null;
    constructor(data: NodeRenderGraphBlock, nodeContainer: INodeContainer);
}

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

}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/properties/nodePortPropertyComponent" {
import * as React from "react";
import { StateManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/stateManager";
import { NodePort } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/nodePort";
export interface IFrameNodePortPropertyTabComponentProps {
    stateManager: StateManager;
    nodePort: NodePort;
}
export class NodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps> {
    constructor(props: IFrameNodePortPropertyTabComponentProps);
    toggleExposeOnFrame(value: boolean): void;

}

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

    setDefaultValue(): void;

}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/properties/genericNodePropertyComponent" {
import * as React from "react";
import { IPropertyComponentProps } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/propertyComponentProps";
export const samplingModeList: {
    label: string;
    value: number;
}[];
export const textureFormatList: {
    label: string;
    value: number;
}[];
export const textureTypeList: {
    label: string;
    value: number;
}[];
export const textureDepthStencilFormatList: {
    label: string;
    value: number;
}[];
export class GenericPropertyComponent extends React.Component<IPropertyComponentProps> {
    constructor(props: IPropertyComponentProps);

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

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

}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/properties/framePropertyComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import { GraphFrame } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphFrame";
export interface IFramePropertyTabComponentProps {
    globalState: GlobalState;
    frame: GraphFrame;
}
export class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
    private _onFrameExpandStateChangedObserver;
    constructor(props: IFramePropertyTabComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;

}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/properties/frameNodePortPropertyComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import { StateManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/stateManager";
import { GraphFrame } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphFrame";
import { FrameNodePort } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/frameNodePort";
export interface IFrameNodePortPropertyTabComponentProps {
    stateManager: StateManager;
    globalState: GlobalState;
    frameNodePort: FrameNodePort;
    frame: GraphFrame;
}
export class FrameNodePortPropertyTabComponent extends React.Component<IFrameNodePortPropertyTabComponentProps, {
    port: FrameNodePort;
}> {
    private _onFramePortPositionChangedObserver;
    private _onSelectionChangedObserver;
    constructor(props: IFrameNodePortPropertyTabComponentProps);
    componentWillUnmount(): void;

}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/textureDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
export class TextureDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/teleportOutDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
import { Nullable } from "@babylonjs/core/types";
import { StateManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/stateManager";
export class TeleportOutDisplayManager implements IDisplayManager {
    private _hasHighlights;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
    onSelectionChanged(nodeData: INodeData, selectedData: Nullable<INodeData>, manager: StateManager): void;
    onDispose(nodeData: INodeData, manager: StateManager): void;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/teleportInDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
import { Nullable } from "@babylonjs/core/types";
import { StateManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/stateManager";
export class TeleportInDisplayManager implements IDisplayManager {
    private _hasHighlights;
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
    onSelectionChanged(nodeData: INodeData, selectedData: Nullable<INodeData>, manager: StateManager): void;
    onDispose(nodeData: INodeData, manager: StateManager): void;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/postProcessDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
export class PostProcessDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/outputDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
export class OutputDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/inputDisplayManager" {
import { IDisplayManager } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
import { NodeRenderGraphBlockConnectionPointTypes } from "@babylonjs/core/FrameGraph/Node/Types/nodeRenderGraphTypes";
export class InputDisplayManager implements IDisplayManager {
    getHeaderClass(_nodeData: INodeData): string;
    getHeaderText(nodeData: INodeData): string;
    shouldDisplayPortLabels(): boolean;
    static GetBaseType(type: NodeRenderGraphBlockConnectionPointTypes): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(nodeData: INodeData, contentArea: HTMLDivElement): void;
}

}
declare module "@babylonjs/node-render-graph-editor/graphSystem/display/elbowDisplayManager" {
import { IDisplayManager, VisualContentDescription } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/displayManager";
import { INodeData } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/interfaces/nodeData";
export class ElbowDisplayManager implements IDisplayManager {
    getHeaderClass(): string;
    shouldDisplayPortLabels(): boolean;
    getHeaderText(nodeData: INodeData): string;
    getBackgroundColor(nodeData: INodeData): string;
    updatePreviewContent(_nodeData: INodeData, _contentArea: HTMLDivElement): void;
    updateFullVisualContent(data: INodeData, visualContent: VisualContentDescription): void;
}

}
declare module "@babylonjs/node-render-graph-editor/components/propertyTab/textureMemoryUsagePropertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import "@babylonjs/node-render-graph-editor/components/propertyTab/propertyTab.scss";
interface ITextureMemoryUsagePropertyTabComponentProps {
    globalState: GlobalState;
}
export class TextureMemoryUsagePropertyTabComponent extends React.Component<ITextureMemoryUsagePropertyTabComponentProps> {
    constructor(props: ITextureMemoryUsagePropertyTabComponentProps);
    private _formatMemorySize;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/components/propertyTab/propertyTabComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import { Nullable } from "@babylonjs/core/types";
import "@babylonjs/node-render-graph-editor/components/propertyTab/propertyTab.scss";
import { GraphNode } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphNode";
import { GraphFrame } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/graphFrame";
import { NodePort } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/nodePort";
import { FrameNodePort } from "@babylonjs/node-render-graph-editor/nodeGraphSystem/frameNodePort";
import { LockObject } from "@babylonjs/node-render-graph-editor/tabs/propertyGrids/lockObject";
interface IPropertyTabComponentProps {
    globalState: GlobalState;
    lockObject: LockObject;
}
interface IPropertyTabComponentState {
    currentNode: Nullable<GraphNode>;
    currentFrame: Nullable<GraphFrame>;
    currentFrameNodePort: Nullable<FrameNodePort>;
    currentNodePort: Nullable<NodePort>;
    uploadInProgress: boolean;
}
export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
    private _onBuiltObserver;
    constructor(props: IPropertyTabComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    load(file: File): void;
    loadFrame(file: File): void;
    save(): void;
    customSave(): void;
    saveToSnippetServer(): void;
    loadFromSnippet(): void;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/components/preview/previewType" {
export enum PreviewType {
    Sphere = 0,
    Box = 1,
    Cylinder = 2,
    Plane = 3,
    ShaderBall = 4,
    Custom = 5,
    Room = 6
}

}
declare module "@babylonjs/node-render-graph-editor/components/preview/previewMeshControlComponent" {
import * as React from "react";
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
import { PreviewType } from "@babylonjs/node-render-graph-editor/components/preview/previewType";
interface IPreviewMeshControlComponent {
    globalState: GlobalState;
    togglePreviewAreaComponent: () => void;
    onMounted?: () => void;
}
export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
    private _filePickerRef;
    private _envPickerRef;
    private _onResetRequiredObserver;
    private _onDropEventObserver;
    private _onRefreshPreviewMeshControlComponentRequiredObserver;
    constructor(props: IPreviewMeshControlComponent);
    componentWillUnmount(): void;
    componentDidMount(): void;
    changeMeshType(newOne: PreviewType): void;
    useCustomMesh(evt: any): void;
    useCustomEnv(evt: any): void;
    onPopUp(): void;
    frame(): void;

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/components/preview/previewManager" {
import { GlobalState } from "@babylonjs/node-render-graph-editor/globalState";
export class PreviewManager {
    private _nodeRenderGraph;
    private _onFrameObserver;
    private _onPreviewCommandActivatedObserver;
    private _onUpdateRequiredObserver;
    private _onRebuildRequiredObserver;
    private _onImportFrameObserver;
    private _onResetRequiredObserver;
    private _onLightUpdatedObserver;
    private _engine;
    private _scene;
    private _globalState;
    private _currentType;
    private _lightParent;
    private _hdrTexture;
    private _dummyExternalTexture;
    constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
    private _initAsync;
    private _initSceneAsync;
    private _reset;
    private _prepareLights;
    private _createNodeRenderGraph;
    private _getMesh;
    private _buildGraphAsync;
    private _frameCamera;
    private _prepareBackgroundHDR;
    private _prepareScene;
    static DefaultEnvironmentURL: string;
    private _refreshPreviewMesh;
    dispose(): void;
}

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

}
export {};

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

}
export {};

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

}
export {};

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

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

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

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

}
declare module "@babylonjs/node-render-graph-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;
    /**
     * Undo the latest operation
     */
    undo(): void;
    /**
     * Redo the latest undo operation
     */
    redo(): void;
    /**
     * Disposes the stack
     */
    dispose(): void;
}

}
declare module "@babylonjs/node-render-graph-editor/copyCommandToClipboard" {
export function copyCommandToClipboard(strCommand: string): void;
export function getClassNameWithNamespace(obj: any): {
    className: string;
    babylonNamespace: string;
};

}
declare module "@babylonjs/node-render-graph-editor/constToOptionsMaps" {
/**
 * Used by both particleSystem and alphaBlendModes
 */
export const CommonBlendModes: {
    label: string;
    value: number;
}[];
/**
 * Used to populated the blendMode dropdown in our various tools (Node Editor, Inspector, etc.)
 * The below ParticleSystem consts were defined before new Engine alpha blend modes were added, so we have to reference
 * the ParticleSystem.FOO consts explicitly (as the underlying const values are different - they get mapped to engine consts within baseParticleSystem.ts)
 */
export const BlendModeOptions: {
    label: string;
    value: number;
}[];
/**
 * Used to populated the alphaMode dropdown in our various tools (Node Editor, Inspector, etc.)
 */
export const AlphaModeOptions: {
    label: string;
    value: number;
}[];

}
declare module "@babylonjs/node-render-graph-editor/tabs/propertyGrids/lockObject" {
/**
 * Class used to provide lock mechanism
 */
export class LockObject {
    /**
     * Gets or set if the lock is engaged
     */
    lock: boolean;
}

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

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/node-render-graph-editor/propertyChangedEvent";
import { LockObject } from "@babylonjs/node-render-graph-editor/tabs/propertyGrids/lockObject";
import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
interface IStackPanelPropertyGridComponentProps {
    stackPanel: StackPanel;
    lockObject: LockObject;
    onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
}
export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
    constructor(props: IStackPanelPropertyGridComponentProps);

}
export {};

}
declare module "@babylonjs/node-render-graph-editor/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "@babylonjs/core/Misc/observable";
import { PropertyChangedEvent } from "@babylonjs/node-render-graph-editor/prop