babylonjs-editor 4.5.0 → 5.4.0-alpha.2

package/declaration/src/editor/layout/inspector/light/shadows.d.ts

@@ -0,0 +1,28 @@
+import { Component, PropsWithChildren, ReactNode } from "react";
+import { IShadowGenerator, IShadowLight } from "babylonjs";
+import { IEditorInspectorListFieldItem } from "../fields/list";
+export interface IEditorLightShadowsInspectorProps extends PropsWithChildren {
+    light: IShadowLight;
+}
+export interface IEditorLightShadowsInspectorState {
+    generator: IShadowGenerator | null;
+}
+export type SoftShadowType = "usePoissonSampling" | "useExponentialShadowMap" | "useCloseExponentialShadowMap" | "usePercentageCloserFiltering" | "useContactHardeningShadow" | "none";
+export declare class EditorLightShadowsInspector extends Component<IEditorLightShadowsInspectorProps, IEditorLightShadowsInspectorState> {
+    protected _generatorSize: number;
+    protected _generatorType: string;
+    protected _softShadowType: SoftShadowType;
+    protected _sizes: IEditorInspectorListFieldItem[];
+    constructor(props: IEditorLightShadowsInspectorProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    private _refreshShadowGenerator;
+    private _createShadowGenerator;
+    private _reszeShadowGenerator;
+    private _getEmptyShadowGeneratorComponent;
+    private _getClassicShadowGeneratorComponent;
+    private _getClassicSoftShadowComponent;
+    private _getCascadedShadowGeneratorComponent;
+    private _getSoftShadowType;
+    private _updateSoftShadowType;
+}

package/declaration/src/editor/layout/inspector/light/spot.d.ts

@@ -0,0 +1,12 @@
+import { Component, ReactNode } from "react";
+import { SpotLight } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export declare class EditorSpotLightInspector extends Component<IEditorInspectorImplementationProps<SpotLight>> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/marketplace-asset.d.ts

@@ -0,0 +1,40 @@
+import { Component, ReactNode } from "react";
+import { IMarketplaceAsset } from "../../../tools/marketplaces/types";
+import { MarketplaceProvider } from "../../../tools/marketplaces/provider";
+import { IEditorInspectorImplementationProps } from "./inspector";
+export declare class MarketplaceAssetInspectorObject {
+    readonly asset: IMarketplaceAsset;
+    readonly provider: MarketplaceProvider;
+    readonly openSettings: () => void;
+    readonly isMarketplaceAssetInspectorObject = true;
+    constructor(asset: IMarketplaceAsset, provider: MarketplaceProvider, openSettings: () => void);
+}
+interface IEditorMarketplaceAssetInspectorState {
+    selectedDownloadQuality?: string;
+    selectedDownloadType?: string;
+    detailsLoading: boolean;
+    isDownloading: boolean;
+    details?: IMarketplaceAsset;
+    assetPath?: string;
+}
+export declare class EditorMarketplaceAssetInspector extends Component<IEditorInspectorImplementationProps<MarketplaceAssetInspectorObject>, IEditorMarketplaceAssetInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: any): object is MarketplaceAssetInspectorObject;
+    constructor(props: IEditorInspectorImplementationProps<MarketplaceAssetInspectorObject>);
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: IEditorInspectorImplementationProps<MarketplaceAssetInspectorObject>): void;
+    private _handleSettingsChanged;
+    private _getAssetPath;
+    private _openAssetFolder;
+    render(): ReactNode;
+    private _shouldShowLoginAction;
+    private _loadDetails;
+    private _handleImport;
+    private _getFirstType;
+}
+export {};

