@babylonjs/inspector 9.0.0 → 9.1.0

package/lib/components/scene/sceneExplorer.d.ts

@@ -0,0 +1,182 @@
+import { type ComponentType, type FunctionComponent } from "react";
+import { type IDisposable, type IReadonlyObservable, type Nullable, type Scene } from "@babylonjs/core/index.js";
+/**
+ * Information about how to display an entity in the Scene Explorer tree.
+ */
+export type EntityDisplayInfo = Partial<IDisposable> & Readonly<{
+    /**
+     * The name of the entity to display in the Scene Explorer tree.
+     */
+    name: string;
+    /**
+     * An observable that notifies when the display info (such as the name) changes.
+     */
+    onChange?: IReadonlyObservable<void>;
+}>;
+/**
+ * Configuration for drag-and-drop behavior within a section.
+ */
+export type SceneExplorerDragDropConfig<T> = Readonly<{
+    /**
+     * Determines whether an entity can be dragged.
+     * @param entity The entity to check.
+     * @returns True if the entity can be dragged, false otherwise.
+     */
+    canDrag: (entity: T) => boolean;
+    /**
+     * Determines whether an entity can be dropped onto a target.
+     * @param draggedEntity The entity being dragged.
+     * @param targetEntity The potential drop target entity, or null if dropping onto the section root.
+     * @returns True if the drop is allowed, false otherwise.
+     */
+    canDrop: (draggedEntity: T, targetEntity: T | null) => boolean;
+    /**
+     * Called when a drag-and-drop operation completes.
+     * @param draggedEntity The entity that was dragged.
+     * @param targetEntity The entity it was dropped onto, or null if dropped onto the section root.
+     */
+    onDrop: (draggedEntity: T, targetEntity: T | null) => void;
+}>;
+/**
+ * Describes a section in the Scene Explorer (e.g. "Nodes", "Materials", etc.).
+ */
+export type SceneExplorerSection<T extends object> = Readonly<{
+    /**
+     * The display name of the section (e.g. "Nodes", "Materials", etc.).
+     */
+    displayName: string;
+    /**
+     * An optional order for the section, relative to other sections.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * A function that returns the root entities for this section.
+     */
+    getRootEntities: () => readonly T[];
+    /**
+     * An optional function that returns the children of a given entity.
+     */
+    getEntityChildren?: (entity: T) => readonly T[];
+    /**
+     * Gets the display information for a given entity.
+     * This is ideally "live" display info (e.g. updates to the display info are taken into account and communicated via the observable).
+     * This means in many cases the display info will need to be disposed when it is no longer needed so observable registrations can be removed.
+     */
+    getEntityDisplayInfo: (entity: T) => EntityDisplayInfo;
+    /**
+     * An optional icon component to render for the entity.
+     */
+    entityIcon?: ComponentType<{
+        entity: T;
+    }>;
+    /**
+     * A function that returns an array of observables for when entities are added to the scene.
+     */
+    getEntityAddedObservables: () => readonly IReadonlyObservable<T>[];
+    /**
+     * A function that returns an array of observables for when entities are removed from the scene.
+     */
+    getEntityRemovedObservables: () => readonly IReadonlyObservable<T>[];
+    /**
+     * A function that returns an array of observables for when entities are moved (e.g. re-parented) within the scene.
+     */
+    getEntityMovedObservables?: () => readonly IReadonlyObservable<T>[];
+    /**
+     * Optional configuration for drag-and-drop behavior within this section.
+     * If not provided, drag-and-drop is disabled for this section.
+     */
+    dragDropConfig?: SceneExplorerDragDropConfig<T>;
+}>;
+type InlineCommand = {
+    /**
+     * An icon component to render for the command. Required for inline commands.
+     */
+    icon: ComponentType;
+    /**
+     * The mode of the command. Inline commands are shown directly in the tree item layout. Inline by default.
+     */
+    mode?: "inline";
+};
+type ContextMenuCommand = {
+    /**
+     * An icon component to render for the command. Optional for context menu commands.
+     */
+    icon?: ComponentType;
+    /**
+     * The mode of the command. Context menu commands are shown in the context menu for the tree item.
+     */
+    mode: "contextMenu";
+};
+type CommandMode = NonNullable<(InlineCommand | ContextMenuCommand)["mode"]>;
+type ActionCommand = {
+    readonly type: "action";
+    /**
+     * The function that executes the command.
+     */
+    execute(): unknown | Promise<unknown>;
+};
+type ToggleCommand = {
+    readonly type: "toggle";
+    /**
+     * A boolean indicating if the command is enabled.
+     */
+    isEnabled: boolean;
+};
+type CommandType = (ActionCommand | ToggleCommand)["type"];
+/**
+ * Describes a command that can be executed on entities or sections in the Scene Explorer.
+ */
+export type SceneExplorerCommand<ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = Partial<IDisposable> & Readonly<{
+    /**
+     * The display name of the command (e.g. "Delete", "Rename", etc.).
+     */
+    displayName: string;
+    /**
+     * An optional array of hotkeys that trigger the command.
+     */
+    hotKey?: {
+        keyCode: string;
+        control?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+    };
+    /**
+     * An observable that notifies when the command state changes.
+     */
+    onChange?: IReadonlyObservable<unknown>;
+}> & (ModeT extends "inline" ? InlineCommand : ContextMenuCommand) & (TypeT extends "action" ? ActionCommand : ToggleCommand);
+/**
+ * Provides a command for a specific entity or section context in the Scene Explorer.
+ */
+export type SceneExplorerCommandProvider<ContextT, ModeT extends CommandMode = CommandMode, TypeT extends CommandType = CommandType> = Readonly<{
+    /**
+     * An optional order for the section, relative to other commands.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * A predicate function that determines if the command is applicable to the given context.
+     */
+    predicate: (context: unknown) => context is ContextT;
+    /**
+     * Gets the command information for the given context.
+     */
+    getCommand: (context: ContextT) => SceneExplorerCommand<ModeT, TypeT>;
+}>;
+declare const ActionCommand: FunctionComponent<{
+    command: SceneExplorerCommand<"inline", "action">;
+}>;
+declare const ToggleCommand: FunctionComponent<{
+    command: SceneExplorerCommand<"inline", "toggle">;
+}>;
+export declare const SceneExplorer: FunctionComponent<{
+    sections: readonly SceneExplorerSection<object>[];
+    entityCommandProviders: readonly SceneExplorerCommandProvider<object>[];
+    sectionCommandProviders: readonly SceneExplorerCommandProvider<string, "contextMenu">[];
+    scene: Scene;
+    selectedEntity?: Nullable<object>;
+    setSelectedEntity?: (entity: Nullable<object>) => void;
+}>;
+export {};

