@babylonjs/inspector 8.56.2 → 9.1.0

package/lib/components/errorBoundary.d.ts

@@ -0,0 +1,31 @@
+import { type ErrorInfo, type ReactNode, Component } from "react";
+/**
+ * Props for the {@link ErrorBoundary} component.
+ */
+type ErrorBoundaryProps = {
+    /** Child components to render */
+    children: ReactNode;
+    /** Optional fallback UI to show on error */
+    fallback?: ReactNode;
+    /** Optional callback when an error occurs */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Optional name for identifying this boundary in logs */
+    name?: string;
+};
+type ErrorBoundaryState = {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+};
+/**
+ * Error boundary component that catches JavaScript errors in child components
+ * and displays a fallback UI instead of crashing the entire application.
+ */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private _handleRetry;
+    render(): string | number | boolean | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/lib/components/extensibleAccordion.d.ts

@@ -0,0 +1,67 @@
+import { type ComponentType, type PropsWithChildren, type Ref } from "react";
+import { type AccordionProps } from "@babylonjs/shared-ui-components/fluent/primitives/accordion.js";
+/**
+ * Describes a section within a dynamic accordion that can be added at runtime.
+ */
+export type DynamicAccordionSection = Readonly<{
+    /**
+     * A unique identity for the section, which can be referenced by section content.
+     */
+    identity: string;
+    /**
+     * An optional order for the section, relative to other sections.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * An optional flag indicating whether the section should be collapsed by default.
+     * Defaults to false.
+     */
+    collapseByDefault?: boolean;
+}>;
+/**
+ * Describes content that belongs to a section within a dynamic accordion.
+ */
+export type DynamicAccordionSectionContent<ContextT> = Readonly<{
+    /**
+     * A unique key for the the content.
+     */
+    key: string;
+    /**
+     * The section this content belongs to.
+     */
+    section: string;
+    /**
+     * An optional order for the content within the section.
+     * Defaults to 0.
+     */
+    order?: number;
+    /**
+     * The React component that will be rendered for this content.
+     */
+    component: ComponentType<{
+        context: ContextT;
+    }>;
+}>;
+/**
+ * Imperative handle for controlling section highlights on the extensible accordion.
+ */
+export type SectionsImperativeRef = {
+    /**
+     * Highlights the specified sections, collapsing all others until the context changes.
+     * @param sections The identity strings of the sections to highlight.
+     */
+    highlightSections: (sections: readonly string[]) => void;
+};
+/**
+ * An accordion component that supports dynamically adding sections and section content at runtime.
+ * Combines statically defined children sections with dynamically registered sections and content.
+ * @param props The accordion props including sections, section content, context, and an optional imperative ref.
+ * @returns The extensible accordion component.
+ */
+export declare function ExtensibleAccordion<ContextT = unknown>(props: PropsWithChildren<{
+    sections: readonly DynamicAccordionSection[];
+    sectionContent: readonly DynamicAccordionSectionContent<ContextT>[];
+    context: ContextT;
+    sectionsRef?: Ref<SectionsImperativeRef>;
+} & AccordionProps>): import("react/jsx-runtime").JSX.Element;

package/lib/components/gizmoToolbar.d.ts

@@ -0,0 +1,7 @@
+import { type FunctionComponent } from "react";
+import { type IGizmoService } from "../services/gizmoService";
+import { type ISceneContext } from "../services/sceneContext";
+export declare const GizmoToolbar: FunctionComponent<{
+    gizmoService: IGizmoService;
+    sceneContext: ISceneContext;
+}>;

package/lib/components/pane.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Used to apply common styles to panes.
+ */
+export declare const SidePaneContainer: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/lib/components/performanceViewer/canvasGraph.d.ts

