@newkrok/nape-js 1.0.0 → 3.0.0

package/dist/index.d.cts

@@ -0,0 +1,840 @@
+/**
+ * Core engine module — manages access to the compiled nape namespace.
+ *
+ * The nape-compiled.js file is generated by the prebuild script from the
+ * original AMD module.  It evaluates synchronously on import, so the
+ * namespace is available immediately.
+ */
+/**
+ * Returns the internal nape namespace object.
+ *
+ * All wrapper classes use this to access the underlying Haxe-compiled
+ * constructors and prototypes.
+ *
+ * @internal
+ */
+declare function getNape(): any;
+
+/**
+ * 2D vector used for positions, velocities, forces, and other 2D quantities.
+ *
+ * Many methods return a new Vec2 unless noted as "in-place".
+ */
+declare class Vec2 {
+    /** @internal Raw Haxe nape Vec2 object. */
+    readonly _inner: NapeInner;
+    constructor(x?: number, y?: number);
+    /** @internal Wrap an existing Haxe Vec2 with caching. */
+    static _wrap(inner: NapeInner): Vec2;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    /** Magnitude of the vector. Setting this scales the vector to the given length. */
+    get length(): number;
+    set length(value: number);
+    /** Angle of the vector in radians (measured from the +x axis). */
+    get angle(): number;
+    set angle(value: number);
+    /** Squared length — avoids a square root when only comparison is needed. */
+    lsq(): number;
+    /** Copy values from another vector into this one (in-place). */
+    set(other: Vec2): this;
+    /** Set both components at once (in-place). */
+    setxy(x: number, y: number): this;
+    /** Return a new copy of this vector. */
+    copy(weak?: boolean): Vec2;
+    /** Rotate this vector by the given angle in radians (in-place). */
+    rotate(angle: number): this;
+    /** Reflect this vector about the given axis vector (returns new Vec2). */
+    reflect(axis: Vec2, weak?: boolean): Vec2;
+    /** Normalize this vector to unit length (in-place). Returns original length. */
+    normalise(): number;
+    /** Return a new unit-length vector with the same direction. */
+    unit(weak?: boolean): Vec2;
+    /** Return a new vector = this + other. */
+    add(other: Vec2, weak?: boolean): Vec2;
+    /** Return a new vector = this + other * scalar. */
+    addMul(other: Vec2, scalar: number, weak?: boolean): Vec2;
+    /** Return a new vector = this − other. */
+    sub(other: Vec2, weak?: boolean): Vec2;
+    /** Return a new vector = this * scalar. */
+    mul(scalar: number, weak?: boolean): Vec2;
+    /** this += other (in-place). */
+    addeq(other: Vec2): this;
+    /** this -= other (in-place). */
+    subeq(other: Vec2): this;
+    /** this *= scalar (in-place). */
+    muleq(scalar: number): this;
+    /** Dot product of this and other. */
+    dot(other: Vec2): number;
+    /** 2D cross product (returns scalar: this.x*other.y − this.y*other.x). */
+    cross(other: Vec2): number;
+    /** Return the perpendicular vector (rotated 90° counter-clockwise). */
+    perp(weak?: boolean): Vec2;
+    /** Release this vector back to the object pool. */
+    dispose(): void;
+    toString(): string;
+    /** Obtain a Vec2 from the object pool (or create a new one). */
+    static get(x?: number, y?: number, weak?: boolean): Vec2;
+    /** Obtain a weak Vec2 that auto-disposes after a single use. */
+    static weak(x?: number, y?: number): Vec2;
+    /** Create a Vec2 from polar coordinates. */
+    static fromPolar(length: number, angle: number, weak?: boolean): Vec2;
+}
+/** @internal Opaque handle for any Haxe-compiled nape object. */
+type NapeInner = any;
+
+/**
+ * Axis-aligned bounding box defined by min/max corners or x/y/width/height.
+ */
+declare class AABB {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): AABB;
+    get min(): Vec2;
+    set min(value: Vec2);
+    get max(): Vec2;
+    set max(value: Vec2);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    copy(): AABB;
+    toString(): string;
+}
+
+/**
+ * Generic typed wrapper around Haxe list objects (BodyList, ShapeList, etc.).
+ *
+ * Provides a modern iterable interface with `for...of`, `length`, `at()`, etc.
+ */
+declare class NapeList<T> implements Iterable<T> {
+    /** @internal */
+    readonly _inner: NapeInner;
+    /** @internal Function that wraps a raw Haxe element into its TS counterpart. */
+    private readonly _wrap;
+    /** @internal */
+    constructor(inner: NapeInner, wrap: (inner: NapeInner) => T);
+    /** Number of elements in the list. */
+    get length(): number;
+    /** Get element at index. */
+    at(index: number): T;
+    /** Add an element to the list. */
+    add(item: T & {
+        _inner: NapeInner;
+    }): void;
+    /** Remove an element from the list. */
+    remove(item: T & {
+        _inner: NapeInner;
+    }): void;
+    /** Check if the list contains an element. */
+    has(item: T & {
+        _inner: NapeInner;
+    }): boolean;
+    /** Remove all elements. */
+    clear(): void;
+    /** Whether the list is empty. */
+    get empty(): boolean;
+    /** Push an element to the end. */
+    push(item: T & {
+        _inner: NapeInner;
+    }): void;
+    /** Pop the last element. */
+    pop(): T;
+    /** Shift the first element. */
+    shift(): T;
+    /** Unshift an element to the front. */
+    unshift(item: T & {
+        _inner: NapeInner;
+    }): void;
+    /** Iterate over all elements. */
+    [Symbol.iterator](): Iterator<T>;
+    /** Convert to a plain array. */
+    toArray(): T[];
+    /** Apply a function to each element. */
+    forEach(fn: (item: T, index: number) => void): void;
+    toString(): string;
+}
+
+/**
+ * Physical material properties applied to shapes.
+ */
+declare class Material {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(elasticity?: number, dynamicFriction?: number, staticFriction?: number, density?: number, rollingFriction?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): Material;
+    get elasticity(): number;
+    set elasticity(value: number);
+    get dynamicFriction(): number;
+    set dynamicFriction(value: number);
+    get staticFriction(): number;
+    set staticFriction(value: number);
+    get density(): number;
+    set density(value: number);
+    get rollingFriction(): number;
+    set rollingFriction(value: number);
+    get userData(): Record<string, unknown>;
+    copy(): Material;
+    toString(): string;
+}
+
+/**
+ * Fluid properties for shapes that act as fluid regions.
+ */
+declare class FluidProperties {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(density?: number, viscosity?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): FluidProperties;
+    get density(): number;
+    set density(value: number);
+    get viscosity(): number;
+    set viscosity(value: number);
+    get gravity(): Vec2;
+    set gravity(value: Vec2);
+    get userData(): Record<string, unknown>;
+    copy(): FluidProperties;
+    toString(): string;
+}
+
+/**
+ * Bit-mask based interaction filter for controlling which shapes
+ * collide, sense, or interact as fluids.
+ */
+declare class InteractionFilter {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(collisionGroup?: number, collisionMask?: number, sensorGroup?: number, sensorMask?: number, fluidGroup?: number, fluidMask?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): InteractionFilter;
+    get collisionGroup(): number;
+    set collisionGroup(value: number);
+    get collisionMask(): number;
+    set collisionMask(value: number);
+    get sensorGroup(): number;
+    set sensorGroup(value: number);
+    get sensorMask(): number;
+    set sensorMask(value: number);
+    get fluidGroup(): number;
+    set fluidGroup(value: number);
+    get fluidMask(): number;
+    set fluidMask(value: number);
+    get userData(): Record<string, unknown>;
+    shouldCollide(other: InteractionFilter): boolean;
+    shouldSense(other: InteractionFilter): boolean;
+    shouldFlow(other: InteractionFilter): boolean;
+    copy(): InteractionFilter;
+    toString(): string;
+}
+
+declare enum ShapeType {
+    CIRCLE = "CIRCLE",
+    POLYGON = "POLYGON"
+}
+
+/**
+ * Base class for physics shapes (Circle, Polygon).
+ */
+declare class Shape {
+    /** @internal */
+    readonly _inner: NapeInner;
+    /** @internal – shapes are created via Circle or Polygon constructors. */
+    protected constructor();
+    /** @internal */
+    static _wrap(inner: NapeInner): Shape;
+    get type(): ShapeType;
+    get body(): Body;
+    set body(value: Body | null);
+    get worldCOM(): Vec2;
+    get localCOM(): Vec2;
+    set localCOM(value: Vec2);
+    get area(): number;
+    get inertia(): number;
+    get angDrag(): number;
+    get material(): Material;
+    set material(value: Material);
+    get filter(): InteractionFilter;
+    set filter(value: InteractionFilter);
+    get fluidProperties(): FluidProperties;
+    set fluidProperties(value: FluidProperties);
+    /** Callback types assigned to this shape. */
+    get cbTypes(): CbTypeSet;
+    get fluidEnabled(): boolean;
+    set fluidEnabled(value: boolean);
+    get sensorEnabled(): boolean;
+    set sensorEnabled(value: boolean);
+    get bounds(): AABB;
+    /** Cast to Circle — returns the Circle wrapper or null if not a circle. */
+    get castCircle(): Shape | null;
+    /** Cast to Polygon — returns the Polygon wrapper or null if not a polygon. */
+    get castPolygon(): Shape | null;
+    isCircle(): boolean;
+    isPolygon(): boolean;
+    translate(translation: Vec2): void;
+    scale(scaleX: number, scaleY: number): void;
+    rotate(angle: number): void;
+    transform(matrix: {
+        _inner: NapeInner;
+    }): void;
+    contains(point: Vec2): boolean;
+    copy(): Shape;
+    toString(): string;
+}
+/** Lightweight typed interface for the callback type set on a shape. */
+interface CbTypeSet {
+    readonly _inner: NapeInner;
+    add(cbType: {
+        _inner: NapeInner;
+    }): void;
+    remove(cbType: {
+        _inner: NapeInner;
+    }): void;
+    has(cbType: {
+        _inner: NapeInner;
+    }): boolean;
+    clear(): void;
+    readonly length: number;
+}
+
+/**
+ * The physics world. Add bodies and constraints, then call `step()` each frame.
+ */
+declare class Space {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(gravity?: Vec2);
+    /** @internal */
+    static _wrap(inner: NapeInner): Space;
+    get gravity(): Vec2;
+    set gravity(value: Vec2);
+    get worldLinearDrag(): number;
+    set worldLinearDrag(value: number);
+    get worldAngularDrag(): number;
+    set worldAngularDrag(value: number);
+    get sortContacts(): boolean;
+    set sortContacts(value: boolean);
+    get bodies(): NapeList<Body>;
+    get liveBodies(): NapeList<Body>;
+    get constraints(): NapeInner;
+    get liveConstraints(): NapeInner;
+    get arbiters(): NapeInner;
+    get listeners(): NapeInner;
+    get compounds(): NapeInner;
+    /** The static world body (always present, immovable). */
+    get world(): Body;
+    get timeStamp(): number;
+    get elapsedTime(): number;
+    get broadphase(): NapeInner;
+    get userData(): Record<string, unknown>;
+    step(deltaTime: number, velocityIterations?: number, positionIterations?: number): void;
+    clear(): void;
+    visitBodies(fn: (body: Body) => void): void;
+    visitConstraints(fn: (constraint: NapeInner) => void): void;
+    visitCompounds(fn: (compound: NapeInner) => void): void;
+    shapesUnderPoint(point: Vec2, filter?: InteractionFilterLike, output?: NapeInner): NapeInner;
+    bodiesUnderPoint(point: Vec2, filter?: InteractionFilterLike, output?: NapeInner): NapeInner;
+    shapesInAABB(aabb: AABB, containment?: boolean, strict?: boolean, filter?: InteractionFilterLike, output?: NapeInner): NapeInner;
+    bodiesInAABB(aabb: AABB, containment?: boolean, strict?: boolean, filter?: InteractionFilterLike, output?: NapeInner): NapeInner;
+    rayCast(ray: {
+        _inner: NapeInner;
+    } | NapeInner, inner?: boolean, filter?: InteractionFilterLike): NapeInner;
+    rayMultiCast(ray: {
+        _inner: NapeInner;
+    } | NapeInner, inner?: boolean, filter?: InteractionFilterLike, output?: NapeInner): NapeInner;
+    toString(): string;
+}
+/** @internal Helper type for filter-like parameters. */
+type InteractionFilterLike = {
+    _inner: NapeInner;
+} | NapeInner | undefined;
+
+/**
+ * Body type enumeration.
+ *
+ * - `STATIC`    — immovable, infinite mass (walls, floors)
+ * - `DYNAMIC`   — fully simulated (default)
+ * - `KINEMATIC` — moves only via velocity, not affected by forces
+ */
+declare enum BodyType {
+    STATIC = "STATIC",
+    DYNAMIC = "DYNAMIC",
+    KINEMATIC = "KINEMATIC"
+}
+
+/**
+ * A rigid body in the physics simulation.
+ */
+declare class Body {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(type?: BodyType, position?: Vec2);
+    /** @internal */
+    static _wrap(inner: NapeInner): Body;
+    get type(): BodyType;
+    set type(value: BodyType);
+    isStatic(): boolean;
+    isDynamic(): boolean;
+    isKinematic(): boolean;
+    get position(): Vec2;
+    set position(value: Vec2);
+    get rotation(): number;
+    set rotation(value: number);
+    get velocity(): Vec2;
+    set velocity(value: Vec2);
+    get angularVel(): number;
+    set angularVel(value: number);
+    get kinematicVel(): Vec2;
+    set kinematicVel(value: Vec2);
+    get kinAngVel(): number;
+    set kinAngVel(value: number);
+    get surfaceVel(): Vec2;
+    set surfaceVel(value: Vec2);
+    get force(): Vec2;
+    set force(value: Vec2);
+    get torque(): number;
+    set torque(value: number);
+    get mass(): number;
+    set mass(value: number);
+    get inertia(): number;
+    set inertia(value: number);
+    get constraintMass(): number;
+    get constraintInertia(): number;
+    get gravMass(): number;
+    set gravMass(value: number);
+    get gravMassScale(): number;
+    set gravMassScale(value: number);
+    get isBullet(): boolean;
+    set isBullet(value: boolean);
+    get disableCCD(): boolean;
+    set disableCCD(value: boolean);
+    get allowMovement(): boolean;
+    set allowMovement(value: boolean);
+    get allowRotation(): boolean;
+    set allowRotation(value: boolean);
+    get isSleeping(): boolean;
+    get shapes(): NapeList<Shape>;
+    get space(): Space;
+    set space(value: Space | null);
+    get compound(): NapeInner;
+    set compound(value: {
+        _inner: NapeInner;
+    } | null);
+    get bounds(): AABB;
+    get constraintVelocity(): Vec2;
+    get localCOM(): Vec2;
+    get worldCOM(): Vec2;
+    get userData(): Record<string, unknown>;
+    integrate(deltaTime: number): void;
+    applyImpulse(impulse: Vec2, pos?: Vec2, sleepable?: boolean): void;
+    applyAngularImpulse(impulse: number, sleepable?: boolean): void;
+    setVelocityFromTarget(targetPosition: Vec2, targetRotation: number, deltaTime: number): void;
+    localPointToWorld(point: Vec2, weak?: boolean): Vec2;
+    worldPointToLocal(point: Vec2, weak?: boolean): Vec2;
+    localVectorToWorld(vector: Vec2, weak?: boolean): Vec2;
+    worldVectorToLocal(vector: Vec2, weak?: boolean): Vec2;
+    translateShapes(translation: Vec2): void;
+    rotateShapes(angle: number): void;
+    scaleShapes(scaleX: number, scaleY: number): void;
+    align(): void;
+    rotate(centre: Vec2, angle: number): void;
+    setShapeMaterials(material: Material): void;
+    setShapeFilters(filter: InteractionFilter): void;
+    setShapeFluidProperties(fluidProperties: FluidProperties): void;
+    contains(point: Vec2): boolean;
+    crushFactor(): number;
+    copy(): Body;
+    toString(): string;
+}
+
+/**
+ * A circular physics shape.
+ */
+declare class Circle extends Shape {
+    constructor(radius?: number, localCOM?: Vec2, material?: Material, filter?: InteractionFilter);
+    /** @internal */
+    static _wrap(inner: NapeInner): Circle;
+    get radius(): number;
+    set radius(value: number);
+}
+
+/**
+ * A convex polygon physics shape.
+ *
+ * Use the static helper methods (`box`, `rect`, `regular`) for common shapes.
+ */
+declare class Polygon extends Shape {
+    constructor(vertices?: Vec2[] | NapeInner, material?: Material, filter?: InteractionFilter);
+    /** @internal */
+    static _wrap(inner: NapeInner): Polygon;
+    static box(width: number, height: number, weak?: boolean): NapeInner;
+    static rect(x: number, y: number, width: number, height: number, weak?: boolean): NapeInner;
+    static regular(xRadius: number, yRadius: number, sides: number, angle?: number, weak?: boolean): NapeInner;
+    /** Read-only list of local-space vertices. */
+    get localVerts(): NapeInner;
+    /** Read-only list of world-space vertices (computed after stepping). */
+    get worldVerts(): NapeInner;
+    /** Read-only edge list. */
+    get edges(): NapeInner;
+    /** Validate the polygon geometry. */
+    validity(): NapeInner;
+}
+
+/**
+ * Hierarchical interaction group for controlling interactions
+ * between sets of interactors.
+ */
+declare class InteractionGroup {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(ignore?: boolean);
+    /** @internal */
+    static _wrap(inner: NapeInner): InteractionGroup;
+    get group(): InteractionGroup;
+    set group(value: InteractionGroup | null);
+    get ignore(): boolean;
+    set ignore(value: boolean);
+    toString(): string;
+}
+
+/**
+ * Callback event types.
+ */
+declare enum CbEvent {
+    BEGIN = "BEGIN",
+    ONGOING = "ONGOING",
+    END = "END",
+    WAKE = "WAKE",
+    SLEEP = "SLEEP",
+    BREAK = "BREAK",
+    PRE = "PRE"
+}
+
+/**
+ * Callback type — used to tag interactors so that listeners
+ * can filter which interactions they respond to.
+ */
+declare class CbType {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor();
+    /** @internal */
+    static _wrap(inner: NapeInner): CbType;
+    /** Built-in type matching any body. */
+    static get ANY_BODY(): CbType;
+    /** Built-in type matching any constraint. */
+    static get ANY_CONSTRAINT(): CbType;
+    /** Built-in type matching any shape. */
+    static get ANY_SHAPE(): CbType;
+    /** Built-in type matching any compound. */
+    static get ANY_COMPOUND(): CbType;
+}
+
+/**
+ * Interaction type filter for interaction listeners.
+ */
+declare enum InteractionType {
+    COLLISION = "COLLISION",
+    SENSOR = "SENSOR",
+    FLUID = "FLUID",
+    ANY = "ANY"
+}
+
+/**
+ * Return value flags for PreListener handlers.
+ */
+declare enum PreFlag {
+    ACCEPT = "ACCEPT",
+    IGNORE = "IGNORE",
+    ACCEPT_ONCE = "ACCEPT_ONCE",
+    IGNORE_ONCE = "IGNORE_ONCE"
+}
+
+/**
+ * Composite callback type option — allows including and excluding CbTypes.
+ */
+declare class OptionType {
+    /** @internal */
+    readonly _inner: NapeInner;
+    constructor(cbTypes?: CbType | CbType[]);
+    /** @internal */
+    static _wrap(inner: NapeInner): OptionType;
+}
+
+/**
+ * Base class for all listener types.
+ * Not instantiated directly — use BodyListener, InteractionListener, etc.
+ */
+declare class Listener {
+    /** @internal */
+    readonly _inner: NapeInner;
+    /** @internal */
+    protected constructor();
+    /** @internal */
+    static _wrap(inner: NapeInner): Listener;
+    get space(): Space;
+    set space(value: Space | null);
+    get precedence(): number;
+    set precedence(value: number);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    toString(): string;
+}
+
+/**
+ * Listener that fires when a body wakes, sleeps, etc.
+ */
+declare class BodyListener extends Listener {
+    /**
+     * @param event     The event to listen for (WAKE, SLEEP).
+     * @param options   CbType or OptionType to filter which bodies trigger this.
+     * @param handler   Callback function receiving a BodyCallback.
+     * @param precedence  Lower precedence listeners fire first (default 0).
+     */
+    constructor(event: CbEvent, options: CbType | OptionType, handler: (callback: any) => void, precedence?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): BodyListener;
+}
+
+/**
+ * Listener that fires on collision/sensor/fluid interactions between bodies.
+ */
+declare class InteractionListener extends Listener {
+    /**
+     * @param event           BEGIN, ONGOING, or END.
+     * @param interactionType COLLISION, SENSOR, FLUID, or ANY.
+     * @param options1        CbType/OptionType for the first interactor.
+     * @param options2        CbType/OptionType for the second interactor.
+     * @param handler         Callback receiving an InteractionCallback.
+     * @param precedence      Lower values fire first (default 0).
+     */
+    constructor(event: CbEvent, interactionType: InteractionType, options1: CbType | OptionType, options2: CbType | OptionType, handler: (callback: any) => void, precedence?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): InteractionListener;
+}
+
+/**
+ * Listener that fires on constraint events (WAKE, SLEEP, BREAK).
+ */
+declare class ConstraintListener extends Listener {
+    constructor(event: CbEvent, options: CbType | OptionType, handler: (callback: any) => void, precedence?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): ConstraintListener;
+}
+
+/**
+ * Listener that fires before collision resolution, allowing
+ * the handler to accept/ignore the interaction.
+ */
+declare class PreListener extends Listener {
+    constructor(interactionType: InteractionType, options1: CbType | OptionType, options2: CbType | OptionType, handler: (callback: NapeInner) => PreFlag | NapeInner, precedence?: number, pure?: boolean);
+    /** @internal */
+    static _wrap(inner: NapeInner): PreListener;
+}
+
+/**
+ * Base class for all constraints / joints.
+ * Not instantiated directly.
+ */
+declare class Constraint {
+    /** @internal */
+    readonly _inner: NapeInner;
+    /** @internal */
+    protected constructor();
+    /** @internal */
+    static _wrap(inner: NapeInner): Constraint;
+    get space(): Space;
+    set space(value: Space | null);
+    get compound(): NapeInner;
+    set compound(value: {
+        _inner: NapeInner;
+    } | null);
+    get active(): boolean;
+    set active(value: boolean);
+    get ignore(): boolean;
+    set ignore(value: boolean);
+    get stiff(): boolean;
+    set stiff(value: boolean);
+    get frequency(): number;
+    set frequency(value: number);
+    get damping(): number;
+    set damping(value: number);
+    get maxForce(): number;
+    set maxForce(value: number);
+    get maxError(): number;
+    set maxError(value: number);
+    get breakUnderForce(): boolean;
+    set breakUnderForce(value: boolean);
+    get breakUnderError(): boolean;
+    set breakUnderError(value: boolean);
+    get removeOnBreak(): boolean;
+    set removeOnBreak(value: boolean);
+    get isSleeping(): boolean;
+    get userData(): Record<string, unknown>;
+    impulse(): NapeInner;
+    bodyImpulse(body: Body): NapeInner;
+    visitBodies(fn: (body: Body) => void): void;
+    copy(): Constraint;
+    toString(): string;
+}
+
+/**
+ * A pivot (pin) joint that constrains two bodies to share an anchor point.
+ */
+declare class PivotJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, anchor1: Vec2, anchor2: Vec2);
+    /** @internal */
+    static _wrap(inner: NapeInner): PivotJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get anchor1(): Vec2;
+    set anchor1(value: Vec2);
+    get anchor2(): Vec2;
+    set anchor2(value: Vec2);
+}
+
+/**
+ * Constrains the distance between two anchor points on two bodies.
+ */
+declare class DistanceJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, anchor1: Vec2, anchor2: Vec2, jointMin: number, jointMax: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): DistanceJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get anchor1(): Vec2;
+    set anchor1(value: Vec2);
+    get anchor2(): Vec2;
+    set anchor2(value: Vec2);
+    get jointMin(): number;
+    set jointMin(value: number);
+    get jointMax(): number;
+    set jointMax(value: number);
+}
+
+/**
+ * Constrains the relative angle between two bodies.
+ */
+declare class AngleJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, jointMin: number, jointMax: number, ratio?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): AngleJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get jointMin(): number;
+    set jointMin(value: number);
+    get jointMax(): number;
+    set jointMax(value: number);
+    get ratio(): number;
+    set ratio(value: number);
+}
+
+/**
+ * Weld joint — constrains two bodies to maintain a fixed relative
+ * position and angle (like gluing them together).
+ */
+declare class WeldJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, anchor1: Vec2, anchor2: Vec2, phase?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): WeldJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get anchor1(): Vec2;
+    set anchor1(value: Vec2);
+    get anchor2(): Vec2;
+    set anchor2(value: Vec2);
+    get phase(): number;
+    set phase(value: number);
+}
+
+/**
+ * Motor joint — applies angular velocity to rotate bodies relative to each other.
+ */
+declare class MotorJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, rate: number, ratio?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): MotorJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get rate(): number;
+    set rate(value: number);
+    get ratio(): number;
+    set ratio(value: number);
+}
+
+/**
+ * Line joint — constrains body2's anchor to slide along a line
+ * defined by body1's anchor and direction.
+ */
+declare class LineJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, anchor1: Vec2, anchor2: Vec2, direction: Vec2, jointMin: number, jointMax: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): LineJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get anchor1(): Vec2;
+    set anchor1(value: Vec2);
+    get anchor2(): Vec2;
+    set anchor2(value: Vec2);
+    get direction(): Vec2;
+    set direction(value: Vec2);
+    get jointMin(): number;
+    set jointMin(value: number);
+    get jointMax(): number;
+    set jointMax(value: number);
+}
+
+/**
+ * Pulley joint — constrains the sum of distances between four anchor points
+ * on four bodies.
+ */
+declare class PulleyJoint extends Constraint {
+    constructor(body1: Body | null, body2: Body | null, body3: Body | null, body4: Body | null, anchor1: Vec2, anchor2: Vec2, anchor3: Vec2, anchor4: Vec2, jointMin: number, jointMax: number, ratio?: number);
+    /** @internal */
+    static _wrap(inner: NapeInner): PulleyJoint;
+    get body1(): Body;
+    set body1(value: Body | null);
+    get body2(): Body;
+    set body2(value: Body | null);
+    get body3(): Body;
+    set body3(value: Body | null);
+    get body4(): Body;
+    set body4(value: Body | null);
+    get anchor1(): Vec2;
+    set anchor1(value: Vec2);
+    get anchor2(): Vec2;
+    set anchor2(value: Vec2);
+    get anchor3(): Vec2;
+    set anchor3(value: Vec2);
+    get anchor4(): Vec2;
+    set anchor4(value: Vec2);
+    get jointMin(): number;
+    set jointMin(value: number);
+    get jointMax(): number;
+    set jointMax(value: number);
+    get ratio(): number;
+    set ratio(value: number);
+}
+
+export { AABB, AngleJoint, Body, BodyListener, BodyType, CbEvent, CbType, Circle, Constraint, ConstraintListener, DistanceJoint, FluidProperties, InteractionFilter, InteractionGroup, InteractionListener, InteractionType, LineJoint, Listener, Material, MotorJoint, NapeList, OptionType, PivotJoint, Polygon, PreFlag, PreListener, PulleyJoint, Shape, ShapeType, Space, Vec2, WeldJoint, getNape };