package/lib/components/scene/sceneExplorerDragDrop.d.ts

@@ -0,0 +1,38 @@
+import { type DragEvent } from "react";
+import { type SceneExplorerDragDropConfig } from "./sceneExplorer";
+/**
+ * Props for drop-only event handlers on a section header.
+ */
+export type DropProps = {
+    onDragOver: (e: DragEvent) => void;
+    onDragLeave: (e: DragEvent) => void;
+    onDrop: (e: DragEvent) => void;
+};
+/**
+ * Props for drag-drop event handlers on a tree item.
+ */
+export type DragDropProps = {
+    draggable: boolean;
+    onDragStart: (e: DragEvent) => void;
+    onDragEnd: (e: DragEvent) => void;
+} & DropProps;
+/**
+ * Options for the drag-drop hook.
+ */
+export type SceneExplorerDragDropOptions = {
+    /** Called after a successful drop with the dragged entity and target (entity or null for section root). */
+    onDrop?: (draggedEntity: object, targetEntity: object | null) => void;
+};
+/**
+ * Hook that provides drag-drop functionality for the scene explorer.
+ * Uses vanilla HTML5 drag and drop APIs.
+ * @param options Optional callbacks for drag-drop events.
+ * @returns State and props factory for drag-drop functionality.
+ */
+export declare function useSceneExplorerDragDrop(options?: SceneExplorerDragDropOptions): {
+    draggedEntity: object | undefined;
+    dropTarget: object | undefined;
+    dropTargetIsRoot: boolean;
+    createDragProps: (entity: object, getName: () => string, dragDropConfig?: SceneExplorerDragDropConfig<object>) => DragDropProps;
+    createSectionDropProps: (dragDropConfig: SceneExplorerDragDropConfig<object> | undefined) => DropProps;
+};