@@ -0,0 +1,16 @@
+import { type PerformanceViewerCollector } from "@babylonjs/core/Misc/PerformanceViewer/performanceViewerCollector.js";
+import { type Observable } from "@babylonjs/core/Misc/observable.js";
+import { type FunctionComponent } from "react";
+import { type PerfLayoutSize, type VisibleRangeChangedObservableProps } from "./graphSupportingTypes";
+import { type Scene } from "@babylonjs/core/scene.js";
+import { type Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+type CanvasGraphProps = {
+    scene: Scene;
+    collector: PerformanceViewerCollector;
+    layoutObservable?: Observable<PerfLayoutSize>;
+    returnToPlayheadObservable?: Observable<void>;
+    onVisibleRangeChangedObservable?: Observable<VisibleRangeChangedObservableProps>;
+    initialGraphSize?: Vector2;
+};
+export declare const CanvasGraph: FunctionComponent<CanvasGraphProps>;
+export {};

package/lib/components/performanceViewer/canvasGraphService.d.ts

@@ -0,0 +1,238 @@
+import { type CanvasGraphServiceSettings, type PerfLayoutSize } from "./graphSupportingTypes";
+import { type IPerfDatasets, type IPerfMetadata } from "@babylonjs/core/Misc/interfaces/iPerfViewer.js";
+/**
+ * This class acts as the main API for graphing. Here is where you will find methods to let the service know new data needs to be drawn,
+ * let it know something has been resized, etc!
+ */
+export declare class CanvasGraphService {
+    private _ctx;
+    private _width;
+    private _height;
+    private _sizeOfWindow;
+    private _ticks;
+    private _panPosition;
+    private _position;
+    private _datasetBounds;
+    private _globalTimeMinMax;
+    private _hoverPosition;
+    private _drawableArea;
+    private _axisHeight;
+    private _tooltipItems;
+    private _tooltipTextCache;
+    private _tickerTextCache;
+    private _tickerItems;
+    private _preprocessedTooltipInfo;
+    private _numberOfTickers;
+    private _onVisibleRangeChangedObservable?;
+    private readonly _addonFontLineHeight;
+    private readonly _defaultLineHeight;
+    /**
+     * The datasets to render.
+     */
+    readonly datasets: IPerfDatasets;
+    /**
+     * Metadata for each dataset.
+     */
+    metadata: Map<string, IPerfMetadata>;
+    /**
+     * Creates an instance of CanvasGraphService.
+     *
+     * @param canvas a pointer to the canvas dom element we would like to write to.
+     * @param settings settings for our service.
+     */
+    constructor(canvas: HTMLCanvasElement, settings: CanvasGraphServiceSettings);
+    /**
+     * This method lets the service know it should get ready to update what it is displaying.
+     */
+    update: () => void;
+    /**
+     * Update the canvas graph service with the new height and width of the canvas.
+     * @param size The new size of the canvas.
+     */
+    resize(size: PerfLayoutSize): void;
+    /**
+     * Force resets the position in the data, effectively returning to the most current data.
+     */
+    resetDataPosition(): void;
+    private _prevPointById;
+    private _prevValueById;
+    /**
+     * This method draws the data and sets up the appropriate scales.
+     */
+    private _draw;
+    private _drawTickers;
+    /**
+     * Returns the index of the closest time for the datasets.
+     * Uses a modified binary search to get value.
+     *
+     * @param targetTime the time we want to get close to.
+     * @returns index of the item with the closest time to the targetTime
+     */
+    private _getClosestPointToTimestamp;
+    /**
+     * This is a convenience method to get the number of collected slices.
+     * @returns the total number of collected slices.
+     */
+    private _getNumberOfSlices;
+    /**
+     * Draws the time axis, adjusts the drawable area for the graph.
+     *
+     * @param timeMinMax the minimum and maximum for the time axis.
+     * @param drawableArea the current allocated drawable area.
+     */
+    private _drawTimeAxis;
+    /**
+     * Given a timestamp (should be the maximum timestamp in view), this function returns the maximum unit the timestamp contains.
+     * This information can be used for formatting purposes.
+     * @param timestamp the maximum timestamp to find the maximum timestamp unit for.
+     * @returns The maximum unit the timestamp has.
+     */
+    private _getTimestampUnit;
+    /**
+     * Given a timestamp and the interval unit, this function will parse the timestamp to the appropriate format.
+     * @param timestamp The timestamp to parse
+     * @param intervalUnit The maximum unit of the maximum timestamp in an interval.
+     * @returns a string representing the parsed timestamp.
+     */
+    private _parseTimestamp;
+    /**
+     * Generates a list of ticks given the min and max of the axis, and the space available in the axis.
+     *
+     * @param minMax the minimum and maximum values of the axis
+     * @param spaceAvailable the total amount of space we have allocated to our axis
+     */
+    private _generateTicks;
+    /**
+     * Nice number algorithm based on psueudo code defined in "Graphics Gems" by Andrew S. Glassner.
+     * This will find a "nice" number approximately equal to num.
+     *
+     * @param num The number we want to get close to.
+     * @param shouldRound if true we will round the number, otherwise we will get the ceiling.
+     * @returns a "nice" number approximately equal to num.
+     */
+    private _niceNumber;
+    /**
+     * Gets the min and max as a single object from an array of numbers.
+     * @param bounds
+     * @param offset
+     * @returns the min and max of the array.
+     */
+    private _getMinMax;
+    /**
+     * Converts a single number to a pixel coordinate in a single axis by normalizing the data to a [0, 1] scale using the minimum and maximum values.
+     *
+     * @param num the number we want to get the pixel coordinate for
+     * @param minMax the min and max of the dataset in the axis we want the pixel coordinate for.
+     * @param startingPixel the starting pixel coordinate (this means it takes account for any offset).
+     * @param spaceAvailable the total space available in this axis.
+     * @param shouldFlipValue if we should use a [1, 0] scale instead of a [0, 1] scale.
+     * @returns the pixel coordinate of the value in a single axis.
+     */
+    private _getPixelForNumber;
+    /**
+     * Add in any necessary event listeners.
+     *
+     * @param canvas The canvas we want to attach listeners to.
+     */
+    private _attachEventListeners;
+    /**
+     * We remove all event listeners we added.
+     *
+     * @param canvas The canvas we want to remove listeners from.
+     */
+    private _removeEventListeners;
+    /**
+     * Handles what to do when we are hovering over the canvas and not panning.
+     *
+     * @param event A reference to the event to be handled.
+     */
+    private _handleDataHover;
+    /**
+     * Debounced processing and drawing of tooltip.
+     */
+    private _debouncedTooltip;
+    /**
+     * Handles what to do when we stop hovering over the canvas.
+     */
+    private _handleStopHover;
+    /**
+     * Given a line defined by P1: (x1, y1) and P2: (x2, y2) get the distance of P0 (x0, y0) from the line.
+     * https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_two_points
+     * @param x1 x position of point P1
+     * @param y1 y position of point P1
+     * @param x2 x position of point P2
+     * @param y2 y position of point P2
+     * @param x0 x position of point P0
+     * @param y0 y position of point P0
+     * @returns distance of P0 from the line defined by P1 and P2
+     */
+    private _getDistanceFromLine;
+    /**
+     * This method does preprocessing calculations for the tooltip.
+     * @param pos the position of our mouse.
+     * @param drawableArea the remaining drawable area.
+     */
+    private _preprocessTooltip;
+    /**
+     * Draws the tooltip given the area it is allowed to draw in and the current pixel position.
+     *
+     * @param pos the position of the mouse cursor in pixels (x, y).
+     * @param drawableArea  the available area we can draw in.
+     */
+    private _drawTooltip;
+    /**
+     * Gets the number from a pixel position given the minimum and maximum value in range, and the starting pixel and the ending pixel.
+     *
+     * @param pixel current pixel position we want to get the number for.
+     * @param minMax the minimum and maximum number in the range.
+     * @param startingPixel position of the starting pixel in range.
+     * @param endingPixel position of ending pixel in range.
+     * @param shouldFlip if we should use a [1, 0] scale instead of a [0, 1] scale.
+     * @returns number corresponding to pixel position
+     */
+    private _getNumberFromPixel;
+    /**
+     * The handler for when we want to zoom in and out of the graph.
+     *
+     * @param event a mouse wheel event.
+     */
+    private _handleZoom;
+    /**
+     * Initializes the panning object and attaches appropriate listener.
+     *
+     * @param event the mouse event containing positional information.
+     */
+    private _handlePanStart;
+    /**
+     * While panning this event will keep track of the delta and update the "positions".
+     *
+     * @param event The mouse event that contains positional information.
+     */
+    private _handlePan;
+    /**
+     * Clears the panning object and removes the appropriate listener.
+     */
+    private _handlePanStop;
+    /**
+     * Method which returns true if the data should become realtime, false otherwise.
+     *
+     * @returns if the data should become realtime or not.
+     */
+    private _shouldBecomeRealtime;
+    /**
+     * Will generate a playhead with a futurebox that takes up (1-scalefactor)*100% of the canvas.
+     *
+     * @param drawableArea The remaining drawable area.
+     * @param scaleFactor The Percentage between 0.0 and 1.0 of the canvas the data gets drawn on.
+     */
+    private _drawPlayheadRegion;
+    /**
+     *  Method to do cleanup when the object is done being used.
+     *
+     */
+    destroy(): void;
+    /**
+     * This method clears the canvas
+     */
+    clear(): void;
+}

package/lib/components/performanceViewer/graphSupportingTypes.d.ts

@@ -0,0 +1,90 @@
+import { type IPerfDatasets } from "@babylonjs/core/Misc/interfaces/iPerfViewer.js";
+import { type Observable } from "@babylonjs/core/Misc/observable.js";
+/**
+ * Defines a structure to hold max, min and a optional current.
+ */
+export type PerfMinMax = {
+    min: number;
+    max: number;
+    current?: number;
+};
+/**
+ * Defines structure of the object which contains information related to panning.
+ */
+export type PerfMousePanningPosition = {
+    xPos: number;
+    delta: number;
+};
+/**
+ * Defines structure of the object which contains information regarding the bounds of each dataset we want to consider.
+ */
+export type PerfIndexBounds = {
+    start: number;
+    end: number;
+};
+export type PerfLayoutSize = {
+    width: number;
+    height: number;
+};
+/**
+ * Defines the structure of the meta object for the tooltip that appears when hovering over a performance graph!
+ */
+export type PerfTooltip = {
+    text: string;
+    color: string;
+};
+/**
+ * Defines the structure of a cache object used to store the result of measureText().
+ */
+export type PerfTextMeasureCache = {
+    text: string;
+    width: number;
+};
+/**
+ * Defines a structure defining the available space in a drawable area.
+ */
+export type GraphDrawableArea = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+/**
+ * Defines the structure representing necessary ticker information.
+ */
+export type PerfTicker = PerfMinMax & {
+    id: string;
+    text: string;
+};
+export type VisibleRangeChangedObservableProps = {
+    valueMap: Map<string, PerfMinMax>;
+};
+/**
+ * Defines what settings our canvas graphing service accepts
+ */
+export type CanvasGraphServiceSettings = {
+    datasets: IPerfDatasets;
+    onVisibleRangeChangedObservable?: Observable<VisibleRangeChangedObservableProps>;
+};
+/**
+ * Defines the structure representing the preprocessable tooltip information.
+ */
+export type TooltipPreprocessedInformation = {
+    xForActualTimestamp: number;
+    numberOfTooltipItems: number;
+    longestText: string;
+    focusedId: string;
+};
+export type PerfTooltipHoverPosition = {
+    xPos: number;
+    yPos: number;
+};
+/**
+ * Defines the supported timestamp units.
+ */
+export declare enum TimestampUnit {
+    Milliseconds = 0,
+    Seconds = 1,
+    Minutes = 2,
+    Hours = 3
+}

package/lib/components/performanceViewer/performanceSidebar.d.ts

@@ -0,0 +1,10 @@
+import { type FunctionComponent } from "react";
+import { type Observable } from "@babylonjs/core/Misc/observable.js";
+import { type PerformanceViewerCollector } from "@babylonjs/core/Misc/PerformanceViewer/performanceViewerCollector.js";
+import { type VisibleRangeChangedObservableProps } from "./graphSupportingTypes";
+interface IPerformanceSidebarProps {
+    collector: PerformanceViewerCollector;
+    onVisibleRangeChangedObservable?: Observable<VisibleRangeChangedObservableProps>;
+}
+export declare const PerformanceSidebar: FunctionComponent<IPerformanceSidebarProps>;
+export {};

package/lib/components/performanceViewer/performanceViewer.d.ts

@@ -0,0 +1,15 @@
+import { type PerformanceViewerCollector } from "@babylonjs/core/Misc/PerformanceViewer/performanceViewerCollector.js";
+import { type Observable } from "@babylonjs/core/Misc/observable.js";
+import { type Scene } from "@babylonjs/core/scene.js";
+import { type FunctionComponent } from "react";
+import { type PerfLayoutSize } from "./graphSupportingTypes";
+import { type Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+type PerformanceViewerProps = {
+    scene: Scene;
+    layoutObservable: Observable<PerfLayoutSize>;
+    returnToLiveObservable: Observable<void>;
+    performanceCollector: PerformanceViewerCollector;
+    initialGraphSize?: Vector2;
+};
+export declare const PerformanceViewer: FunctionComponent<PerformanceViewerProps>;
+export {};

package/lib/components/pickingToolbar.d.ts

@@ -0,0 +1,11 @@
+import { type FunctionComponent } from "react";
+import { type Nullable, type Scene } from "@babylonjs/core/index.js";
+import { type IGizmoService } from "../services/gizmoService";
+export declare const PickingToolbar: FunctionComponent<{
+    scene: Scene;
+    selectEntity: (entity: Nullable<object>) => void;
+    gizmoService: IGizmoService;
+    ignoreBackfaces?: boolean;
+    highlightSelectedEntity?: boolean;
+    onHighlightSelectedEntityChange?: (value: boolean) => void;
+}>;

package/lib/components/properties/animation/animationGroupProperties.d.ts

@@ -0,0 +1,8 @@
+import { type FunctionComponent } from "react";
+import { type AnimationGroup } from "@babylonjs/core/Animations/animationGroup.js";
+export declare const AnimationGroupControlProperties: FunctionComponent<{
+    animationGroup: AnimationGroup;
+}>;
+export declare const AnimationGroupInfoProperties: FunctionComponent<{
+    animationGroup: AnimationGroup;
+}>;

package/lib/components/properties/animation/animationsProperties.d.ts

@@ -0,0 +1,21 @@
+import { type FunctionComponent } from "react";
+import { type AnimationRange } from "@babylonjs/core/Animations/animationRange.js";
+import { type Nullable } from "@babylonjs/core/types.js";
+import { type IAnimatable } from "@babylonjs/core/Animations/animatable.interface.js";
+import { type Scene } from "@babylonjs/core/scene.js";
+import { AnimationPropertiesOverride } from "@babylonjs/core/Animations/animationPropertiesOverride.js";
+export interface IAnimationRangeContainer {
+    getAnimationRanges(): Nullable<AnimationRange>[];
+}
+export interface IAnimatableContainer {
+    getAnimatables(): IAnimatable[];
+}
+declare module "@babylonjs/core/Animations/animatable.js" {
+    interface Animatable {
+        animationPropertiesOverride?: AnimationPropertiesOverride;
+    }
+}
+export declare const AnimationsProperties: FunctionComponent<{
+    scene: Scene;
+    entity: Partial<IAnimatable & IAnimationRangeContainer & IAnimatableContainer>;
+}>;

package/lib/components/properties/animation/targetedAnimationProperties.d.ts

@@ -0,0 +1,7 @@
+import { type FunctionComponent } from "react";
+import { type TargetedAnimation } from "@babylonjs/core/index.js";
+import { type ISelectionService } from "../../../services/selectionService";
+export declare const TargetedAnimationGeneralProperties: FunctionComponent<{
+    targetedAnimation: TargetedAnimation;
+    selectionService: ISelectionService;
+}>;

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

@@ -0,0 +1,20 @@
+import { type FunctionComponent } from "react";
+import { type Atmosphere } from "@babylonjs/addons/atmosphere/atmosphere.js";
+export declare const GeneralAtmosphereProperties: FunctionComponent<{
+    entity: Atmosphere;
+}>;
+export declare const ScatteringAndAbsorptionProperties: FunctionComponent<{
+    entity: Atmosphere;
+}>;
+export declare const MultipleScatteringProperties: FunctionComponent<{
+    entity: Atmosphere;
+}>;
+export declare const AerialPerspectiveProperties: FunctionComponent<{
+    entity: Atmosphere;
+}>;
+export declare const DiffuseIrradianceProperties: FunctionComponent<{
+    entity: Atmosphere;
+}>;
+export declare const RenderingOptionsProperties: FunctionComponent<{
+    entity: Atmosphere;
+}>;

package/lib/components/properties/audio/soundProperties.d.ts

@@ -0,0 +1,8 @@
+import { type Sound } from "@babylonjs/core/index.js";
+import { type FunctionComponent } from "react";
+export declare const SoundGeneralProperties: FunctionComponent<{
+    sound: Sound;
+}>;
+export declare const SoundCommandProperties: FunctionComponent<{
+    sound: Sound;
+}>;

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

@@ -0,0 +1,80 @@
+import { type ComponentProps, type ComponentType } from "react";
+/**
+ * Helper type to check if a type includes null or undefined
+ */
+type IsNullable<T> = null extends T ? true : undefined extends T ? true : false;
+/**
+ * Base props for BoundProperty
+ */
+type BaseBoundPropertyProps<TargetT extends object, PropertyKeyT extends keyof TargetT, ComponentT extends ComponentType<any>> = Omit<ComponentProps<ComponentT>, "value" | "onChange" | "nullable" | "defaultValue" | "ignoreNullable"> & {
+    component: ComponentT;
+    target: TargetT | null | undefined;
+    propertyKey: PropertyKeyT;
+    /** Optional propertyPath used to generate the copyString if path to property is not equal to entity.target */
+    propertyPath?: string;
+    convertTo?: (value: TargetT[PropertyKeyT]) => TargetT[PropertyKeyT];
+    convertFrom?: (value: TargetT[PropertyKeyT]) => TargetT[PropertyKeyT];
+};
+/**
+ * Enhanced BoundProperty props that enforces strict nullable handling
+ */
+export type BoundPropertyProps<TargetT extends object, PropertyKeyT extends keyof TargetT, ComponentT extends ComponentType<any>> = BaseBoundPropertyProps<TargetT, PropertyKeyT, ComponentT> & (IsNullable<TargetT[PropertyKeyT]> extends true ? {
+    defaultValue: null;
+    nullable?: never;
+    ignoreNullable?: never;
+} | (ComponentProps<ComponentT> extends {
+    nullable?: boolean;
+} ? {
+    nullable: true;
+    defaultValue: NonNullable<TargetT[PropertyKeyT]>;
+    ignoreNullable?: never;
+} | {
+    ignoreNullable: true;
+    defaultValue: NonNullable<TargetT[PropertyKeyT]>;
+    nullable?: never;
+} : never) : {});
+declare function BoundPropertyImpl<TargetT extends object, PropertyKeyT extends keyof TargetT, ComponentT extends ComponentType<any>>(props: BoundPropertyProps<TargetT, PropertyKeyT, ComponentT>, ref?: any): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Intercepts the passed in component's target[propertyKey] with useInterceptObservable and sets component state using useObservableState.
+ * Renders the passed in component with value as the new observableState value and onChange as a callback to set the target[propertyKey] value.
+ *
+ * NOTE: BoundProperty has strict nullable enforcement!
+ *
+ * If Target[PropertyKey] is Nullable, caller has three options:
+ * 1. `nullable: true` + `defaultValue: NonNullable<T>` - Shows enable/disable checkbox UI
+ * 2. `ignoreNullable: true` + `defaultValue: NonNullable<T>` - Shows disabled state when null
+ * 3. `defaultValue: null` - Skips nullable handling entirely, passes value through as-is
+ *
+ * @param props BoundPropertyProps with strict nullable validation
+ * @returns JSX element
+ */
+export declare const BoundProperty: typeof BoundPropertyImpl;
+/**
+ * Mutually exclusive propertyPath or functionPath - one required
+ */
+type RequiredPropertyPath = {
+    propertyPath: string;
+    functionPath?: never;
+} | {
+    functionPath: string;
+    propertyPath?: never;
+};
+/**
+ * Props for Property component - a simpler version of BoundProperty that only handles onCopy functionality
+ * Pass in the full propertyPath from entity to property (e.g. "meshes[0].position.x") to ensure copyString is accurate
+ * Use functionPath for function-based properties (e.g. "setEnabled" generates "debugNode.setEnabled(value)")
+ */
+export type PropertyProps<ComponentT extends ComponentType<any>> = Omit<ComponentProps<ComponentT>, "onCopy"> & {
+    component: ComponentT;
+} & RequiredPropertyPath;
+declare function PropertyImpl<ComponentT extends ComponentType<any>>(props: PropertyProps<ComponentT>, ref?: any): import("react/jsx-runtime").JSX.Element;
+/**
+ * A simpler version of BoundProperty that only provides the onCopy functionality.
+ * Does not bind the value/onChange - those must be provided by the caller.
+ * Use this when you need copy support but have custom value/onChange handling.
+ *
+ * @param props PropertyProps with propertyName for copy support
+ * @returns JSX element
+ */
+export declare const Property: typeof PropertyImpl;
+export {};

package/lib/components/properties/cameras/arcRotateCameraProperties.d.ts

@@ -0,0 +1,17 @@
+import { type FunctionComponent } from "react";
+import { type ArcRotateCamera } from "@babylonjs/core/index.js";
+export declare const ArcRotateCameraTransformProperties: FunctionComponent<{
+    camera: ArcRotateCamera;
+}>;
+export declare const ArcRotateCameraControlProperties: FunctionComponent<{
+    camera: ArcRotateCamera;
+}>;
+export declare const ArcRotateCameraCollisionProperties: FunctionComponent<{
+    camera: ArcRotateCamera;
+}>;
+export declare const ArcRotateCameraLimitsProperties: FunctionComponent<{
+    camera: ArcRotateCamera;
+}>;
+export declare const ArcRotateCameraBehaviorsProperties: FunctionComponent<{
+    camera: ArcRotateCamera;
+}>;