@absolutejs/rapier3d 0.0.0-stage → 0.2.0

package/dist/types/dynamics/impulse_joint.d.ts

@@ -0,0 +1,359 @@
+import { Rotation, Vector } from "../math";
+import { RawGenericJoint, RawImpulseJointSet, RawJointAxis } from "../raw";
+import { RigidBody } from "./rigid_body";
+import { RigidBodySet } from "./rigid_body_set";
+/**
+ * The integer identifier of a collider added to a `ColliderSet`.
+ */
+export type ImpulseJointHandle = number;
+/**
+ * An enum grouping all possible types of joints:
+ *
+ * - `Revolute`: A revolute joint that removes all degrees of freedom between the affected
+ *               bodies except for the rotation along one axis.
+ * - `Fixed`: A fixed joint that removes all relative degrees of freedom between the affected bodies.
+ * - `Prismatic`: A prismatic joint that removes all degrees of freedom between the affected
+ *                bodies except for the translation along one axis.
+ * - `Spherical`: (3D only) A spherical joint that removes all relative linear degrees of freedom between the affected bodies.
+ * - `Generic`: (3D only) A joint with customizable degrees of freedom, allowing any of the 6 axes to be locked.
+ */
+export declare enum JointType {
+    Revolute = 0,
+    Fixed = 1,
+    Prismatic = 2,
+    Rope = 3,
+    Spring = 4,
+    Spherical = 5,
+    Generic = 6
+}
+export declare enum MotorModel {
+    AccelerationBased = 0,
+    ForceBased = 1
+}
+/**
+ * An enum representing a single joint axis, used to configure per-axis joint
+ * properties like the motors of a spherical joint.
+ */
+export declare enum JointAxis {
+    LinX = 0,
+    LinY = 1,
+    LinZ = 2,
+    AngX = 3,
+    AngY = 4,
+    AngZ = 5
+}
+/**
+ * An enum representing the possible joint axes of a generic joint.
+ * They can be ORed together, like:
+ * JointAxesMask.LinX || JointAxesMask.LinY
+ * to get a joint that is only free in the X and Y translational (positional) axes.
+ *
+ * Possible free axes are:
+ *
+ * - `X`: X translation axis
+ * - `Y`: Y translation axis
+ * - `Z`: Z translation axis
+ * - `AngX`: X angular rotation axis
+ * - `AngY`: Y angular rotations axis
+ * - `AngZ`: Z angular rotation axis
+ */
+export declare enum JointAxesMask {
+    LinX = 1,
+    LinY = 2,
+    LinZ = 4,
+    AngX = 8,
+    AngY = 16,
+    AngZ = 32
+}
+export declare class ImpulseJoint {
+    protected rawSet: RawImpulseJointSet;
+    protected bodySet: RigidBodySet;
+    handle: ImpulseJointHandle;
+    constructor(rawSet: RawImpulseJointSet, bodySet: RigidBodySet, handle: ImpulseJointHandle);
+    static newTyped(rawSet: RawImpulseJointSet, bodySet: RigidBodySet, handle: ImpulseJointHandle): ImpulseJoint;
+    /** @internal */
+    finalizeDeserialization(bodySet: RigidBodySet): void;
+    /**
+     * Checks if this joint is still valid (i.e. that it has
+     * not been deleted from the joint set yet).
+     */
+    isValid(): boolean;
+    /**
+     * The first rigid-body this joint it attached to.
+     */
+    body1(): RigidBody;
+    /**
+     * The second rigid-body this joint is attached to.
+     */
+    body2(): RigidBody;
+    /**
+     * The type of this joint given as a string.
+     */
+    type(): JointType;
+    /**
+     * The rotation quaternion that aligns this joint's first local axis to the `x` axis.
+     *
+     * @param {Rotation?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    frameX1(target?: Rotation): Rotation;
+    /**
+     * The rotation matrix that aligns this joint's second local axis to the `x` axis.
+     *
+     * @param {Rotation?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    frameX2(target?: Rotation): Rotation;
+    /**
+     * The position of the first anchor of this joint.
+     *
+     * The first anchor gives the position of the application point on the
+     * local frame of the first rigid-body it is attached to.
+     *
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    anchor1(target?: Vector): Vector;
+    /**
+     * The position of the second anchor of this joint.
+     *
+     * The second anchor gives the position of the application point on the
+     * local frame of the second rigid-body it is attached to.
+     *
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    anchor2(target?: Vector): Vector;
+    /**
+     * Sets the position of the first anchor of this joint.
+     *
+     * The first anchor gives the position of the application point on the
+     * local frame of the first rigid-body it is attached to.
+     */
+    setAnchor1(newPos: Vector): void;
+    /**
+     * Sets the position of the second anchor of this joint.
+     *
+     * The second anchor gives the position of the application point on the
+     * local frame of the second rigid-body it is attached to.
+     */
+    setAnchor2(newPos: Vector): void;
+    /**
+     * Sets the rotation quaternion that aligns this joint's first local axis to the `x` axis.
+     */
+    setFrameX1(rot: Rotation): void;
+    /**
+     * Sets the rotation quaternion that aligns this joint's second local axis to the `x` axis.
+     */
+    setFrameX2(rot: Rotation): void;
+    /**
+     * Sets the full local frame (anchor position and rotation) for the first rigid-body attachment.
+     */
+    setLocalFrame1(anchor: Vector, rot: Rotation): void;
+    /**
+     * Sets the full local frame (anchor position and rotation) for the second rigid-body attachment.
+     */
+    setLocalFrame2(anchor: Vector, rot: Rotation): void;
+    /**
+     * Controls whether contacts are computed between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    setContactsEnabled(enabled: boolean): void;
+    /**
+     * Indicates if contacts are enabled between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    contactsEnabled(): boolean;
+}
+export declare class UnitImpulseJoint extends ImpulseJoint {
+    /**
+     * The axis left free by this joint.
+     */
+    protected rawAxis?(): RawJointAxis;
+    /**
+     * Are the limits enabled for this joint?
+     */
+    limitsEnabled(): boolean;
+    /**
+     * The min limit of this joint.
+     */
+    limitsMin(): number;
+    /**
+     * The max limit of this joint.
+     */
+    limitsMax(): number;
+    /**
+     * Sets the limits of this joint.
+     *
+     * @param min - The minimum bound of this joint’s free coordinate.
+     * @param max - The maximum bound of this joint’s free coordinate.
+     */
+    setLimits(min: number, max: number): void;
+    configureMotorModel(model: MotorModel): void;
+    setMotorMaxForce(maxForce: number): void;
+    configureMotorVelocity(targetVel: number, factor: number): void;
+    configureMotorPosition(targetPos: number, stiffness: number, damping: number): void;
+    configureMotor(targetPos: number, targetVel: number, stiffness: number, damping: number): void;
+}
+export declare class FixedImpulseJoint extends ImpulseJoint {
+}
+export declare class RopeImpulseJoint extends ImpulseJoint {
+}
+export declare class SpringImpulseJoint extends ImpulseJoint {
+}
+export declare class PrismaticImpulseJoint extends UnitImpulseJoint {
+    rawAxis(): RawJointAxis;
+}
+export declare class RevoluteImpulseJoint extends UnitImpulseJoint {
+    rawAxis(): RawJointAxis;
+}
+export declare class GenericImpulseJoint extends ImpulseJoint {
+}
+export declare class SphericalImpulseJoint extends ImpulseJoint {
+    /**
+     * Sets the motor model of one of this joint's angular axes.
+     *
+     * @param axis - The angular axis (`JointAxis.AngX/AngY/AngZ`) to configure.
+     * @param model - The motor model to apply to that axis.
+     */
+    configureMotorModel(axis: JointAxis, model: MotorModel): void;
+    /**
+     * Sets the maximum force/torque the motor of the given angular axis can deliver.
+     *
+     * @param axis - The angular axis (`JointAxis.AngX/AngY/AngZ`) to configure.
+     * @param maxForce - The maximum torque the axis motor can deliver.
+     */
+    setMotorMaxForce(axis: JointAxis, maxForce: number): void;
+    /**
+     * Makes the motor of the given angular axis target a specific angular velocity.
+     *
+     * @param axis - The angular axis (`JointAxis.AngX/AngY/AngZ`) to configure.
+     * @param targetVel - The target angular velocity along the axis, in radians per second.
+     * @param factor - The strength used to reach the target velocity (a damping coefficient).
+     */
+    configureMotorVelocity(axis: JointAxis, targetVel: number, factor: number): void;
+    /**
+     * Makes the motor of the given angular axis target a specific angle.
+     *
+     * @param axis - The angular axis (`JointAxis.AngX/AngY/AngZ`) to configure.
+     * @param targetPos - The target angle along the axis, in radians.
+     * @param stiffness - The spring-like stiffness used to reach the target angle.
+     * @param damping - The damping applied to the axis' angular velocity.
+     */
+    configureMotorPosition(axis: JointAxis, targetPos: number, stiffness: number, damping: number): void;
+    /**
+     * Configures the motor of the given angular axis with both an angle and an
+     * angular-velocity target.
+     *
+     * @param axis - The angular axis (`JointAxis.AngX/AngY/AngZ`) to configure.
+     * @param targetPos - The target angle along the axis, in radians.
+     * @param targetVel - The target angular velocity along the axis, in radians per second.
+     * @param stiffness - The spring-like stiffness used to reach the target angle.
+     * @param damping - The damping applied to the axis' angular velocity.
+     */
+    configureMotor(axis: JointAxis, targetPos: number, targetVel: number, stiffness: number, damping: number): void;
+}
+export declare class JointData {
+    anchor1: Vector;
+    anchor2: Vector;
+    axis: Vector;
+    axis1: Vector;
+    axis2: Vector;
+    frame1: Rotation;
+    frame2: Rotation;
+    jointType: JointType;
+    limitsEnabled: boolean;
+    limits: Array<number>;
+    axesMask: JointAxesMask;
+    stiffness: number;
+    damping: number;
+    length: number;
+    private constructor();
+    /**
+     * Creates a new joint descriptor that builds a Fixed joint.
+     *
+     * A fixed joint removes all the degrees of freedom between the affected bodies, ensuring their
+     * anchor and local frames coincide in world-space.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param frame1 - The reference orientation of the joint wrt. the first rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param frame2 - The reference orientation of the joint wrt. the second rigid-body.
+     */
+    static fixed(anchor1: Vector, frame1: Rotation, anchor2: Vector, frame2: Rotation): JointData;
+    static spring(rest_length: number, stiffness: number, damping: number, anchor1: Vector, anchor2: Vector): JointData;
+    static rope(length: number, anchor1: Vector, anchor2: Vector): JointData;
+    /**
+     * Create a new joint descriptor that builds generic joints.
+     *
+     * A generic joint allows customizing its degrees of freedom
+     * by supplying a mask of the joint axes that should remain locked.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - The X axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     * @param axesMask - Mask representing the locked axes of the joint. You can use logical OR to select these from
+     *                   the JointAxesMask enum. For example, passing (JointAxesMask.AngX || JointAxesMask.AngY) will
+     *                   create a joint locked in the X and Y rotational axes.
+     */
+    static generic(anchor1: Vector, anchor2: Vector, axis: Vector, axesMask: JointAxesMask): JointData;
+    /**
+     * Create a new joint descriptor that builds spherical joints.
+     *
+     * A spherical joint allows three relative rotational degrees of freedom
+     * by preventing any relative translation between the anchors of the
+     * two attached rigid-bodies.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     */
+    static spherical(anchor1: Vector, anchor2: Vector): JointData;
+    /**
+     * Creates a new joint descriptor that builds a Prismatic joint.
+     *
+     * A prismatic joint removes all the degrees of freedom between the
+     * affected bodies, except for the translation along one axis.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     */
+    static prismatic(anchor1: Vector, anchor2: Vector, axis: Vector): JointData;
+    /**
+     * Create a new joint descriptor that builds Revolute joints.
+     *
+     * A revolute joint removes all degrees of freedom between the affected
+     * bodies except for the rotation along one axis.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     */
+    static revolute(anchor1: Vector, anchor2: Vector, axis: Vector): JointData;
+    /**
+     * Create a new joint descriptor that builds Revolute joints with independent
+     * local axes for each attached rigid-body.
+     *
+     * This is useful when the same world-space hinge axis is represented by
+     * different local axes on the two bodies.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis1 - Axis of the joint, expressed in the local-space of the first rigid-body.
+     * @param axis2 - Axis of the joint, expressed in the local-space of the second rigid-body.
+     */
+    static revoluteWithAxes(anchor1: Vector, anchor2: Vector, axis1: Vector, axis2: Vector): JointData;
+    intoRaw(): RawGenericJoint;
+}