package/lib/components/scene/sceneProperties.d.ts

@@ -0,0 +1,19 @@
+import { Scene } from "@babylonjs/core/scene.js";
+import { type FunctionComponent } from "react";
+import { type ISelectionService } from "../../services/selectionService";
+export declare const SceneMaterialImageProcessingProperties: FunctionComponent<{
+    scene: Scene;
+}>;
+export declare const ScenePhysicsProperties: FunctionComponent<{
+    scene: Scene;
+}>;
+export declare const SceneCollisionsProperties: FunctionComponent<{
+    scene: Scene;
+}>;
+export declare const SceneShadowsProperties: FunctionComponent<{
+    scene: Scene;
+}>;
+export declare const SceneRenderingProperties: FunctionComponent<{
+    scene: Scene;
+    selectionService: ISelectionService;
+}>;

package/lib/components/stats/countStats.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/index.js";
+export declare const CountStats: FunctionComponent<{
+    context: Scene;
+}>;

package/lib/components/stats/frameStepStats.d.ts

@@ -0,0 +1,8 @@
+import { type Scene } from "@babylonjs/core/index.js";
+import { type FunctionComponent } from "react";
+import "@babylonjs/core/Engines/AbstractEngine/abstractEngine.timeQuery.js";
+import "@babylonjs/core/Engines/Extensions/engine.query.js";
+import "@babylonjs/core/Engines/WebGPU/Extensions/engine.query.js";
+export declare const FrameStepsStats: FunctionComponent<{
+    context: Scene;
+}>;

package/lib/components/stats/performanceStats.d.ts

@@ -0,0 +1,6 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/index.js";
+import "@babylonjs/core/Misc/PerformanceViewer/performanceViewerSceneExtension.js";
+export declare const PerformanceStats: FunctionComponent<{
+    context: Scene;
+}>;

package/lib/components/stats/statsPane.d.ts

@@ -0,0 +1,3 @@
+import { type Scene } from "@babylonjs/core/index.js";
+import { ExtensibleAccordion } from "../extensibleAccordion";
+export declare const StatsPane: typeof ExtensibleAccordion<Scene>;

package/lib/components/stats/systemStats.d.ts

@@ -0,0 +1,5 @@
+import { type Scene } from "@babylonjs/core/index.js";
+import { type FunctionComponent } from "react";
+export declare const SystemStats: FunctionComponent<{
+    context: Scene;
+}>;

package/lib/components/teachingMoment.d.ts

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

package/lib/components/textureEditor/canvasManager.d.ts