package/declaration/src/editor/layout/inspector/material/cell.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { CellMaterial } from "babylonjs-materials";
+export interface IEditorCellMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: CellMaterial;
+}
+export declare class EditorCellMaterialInspector extends Component<IEditorCellMaterialInspectorProps> {
+    constructor(props: IEditorCellMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/components/alpha.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+export interface IEditorAlphaModeFieldProps {
+    object: any;
+    onChange?: () => void;
+}
+export declare function EditorAlphaModeField(props: IEditorAlphaModeFieldProps): ReactNode;

package/declaration/src/editor/layout/inspector/material/components/transparency.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+import { Material } from "babylonjs";
+export interface IEditorTransparencyModeFieldProps {
+    object: Material;
+    onChange?: () => void;
+}
+export declare function EditorTransparencyModeField(props: IEditorTransparencyModeFieldProps): ReactNode;

package/declaration/src/editor/layout/inspector/material/components/utils.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { Material, AbstractMesh } from "babylonjs";
+export interface IEditorMaterialInspectorUtilsComponentProps {
+    mesh?: AbstractMesh;
+    material: Material;
+}
+export declare class EditorMaterialInspectorUtilsComponent extends Component<IEditorMaterialInspectorUtilsComponentProps> {
+    render(): ReactNode;
+    private _handleRemove;
+    private _handleExport;
+}

package/declaration/src/editor/layout/inspector/material/fire.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { FireMaterial } from "babylonjs-materials";
+export interface IEditorFireMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: FireMaterial;
+}
+export declare class EditorFireMaterialInspector extends Component<IEditorFireMaterialInspectorProps> {
+    constructor(props: IEditorFireMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/gradient.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { GradientMaterial } from "babylonjs-materials";
+export interface IEditorGradientMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: GradientMaterial;
+}
+export declare class EditorGradientMaterialInspector extends Component<IEditorGradientMaterialInspectorProps> {
+    constructor(props: IEditorGradientMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/grid.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { GridMaterial } from "babylonjs-materials";
+export interface IEditorGridMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: GridMaterial;
+}
+export declare class EditorGridMaterialInspector extends Component<IEditorGridMaterialInspectorProps> {
+    constructor(props: IEditorGridMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/lava.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { LavaMaterial } from "babylonjs-materials";
+export interface IEditorLavaMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: LavaMaterial;
+}
+export declare class EditorLavaMaterialInspector extends Component<IEditorLavaMaterialInspectorProps> {
+    constructor(props: IEditorLavaMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/multi.d.ts

@@ -0,0 +1,15 @@
+import { Component, ReactNode } from "react";
+import { Material, MultiMaterial } from "babylonjs";
+export interface IEditorPBRMaterialInspectorProps {
+    material: MultiMaterial;
+}
+export interface IEditorMultiMaterialInspectorState {
+    material: Material | null;
+}
+export declare class EditorMultiMaterialInspector extends Component<IEditorPBRMaterialInspectorProps, IEditorMultiMaterialInspectorState> {
+    constructor(props: IEditorPBRMaterialInspectorProps);
+    render(): ReactNode;
+    private _getMaterialSelectorComponent;
+    private _handleAssetDropped;
+    private _getMaterialComponent;
+}

package/declaration/src/editor/layout/inspector/material/node.d.ts

@@ -0,0 +1,19 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh, NodeMaterial } from "babylonjs";
+export interface IEditorNodeMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: NodeMaterial;
+}
+export interface IEditorNodeMaterialInspectorState {
+    searchingToEdit: boolean;
+}
+export declare class EditorNodeMaterialInspector extends Component<IEditorNodeMaterialInspectorProps, IEditorNodeMaterialInspectorState> {
+    private _buildObserver;
+    constructor(props: IEditorNodeMaterialInspectorProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private _openNodeMaterialEditor;
+    private _getTextureBlocks;
+    private _getEditableBlocks;
+}

package/declaration/src/editor/layout/inspector/material/normal.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { NormalMaterial } from "babylonjs-materials";
+export interface IEditorNormalMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: NormalMaterial;
+}
+export declare class EditorNormalMaterialInspector extends Component<IEditorNormalMaterialInspectorProps> {
+    constructor(props: IEditorNormalMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/pbr.d.ts

@@ -0,0 +1,10 @@
+import { Component, ReactNode } from "react";
+import { PBRMaterial, AbstractMesh } from "babylonjs";
+export interface IEditorPBRMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: PBRMaterial;
+}
+export declare class EditorPBRMaterialInspector extends Component<IEditorPBRMaterialInspectorProps> {
+    constructor(props: IEditorPBRMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/sky.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { SkyMaterial } from "babylonjs-materials";
+export interface IEditorSkyMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: SkyMaterial;
+}
+export declare class EditorSkyMaterialInspector extends Component<IEditorSkyMaterialInspectorProps> {
+    constructor(props: IEditorSkyMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/standard.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+import { StandardMaterial, AbstractMesh } from "babylonjs";
+export interface IEditorStandardMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: StandardMaterial;
+}
+export declare function EditorStandardMaterialInspector(props: IEditorStandardMaterialInspectorProps): ReactNode;

package/declaration/src/editor/layout/inspector/material/tri-planar.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { TriPlanarMaterial } from "babylonjs-materials";
+export interface IEditorTriPlanarMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: TriPlanarMaterial;
+}
+export declare class EditorTriPlanarMaterialInspector extends Component<IEditorTriPlanarMaterialInspectorProps> {
+    constructor(props: IEditorTriPlanarMaterialInspectorProps);
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/material/water.d.ts

@@ -0,0 +1,15 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { WaterMaterial } from "babylonjs-materials";
+export interface IEditorWaterMaterialInspectorProps {
+    mesh?: AbstractMesh;
+    material: WaterMaterial;
+}
+export interface IEditorWaterMaterialInspectorState {
+    renderListSearch: string;
+}
+export declare class EditorWaterMaterialInspector extends Component<IEditorWaterMaterialInspectorProps, IEditorWaterMaterialInspectorState> {
+    constructor(props: IEditorWaterMaterialInspectorProps);
+    render(): ReactNode;
+    private _getRenderListItem;
+}

package/declaration/src/editor/layout/inspector/mesh/collision.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorMeshInspectorState {
+    computingCollisionMesh: boolean;
+}
+export declare class EditorMeshCollisionInspector extends Component<IEditorInspectorImplementationProps<AbstractMesh>, IEditorMeshInspectorState> {
+    private _mesh;
+    private _collisionMesh;
+    constructor(props: IEditorInspectorImplementationProps<AbstractMesh>);
+    render(): ReactNode;
+    componentWillUnmount(): void;
+    private _getCollisionType;
+    private _configureCollisionMesh;
+    private _setTemporaryCollisionMeshVisible;
+    private _disposeCollisionMesh;
+}

package/declaration/src/editor/layout/inspector/mesh/decal.d.ts

@@ -0,0 +1,15 @@
+import { Component, ReactNode } from "react";
+import { Mesh } from "babylonjs";
+export interface IMeshDecalInspectorProps {
+    object: Mesh;
+}
+export interface IMeshDecalInspectorState {
+    meshExists: boolean;
+}
+export declare class MeshDecalInspector extends Component<IMeshDecalInspectorProps, IMeshDecalInspectorState> {
+    constructor(props: IMeshDecalInspectorProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    private _handleUpdateCurrentDecalMesh;
+    private _getProxy;
+}

package/declaration/src/editor/layout/inspector/mesh/geometry/box.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface IBoxMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function BoxMeshGeometryInspector(props: IBoxMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/capsule.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface ICapsuleMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function CapsuleMeshGeometryInspector(props: ICapsuleMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/cylinder.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface ICylinderMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function CylinderMeshGeometryInspector(props: ICylinderMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/ground.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface IGroundMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function GroundMeshGeometryInspector(props: IGroundMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/plane.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface IPlaneMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function PlaneMeshGeometryInspector(props: IPlaneMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/proxy.d.ts

@@ -0,0 +1 @@
+export declare function getProxy<T>(metadata: any, onChange: () => void): T;

package/declaration/src/editor/layout/inspector/mesh/geometry/sphere.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface ISphereMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function SphereMeshGeometryInspector(props: ISphereMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/torus-knot.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface ITorusKnotMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function TorusKnotMeshGeometryInspector(props: ITorusKnotMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry/torus.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface ITorusMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function TorusMeshGeometryInspector(props: ITorusMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/mesh/geometry.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../../main";
+export interface IMeshGeometryInspectorProps {
+    object: Mesh;
+    editor: Editor;
+}
+export declare function MeshGeometryInspector(props: IMeshGeometryInspectorProps): import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/inspector/mesh/mesh.d.ts

@@ -0,0 +1,32 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorMeshInspectorState {
+    dragOver: boolean;
+}
+export declare class EditorMeshInspector extends Component<IEditorInspectorImplementationProps<AbstractMesh>, IEditorMeshInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    private _castShadows;
+    private _collisionMesh;
+    constructor(props: IEditorInspectorImplementationProps<AbstractMesh>);
+    render(): ReactNode;
+    private _gizmoObserver;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private _handleTransformsUpdated;
+    private _getLODsComponent;
+    private _getMaterialComponent;
+    private _handleMaterialDrop;
+    private _handleMaterialDragOver;
+    private _handleMaterialDropped;
+    private _handleAddMaterial;
+    private _getMaterialInspectorComponent;
+    private _getSkeletonComponent;
+    private _getMorphTargetManagerComponent;
+    private _handleCastShadowsChanged;
+}

package/declaration/src/editor/layout/inspector/mesh/physics.d.ts

@@ -0,0 +1,12 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh } from "babylonjs";
+export interface IEditorMeshPhysicsInspectorProps {
+    mesh: AbstractMesh;
+}
+export declare class EditorMeshPhysicsInspector extends Component<IEditorMeshPhysicsInspectorProps> {
+    render(): ReactNode;
+    private _handleHasPhysicsAggregateChange;
+    private _getPhysicsInspector;
+    private _getShapeTypeInspector;
+    private _getBodyMotionTypeInspeector;
+}

package/declaration/src/editor/layout/inspector/mesh/skeleton.d.ts

@@ -0,0 +1,12 @@
+import { Component, ReactNode } from "react";
+import { Skeleton } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export declare class EditorSkeletonInspector extends Component<IEditorInspectorImplementationProps<Skeleton>> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: any): boolean;
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/inspector/metadata/custom-metadata.d.ts

@@ -0,0 +1,14 @@
+import { Component, ReactNode } from "react";
+import { Node } from "babylonjs";
+export interface ICustomMetadataInspectorProps {
+    object: Node;
+}
+/**
+ * Custom metadata inspector component that allows users to add/edit/remove key-value pairs
+ * for custom metadata on nodes.
+ */
+export declare class CustomMetadataInspector extends Component<ICustomMetadataInspectorProps> {
+    render(): ReactNode;
+    private _handleAddKey;
+    private _handleRemoveKey;
+}

package/declaration/src/editor/layout/inspector/particles/gpu-particle-system.d.ts

@@ -0,0 +1,26 @@
+import { Component, ReactNode } from "react";
+import { GPUParticleSystem } from "babylonjs";
+import { IEditorInspectorListFieldItem } from "../fields/list";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorGPUParticleSystemInspectorState {
+    started: boolean;
+}
+export declare class EditorGPUParticleSystemInspector extends Component<IEditorInspectorImplementationProps<GPUParticleSystem>, IEditorGPUParticleSystemInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    protected _randomTextureSize: number;
+    protected _sizes: IEditorInspectorListFieldItem[];
+    private _stoppedObserver;
+    constructor(props: IEditorInspectorImplementationProps<GPUParticleSystem>);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): ReactNode;
+    private _handleStartOrStop;
+    private _getCapacityInspector;
+    private _getRandomTextureSizeInspector;
+    private _getEmitterTypeInspector;
+}

package/declaration/src/editor/layout/inspector/particles/gradient.d.ts

@@ -0,0 +1,6 @@
+import { IValueGradient } from "babylonjs";
+export interface IGradientFieldProps {
+    gradient: IValueGradient;
+    onRemove: () => void;
+}
+export declare function GradientField(props: IGradientFieldProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/particles/node-particle-system-set.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+import { NodeParticleSystemSetMesh } from "../../../nodes/node-particle-system";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorNodeParticleSystemSetMeshInspectorState {
+    searchingToEdit: boolean;
+}
+export declare class EditorNodeParticleSystemSetMeshInspector extends Component<IEditorInspectorImplementationProps<NodeParticleSystemSetMesh>, IEditorNodeParticleSystemSetMeshInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    constructor(props: IEditorInspectorImplementationProps<NodeParticleSystemSetMesh>);
+    render(): ReactNode;
+    private _openNodeParticleSystemSetEditor;
+}

package/declaration/src/editor/layout/inspector/particles/particle-system.d.ts

@@ -0,0 +1,22 @@
+import { Component, ReactNode } from "react";
+import { ParticleSystem } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorParticleSystemInspectorState {
+    started: boolean;
+}
+export declare class EditorParticleSystemInspector extends Component<IEditorInspectorImplementationProps<ParticleSystem>, IEditorParticleSystemInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    private _stoppedObserver;
+    constructor(props: IEditorInspectorImplementationProps<ParticleSystem>);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): ReactNode;
+    private _handleStartOrStop;
+    private _getCapacityInspector;
+    private _getEmitterTypeInspector;
+}

package/declaration/src/editor/layout/inspector/particles/property-gradient.d.ts

@@ -0,0 +1,13 @@
+import { PropsWithChildren } from "react";
+import { ParticleSystem, IValueGradient } from "babylonjs";
+export interface IParticleSystemGradientInspectorProps extends PropsWithChildren {
+    title?: string;
+    label: string;
+    particleSystem: ParticleSystem;
+    getGradients: () => IValueGradient[] | null;
+    createGradient: () => void;
+    addGradient: (gradient: number, value1: any, value2?: any) => void;
+    removeGradient: (gradient: number) => void;
+    onUpdate: () => void;
+}
+export declare function ParticleSystemGradientInspector(props: IParticleSystemGradientInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/scene/animation-groups.d.ts

@@ -0,0 +1,7 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../main";
+export interface IEditorSceneAnimationGroupsInspectorProps {
+    object: Scene;
+    editor: Editor;
+}
+export declare function EditorSceneAnimationGroupsInspector(props: IEditorSceneAnimationGroupsInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/inspector/scene/scene.d.ts

@@ -0,0 +1,28 @@
+import { Component, ReactNode } from "react";
+import { Scene, AnimationGroup } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorSceneInspectorState {
+    dragOverVlsMesh: boolean;
+    animationGroupsSearch: string;
+    selectedAnimationGroups: AnimationGroup[];
+}
+export declare class EditorSceneInspector extends Component<IEditorInspectorImplementationProps<Scene>, IEditorSceneInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    constructor(props: IEditorInspectorImplementationProps<Scene>);
+    render(): ReactNode;
+    private _getPhysicsComponent;
+    private _getDefaultRenderingPipelineComponent;
+    private _getTAARenderingPipelineComponent;
+    private _getSSAO2RenderingPipelineComponent;
+    private _getMotionBlurPostProcessComponent;
+    private _getSSRPipelineComponent;
+    private _getVLSComponent;
+    private _handleDragOverVlsMesh;
+    private _handleDropVlsMesh;
+    private _getIblShadowsRenderingPipelineComponent;
+}

package/declaration/src/editor/layout/inspector/script/field.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from "../../../main";
+export interface IInspectorScriptFieldProps {
+    object: any;
+    script: any;
+    scriptIndex: number;
+    editor: Editor;
+    onRemove: () => void;
+}
+export declare function InspectorScriptField(props: IInspectorScriptFieldProps): import("react/jsx-runtime").JSX.Element;