package/dist/types/dynamics/impulse_joint_set.d.ts

@@ -0,0 +1,84 @@
+import { RawImpulseJointSet } from "../raw";
+import { RigidBodySet } from "./rigid_body_set";
+import { ImpulseJoint, ImpulseJointHandle, JointData } from "./impulse_joint";
+import { RigidBodyHandle } from "./rigid_body";
+/**
+ * A set of joints.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `jointSet.free()`
+ * once you are done using it (and all the joints it created).
+ */
+export declare class ImpulseJointSet {
+    raw: RawImpulseJointSet;
+    private map;
+    /**
+     * Release the WASM memory occupied by this joint set.
+     */
+    free(): void;
+    constructor(raw?: RawImpulseJointSet);
+    /** @internal */
+    finalizeDeserialization(bodies: RigidBodySet): void;
+    /**
+     * Creates a new joint and return its integer handle.
+     *
+     * @param bodies - The set of rigid-bodies containing the bodies the joint is attached to.
+     * @param desc - The joint's parameters.
+     * @param parent1 - The handle of the first rigid-body this joint is attached to.
+     * @param parent2 - The handle of the second rigid-body this joint is attached to.
+     * @param wakeUp - Should the attached rigid-bodies be awakened?
+     */
+    createJoint(bodies: RigidBodySet, desc: JointData, parent1: RigidBodyHandle, parent2: RigidBodyHandle, wakeUp: boolean): ImpulseJoint;
+    /**
+     * Remove a joint from this set.
+     *
+     * @param handle - The integer handle of the joint.
+     * @param wakeUp - If `true`, the rigid-bodies attached by the removed joint will be woken-up automatically.
+     */
+    remove(handle: ImpulseJointHandle, wakeUp: boolean): void;
+    /**
+     * Calls the given closure with the integer handle of each impulse joint attached to this rigid-body.
+     *
+     * @param f - The closure called with the integer handle of each impulse joint attached to the rigid-body.
+     */
+    forEachJointHandleAttachedToRigidBody(handle: RigidBodyHandle, f: (handle: ImpulseJointHandle) => void): void;
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    unmap(handle: ImpulseJointHandle): void;
+    /**
+     * Drops the wrappers of the joints the engine removed on its own (the joints of removed
+     * soft bodies and clusters).
+     */
+    unmapRemovedJoints(): void;
+    /**
+     * The number of joints on this set.
+     */
+    len(): number;
+    /**
+     * Does this set contain a joint with the given handle?
+     *
+     * @param handle - The joint handle to check.
+     */
+    contains(handle: ImpulseJointHandle): boolean;
+    /**
+     * Gets the joint with the given handle.
+     *
+     * Returns `null` if no joint with the specified handle exists.
+     *
+     * @param handle - The integer handle of the joint to retrieve.
+     */
+    get(handle: ImpulseJointHandle): ImpulseJoint | null;
+    /**
+     * Applies the given closure to each joint contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    forEach(f: (joint: ImpulseJoint) => void): void;
+    /**
+     * Gets all joints in the list.
+     *
+     * @returns joint list.
+     */
+    getAll(): ImpulseJoint[];
+}