@@ -0,0 +1,113 @@
+import { type BaseTexture, type ISize, type Nullable, type PointerInfo } from "@babylonjs/core/index.js";
+import { type Channel } from "./channels";
+import { type IMetadata } from "./textureEditor";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+import { Scene } from "@babylonjs/core/scene.js";
+export type CanvasManagerTool = {
+    readonly is3D: boolean;
+    activate(): void;
+    deactivate(): void;
+    reset(): void;
+};
+export interface IPixelData {
+    x?: number;
+    y?: number;
+    r?: number;
+    g?: number;
+    b?: number;
+    a?: number;
+}
+export declare class TextureCanvasManager {
+    private readonly _engine;
+    private readonly _scene;
+    private readonly _camera;
+    private readonly _cameraPos;
+    private _scale;
+    private _isPanning;
+    private _mouseX;
+    private _mouseY;
+    private readonly _uiCanvas;
+    private _size;
+    /** The canvas we paint onto using the canvas API */
+    private readonly _2DCanvas;
+    /** The canvas we apply post processes to */
+    private readonly _3DCanvas;
+    /** The canvas which handles channel filtering */
+    private readonly _channelsTexture;
+    private readonly _3DEngine;
+    private readonly _3DPlane;
+    private readonly _3DCanvasTexture;
+    private readonly _3DScene;
+    private _channels;
+    private _face;
+    private _mipLevel;
+    /** The texture from the original engine that we invoked the editor on */
+    private readonly _originalTexture;
+    /** This is a hidden texture which is only responsible for holding the actual texture memory in the original engine */
+    private _target;
+    private readonly _originalTextureProperties;
+    /** Keeps track of whether we have modified the texture */
+    private _didEdit;
+    private _plane;
+    private readonly _planeMaterial;
+    /** Tracks which keys are currently pressed */
+    private _keyMap;
+    /** Tracks which mouse buttons are currently pressed */
+    private _buttonsPressed;
+    private readonly ZOOM_MOUSE_SPEED;
+    private readonly ZOOM_KEYBOARD_SPEED;
+    private readonly ZOOM_IN_KEY;
+    private readonly ZOOM_OUT_KEY;
+    private readonly PAN_SPEED;
+    private readonly PAN_KEY;
+    private readonly MIN_SCALE;
+    private readonly GRID_SCALE;
+    private readonly MAX_SCALE;
+    private readonly SELECT_ALL_KEY;
+    private readonly SAVE_KEY;
+    private readonly RESET_KEY;
+    private readonly DESELECT_KEY;
+    /** The number of milliseconds between texture updates */
+    private readonly PUSH_FREQUENCY;
+    private _tool;
+    private _setPixelData;
+    private _setMipLevel;
+    private readonly _window;
+    private _metadata;
+    private _editing3D;
+    private readonly _onUpdate;
+    private _setMetadata;
+    private _imageData;
+    private _canPush;
+    private _shouldPush;
+    private readonly _paintCanvas;
+    constructor(texture: BaseTexture, window: Window, canvasUI: HTMLCanvasElement, canvas2D: HTMLCanvasElement, canvas3D: HTMLCanvasElement, setPixelData: (pixelData: IPixelData) => void, metadata: IMetadata, onUpdate: () => void, setMetadata: (metadata: any) => void, setMipLevel: (level: number) => void);
+    updateTexture(): Promise<void>;
+    private pushTexture;
+    startPainting(): Promise<CanvasRenderingContext2D>;
+    updatePainting(): void;
+    stopPainting(): void;
+    private updateDisplay;
+    set channels(channels: Channel[]);
+    paintPixelsOnCanvas(pixelData: Uint8Array, canvas: HTMLCanvasElement): void;
+    grabOriginalTexture(): Promise<Uint8Array<ArrayBufferLike>>;
+    getMouseCoordinates(pointerInfo: PointerInfo): Vector2;
+    get scene(): Scene;
+    get canvas2D(): HTMLCanvasElement;
+    get size(): ISize;
+    set tool(tool: Nullable<CanvasManagerTool>);
+    get tool(): Nullable<CanvasManagerTool>;
+    set face(face: number);
+    set mipLevel(mipLevel: number);
+    /** Returns the 3D scene used for postprocesses */
+    get scene3D(): Scene;
+    set metadata(metadata: IMetadata);
+    private makePlane;
+    reset(): void;
+    resize(newSize: ISize): Promise<void>;
+    setSize(size: ISize): void;
+    upload(file: File): void;
+    saveTexture(): void;
+    toolInteractionEnabled(): boolean;
+    dispose(): void;
+}

package/lib/components/textureEditor/canvasShader.d.ts

@@ -0,0 +1,10 @@
+export declare const canvasShader: {
+    path: {
+        vertexSource: string;
+        fragmentSource: string;
+    };
+    options: {
+        attributes: string[];
+        uniforms: string[];
+    };
+};

package/lib/components/textureEditor/channels.d.ts

