mujoco-react 8.9.2 → 8.10.0

package/dist/types-FFW7ykBu.d.ts

@@ -0,0 +1,817 @@
+import React__default, { ReactNode } from 'react';
+import { CanvasProps, ThreeElements } from '@react-three/fiber';
+import * as THREE from 'three';
+
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Module augmentation interface for type-safe resource names.
+ *
+ * Declare your model's resource names via module augmentation:
+ * ```ts
+ * declare module 'mujoco-react' {
+ *   interface Register {
+ *     robots: {
+ *       panda: {
+ *         actuators: 'joint1' | 'joint2' | 'gripper';
+ *         sensors: 'force_sensor' | 'torque_sensor';
+ *         bodies: 'link0' | 'link1' | 'hand';
+ *       };
+ *     };
+ *     actuators: 'joint1' | 'joint2' | 'gripper';
+ *     sensors: 'force_sensor' | 'torque_sensor';
+ *     bodies: 'link0' | 'link1' | 'hand';
+ *   }
+ * }
+ * ```
+ *
+ * When no augmentation is declared, all names fall back to `string`.
+ */
+interface Register {
+}
+type RegisteredRobotMap = Register extends {
+    robots: infer T extends Record<string, Record<string, string>>;
+} ? T : never;
+type Robots = [RegisteredRobotMap] extends [never] ? string : Extract<keyof RegisteredRobotMap, string>;
+type RobotResource<TRobot extends string, TKey extends string> = [
+    RegisteredRobotMap
+] extends [never] ? string : TRobot extends keyof RegisteredRobotMap ? TKey extends keyof RegisteredRobotMap[TRobot] ? RegisteredRobotMap[TRobot][TKey] : string : never;
+type RegisterResourceKey = 'actuators' | 'sensors' | 'bodies' | 'joints' | 'sites' | 'geoms' | 'keyframes';
+type RobotResourceObject<TRobot extends string, TKey extends RegisterResourceKey> = string extends RobotResource<TRobot, TKey> ? Record<string, string> : {
+    readonly [K in RobotResource<TRobot, TKey>]: K;
+};
+type RobotResourceCategory<TKey extends RegisterResourceKey> = string extends Robots ? Record<string, Record<string, string>> : {
+    readonly [TRobot in Robots]: RobotResourceObject<TRobot, TKey>;
+};
+type RobotResourceRegistry = string extends Robots ? Record<string, Record<RegisterResourceKey, Record<string, string>>> : {
+    readonly [TRobot in Robots]: {
+        readonly [TKey in RegisterResourceKey]: RobotResourceObject<TRobot, TKey>;
+    };
+};
+type RuntimeRobotResourceRegistration = Readonly<Record<string, Readonly<Record<RegisterResourceKey, Readonly<Record<string, string>>>>>>;
+declare function registerRobotResources(resources: RuntimeRobotResourceRegistration): void;
+declare const RobotResources: RobotResourceRegistry;
+type RobotActuators<TRobot extends string> = RobotResource<TRobot, 'actuators'>;
+declare const RobotActuators: RobotResourceCategory<'actuators'>;
+type RobotSensors<TRobot extends string> = RobotResource<TRobot, 'sensors'>;
+declare const RobotSensors: RobotResourceCategory<'sensors'>;
+type RobotBodies<TRobot extends string> = RobotResource<TRobot, 'bodies'>;
+declare const RobotBodies: RobotResourceCategory<'bodies'>;
+type RobotJoints<TRobot extends string> = RobotResource<TRobot, 'joints'>;
+declare const RobotJoints: RobotResourceCategory<'joints'>;
+type RobotSites<TRobot extends string> = RobotResource<TRobot, 'sites'>;
+declare const RobotSites: RobotResourceCategory<'sites'>;
+type RobotGeoms<TRobot extends string> = RobotResource<TRobot, 'geoms'>;
+declare const RobotGeoms: RobotResourceCategory<'geoms'>;
+type RobotKeyframes<TRobot extends string> = RobotResource<TRobot, 'keyframes'>;
+declare const RobotKeyframes: RobotResourceCategory<'keyframes'>;
+type Actuators = Register extends {
+    actuators: infer T extends string;
+} ? T : string;
+type Sensors = Register extends {
+    sensors: infer T extends string;
+} ? T : string;
+type Bodies = Register extends {
+    bodies: infer T extends string;
+} ? T : string;
+type Joints = Register extends {
+    joints: infer T extends string;
+} ? T : string;
+type Sites = Register extends {
+    sites: infer T extends string;
+} ? T : string;
+type Geoms = Register extends {
+    geoms: infer T extends string;
+} ? T : string;
+type Keyframes = Register extends {
+    keyframes: infer T extends string;
+} ? T : string;
+/**
+ * A single MuJoCo contact from the WASM module.
+ * Accessed via `data.contact.get(i)`.
+ */
+interface MujocoContact {
+    geom1: number;
+    geom2: number;
+    pos: Float64Array;
+    frame: Float64Array;
+    dist: number;
+}
+/**
+ * WASM contact array — supports indexed access via `.get(i)`.
+ */
+interface MujocoContactArray {
+    get(i: number): MujocoContact | undefined;
+    delete?: () => void;
+}
+/**
+ * Read a single contact from an already-acquired WASM contact array.
+ * Returns undefined if the access fails (WASM heap issue, bad index, etc.).
+ */
+declare function getContact(contacts: MujocoContactArray, i: number): MujocoContact | undefined;
+/**
+ * Minimal interface for MuJoCo Model to avoid 'any'.
+ */
+interface MujocoModel {
+    nbody: number;
+    ngeom: number;
+    nsite: number;
+    nu: number;
+    njnt: number;
+    nq: number;
+    nv: number;
+    nkey: number;
+    nsensor: number;
+    nsensordata: number;
+    nlight: number;
+    ntendon: number;
+    nflex: number;
+    nmesh: number;
+    nmat: number;
+    names: Int8Array;
+    name_bodyadr: Int32Array;
+    name_jntadr: Int32Array;
+    name_geomadr: Int32Array;
+    name_siteadr: Int32Array;
+    name_actuatoradr: Int32Array;
+    name_keyadr: Int32Array;
+    name_sensoradr: Int32Array;
+    name_tendonadr: Int32Array;
+    body_mass: Float64Array;
+    body_parentid: Int32Array;
+    body_jntnum: Int32Array;
+    body_jntadr: Int32Array;
+    body_pos: Float64Array;
+    body_quat: Float64Array;
+    body_geomnum: Int32Array;
+    body_geomadr: Int32Array;
+    body_inertia: Float64Array;
+    qpos0: Float64Array;
+    jnt_qposadr: Int32Array;
+    jnt_dofadr: Int32Array;
+    jnt_type: Int32Array;
+    jnt_range: Float64Array;
+    jnt_bodyid: Int32Array;
+    jnt_pos: Float64Array;
+    jnt_axis: Float64Array;
+    jnt_limited: Uint8Array;
+    geom_group: Int32Array;
+    geom_type: Int32Array;
+    geom_size: Float64Array;
+    geom_pos: Float64Array;
+    geom_quat: Float64Array;
+    geom_matid: Int32Array;
+    geom_rgba: Float32Array;
+    geom_dataid: Int32Array;
+    geom_bodyid: Int32Array;
+    geom_contype: Int32Array;
+    geom_conaffinity: Int32Array;
+    geom_friction: Float64Array;
+    mat_rgba: Float32Array;
+    mesh_vertadr: Int32Array;
+    mesh_vertnum: Int32Array;
+    mesh_faceadr: Int32Array;
+    mesh_facenum: Int32Array;
+    mesh_vert: Float32Array;
+    mesh_face: Int32Array;
+    mesh_normal: Float32Array;
+    site_bodyid: Int32Array;
+    actuator_trnid: Int32Array;
+    actuator_ctrlrange: Float64Array;
+    actuator_trntype: Int32Array;
+    actuator_gainprm: Float64Array;
+    actuator_biasprm: Float64Array;
+    sensor_type: Int32Array;
+    sensor_dim: Int32Array;
+    sensor_adr: Int32Array;
+    sensor_objtype: Int32Array;
+    sensor_objid: Int32Array;
+    key_qpos: Float64Array;
+    key_ctrl: Float64Array;
+    key_time: Float64Array;
+    key_qvel: Float64Array;
+    light_pos: Float64Array;
+    light_dir: Float64Array;
+    light_diffuse: Float32Array;
+    light_specular: Float32Array;
+    light_type: Int32Array;
+    light_active: Uint8Array;
+    light_castshadow: Uint8Array;
+    light_attenuation: Float32Array;
+    light_cutoff: Float32Array;
+    light_exponent: Float32Array;
+    light_intensity: Float32Array;
+    ten_wrapadr: Int32Array;
+    ten_wrapnum: Int32Array;
+    ten_range: Float64Array;
+    ten_rgba: Float32Array;
+    ten_width: Float64Array;
+    flex_vertadr: Int32Array;
+    flex_vertnum: Int32Array;
+    flex_faceadr: Int32Array;
+    flex_facenum: Int32Array;
+    flex_face: Int32Array;
+    flex_rgba: Float32Array;
+    opt: {
+        timestep: number;
+        gravity: Float64Array;
+        integrator: number;
+        [key: string]: unknown;
+    };
+    delete: () => void;
+    [key: string]: unknown;
+}
+/**
+ * Minimal interface for MuJoCo Data to avoid 'any'.
+ */
+interface MujocoData {
+    time: number;
+    qpos: Float64Array;
+    qvel: Float64Array;
+    ctrl: Float64Array;
+    act: Float64Array;
+    xpos: Float64Array;
+    xquat: Float64Array;
+    xfrc_applied: Float64Array;
+    qfrc_applied: Float64Array;
+    qfrc_bias: Float64Array;
+    site_xpos: Float64Array;
+    site_xmat: Float64Array;
+    sensordata: Float64Array;
+    ncon: number;
+    contact: MujocoContactArray;
+    cvel: Float64Array;
+    cfrc_ext: Float64Array;
+    ten_length: Float64Array;
+    wrap_xpos: Float64Array;
+    ten_wrapadr: Int32Array;
+    flexvert_xpos: Float64Array;
+    geom_xpos: Float64Array;
+    geom_xmat: Float64Array;
+    delete: () => void;
+    [key: string]: unknown;
+}
+/**
+ * Minimal interface for the MuJoCo WASM Module.
+ */
+interface MujocoModule {
+    MjModel: {
+        from_xml_path?: (path: string) => MujocoModel;
+        from_xml_string?: (xml: string, vfs?: unknown) => MujocoModel;
+        loadFromXML?: (path: string) => MujocoModel;
+        [key: string]: unknown;
+    };
+    MjData: new (model: MujocoModel) => MujocoData;
+    MjvOption: new () => {
+        delete: () => void;
+        [key: string]: unknown;
+    };
+    mj_forward: (m: MujocoModel, d: MujocoData) => void;
+    mj_step: (m: MujocoModel, d: MujocoData) => void;
+    mj_resetData: (m: MujocoModel, d: MujocoData) => void;
+    mj_step1: (m: MujocoModel, d: MujocoData) => void;
+    mj_step2: (m: MujocoModel, d: MujocoData) => void;
+    mj_applyFT: (model: MujocoModel, data: MujocoData, force: Float64Array, torque: Float64Array, point: Float64Array, bodyId: number, qfrc_target: Float64Array) => void;
+    mj_ray: (model: MujocoModel, data: MujocoData, pnt: Float64Array, vec: Float64Array, geomgroup: Uint8Array | null, flg_static: number, bodyexclude: number, geomid: Int32Array) => number;
+    mj_name2id: (model: MujocoModel, type: number, name: string) => number;
+    mjtObj: Record<string, number>;
+    mjtGeom: Record<string, number | {
+        value: number;
+    }>;
+    mjtJoint: Record<string, number | {
+        value: number;
+    }>;
+    mjtSensor: Record<string, number | {
+        value: number;
+    }>;
+    FS: {
+        writeFile: (path: string, content: string | Uint8Array) => void;
+        readFile: (path: string, opts?: {
+            encoding: string;
+        }) => string | Uint8Array;
+        mkdir: (path: string) => void;
+        unmount: (path: string) => void;
+    };
+    [key: string]: unknown;
+}
+interface SceneObject {
+    name: string;
+    type: 'box' | 'sphere' | 'cylinder';
+    size: [number, number, number];
+    position: [number, number, number];
+    rgba: [number, number, number, number];
+    mass?: number;
+    freejoint?: boolean;
+    friction?: string;
+    solref?: string;
+    solimp?: string;
+    condim?: number;
+}
+interface XmlPatch {
+    target: string;
+    inject?: string;
+    injectAfter?: string;
+    replace?: [string, string];
+}
+type LocalMujocoFile = File;
+interface LoadFromFilesOptions {
+    /** Entry MJCF/URDF file. Inferred from scene.xml, model.xml, robot.xml, or the first XML/URDF file when omitted. */
+    sceneFile?: string;
+    homeJoints?: number[];
+    xmlPatches?: XmlPatch[];
+    sceneObjects?: SceneObject[];
+    onReset?: (model: MujocoModel, data: MujocoData) => void;
+}
+interface SceneConfig {
+    /** Base URL for fetching model files. The loader fetches `src + sceneFile` and follows dependencies. */
+    src: string;
+    /** Entry MJCF XML or URDF file name, e.g. 'scene.xml' or 'robot.urdf'. */
+    sceneFile: string;
+    /** Browser-selected files for local MJCF/URDF loading. Preserves webkitRelativePath when available. */
+    files?: readonly LocalMujocoFile[];
+    sceneObjects?: SceneObject[];
+    homeJoints?: number[];
+    xmlPatches?: XmlPatch[];
+    onReset?: (model: MujocoModel, data: MujocoData) => void;
+}
+type ResourceSelector<TInfo, TName extends string = string> = TName | readonly TName[] | RegExp | ((info: TInfo) => boolean);
+interface IkConfig {
+    /** MuJoCo site name for IK target. */
+    siteName: Sites;
+    /**
+     * Explicit joints for IK. When omitted, the controller infers scalar hinge/slide
+     * joints by walking from the site body to the model root.
+     */
+    joints?: ResourceSelector<JointInfo, Joints>;
+    /** Explicit actuators for IK control output. */
+    actuators?: ResourceSelector<ActuatorInfo, Actuators>;
+    /**
+     * Number of joints to solve for, assuming legacy contiguous qpos/ctrl layout
+     * starting at index 0. Prefer inferred IK or `joints`/`actuators`.
+     */
+    numJoints?: number;
+    /** Custom IK solver. When omitted, uses built-in Damped Least-Squares solver. */
+    ikSolveFn?: IKSolveFn;
+    /** DLS damping. Default: 0.01. */
+    damping?: number;
+    /** Max solver iterations. Default: 50. */
+    maxIterations?: number;
+}
+interface IkContextValue {
+    ikEnabledRef: React__default.RefObject<boolean>;
+    ikCalculatingRef: React__default.RefObject<boolean>;
+    ikTargetRef: React__default.RefObject<THREE.Group>;
+    siteIdRef: React__default.RefObject<number>;
+    setIkEnabled: (enabled: boolean) => void;
+    moveTarget: (pos: THREE.Vector3, duration?: number) => void;
+    syncTargetToSite: () => void;
+    solveIK: (pos: THREE.Vector3, quat: THREE.Quaternion, currentQ: number[]) => number[] | null;
+    getGizmoStats: () => {
+        pos: THREE.Vector3;
+        rot: THREE.Euler;
+    } | null;
+}
+interface SceneMarker {
+    id: number;
+    position: THREE.Vector3;
+    label: string;
+}
+interface PhysicsConfig {
+    gravity?: [number, number, number];
+    timestep?: number;
+    substeps?: number;
+    paused?: boolean;
+    speed?: number;
+}
+type IKSolveFn = (pos: THREE.Vector3, quat: THREE.Quaternion, currentQ: number[], context?: IKSolveContext) => number[] | null;
+interface IKSolveContext {
+    model: MujocoModel;
+    data: MujocoData;
+    siteId: number;
+    controlGroup: ControlGroupInfo;
+}
+type PhysicsStepCallback = (model: MujocoModel, data: MujocoData) => void;
+interface StateSnapshot {
+    time: number;
+    qpos: Float64Array;
+    qvel: Float64Array;
+    ctrl: Float64Array;
+    act: Float64Array;
+    qfrc_applied: Float64Array;
+}
+interface BodyInfo {
+    id: number;
+    name: string;
+    mass: number;
+    parentId: number;
+}
+interface JointInfo {
+    id: number;
+    name: string;
+    type: number;
+    typeName: string;
+    range: [number, number];
+    limited: boolean;
+    bodyId: number;
+    qposAdr: number;
+    dofAdr: number;
+}
+interface GeomInfo {
+    id: number;
+    name: string;
+    type: number;
+    typeName: string;
+    size: [number, number, number];
+    bodyId: number;
+}
+interface SiteInfo {
+    id: number;
+    name: string;
+    bodyId: number;
+}
+interface ActuatorInfo {
+    id: number;
+    name: string;
+    range: [number, number];
+}
+interface ActuatedJointInfo extends JointInfo {
+    actuatorId: number;
+    actuatorName: string;
+    ctrlAdr: number;
+    ctrlRange: [number, number];
+}
+interface ControlJointInfo extends JointInfo {
+    actuatorId: number | null;
+    actuatorName: string | null;
+    ctrlAdr: number | null;
+    ctrlRange: [number, number] | null;
+}
+interface ControlGroupSelector {
+    /** Infer a kinematic chain from a MuJoCo site. */
+    siteName?: Sites;
+    /** Infer a kinematic chain from a body. */
+    bodyName?: Bodies;
+    /** Select joints by name, names, regex, or predicate. */
+    joints?: ResourceSelector<JointInfo, Joints>;
+    /** Select actuators by name, names, regex, or predicate. */
+    actuators?: ResourceSelector<ActuatorInfo, Actuators>;
+}
+interface ControlGroupInfo {
+    /** Joints in solve/control order. */
+    joints: ControlJointInfo[];
+    /** Actuators in control output order. */
+    actuators: ActuatorInfo[];
+    /** qpos addresses for scalar hinge/slide joints. */
+    qposAdr: number[];
+    /** dof addresses for scalar hinge/slide joints. */
+    dofAdr: number[];
+    /** ctrl addresses matching writable actuators. */
+    ctrlAdr: number[];
+    readQpos(data: MujocoData): Float64Array;
+    readCtrl(data: MujocoData): Float64Array;
+    writeQpos(data: MujocoData, values: ArrayLike<number>): void;
+    writeCtrl(data: MujocoData, values: ArrayLike<number>): void;
+}
+interface SensorInfo {
+    id: number;
+    name: string;
+    type: number;
+    typeName: string;
+    dim: number;
+    adr: number;
+}
+interface ContactInfo {
+    geom1: number;
+    geom1Name: string;
+    geom2: number;
+    geom2Name: string;
+    pos: [number, number, number];
+    depth: number;
+}
+interface RayHit {
+    point: THREE.Vector3;
+    bodyId: number;
+    geomId: number;
+    distance: number;
+}
+interface ModelOptions {
+    timestep: number;
+    gravity: [number, number, number];
+    integrator: number;
+}
+interface TrajectoryFrame {
+    time: number;
+    qpos: Float64Array;
+    qvel?: Float64Array;
+    ctrl?: Float64Array;
+    sensordata?: Float64Array;
+}
+interface TrajectoryData {
+    frames: TrajectoryFrame[];
+    fps: number;
+}
+type PlaybackState = 'idle' | 'playing' | 'paused' | 'completed';
+interface KeyBinding {
+    actuator: Actuators;
+    delta?: number;
+    toggle?: [number, number];
+    set?: number;
+}
+interface KeyboardTeleopConfig {
+    bindings: Record<string, KeyBinding>;
+    enabled?: boolean;
+}
+interface PolicyConfig {
+    frequency: number;
+    onObservation: (model: MujocoModel, data: MujocoData) => Float32Array | Float64Array | number[];
+    onAction: (action: Float32Array | Float64Array | number[], model: MujocoModel, data: MujocoData) => void;
+}
+type ObservationOutput = 'float32' | 'float64';
+interface ObservationConfig {
+    /** Include scalar simulation time. */
+    time?: boolean;
+    /** Include all qpos values. */
+    qpos?: boolean;
+    /** Include all qvel values. */
+    qvel?: boolean;
+    /** Include all ctrl values. */
+    ctrl?: boolean;
+    /** Include all actuator activation values. */
+    act?: boolean;
+    /** Include all raw sensordata values. */
+    sensordata?: boolean;
+    /** Include named sensor values in the configured order. */
+    sensors?: readonly Sensors[];
+    /** Include named site world positions in the configured order. */
+    sites?: readonly Sites[];
+    /** Include world gravity projected into each named body's local frame. */
+    projectedGravity?: Bodies | readonly Bodies[];
+    /** Output array type. Defaults to Float32Array. */
+    output?: ObservationOutput;
+}
+interface ObservationLayoutItem {
+    name: string;
+    start: number;
+    size: number;
+}
+interface ObservationResult {
+    values: Float32Array | Float64Array;
+    layout: ObservationLayoutItem[];
+}
+interface ObservationHandle {
+    /** Read a fresh observation from the current live MuJoCo model/data refs. */
+    read(): ObservationResult;
+    /** Read just the vector values for policy inference. */
+    readValues(): Float32Array | Float64Array;
+}
+interface DebugProps {
+    showGeoms?: boolean;
+    showSites?: boolean;
+    showJoints?: boolean;
+    showContacts?: boolean;
+    showCOM?: boolean;
+    showInertia?: boolean;
+    showTendons?: boolean;
+}
+interface IkGizmoProps {
+    controller: IkContextValue;
+    siteName?: string;
+    scale?: number;
+    onDrag?: (position: THREE.Vector3, quaternion: THREE.Quaternion) => void;
+}
+interface DragInteractionProps {
+    stiffness?: number;
+    showArrow?: boolean;
+}
+interface SceneLightsProps {
+    /** Override intensity for all MJCF lights. Default: 1.0. */
+    intensity?: number;
+}
+type ScenarioLightingPreset = 'studio' | 'warehouse' | 'low-light' | 'splat';
+type SplatFormat = 'spz' | 'ply' | 'splat';
+type SplatRendererKind = 'spark' | 'custom';
+type SplatCollisionPrimitive = 'plane' | 'box' | 'sphere' | 'capsule' | 'mesh';
+interface ScenarioCameraConfig {
+    jitter?: number;
+    exposure?: number;
+    noise?: number;
+    blur?: number;
+}
+interface SplatAssetConfig {
+    src: string;
+    /** Common browser-friendly splat format. Renderer-specific loaders may accept more. */
+    format?: SplatFormat;
+    /** Optional renderer hint. The library does not import renderer-specific code. */
+    renderer?: SplatRendererKind;
+}
+interface SplatScenarioConfig {
+    enabled: boolean;
+    /** Common browser-friendly splat format. Renderer-specific loaders may accept more. */
+    format?: SplatFormat;
+    src?: string;
+    requiresCollisionProxy?: boolean;
+    collisionProxy?: SplatCollisionProxyConfig;
+}
+interface SplatCollisionProxyConfig {
+    /** MJCF/XML file or artifact path that provides physics collision for the visual splat. */
+    xmlPath?: string;
+    /** Human-readable status for authoring and validation flows. */
+    status?: 'missing' | 'planned' | 'generated' | 'validated';
+    /** Primitive proxy shapes expected in the MJCF collision proxy. */
+    primitives?: SplatCollisionPrimitive[];
+    /** Optional notes that should travel with scene variants and rollout metadata. */
+    notes?: string[];
+}
+interface PairedSplatEnvironmentConfig {
+    id: string;
+    label: string;
+    description?: string;
+    /** Visual-only Gaussian splat asset. */
+    splat: SplatAssetConfig;
+    /** MJCF/XML contact geometry paired with the visual splat. */
+    collisionProxy: SplatCollisionProxyConfig & {
+        xmlPath: string;
+    };
+}
+interface SplatEnvironmentMetadataInput {
+    environment?: PairedSplatEnvironmentConfig;
+    src?: string;
+    format?: SplatFormat;
+    collisionProxy?: SplatCollisionProxyConfig;
+}
+interface SplatEnvironmentMetadata {
+    src?: string;
+    format: SplatFormat;
+    collisionProxy?: SplatCollisionProxyConfig;
+    userData: Record<string, unknown>;
+}
+interface VisualScenarioConfig {
+    id?: string;
+    label?: string;
+    seed?: number;
+    lighting?: ScenarioLightingPreset;
+    environment?: string;
+    camera?: ScenarioCameraConfig;
+    splat?: SplatScenarioConfig;
+}
+interface ScenarioLightingProps {
+    preset?: ScenarioLightingPreset;
+    intensity?: number;
+    castShadow?: boolean;
+}
+interface SplatEnvironmentProps extends Omit<ThreeElements['group'], 'ref'> {
+    environment?: PairedSplatEnvironmentConfig;
+    src?: string;
+    format?: SplatFormat;
+    collisionProxy?: ReactNode;
+    collisionProxyMetadata?: SplatCollisionProxyConfig;
+    showPlaceholder?: boolean;
+}
+type TrajectoryInput = TrajectoryFrame[] | number[][];
+interface TrajectoryPlayerProps {
+    trajectory: TrajectoryInput;
+    fps?: number;
+    speed?: number;
+    loop?: boolean;
+    playing?: boolean;
+    mode?: 'kinematic' | 'physics';
+    onFrame?: (frameIdx: number) => void;
+    onComplete?: () => void;
+    onStateChange?: (state: PlaybackState) => void;
+}
+interface ContactListenerProps {
+    body: Bodies;
+    onContactEnter?: (info: ContactInfo) => void;
+    onContactExit?: (info: ContactInfo) => void;
+}
+interface BodyProps {
+    name: Bodies;
+    type: 'box' | 'sphere' | 'cylinder';
+    size: [number, number, number];
+    position?: [number, number, number];
+    rgba?: [number, number, number, number];
+    mass?: number;
+    freejoint?: boolean;
+    friction?: string;
+    solref?: string;
+    solimp?: string;
+    condim?: number;
+    children?: ReactNode;
+}
+interface MujocoSimAPI {
+    readonly status: 'loading' | 'ready' | 'error';
+    readonly config: SceneConfig;
+    reset(): void;
+    setSpeed(multiplier: number): void;
+    togglePause(): boolean;
+    setPaused(paused: boolean): void;
+    step(n?: number): void;
+    getTime(): number;
+    getTimestep(): number;
+    applyKeyframe(nameOrIndex: Keyframes | number): void;
+    saveState(): StateSnapshot;
+    restoreState(snapshot: StateSnapshot): void;
+    setQpos(values: Float64Array | number[]): void;
+    setQvel(values: Float64Array | number[]): void;
+    getQpos(): Float64Array;
+    getQvel(): Float64Array;
+    setCtrl(nameOrValues: Actuators | Record<Actuators, number>, value?: number): void;
+    getCtrl(): Float64Array;
+    getControlMap(): ControlGroupInfo;
+    getActuatedJoints(): ActuatedJointInfo[];
+    resolveControlGroup(selector: ControlGroupSelector): ControlGroupInfo | null;
+    applyForce(bodyName: Bodies, force: THREE.Vector3, point?: THREE.Vector3): void;
+    applyTorque(bodyName: Bodies, torque: THREE.Vector3): void;
+    setExternalForce(bodyName: Bodies, force: THREE.Vector3, torque: THREE.Vector3): void;
+    applyGeneralizedForce(values: Float64Array | number[]): void;
+    getSensorData(name: Sensors): Float64Array | null;
+    getContacts(): ContactInfo[];
+    getBodies(): BodyInfo[];
+    getJoints(): JointInfo[];
+    getGeoms(): GeomInfo[];
+    getSites(): SiteInfo[];
+    getActuators(): ActuatorInfo[];
+    getSensors(): SensorInfo[];
+    getModelOption(): ModelOptions;
+    setGravity(g: [number, number, number]): void;
+    setTimestep(dt: number): void;
+    raycast(origin: THREE.Vector3, direction: THREE.Vector3, maxDist?: number): RayHit | null;
+    getKeyframeNames(): string[];
+    getKeyframeCount(): number;
+    loadScene(newConfig: SceneConfig): Promise<void>;
+    loadFromFiles(files: FileList | readonly LocalMujocoFile[], options?: LoadFromFilesOptions): Promise<void>;
+    addBody(body: SceneObject): Promise<void>;
+    removeBody(name: Bodies): Promise<void>;
+    recompile(patches?: XmlPatch[]): Promise<void>;
+    getCanvasSnapshot(width?: number, height?: number, mimeType?: string): string;
+    project2DTo3D(x: number, y: number, cameraPos: THREE.Vector3, lookAt: THREE.Vector3): {
+        point: THREE.Vector3;
+        bodyId: number;
+        geomId: number;
+    } | null;
+    setBodyMass(name: Bodies, mass: number): void;
+    setGeomFriction(name: Geoms, friction: [number, number, number]): void;
+    setGeomSize(name: Geoms, size: [number, number, number]): void;
+    readonly mjModelRef: React__default.RefObject<MujocoModel | null>;
+    readonly mjDataRef: React__default.RefObject<MujocoData | null>;
+}
+type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
+    config: SceneConfig;
+    onReady?: (api: MujocoSimAPI) => void;
+    onError?: (error: Error) => void;
+    onStep?: (time: number) => void;
+    onSelection?: (bodyId: number, name: string) => void;
+    gravity?: [number, number, number];
+    timestep?: number;
+    substeps?: number;
+    paused?: boolean;
+    speed?: number;
+    interpolate?: boolean;
+};
+interface SitePositionResult {
+    position: React__default.RefObject<THREE.Vector3>;
+    quaternion: React__default.RefObject<THREE.Quaternion>;
+}
+interface MujocoContextValue {
+    mujoco: MujocoModule | null;
+    status: 'loading' | 'ready' | 'error';
+    error: string | null;
+}
+/** @deprecated Use `SensorHandle` instead. */
+interface SensorResult {
+    value: React__default.RefObject<Float64Array>;
+    size: number;
+}
+interface CtrlHandle {
+    /** Read the current ctrl value. */
+    read(): number;
+    /** Write a ctrl value (goes directly to data.ctrl). */
+    write(value: number): void;
+    /** Actuator name. */
+    name: Actuators;
+    /** Actuator control range [min, max]. */
+    range: [number, number];
+}
+interface SensorHandle {
+    /** Read the current sensor data. */
+    read(): Float64Array;
+    /** Sensor dimensionality. */
+    dim: number;
+    /** Sensor name. */
+    name: Sensors;
+}
+interface BodyStateResult {
+    position: React__default.RefObject<THREE.Vector3>;
+    quaternion: React__default.RefObject<THREE.Quaternion>;
+    linearVelocity: React__default.RefObject<THREE.Vector3>;
+    angularVelocity: React__default.RefObject<THREE.Vector3>;
+}
+interface JointStateResult {
+    position: React__default.RefObject<number | Float64Array>;
+    velocity: React__default.RefObject<number | Float64Array>;
+}
+
+export { type BodyInfo as $, type ActuatedJointInfo as A, type BodyProps as B, type ControlGroupInfo as C, type DragInteractionProps as D, type SensorHandle as E, type SensorInfo as F, type GeomInfo as G, type JointStateResult as H, type IkConfig as I, type Joints as J, type Bodies as K, type BodyStateResult as L, type MujocoContextValue as M, type Actuators as N, type ObservationConfig as O, type PhysicsStepCallback as P, type CtrlHandle as Q, type ContactInfo as R, type SceneConfig as S, type TrajectoryPlayerProps as T, type KeyboardTeleopConfig as U, type VisualScenarioConfig as V, type PolicyConfig as W, type ObservationHandle as X, type TrajectoryInput as Y, type PlaybackState as Z, type TrajectoryFrame as _, type MujocoCanvasProps as a, type ControlJointInfo as a0, type Geoms as a1, type IKSolveFn as a2, type JointInfo as a3, type KeyBinding as a4, type Keyframes as a5, type ModelOptions as a6, type MujocoContact as a7, type MujocoContactArray as a8, type ObservationLayoutItem as a9, getContact as aA, registerRobotResources as aB, type ObservationOutput as aa, type PhysicsConfig as ab, type RayHit as ac, type Register as ad, type RegisteredRobotMap as ae, type ResourceSelector as af, RobotActuators as ag, RobotBodies as ah, RobotGeoms as ai, RobotJoints as aj, RobotKeyframes as ak, type RobotResource as al, RobotResources as am, RobotSensors as an, RobotSites as ao, type Robots as ap, type ScenarioCameraConfig as aq, type SceneMarker as ar, type SceneObject as as, type SensorResult as at, type SiteInfo as au, type SplatAssetConfig as av, type SplatScenarioConfig as aw, type StateSnapshot as ax, type TrajectoryData as ay, type XmlPatch as az, type MujocoSimAPI as b, type MujocoModule as c, type MujocoModel as d, type MujocoData as e, type ControlGroupSelector as f, type ObservationResult as g, type IkContextValue as h, type IkGizmoProps as i, type SceneLightsProps as j, type ScenarioLightingProps as k, type SplatEnvironmentProps as l, type PairedSplatEnvironmentConfig as m, type SplatFormat as n, type SplatCollisionProxyConfig as o, type SplatRendererKind as p, type SplatCollisionPrimitive as q, type ScenarioLightingPreset as r, type SplatEnvironmentMetadataInput as s, type SplatEnvironmentMetadata as t, type DebugProps as u, type ContactListenerProps as v, type ActuatorInfo as w, type Sites as x, type SitePositionResult as y, type Sensors as z };