package/dist/types/dynamics/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./rigid_body";
+export * from "./rigid_body_set";
+export * from "./integration_parameters";
+export * from "./impulse_joint";
+export * from "./impulse_joint_set";
+export * from "./multibody_joint";
+export * from "./multibody_joint_set";
+export * from "./coefficient_combine_rule";
+export * from "./ccd_solver";
+export * from "./island_manager";
+export * from "./soft_body";
+export * from "./soft_body_set";

package/dist/types/dynamics/integration_parameters.d.ts

@@ -0,0 +1,109 @@
+import { RawIntegrationParameters } from "../raw";
+import { SoftRecoverySettings } from "./soft_body";
+export declare class IntegrationParameters {
+    raw: RawIntegrationParameters;
+    constructor(raw?: RawIntegrationParameters);
+    /**
+     * Free the WASM memory used by these integration parameters.
+     */
+    free(): void;
+    /** Merge compatible contact manifolds into solver clusters. Upstream default: true. */
+    get contactClustering(): boolean;
+    /** Change between simulation steps; false may increase solver workload. */
+    set contactClustering(value: boolean);
+    /** Minimum CCD substep duration in seconds; upstream default is 1/60/100. */
+    get minCcdDt(): number;
+    /** Change between steps. Very small values may introduce numerical instability. */
+    set minCcdDt(value: number);
+    /**
+     * The timestep length (default: `1.0 / 60.0`)
+     */
+    get dt(): number;
+    /**
+     * The Error Reduction Parameter in `[0, 1]` is the proportion of
+     * the positional error to be corrected at each time step (default: `0.2`).
+     */
+    get contact_erp(): number;
+    get lengthUnit(): number;
+    /**
+     * Normalized amount of penetration the engine won’t attempt to correct (default: `0.001m`).
+     *
+     * This threshold considered by the physics engine is this value multiplied by the `lengthUnit`.
+     */
+    get normalizedAllowedLinearError(): number;
+    /**
+     * The maximal normalized distance separating two objects that will generate predictive contacts (default: `0.02`).
+     *
+     * This threshold considered by the physics engine is this value multiplied by the `lengthUnit`.
+     */
+    get normalizedPredictionDistance(): number;
+    /**
+     * The number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+     */
+    get numSolverIterations(): number;
+    /**
+     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+     */
+    get numInternalPgsIterations(): number;
+    /**
+     * Maximum number of substeps performed by the  solver (default: `1`).
+     */
+    get maxCcdSubsteps(): number;
+    /**
+     * Strain beyond which a soft-body constraint is re-solved after the contacts inside every
+     * substep, so a light body buried under heavier ones is not torn (default: `0.75`).
+     */
+    get softBodiesResweepStrain(): number;
+    /**
+     * Maximum number of extra substeps a soft body requests for its island while it is hit
+     * fast (default: `4`; `0` disables the impact-adaptive substeps).
+     */
+    get softBodiesMaxExtraSubsteps(): number;
+    /**
+     * Factor applied to the contact softness natural frequencies for the soft-body contacts
+     * (default: `4.0`).
+     */
+    get softBodiesContactStiffening(): number;
+    /**
+     * The tangle detection and recovery settings shared by every soft body of the world.
+     *
+     * This gives back a copy: change it and assign it back to apply it.
+     */
+    get softBodiesRecovery(): SoftRecoverySettings;
+    /**
+     * Relative residual at which the conjugate gradient of the FEM soft-body solver stops
+     * (default: `1.0e-5`).
+     */
+    get softBodiesFemLinearTolerance(): number;
+    /**
+     * Hard cap on the conjugate-gradient iterations of the FEM soft-body solver, whatever the
+     * residual (default: `20`).
+     */
+    get softBodiesFemMaxLinearIterations(): number;
+    /**
+     * Largest number of degrees of freedom for which a FEM soft body is factorized directly
+     * (default: `600`); the larger ones rely on the conjugate gradient.
+     */
+    get softBodiesFemMaxDenseDofs(): number;
+    set dt(value: number);
+    set softBodiesResweepStrain(value: number);
+    set softBodiesMaxExtraSubsteps(value: number);
+    set softBodiesContactStiffening(value: number);
+    set softBodiesRecovery(value: SoftRecoverySettings);
+    set softBodiesFemLinearTolerance(value: number);
+    set softBodiesFemMaxLinearIterations(value: number);
+    set softBodiesFemMaxDenseDofs(value: number);
+    set contact_natural_frequency(value: number);
+    set lengthUnit(value: number);
+    set normalizedAllowedLinearError(value: number);
+    set normalizedPredictionDistance(value: number);
+    /**
+     * Sets the number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+     */
+    set numSolverIterations(value: number);
+    /**
+     * Sets the number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+     */
+    set numInternalPgsIterations(value: number);
+    set maxCcdSubsteps(value: number);
+}