@@ -0,0 +1,25 @@
+import { type FunctionComponent } from "react";
+/**
+ * Represents a color channel in the texture editor
+ */
+export type Channel = {
+    /** Whether the channel is visible */
+    visible: boolean;
+    /** Whether the channel is editable */
+    editable: boolean;
+    /** Display name for the channel */
+    name: string;
+    /** Channel identifier */
+    id: "R" | "G" | "B" | "A";
+};
+type ChannelsBarProps = {
+    channels: Channel[];
+    setChannels: (channels: Channel[]) => void;
+};
+/**
+ * Displays channel visibility and editability controls
+ * @param props - The channels bar properties
+ * @returns The channels bar component
+ */
+export declare const ChannelsBar: FunctionComponent<ChannelsBarProps>;
+export {};

package/lib/components/textureEditor/properties.d.ts

@@ -0,0 +1,23 @@
+import { type FunctionComponent } from "react";
+import { type BaseTexture, type ISize } from "@babylonjs/core/index.js";
+import { type IPixelData } from "./canvasManager";
+type PropertiesBarProps = {
+    texture: BaseTexture;
+    size: ISize;
+    saveTexture: () => void;
+    pixelData: IPixelData;
+    face: number;
+    setFace: (face: number) => void;
+    resetTexture: () => void;
+    resizeTexture: (width: number, height: number) => void;
+    uploadTexture: (file: File) => void;
+    mipLevel: number;
+    setMipLevel: (mipLevel: number) => void;
+};
+/**
+ * Properties bar component showing texture info and actions
+ * @param props - The properties bar properties
+ * @returns The properties bar component
+ */
+export declare const PropertiesBar: FunctionComponent<PropertiesBarProps>;
+export {};

package/lib/components/textureEditor/status.d.ts

@@ -0,0 +1,13 @@
+import { type FunctionComponent } from "react";
+import { type BaseTexture } from "@babylonjs/core/index.js";
+type StatusBarProps = {
+    texture: BaseTexture;
+    mipLevel: number;
+};
+/**
+ * Displays status information about the texture
+ * @param props - The status bar properties
+ * @returns The status bar component
+ */
+export declare const StatusBar: FunctionComponent<StatusBarProps>;
+export {};

package/lib/components/textureEditor/textureEditor.d.ts

@@ -0,0 +1,113 @@
+import { type ComponentType, type FunctionComponent } from "react";
+import { type BaseTexture, type ISize, type PointerInfo, type Scene, type Vector2 } from "@babylonjs/core/index.js";
+/**
+ * Parameters passed to tools for interaction with the texture editor
+ */
+export interface IToolParameters {
+    /** The visible scene in the editor. Useful for adding pointer and keyboard events. */
+    scene: Scene;
+    /** The 2D canvas which you can sample pixel data from. Tools should not paint directly on this canvas. */
+    canvas2D: HTMLCanvasElement;
+    /** The 3D scene which tools can add post processes to. */
+    scene3D: Scene;
+    /** The size of the texture. */
+    size: ISize;
+    /** Pushes the editor texture back to the original scene. This should be called every time a tool makes any modification to a texture. */
+    updateTexture: () => void;
+    /** The metadata object which is shared between all tools. Feel free to store any information here. Do not set this directly: instead call setMetadata. */
+    metadata: IMetadata;
+    /** Call this when you want to mutate the metadata. */
+    setMetadata: (data: any) => void;
+    /** Returns the texture coordinates under the cursor */
+    getMouseCoordinates: (pointerInfo: PointerInfo) => Vector2;
+    /** Provides a canvas that you can use the canvas API to paint on. */
+    startPainting: () => Promise<CanvasRenderingContext2D>;
+    /** After you have painted on your canvas, call this method to push the updates back to the texture. */
+    updatePainting: () => void;
+    /** Call this when you are finished painting. */
+    stopPainting: () => void;
+    /** Returns whether the tool should be allowed to interact */
+    interactionEnabled: () => boolean;
+}
+export type TextureEditorTool = {
+    /**
+     * Called when the tool is activated from the toolbar.
+     */
+    activate: () => void;
+    /**
+     * Called when the tool is deactivated from the toolbar.
+     */
+    deactivate: () => void;
+    /**
+     * Optional: Called when the user resets the texture or uploads a new texture. Tools may want to reset their state when this happens.
+     */
+    reset?: () => void;
+    /**
+     * Optional: React component for tool-specific settings UI.
+     */
+    settingsComponent?: ComponentType;
+};
+export type TextureEditorToolContext = {
+    getParameters(): IToolParameters;
+};
+export type TextureEditorToolProvider = {
+    /**
+     * An optional order for the section, relative to other commands.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * The name of the tool.
+     */
+    name: string;
+    /**
+     * The icon component for the tool.
+     */
+    icon: ComponentType;
+    /**
+     * Whether the tool uses postprocesses.
+     */
+    is3D?: boolean;
+    /**
+     * Optional system cursor name to use when tool is active (e.g. 'crosshair', 'pointer')
+     */
+    cursor?: string;
+    /**
+     * Instantiates the tool.
+     * @param context The context for the tool.
+     * @returns The instantiated tool.
+     */
+    getTool: (context: TextureEditorToolContext) => TextureEditorTool;
+};
+/**
+ * Metadata shared between tools in the texture editor
+ */
+export interface IMetadata {
+    /** Current paint color in hex format */
+    color: string;
+    /** Current paint alpha value 0-1 */
+    alpha: number;
+    /** Current selection coordinates */
+    select: {
+        /** Left edge of selection */
+        x1: number;
+        /** Top edge of selection */
+        y1: number;
+        /** Right edge of selection */
+        x2: number;
+        /** Bottom edge of selection */
+        y2: number;
+    };
+}
+export type TextureEditorProps = {
+    texture: BaseTexture;
+    toolProviders?: readonly TextureEditorToolProvider[];
+    window?: Window;
+    onUpdate?: () => void;
+};
+/**
+ * Main texture editor component
+ * @param props - The texture editor properties
+ * @returns The texture editor component
+ */
+export declare const TextureEditor: FunctionComponent<TextureEditorProps>;

package/lib/components/textureEditor/tools.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentType, type FunctionComponent } from "react";
+import { type IMetadata } from "./textureEditor";
+type ToolBarProps = {
+    tools: readonly {
+        name: string;
+        icon: ComponentType;
+    }[];
+    changeTool: (toolIndex: number) => void;
+    activeToolIndex: number;
+    metadata: IMetadata;
+    setMetadata: (data: any) => void;
+    hasAlpha: boolean;
+};
+/**
+ * Toolbar component for texture editing tools
+ * @param props - The toolbar properties
+ * @returns The toolbar component
+ */
+export declare const ToolBar: FunctionComponent<ToolBarProps>;
+export {};

package/lib/components/theme.d.ts

@@ -0,0 +1,10 @@
+import { type FluentProviderProps } from "@fluentui/react-components";
+import { type FunctionComponent } from "react";
+/**
+ * A themed Fluent UI provider that applies the current theme mode (light or dark).
+ * @param props Fluent provider props, plus an optional `invert` flag to swap the theme.
+ * @returns The themed Fluent UI provider component.
+ */
+export declare const Theme: FunctionComponent<FluentProviderProps & {
+    invert?: boolean;
+}>;

package/lib/components/tools/capture/equirectangularCaptureTool.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/scene.js";
+export declare const EquirectangularCaptureTool: FunctionComponent<{
+    scene: Scene;
+}>;

package/lib/components/tools/capture/gifCaptureTool.d.ts

@@ -0,0 +1,7 @@
+import { type Scene } from "@babylonjs/core/scene.js";
+export declare const GIFCaptureTool: import("react").ForwardRefExoticComponent<{
+    scene: Scene;
+} & {
+    spinnerSize?: import("@fluentui/react-spinner").SpinnerProps["size"];
+    spinnerLabel?: string;
+} & import("react").RefAttributes<never>>;

package/lib/components/tools/capture/sceneReplayTool.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/scene.js";
+export declare const SceneReplayTool: FunctionComponent<{
+    scene: Scene;
+}>;

package/lib/components/tools/capture/screenshotTool.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/scene.js";
+export declare const ScreenshotTool: FunctionComponent<{
+    scene: Scene;
+}>;

package/lib/components/tools/capture/videoCaptureTool.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/scene.js";
+export declare const VideoCaptureTool: FunctionComponent<{
+    scene: Scene;
+}>;