package/dist/types/dynamics/island_manager.d.ts

@@ -0,0 +1,24 @@
+import { RawIslandManager } from "../raw";
+import { RigidBodyHandle } from "./rigid_body";
+/**
+ * The CCD solver responsible for resolving Continuous Collision Detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `ccdSolver.free()`
+ * once you are done using it.
+ */
+export declare class IslandManager {
+    raw: RawIslandManager;
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    free(): void;
+    constructor(raw?: RawIslandManager);
+    /**
+     * Applies the given closure to the handle of each active rigid-bodies contained by this set.
+     *
+     * A rigid-body is active if it is not sleeping, i.e., if it moved recently.
+     *
+     * @param f - The closure to apply.
+     */
+    forEachActiveRigidBodyHandle(f: (handle: RigidBodyHandle) => void): void;
+}

package/dist/types/dynamics/multibody_joint.d.ts

@@ -0,0 +1,42 @@
+import { RawJointAxis, RawMultibodyJointSet } from "../raw";
+/**
+ * The integer identifier of a collider added to a `ColliderSet`.
+ */
+export type MultibodyJointHandle = number;
+export declare class MultibodyJoint {
+    protected rawSet: RawMultibodyJointSet;
+    handle: MultibodyJointHandle;
+    constructor(rawSet: RawMultibodyJointSet, handle: MultibodyJointHandle);
+    static newTyped(rawSet: RawMultibodyJointSet, handle: MultibodyJointHandle): MultibodyJoint;
+    /**
+     * Checks if this joint is still valid (i.e. that it has
+     * not been deleted from the joint set yet).
+     */
+    isValid(): boolean;
+    /**
+     * Controls whether contacts are computed between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    setContactsEnabled(enabled: boolean): void;
+    /**
+     * Indicates if contacts are enabled between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    contactsEnabled(): boolean;
+}
+export declare class UnitMultibodyJoint extends MultibodyJoint {
+    /**
+     * The axis left free by this joint.
+     */
+    protected rawAxis?(): RawJointAxis;
+}
+export declare class FixedMultibodyJoint extends MultibodyJoint {
+}
+export declare class PrismaticMultibodyJoint extends UnitMultibodyJoint {
+    rawAxis(): RawJointAxis;
+}
+export declare class RevoluteMultibodyJoint extends UnitMultibodyJoint {
+    rawAxis(): RawJointAxis;
+}
+export declare class SphericalMultibodyJoint extends MultibodyJoint {
+}