gdcore-tools 1.0.6 → 1.0.7

package/dist/Runtime/Extensions/Physics2Behavior/box2d.d.ts

@@ -0,0 +1,1804 @@
+// TODO: Improve type checking by using proper typings for Box2D.
+// It comes from a TypeScript port of box2d 2.4.1: https://github.com/Birch-san/box2d-wasm
+// We use a port of box2d 2.3.1 from: https://github.com/kripken/box2d.js/tree/b0e491ce91f05b5390d86655ad6cf3102fabdb95/build
+
+// As the versions don't match, some adaptations were made.
+// Sources must be checked if there is any doubt.
+
+declare namespace Box2D {
+  export function _free(object: any): void;
+  export function _malloc(size: number, type: string, stack: any): any;
+  export const ALLOC_STACK: any;
+  export const HEAPF32: any[];
+  export class b2Contact extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Contact;
+    };
+    protected readonly __class__: typeof b2Contact;
+    GetManifold(): b2Manifold;
+    GetWorldManifold(manifold: b2WorldManifold | number): void;
+    IsTouching(): boolean;
+    SetEnabled(flag: boolean): void;
+    IsEnabled(): boolean;
+    GetNext(): b2Contact;
+    GetFixtureA(): b2Fixture;
+    GetChildIndexA(): number;
+    GetFixtureB(): b2Fixture;
+    GetChildIndexB(): number;
+    SetFriction(friction: number): void;
+    GetFriction(): number;
+    ResetFriction(): void;
+    SetRestitution(restitution: number): void;
+    GetRestitution(): number;
+    ResetRestitution(): void;
+    SetRestitutionThreshold(threshold: number): void;
+    GetRestitutionThreshold(): number;
+    ResetRestitutionThreshold(): void;
+    SetTangentSpeed(speed: number): void;
+    GetTangentSpeed(): number;
+  }
+  export class b2ContactListener extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ContactListener;
+    };
+    protected readonly __class__: typeof b2ContactListener;
+    __destroy__(): void;
+  }
+  export class JSContactListener extends b2ContactListener {
+    protected static readonly __cache__: {
+      [ptr: number]: JSContactListener;
+    };
+    protected readonly __class__: typeof JSContactListener;
+    __destroy__(): void;
+    protected ptr: number;
+    BeginContact(contact: b2Contact | number): void;
+    EndContact(contact: b2Contact | number): void;
+    PreSolve(
+      contact: b2Contact | number,
+      oldManifold: b2Manifold | number
+    ): void;
+    PostSolve(
+      contact: b2Contact | number,
+      impulse: b2ContactImpulse | number
+    ): void;
+  }
+  export class b2World extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2World;
+    };
+    protected readonly __class__: typeof b2World;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(gravity: b2Vec2 | number);
+    SetDestructionListener(listener: b2DestructionListener | number): void;
+    SetContactFilter(filter: JSContactFilter | number): void;
+    SetContactListener(listener: JSContactListener | number): void;
+    SetDebugDraw(debugDraw: b2Draw | number): void;
+    CreateBody(def: b2BodyDef | number): b2Body;
+    DestroyBody(body: b2Body | number): void;
+    CreateJoint(def: b2JointDef | number): b2Joint;
+    DestroyJoint(joint: b2Joint | number): void;
+    Step(
+      timeStep: number,
+      velocityIterations: number,
+      positionIterations: number
+    ): void;
+    ClearForces(): void;
+    DebugDraw(): void;
+    QueryAABB(callback: b2QueryCallback | number, aabb: b2AABB | number): void;
+    RayCast(
+      callback: b2RayCastCallback | number,
+      point1: b2Vec2 | number,
+      point2: b2Vec2 | number
+    ): void;
+    GetBodyList(): b2Body;
+    GetJointList(): b2Joint;
+    GetContactList(): b2Contact;
+    SetAllowSleeping(flag: boolean): void;
+    GetAllowSleeping(): boolean;
+    SetWarmStarting(flag: boolean): void;
+    GetWarmStarting(): boolean;
+    SetContinuousPhysics(flag: boolean): void;
+    GetContinuousPhysics(): boolean;
+    SetSubStepping(flag: boolean): void;
+    GetSubStepping(): boolean;
+    GetProxyCount(): number;
+    GetBodyCount(): number;
+    GetJointCount(): number;
+    GetContactCount(): number;
+    GetTreeHeight(): number;
+    GetTreeBalance(): number;
+    GetTreeQuality(): number;
+    SetGravity(gravity: b2Vec2 | number): void;
+    GetGravity(): b2Vec2;
+    IsLocked(): boolean;
+    SetAutoClearForces(flag: boolean): void;
+    GetAutoClearForces(): boolean;
+    GetProfile(): b2Profile;
+    Dump(): void;
+  }
+  export namespace b2Shape {
+    const e_circle: number;
+    const e_edge: number;
+    const e_polygon: number;
+    const e_chain: number;
+    const e_typeCount: number;
+  }
+  export class b2Shape extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Shape;
+    };
+    protected readonly __class__: typeof b2Shape;
+    __destroy__(): void;
+    GetType(): number;
+    GetChildCount(): number;
+    TestPoint(xf: b2Transform | number, p: b2Vec2 | number): boolean;
+    RayCast(
+      output: b2RayCastOutput | number,
+      input: b2RayCastInput | number,
+      transform: b2Transform | number,
+      childIndex: number
+    ): boolean;
+    ComputeAABB(
+      aabb: b2AABB | number,
+      xf: b2Transform | number,
+      childIndex: number
+    ): void;
+    ComputeMass(massData: b2MassData | number, density: number): void;
+    m_type: number;
+    get_m_type(): number;
+    set_m_type(m_type: number): void;
+    m_radius: number;
+    get_m_radius(): number;
+    set_m_radius(m_radius: number): void;
+  }
+  export class b2FixtureUserData extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2FixtureUserData;
+    };
+    protected readonly __class__: typeof b2FixtureUserData;
+    __destroy__(): void;
+    pointer: number;
+    get_pointer(): number;
+    set_pointer(pointer: number): void;
+  }
+  export class b2FixtureDef extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2FixtureDef;
+    };
+    protected readonly __class__: typeof b2FixtureDef;
+    __destroy__(): void;
+    protected ptr: number;
+    shape: b2Shape;
+    get_shape(): b2Shape;
+    set_shape(shape: b2Shape): void;
+    userData: b2FixtureUserData;
+    get_userData(): b2FixtureUserData;
+    set_userData(userData: b2FixtureUserData): void;
+    friction: number;
+    get_friction(): number;
+    set_friction(friction: number): void;
+    restitution: number;
+    get_restitution(): number;
+    set_restitution(restitution: number): void;
+    restitutionThreshold: number;
+    get_restitutionThreshold(): number;
+    set_restitutionThreshold(restitutionThreshold: number): void;
+    density: number;
+    get_density(): number;
+    set_density(density: number): void;
+    isSensor: boolean;
+    get_isSensor(): boolean;
+    set_isSensor(isSensor: boolean): void;
+    filter: b2Filter;
+    get_filter(): b2Filter;
+    set_filter(filter: b2Filter): void;
+  }
+  export class b2Fixture extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Fixture;
+    };
+    protected readonly __class__: typeof b2Fixture;
+    __destroy__(): void;
+    GetType(): number;
+    GetShape(): b2Shape;
+    SetSensor(sensor: boolean): void;
+    IsSensor(): boolean;
+    SetFilterData(filter: b2Filter | number): void;
+    GetFilterData(): b2Filter;
+    Refilter(): void;
+    GetBody(): b2Body;
+    GetNext(): b2Fixture;
+    GetUserData(): b2FixtureUserData;
+    TestPoint(p: b2Vec2 | number): boolean;
+    RayCast(
+      output: b2RayCastOutput | number,
+      input: b2RayCastInput | number,
+      childIndex: number
+    ): boolean;
+    GetMassData(massData: b2MassData | number): void;
+    SetDensity(density: number): void;
+    GetDensity(): number;
+    GetFriction(): number;
+    SetFriction(friction: number): void;
+    GetRestitution(): number;
+    SetRestitution(restitution: number): void;
+    GetRestitutionThreshold(): number;
+    SetRestitutionThreshold(threshold: number): void;
+    GetAABB(childIndex: number): b2AABB;
+    Dump(bodyIndex: number): void;
+  }
+  export class b2Transform extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Transform;
+    };
+    protected readonly __class__: typeof b2Transform;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(position: b2Vec2 | number, rotation: b2Rot | number);
+    SetIdentity(): void;
+    Set(position: b2Vec2 | number, angle: number): void;
+    p: b2Vec2;
+    get_p(): b2Vec2;
+    set_p(p: b2Vec2): void;
+    q: b2Rot;
+    get_q(): b2Rot;
+    set_q(q: b2Rot): void;
+  }
+  export class b2RayCastCallback extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RayCastCallback;
+    };
+    protected readonly __class__: typeof b2RayCastCallback;
+    __destroy__(): void;
+  }
+  export class JSRayCastCallback extends b2RayCastCallback {
+    protected static readonly __cache__: {
+      [ptr: number]: JSRayCastCallback;
+    };
+    protected readonly __class__: typeof JSRayCastCallback;
+    __destroy__(): void;
+    protected ptr: number;
+    ReportFixture(
+      fixture: b2Fixture | number,
+      point: b2Vec2 | number,
+      normal: b2Vec2 | number,
+      fraction: number
+    ): number;
+  }
+  export class b2QueryCallback extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2QueryCallback;
+    };
+    protected readonly __class__: typeof b2QueryCallback;
+    __destroy__(): void;
+  }
+  export class JSQueryCallback extends b2QueryCallback {
+    protected static readonly __cache__: {
+      [ptr: number]: JSQueryCallback;
+    };
+    protected readonly __class__: typeof JSQueryCallback;
+    __destroy__(): void;
+    protected ptr: number;
+    ReportFixture(fixture: b2Fixture | number): boolean;
+  }
+  export class b2MassData extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2MassData;
+    };
+    protected readonly __class__: typeof b2MassData;
+    __destroy__(): void;
+    protected ptr: number;
+    mass: number;
+    get_mass(): number;
+    set_mass(mass: number): void;
+    center: b2Vec2;
+    get_center(): b2Vec2;
+    set_center(center: b2Vec2): void;
+    I: number;
+    get_I(): number;
+    set_I(I: number): void;
+  }
+  export class b2Vec2 extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Vec2;
+    };
+    protected readonly __class__: typeof b2Vec2;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(x: number, y: number);
+    SetZero(): void;
+    Set(x: number, y: number): void;
+    op_add(v: b2Vec2 | number): void;
+    op_sub(v: b2Vec2 | number): void;
+    op_mul(s: number): void;
+    Length(): number;
+    LengthSquared(): number;
+    Normalize(): number;
+    IsValid(): boolean;
+    Skew(): b2Vec2;
+    x: number;
+    get_x(): number;
+    set_x(x: number): void;
+    y: number;
+    get_y(): number;
+    set_y(y: number): void;
+  }
+  export class b2Vec3 extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Vec3;
+    };
+    protected readonly __class__: typeof b2Vec3;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(x: number, y: number, z: number);
+    SetZero(): void;
+    Set(x: number, y: number, z: number): void;
+    op_add(v: b2Vec3 | number): void;
+    op_sub(v: b2Vec3 | number): void;
+    op_mul(s: number): void;
+    x: number;
+    get_x(): number;
+    set_x(x: number): void;
+    y: number;
+    get_y(): number;
+    set_y(y: number): void;
+    z: number;
+    get_z(): number;
+    set_z(z: number): void;
+  }
+  export class b2BodyUserData extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2BodyUserData;
+    };
+    protected readonly __class__: typeof b2BodyUserData;
+    __destroy__(): void;
+    pointer: number;
+    get_pointer(): number;
+    set_pointer(pointer: number): void;
+  }
+  export class b2Body extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Body;
+    };
+    protected readonly __class__: typeof b2Body;
+    CreateFixture(def: b2FixtureDef | number): b2Fixture;
+    CreateFixture(shape: b2Shape | number, density: number): b2Fixture;
+    DestroyFixture(fixture: b2Fixture | number): void;
+    SetTransform(position: b2Vec2 | number, angle: number): void;
+    GetTransform(): b2Transform;
+    GetPosition(): b2Vec2;
+    GetAngle(): number;
+    GetWorldCenter(): b2Vec2;
+    GetLocalCenter(): b2Vec2;
+    SetLinearVelocity(v: b2Vec2 | number): void;
+    GetLinearVelocity(): b2Vec2;
+    SetAngularVelocity(omega: number): void;
+    GetAngularVelocity(): number;
+    ApplyForce(
+      force: b2Vec2 | number,
+      point: b2Vec2 | number,
+      wake: boolean
+    ): void;
+    ApplyForceToCenter(force: b2Vec2 | number, wake: boolean): void;
+    ApplyTorque(torque: number, awake: boolean): void;
+    ApplyLinearImpulse(
+      impulse: b2Vec2 | number,
+      point: b2Vec2 | number,
+      wake: boolean
+    ): void;
+    ApplyLinearImpulseToCenter(impulse: b2Vec2 | number, wake: boolean): void;
+    ApplyAngularImpulse(impulse: number, wake: boolean): void;
+    GetMass(): number;
+    GetInertia(): number;
+    GetMassData(data: b2MassData | number): void;
+    SetMassData(data: b2MassData | number): void;
+    ResetMassData(): void;
+    GetWorldPoint(localPoint: b2Vec2 | number): b2Vec2;
+    GetWorldVector(localVector: b2Vec2 | number): b2Vec2;
+    GetLocalPoint(worldPoint: b2Vec2 | number): b2Vec2;
+    GetLocalVector(worldVector: b2Vec2 | number): b2Vec2;
+    GetLinearVelocityFromWorldPoint(worldPoint: b2Vec2 | number): b2Vec2;
+    GetLinearVelocityFromLocalPoint(localPoint: b2Vec2 | number): b2Vec2;
+    GetLinearDamping(): number;
+    SetLinearDamping(linearDamping: number): void;
+    GetAngularDamping(): number;
+    SetAngularDamping(angularDamping: number): void;
+    GetGravityScale(): number;
+    SetGravityScale(scale: number): void;
+    SetType(type: number | number): void;
+    GetType(): number;
+    SetBullet(flag: boolean): void;
+    IsBullet(): boolean;
+    SetSleepingAllowed(flag: boolean): void;
+    IsSleepingAllowed(): boolean;
+    SetAwake(flag: boolean): void;
+    IsAwake(): boolean;
+    SetEnabled(flag: boolean): void;
+    IsEnabled(): boolean;
+    SetFixedRotation(flag: boolean): void;
+    IsFixedRotation(): boolean;
+    GetFixtureList(): b2Fixture;
+    GetJointList(): b2JointEdge;
+    GetContactList(): b2ContactEdge;
+    GetNext(): b2Body;
+    GetUserData(): b2BodyUserData;
+    GetWorld(): b2World;
+    Dump(): void;
+  }
+  const b2_staticBody: number;
+  const b2_kinematicBody: number;
+  const b2_dynamicBody: number;
+  export class b2BodyDef extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2BodyDef;
+    };
+    protected readonly __class__: typeof b2BodyDef;
+    __destroy__(): void;
+    protected ptr: number;
+    type: number;
+    get_type(): number;
+    set_type(type: number): void;
+    position: b2Vec2;
+    get_position(): b2Vec2;
+    set_position(position: b2Vec2): void;
+    angle: number;
+    get_angle(): number;
+    set_angle(angle: number): void;
+    linearVelocity: b2Vec2;
+    get_linearVelocity(): b2Vec2;
+    set_linearVelocity(linearVelocity: b2Vec2): void;
+    angularVelocity: number;
+    get_angularVelocity(): number;
+    set_angularVelocity(angularVelocity: number): void;
+    linearDamping: number;
+    get_linearDamping(): number;
+    set_linearDamping(linearDamping: number): void;
+    angularDamping: number;
+    get_angularDamping(): number;
+    set_angularDamping(angularDamping: number): void;
+    allowSleep: boolean;
+    get_allowSleep(): boolean;
+    set_allowSleep(allowSleep: boolean): void;
+    awake: boolean;
+    get_awake(): boolean;
+    set_awake(awake: boolean): void;
+    fixedRotation: boolean;
+    get_fixedRotation(): boolean;
+    set_fixedRotation(fixedRotation: boolean): void;
+    bullet: boolean;
+    get_bullet(): boolean;
+    set_bullet(bullet: boolean): void;
+    enabled: boolean;
+    get_enabled(): boolean;
+    set_enabled(enabled: boolean): void;
+    userData: b2BodyUserData;
+    get_userData(): b2BodyUserData;
+    set_userData(userData: b2BodyUserData): void;
+    gravityScale: number;
+    get_gravityScale(): number;
+    set_gravityScale(gravityScale: number): void;
+  }
+  export class b2Filter extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Filter;
+    };
+    protected readonly __class__: typeof b2Filter;
+    __destroy__(): void;
+    protected ptr: number;
+    categoryBits: number;
+    get_categoryBits(): number;
+    set_categoryBits(categoryBits: number): void;
+    maskBits: number;
+    get_maskBits(): number;
+    set_maskBits(maskBits: number): void;
+    groupIndex: number;
+    get_groupIndex(): number;
+    set_groupIndex(groupIndex: number): void;
+  }
+  export class b2AABB extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2AABB;
+    };
+    protected readonly __class__: typeof b2AABB;
+    __destroy__(): void;
+    protected ptr: number;
+    IsValid(): boolean;
+    GetCenter(): b2Vec2;
+    GetExtents(): b2Vec2;
+    GetPerimeter(): number;
+    Combine(aabb: b2AABB | number): void;
+    Combine(aabb1: b2AABB | number, aabb2: b2AABB | number): void;
+    Contains(aabb: b2AABB | number): boolean;
+    RayCast(
+      output: b2RayCastOutput | number,
+      input: b2RayCastInput | number
+    ): boolean;
+    lowerBound: b2Vec2;
+    get_lowerBound(): b2Vec2;
+    set_lowerBound(lowerBound: b2Vec2): void;
+    upperBound: b2Vec2;
+    get_upperBound(): b2Vec2;
+    set_upperBound(upperBound: b2Vec2): void;
+  }
+  export class b2CircleShape extends b2Shape {
+    protected static readonly __cache__: {
+      [ptr: number]: b2CircleShape;
+    };
+    protected readonly __class__: typeof b2CircleShape;
+    __destroy__(): void;
+    protected ptr: number;
+    m_p: b2Vec2;
+    get_m_p(): b2Vec2;
+    set_m_p(m_p: b2Vec2): void;
+  }
+  export class b2EdgeShape extends b2Shape {
+    protected static readonly __cache__: {
+      [ptr: number]: b2EdgeShape;
+    };
+    protected readonly __class__: typeof b2EdgeShape;
+    __destroy__(): void;
+    protected ptr: number;
+    SetOneSided(
+      v0: b2Vec2 | number,
+      v1: b2Vec2 | number,
+      v2: b2Vec2 | number,
+      v3: b2Vec2 | number
+    ): void;
+    SetTwoSided(v1: b2Vec2 | number, v2: b2Vec2 | number): void;
+    m_vertex1: b2Vec2;
+    get_m_vertex1(): b2Vec2;
+    set_m_vertex1(m_vertex1: b2Vec2): void;
+    m_vertex2: b2Vec2;
+    get_m_vertex2(): b2Vec2;
+    set_m_vertex2(m_vertex2: b2Vec2): void;
+    m_vertex0: b2Vec2;
+    get_m_vertex0(): b2Vec2;
+    set_m_vertex0(m_vertex0: b2Vec2): void;
+    m_vertex3: b2Vec2;
+    get_m_vertex3(): b2Vec2;
+    set_m_vertex3(m_vertex3: b2Vec2): void;
+    m_oneSided: boolean;
+    get_m_oneSided(): boolean;
+    set_m_oneSided(m_oneSided: boolean): void;
+  }
+  const e_unknownJoint: number;
+  const e_revoluteJoint: number;
+  const e_prismaticJoint: number;
+  const e_distanceJoint: number;
+  const e_pulleyJoint: number;
+  const e_mouseJoint: number;
+  const e_gearJoint: number;
+  const e_wheelJoint: number;
+  const e_weldJoint: number;
+  const e_frictionJoint: number;
+  const e_ropeJoint: number;
+  const e_motorJoint: number;
+  export class b2JointUserData extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2JointUserData;
+    };
+    protected readonly __class__: typeof b2JointUserData;
+    __destroy__(): void;
+    pointer: number;
+    get_pointer(): number;
+    set_pointer(pointer: number): void;
+  }
+  export class b2JointDef extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2JointDef;
+    };
+    protected readonly __class__: typeof b2JointDef;
+    __destroy__(): void;
+    type: number;
+    get_type(): number;
+    set_type(type: number): void;
+    userData: b2JointUserData;
+    get_userData(): b2JointUserData;
+    set_userData(userData: b2JointUserData): void;
+    bodyA: b2Body;
+    get_bodyA(): b2Body;
+    set_bodyA(bodyA: b2Body): void;
+    bodyB: b2Body;
+    get_bodyB(): b2Body;
+    set_bodyB(bodyB: b2Body): void;
+    collideConnected: boolean;
+    get_collideConnected(): boolean;
+    set_collideConnected(collideConnected: boolean): void;
+    set_dampingRatio(dampingRatio: number): void;
+    set_frequencyHz(frequencyHz: number): void;
+  }
+  export class b2Joint extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Joint;
+    };
+    protected readonly __class__: typeof b2Joint;
+    GetType(): number;
+    GetBodyA(): b2Body;
+    GetBodyB(): b2Body;
+    GetAnchorA(): b2Vec2;
+    GetAnchorB(): b2Vec2;
+    GetReactionForce(inv_dt: number): b2Vec2;
+    GetReactionTorque(inv_dt: number): number;
+    GetNext(): b2Joint;
+    GetUserData(): b2JointUserData;
+    GetCollideConnected(): boolean;
+    Dump(): void;
+  }
+  export class b2WeldJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2WeldJoint;
+    };
+    protected readonly __class__: typeof b2WeldJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    GetReferenceAngle(): number;
+    GetFrequency(): number;
+    SetFrequency(frequency: number): void;
+    GetDampingRatio(): number;
+    SetDampingRatio(dampingRatio: number): void;
+    Dump(): void;
+  }
+  export class b2WeldJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2WeldJointDef;
+    };
+    protected readonly __class__: typeof b2WeldJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchor: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    referenceAngle: number;
+    get_referenceAngle(): number;
+    set_referenceAngle(referenceAngle: number): void;
+    frequencyHz: number;
+    get_frequencyHz(): number;
+    set_frequencyHz(frequencyHz: number): void;
+    dampingRatio: number;
+    get_dampingRatio(): number;
+    set_dampingRatio(dampingRatio: number): void;
+  }
+  export class b2RopeJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RopeJoint;
+    };
+    protected readonly __class__: typeof b2RopeJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    GetMaxLength(): number;
+    SetMaxLength(maxLength: number): void;
+    Dump(): void;
+  }
+  export class b2RopeJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RopeJointDef;
+    };
+    protected readonly __class__: typeof b2RopeJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchor: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    maxLength: number;
+    get_maxLength(): number;
+    set_maxLength(maxLength: number): void;
+    length: number;
+    get_length(): number;
+    set_length(length: number): void;
+    impulse: number;
+    get_impulse(): number;
+    set_impulse(impulse: number): void;
+  }
+  export class b2ChainShape extends b2Shape {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ChainShape;
+    };
+    protected readonly __class__: typeof b2ChainShape;
+    __destroy__(): void;
+    protected ptr: number;
+    Clear(): void;
+    CreateLoop(vertices: b2Vec2 | number, count: number): void;
+    CreateChain(
+      vertices: b2Vec2 | number,
+      count: number,
+      prevVertex: b2Vec2 | number,
+      nextVertex: b2Vec2 | number
+    ): void;
+    GetChildEdge(edge: b2EdgeShape | number, index: number): void;
+    m_vertices: b2Vec2;
+    get_m_vertices(): b2Vec2;
+    set_m_vertices(m_vertices: b2Vec2): void;
+    m_count: number;
+    get_m_count(): number;
+    set_m_count(m_count: number): void;
+    m_prevVertex: b2Vec2;
+    get_m_prevVertex(): b2Vec2;
+    set_m_prevVertex(m_prevVertex: b2Vec2): void;
+    m_nextVertex: b2Vec2;
+    get_m_nextVertex(): b2Vec2;
+    set_m_nextVertex(m_nextVertex: b2Vec2): void;
+  }
+  export class b2Color extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Color;
+    };
+    protected readonly __class__: typeof b2Color;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(r: number, g: number, b: number);
+    Set(ri: number, gi: number, bi: number): void;
+    r: number;
+    get_r(): number;
+    set_r(r: number): void;
+    g: number;
+    get_g(): number;
+    set_g(g: number): void;
+    b: number;
+    get_b(): number;
+    set_b(b: number): void;
+  }
+  export class b2ContactEdge extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ContactEdge;
+    };
+    protected readonly __class__: typeof b2ContactEdge;
+    __destroy__(): void;
+    protected ptr: number;
+    other: b2Body;
+    get_other(): b2Body;
+    set_other(other: b2Body): void;
+    contact: b2Contact;
+    get_contact(): b2Contact;
+    set_contact(contact: b2Contact): void;
+    prev: b2ContactEdge;
+    get_prev(): b2ContactEdge;
+    set_prev(prev: b2ContactEdge): void;
+    next: b2ContactEdge;
+    get_next(): b2ContactEdge;
+    set_next(next: b2ContactEdge): void;
+  }
+  export namespace b2ContactFeature {
+    const e_vertex: number;
+    const e_face: number;
+  }
+  export class b2ContactFeature extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ContactFeature;
+    };
+    protected readonly __class__: typeof b2ContactFeature;
+    __destroy__(): void;
+    indexA: number;
+    get_indexA(): number;
+    set_indexA(indexA: number): void;
+    indexB: number;
+    get_indexB(): number;
+    set_indexB(indexB: number): void;
+    typeA: number;
+    get_typeA(): number;
+    set_typeA(typeA: number): void;
+    typeB: number;
+    get_typeB(): number;
+    set_typeB(typeB: number): void;
+  }
+  export class b2ContactFilter extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ContactFilter;
+    };
+    protected readonly __class__: typeof b2ContactFilter;
+    __destroy__(): void;
+  }
+  export class JSContactFilter extends b2ContactFilter {
+    protected static readonly __cache__: {
+      [ptr: number]: JSContactFilter;
+    };
+    protected readonly __class__: typeof JSContactFilter;
+    __destroy__(): void;
+    protected ptr: number;
+    ShouldCollide(
+      fixtureA: b2Fixture | number,
+      fixtureB: b2Fixture | number
+    ): boolean;
+  }
+  export class b2ContactID extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ContactID;
+    };
+    protected readonly __class__: typeof b2ContactID;
+    __destroy__(): void;
+    cf: b2ContactFeature;
+    get_cf(): b2ContactFeature;
+    set_cf(cf: b2ContactFeature): void;
+    key: number;
+    get_key(): number;
+    set_key(key: number): void;
+  }
+  export class b2ContactImpulse extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ContactImpulse;
+    };
+    protected readonly __class__: typeof b2ContactImpulse;
+    __destroy__(): void;
+    normalImpulses: number;
+    get_normalImpulses(index?: number): number;
+    set_normalImpulses(index: number, normalImpulses_elem: number): void;
+    tangentImpulses: number;
+    get_tangentImpulses(index?: number): number;
+    set_tangentImpulses(index: number, tangentImpulses_elem: number): void;
+    count: number;
+    get_count(): number;
+    set_count(count: number): void;
+  }
+  export class b2DestructionListener extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2DestructionListener;
+    };
+    protected readonly __class__: typeof b2DestructionListener;
+    __destroy__(): void;
+  }
+  export class b2DestructionListenerWrapper extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2DestructionListenerWrapper;
+    };
+    protected readonly __class__: typeof b2DestructionListenerWrapper;
+    __destroy__(): void;
+  }
+  export class JSDestructionListener extends b2DestructionListenerWrapper {
+    protected static readonly __cache__: {
+      [ptr: number]: JSDestructionListener;
+    };
+    protected readonly __class__: typeof JSDestructionListener;
+    __destroy__(): void;
+    protected ptr: number;
+    SayGoodbyeJoint(joint: b2Joint | number): void;
+    SayGoodbyeFixture(joint: b2Fixture | number): void;
+  }
+  export class b2DistanceJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2DistanceJoint;
+    };
+    protected readonly __class__: typeof b2DistanceJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    GetLength(): number;
+    SetLength(length: number): void;
+    GetFrequency(): number;
+    SetFrequency(frequency: number): void;
+    GetDampingRatio(): number;
+    SetDampingRatio(dampingRatio: number): void;
+  }
+  export class b2DistanceJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2DistanceJointDef;
+    };
+    protected readonly __class__: typeof b2DistanceJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchorA: b2Vec2 | number,
+      anchorB: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    length: number;
+    get_length(): number;
+    set_length(length: number): void;
+    frequencyHz: number;
+    get_frequencyHz(): number;
+    set_frequencyHz(frequencyHz: number): void;
+    dampingRatio: number;
+    get_dampingRatio(): number;
+    set_dampingRatio(dampingRatio: number): void;
+  }
+  export namespace b2Draw {
+    const e_shapeBit: number;
+    const e_jointBit: number;
+    const e_aabbBit: number;
+    const e_pairBit: number;
+    const e_centerOfMassBit: number;
+  }
+  export class b2Draw extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Draw;
+    };
+    protected readonly __class__: typeof b2Draw;
+    __destroy__(): void;
+    SetFlags(flags: number): void;
+    GetFlags(): number;
+    AppendFlags(flags: number): void;
+    ClearFlags(flags: number): void;
+  }
+  export class JSDraw extends b2Draw {
+    protected static readonly __cache__: {
+      [ptr: number]: JSDraw;
+    };
+    protected readonly __class__: typeof JSDraw;
+    __destroy__(): void;
+    protected ptr: number;
+    DrawPolygon(
+      vertices: b2Vec2 | number,
+      vertexCount: number,
+      color: b2Color | number
+    ): void;
+    DrawSolidPolygon(
+      vertices: b2Vec2 | number,
+      vertexCount: number,
+      color: b2Color | number
+    ): void;
+    DrawCircle(
+      center: b2Vec2 | number,
+      radius: number,
+      color: b2Color | number
+    ): void;
+    DrawSolidCircle(
+      center: b2Vec2 | number,
+      radius: number,
+      axis: b2Vec2 | number,
+      color: b2Color | number
+    ): void;
+    DrawSegment(
+      p1: b2Vec2 | number,
+      p2: b2Vec2 | number,
+      color: b2Color | number
+    ): void;
+    DrawTransform(xf: b2Transform | number): void;
+    DrawPoint(p: b2Vec2 | number, size: number, color: b2Color | number): void;
+  }
+  export class b2FrictionJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2FrictionJoint;
+    };
+    protected readonly __class__: typeof b2FrictionJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    SetMaxForce(force: number): void;
+    GetMaxForce(): number;
+    SetMaxTorque(torque: number): void;
+    GetMaxTorque(): number;
+  }
+  export class b2FrictionJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2FrictionJointDef;
+    };
+    protected readonly __class__: typeof b2FrictionJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchor: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    maxForce: number;
+    get_maxForce(): number;
+    set_maxForce(maxForce: number): void;
+    maxTorque: number;
+    get_maxTorque(): number;
+    set_maxTorque(maxTorque: number): void;
+  }
+  export class b2GearJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2GearJoint;
+    };
+    protected readonly __class__: typeof b2GearJoint;
+    __destroy__(): void;
+    GetJoint1(): b2Joint;
+    GetJoint2(): b2Joint;
+    SetRatio(ratio: number): void;
+    GetRatio(): number;
+  }
+  export class b2GearJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2GearJointDef;
+    };
+    protected readonly __class__: typeof b2GearJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    joint1: b2Joint;
+    get_joint1(): b2Joint;
+    set_joint1(joint1: b2Joint): void;
+    joint2: b2Joint;
+    get_joint2(): b2Joint;
+    set_joint2(joint2: b2Joint): void;
+    ratio: number;
+    get_ratio(): number;
+    set_ratio(ratio: number): void;
+  }
+  export class b2JointEdge extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2JointEdge;
+    };
+    protected readonly __class__: typeof b2JointEdge;
+    __destroy__(): void;
+    protected ptr: number;
+    other: b2Body;
+    get_other(): b2Body;
+    set_other(other: b2Body): void;
+    joint: b2Joint;
+    get_joint(): b2Joint;
+    set_joint(joint: b2Joint): void;
+    prev: b2JointEdge;
+    get_prev(): b2JointEdge;
+    set_prev(prev: b2JointEdge): void;
+    next: b2JointEdge;
+    get_next(): b2JointEdge;
+    set_next(next: b2JointEdge): void;
+  }
+  export namespace b2Manifold {
+    const e_circles: number;
+    const e_faceA: number;
+    const e_faceB: number;
+  }
+  export class b2Manifold extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Manifold;
+    };
+    protected readonly __class__: typeof b2Manifold;
+    __destroy__(): void;
+    protected ptr: number;
+    points: b2ManifoldPoint;
+    get_points(index?: number): b2ManifoldPoint;
+    set_points(index: number, points_elem: b2ManifoldPoint): void;
+    localNormal: b2Vec2;
+    get_localNormal(): b2Vec2;
+    set_localNormal(localNormal: b2Vec2): void;
+    localPoint: b2Vec2;
+    get_localPoint(): b2Vec2;
+    set_localPoint(localPoint: b2Vec2): void;
+    type: number;
+    get_type(): number;
+    set_type(type: number): void;
+    pointCount: number;
+    get_pointCount(): number;
+    set_pointCount(pointCount: number): void;
+  }
+  export class b2WorldManifold extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2WorldManifold;
+    };
+    protected readonly __class__: typeof b2WorldManifold;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      manifold: b2Manifold | number,
+      xfA: b2Transform | number,
+      radiusA: number,
+      xfB: b2Transform | number,
+      radiusB: number
+    ): void;
+    normal: b2Vec2;
+    get_normal(): b2Vec2;
+    set_normal(normal: b2Vec2): void;
+    points: b2Vec2;
+    get_points(index?: number): b2Vec2;
+    set_points(index: number, points_elem: b2Vec2): void;
+    separations: number;
+    get_separations(index?: number): number;
+    set_separations(index: number, separations_elem: number): void;
+  }
+  export class b2ManifoldPoint extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ManifoldPoint;
+    };
+    protected readonly __class__: typeof b2ManifoldPoint;
+    __destroy__(): void;
+    protected ptr: number;
+    localPoint: b2Vec2;
+    get_localPoint(): b2Vec2;
+    set_localPoint(localPoint: b2Vec2): void;
+    normalImpulse: number;
+    get_normalImpulse(): number;
+    set_normalImpulse(normalImpulse: number): void;
+    tangentImpulse: number;
+    get_tangentImpulse(): number;
+    set_tangentImpulse(tangentImpulse: number): void;
+    id: b2ContactID;
+    get_id(): b2ContactID;
+    set_id(id: b2ContactID): void;
+  }
+  export class b2Mat22 extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Mat22;
+    };
+    protected readonly __class__: typeof b2Mat22;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(c1: b2Vec2 | number, c2: b2Vec2 | number);
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(a11: number, a12: number, a21: number, a22: number);
+    Set(c1: b2Vec2 | number, c2: b2Vec2 | number): void;
+    SetIdentity(): void;
+    SetZero(): void;
+    GetInverse(): b2Mat22;
+    Solve(b: b2Vec2 | number): b2Vec2;
+    ex: b2Vec2;
+    get_ex(): b2Vec2;
+    set_ex(ex: b2Vec2): void;
+    ey: b2Vec2;
+    get_ey(): b2Vec2;
+    set_ey(ey: b2Vec2): void;
+  }
+  export class b2Mat33 extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Mat33;
+    };
+    protected readonly __class__: typeof b2Mat33;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(c1: b2Vec3 | number, c2: b2Vec3 | number, c3: b2Vec3 | number);
+    SetZero(): void;
+    Solve33(b: b2Vec3 | number): b2Vec3;
+    Solve22(b: b2Vec2 | number): b2Vec2;
+    GetInverse22(M: b2Mat33 | number): void;
+    GetSymInverse33(M: b2Mat33 | number): void;
+    ex: b2Vec3;
+    get_ex(): b2Vec3;
+    set_ex(ex: b2Vec3): void;
+    ey: b2Vec3;
+    get_ey(): b2Vec3;
+    set_ey(ey: b2Vec3): void;
+    ez: b2Vec3;
+    get_ez(): b2Vec3;
+    set_ez(ez: b2Vec3): void;
+  }
+  export class b2MouseJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2MouseJoint;
+    };
+    protected readonly __class__: typeof b2MouseJoint;
+    __destroy__(): void;
+    SetTarget(target: b2Vec2 | number): void;
+    GetTarget(): b2Vec2;
+    SetMaxForce(force: number): void;
+    GetMaxForce(): number;
+    GetFrequency(): number;
+    SetFrequency(frequency: number): void;
+    GetDampingRatio(): number;
+    SetDampingRatio(dampingRatio: number): void;
+  }
+  export class b2MouseJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2MouseJointDef;
+    };
+    protected readonly __class__: typeof b2MouseJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    target: b2Vec2;
+    get_target(): b2Vec2;
+    set_target(target: b2Vec2): void;
+    maxForce: number;
+    get_maxForce(): number;
+    set_maxForce(maxForce: number): void;
+    frequencyHz: number;
+    get_frequencyHz(): number;
+    set_frequencyHz(frequencyHz: number): void;
+    dampingRatio: number;
+    get_dampingRatio(): number;
+    set_dampingRatio(dampingRatio: number): void;
+  }
+  export class b2PolygonShape extends b2Shape {
+    protected static readonly __cache__: {
+      [ptr: number]: b2PolygonShape;
+    };
+    protected readonly __class__: typeof b2PolygonShape;
+    __destroy__(): void;
+    protected ptr: number;
+    Set(vertices: b2Vec2 | number, vertexCount: number): void;
+    SetAsBox(hx: number, hy: number): void;
+    SetAsBox(
+      hx: number,
+      hy: number,
+      center: b2Vec2 | number,
+      angle: number
+    ): void;
+    m_centroid: b2Vec2;
+    get_m_centroid(): b2Vec2;
+    set_m_centroid(m_centroid: b2Vec2): void;
+    m_vertices: b2Vec2;
+    get_m_vertices(index?: number): b2Vec2;
+    set_m_vertices(index: number, m_vertices_elem: b2Vec2): void;
+    m_normals: b2Vec2;
+    get_m_normals(index?: number): b2Vec2;
+    set_m_normals(index: number, m_normals_elem: b2Vec2): void;
+    m_count: number;
+    get_m_count(): number;
+    set_m_count(m_count: number): void;
+  }
+  export class b2PrismaticJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2PrismaticJoint;
+    };
+    protected readonly __class__: typeof b2PrismaticJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    GetLocalAxisA(): b2Vec2;
+    GetReferenceAngle(): number;
+    GetJointTranslation(): number;
+    GetJointSpeed(): number;
+    IsLimitEnabled(): boolean;
+    EnableLimit(flag: boolean): void;
+    GetLowerLimit(): number;
+    GetUpperLimit(): number;
+    SetLimits(lower: number, upper: number): void;
+    IsMotorEnabled(): boolean;
+    EnableMotor(flag: boolean): void;
+    SetMotorSpeed(speed: number): void;
+    GetMotorSpeed(): number;
+    SetMaxMotorForce(force: number): void;
+    GetMaxMotorForce(): number;
+    GetMotorForce(inv_dt: number): number;
+  }
+  export class b2PrismaticJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2PrismaticJointDef;
+    };
+    protected readonly __class__: typeof b2PrismaticJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchor: b2Vec2 | number,
+      axis: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    localAxisA: b2Vec2;
+    get_localAxisA(): b2Vec2;
+    set_localAxisA(localAxisA: b2Vec2): void;
+    referenceAngle: number;
+    get_referenceAngle(): number;
+    set_referenceAngle(referenceAngle: number): void;
+    enableLimit: boolean;
+    get_enableLimit(): boolean;
+    set_enableLimit(enableLimit: boolean): void;
+    lowerTranslation: number;
+    get_lowerTranslation(): number;
+    set_lowerTranslation(lowerTranslation: number): void;
+    upperTranslation: number;
+    get_upperTranslation(): number;
+    set_upperTranslation(upperTranslation: number): void;
+    enableMotor: boolean;
+    get_enableMotor(): boolean;
+    set_enableMotor(enableMotor: boolean): void;
+    maxMotorForce: number;
+    get_maxMotorForce(): number;
+    set_maxMotorForce(maxMotorForce: number): void;
+    motorSpeed: number;
+    get_motorSpeed(): number;
+    set_motorSpeed(motorSpeed: number): void;
+  }
+  export class b2Profile extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Profile;
+    };
+    protected readonly __class__: typeof b2Profile;
+    __destroy__(): void;
+    step: number;
+    get_step(): number;
+    set_step(step: number): void;
+    collide: number;
+    get_collide(): number;
+    set_collide(collide: number): void;
+    solve: number;
+    get_solve(): number;
+    set_solve(solve: number): void;
+    solveInit: number;
+    get_solveInit(): number;
+    set_solveInit(solveInit: number): void;
+    solveVelocity: number;
+    get_solveVelocity(): number;
+    set_solveVelocity(solveVelocity: number): void;
+    solvePosition: number;
+    get_solvePosition(): number;
+    set_solvePosition(solvePosition: number): void;
+    broadphase: number;
+    get_broadphase(): number;
+    set_broadphase(broadphase: number): void;
+    solveTOI: number;
+    get_solveTOI(): number;
+    set_solveTOI(solveTOI: number): void;
+  }
+  export class b2PulleyJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2PulleyJoint;
+    };
+    protected readonly __class__: typeof b2PulleyJoint;
+    __destroy__(): void;
+    GetGroundAnchorA(): b2Vec2;
+    GetGroundAnchorB(): b2Vec2;
+    GetLengthA(): number;
+    GetLengthB(): number;
+    GetRatio(): number;
+    GetCurrentLengthA(): number;
+    GetCurrentLengthB(): number;
+  }
+  export class b2PulleyJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2PulleyJointDef;
+    };
+    protected readonly __class__: typeof b2PulleyJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      groundAnchorA: b2Vec2 | number,
+      groundAnchorB: b2Vec2 | number,
+      anchorA: b2Vec2 | number,
+      anchorB: b2Vec2 | number,
+      ratio: number
+    ): void;
+    groundAnchorA: b2Vec2;
+    get_groundAnchorA(): b2Vec2;
+    set_groundAnchorA(groundAnchorA: b2Vec2): void;
+    groundAnchorB: b2Vec2;
+    get_groundAnchorB(): b2Vec2;
+    set_groundAnchorB(groundAnchorB: b2Vec2): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    lengthA: number;
+    get_lengthA(): number;
+    set_lengthA(lengthA: number): void;
+    lengthB: number;
+    get_lengthB(): number;
+    set_lengthB(lengthB: number): void;
+    ratio: number;
+    get_ratio(): number;
+    set_ratio(ratio: number): void;
+  }
+  export class b2RayCastInput extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RayCastInput;
+    };
+    protected readonly __class__: typeof b2RayCastInput;
+    __destroy__(): void;
+    p1: b2Vec2;
+    get_p1(): b2Vec2;
+    set_p1(p1: b2Vec2): void;
+    p2: b2Vec2;
+    get_p2(): b2Vec2;
+    set_p2(p2: b2Vec2): void;
+    maxFraction: number;
+    get_maxFraction(): number;
+    set_maxFraction(maxFraction: number): void;
+  }
+  export class b2RayCastOutput extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RayCastOutput;
+    };
+    protected readonly __class__: typeof b2RayCastOutput;
+    __destroy__(): void;
+    normal: b2Vec2;
+    get_normal(): b2Vec2;
+    set_normal(normal: b2Vec2): void;
+    fraction: number;
+    get_fraction(): number;
+    set_fraction(fraction: number): void;
+  }
+  export class b2RevoluteJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RevoluteJoint;
+    };
+    protected readonly __class__: typeof b2RevoluteJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    GetReferenceAngle(): number;
+    GetJointAngle(): number;
+    GetJointSpeed(): number;
+    IsLimitEnabled(): boolean;
+    EnableLimit(flag: boolean): void;
+    GetLowerLimit(): number;
+    GetUpperLimit(): number;
+    SetLimits(lower: number, upper: number): void;
+    IsMotorEnabled(): boolean;
+    EnableMotor(flag: boolean): void;
+    SetMotorSpeed(speed: number): void;
+    GetMotorSpeed(): number;
+    SetMaxMotorTorque(torque: number): void;
+    GetMaxMotorTorque(): number;
+    GetMotorTorque(inv_dt: number): number;
+  }
+  export class b2RevoluteJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RevoluteJointDef;
+    };
+    protected readonly __class__: typeof b2RevoluteJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchor: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    referenceAngle: number;
+    get_referenceAngle(): number;
+    set_referenceAngle(referenceAngle: number): void;
+    enableLimit: boolean;
+    get_enableLimit(): boolean;
+    set_enableLimit(enableLimit: boolean): void;
+    lowerAngle: number;
+    get_lowerAngle(): number;
+    set_lowerAngle(lowerAngle: number): void;
+    upperAngle: number;
+    get_upperAngle(): number;
+    set_upperAngle(upperAngle: number): void;
+    enableMotor: boolean;
+    get_enableMotor(): boolean;
+    set_enableMotor(enableMotor: boolean): void;
+    motorSpeed: number;
+    get_motorSpeed(): number;
+    set_motorSpeed(motorSpeed: number): void;
+    maxMotorTorque: number;
+    get_maxMotorTorque(): number;
+    set_maxMotorTorque(maxMotorTorque: number): void;
+  }
+  export class b2Rot extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Rot;
+    };
+    protected readonly __class__: typeof b2Rot;
+    __destroy__(): void;
+    protected ptr: number;
+    /**
+     * @deprecated no-arg construction is forbidden (throws errors).
+     * it's exposed in the types solely so that this class can be structurally-compatible with {@link WrapperObject}.
+     * @throws {string}
+     */
+    constructor();
+    constructor(angle: number);
+    Set(angle: number): void;
+    SetIdentity(): void;
+    GetAngle(): number;
+    GetXAxis(): b2Vec2;
+    GetYAxis(): b2Vec2;
+    s: number;
+    get_s(): number;
+    set_s(s: number): void;
+    c: number;
+    get_c(): number;
+    set_c(c: number): void;
+  }
+  export class b2WheelJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2WheelJoint;
+    };
+    protected readonly __class__: typeof b2WheelJoint;
+    __destroy__(): void;
+    GetLocalAnchorA(): b2Vec2;
+    GetLocalAnchorB(): b2Vec2;
+    GetLocalAxisA(): b2Vec2;
+    GetJointTranslation(): number;
+    GetJointSpeed(): number;
+    IsMotorEnabled(): boolean;
+    EnableMotor(flag: boolean): void;
+    SetMotorSpeed(speed: number): void;
+    GetMotorSpeed(): number;
+    SetMaxMotorTorque(torque: number): void;
+    GetMaxMotorTorque(): number;
+    GetMotorTorque(inv_dt: number): number;
+    GetSpringFrequencyHz(): number;
+    SetSpringFrequencyHz(frequency: number): void;
+    GetSpringDampingRatio(): number;
+    SetSpringDampingRatio(dampingRatio: number): void;
+  }
+  export class b2WheelJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2WheelJointDef;
+    };
+    protected readonly __class__: typeof b2WheelJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(
+      bodyA: b2Body | number,
+      bodyB: b2Body | number,
+      anchor: b2Vec2 | number,
+      axis: b2Vec2 | number
+    ): void;
+    localAnchorA: b2Vec2;
+    get_localAnchorA(): b2Vec2;
+    set_localAnchorA(localAnchorA: b2Vec2): void;
+    localAnchorB: b2Vec2;
+    get_localAnchorB(): b2Vec2;
+    set_localAnchorB(localAnchorB: b2Vec2): void;
+    localAxisA: b2Vec2;
+    get_localAxisA(): b2Vec2;
+    set_localAxisA(localAxisA: b2Vec2): void;
+    enableMotor: boolean;
+    get_enableMotor(): boolean;
+    set_enableMotor(enableMotor: boolean): void;
+    maxMotorTorque: number;
+    get_maxMotorTorque(): number;
+    set_maxMotorTorque(maxMotorTorque: number): void;
+    motorSpeed: number;
+    get_motorSpeed(): number;
+    set_motorSpeed(motorSpeed: number): void;
+    frequencyHz: number;
+    get_frequencyHz(): number;
+    set_frequencyHz(frequencyHz: number): void;
+    dampingRatio: number;
+    get_dampingRatio(): number;
+    set_dampingRatio(dampingRatio: number): void;
+  }
+  export class b2MotorJoint extends b2Joint {
+    protected static readonly __cache__: {
+      [ptr: number]: b2MotorJoint;
+    };
+    protected readonly __class__: typeof b2MotorJoint;
+    __destroy__(): void;
+    SetLinearOffset(linearOffset: b2Vec2 | number): void;
+    GetLinearOffset(): b2Vec2;
+    SetAngularOffset(angularOffset: number): void;
+    GetAngularOffset(): number;
+    SetMaxForce(force: number): void;
+    GetMaxForce(): number;
+    SetMaxTorque(torque: number): void;
+    GetMaxTorque(): number;
+    SetCorrectionFactor(factor: number): void;
+    GetCorrectionFactor(): number;
+  }
+  export class b2MotorJointDef extends b2JointDef {
+    protected static readonly __cache__: {
+      [ptr: number]: b2MotorJointDef;
+    };
+    protected readonly __class__: typeof b2MotorJointDef;
+    __destroy__(): void;
+    protected ptr: number;
+    Initialize(bodyA: b2Body | number, bodyB: b2Body | number): void;
+    linearOffset: b2Vec2;
+    get_linearOffset(): b2Vec2;
+    set_linearOffset(linearOffset: b2Vec2): void;
+    angularOffset: number;
+    get_angularOffset(): number;
+    set_angularOffset(angularOffset: number): void;
+    maxForce: number;
+    get_maxForce(): number;
+    set_maxForce(maxForce: number): void;
+    maxTorque: number;
+    get_maxTorque(): number;
+    set_maxTorque(maxTorque: number): void;
+    correctionFactor: number;
+    get_correctionFactor(): number;
+    set_correctionFactor(correctionFactor: number): void;
+  }
+  const b2_nullState: number;
+  const b2_addState: number;
+  const b2_persistState: number;
+  const b2_removeState: number;
+  const b2_pbdStretchingModel: number;
+  const b2_xpbdStretchingModel: number;
+  const b2_springAngleBendingModel: number;
+  const b2_pbdAngleBendingModel: number;
+  const b2_xpbdAngleBendingModel: number;
+  const b2_pbdDistanceBendingModel: number;
+  const b2_pbdHeightBendingModel: number;
+  export class b2RopeTuning extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RopeTuning;
+    };
+    protected readonly __class__: typeof b2RopeTuning;
+    __destroy__(): void;
+    protected ptr: number;
+    stretchingModel: number;
+    get_stretchingModel(): number;
+    set_stretchingModel(stretchingModel: number): void;
+    bendingModel: number;
+    get_bendingModel(): number;
+    set_bendingModel(bendingModel: number): void;
+    damping: number;
+    get_damping(): number;
+    set_damping(damping: number): void;
+    stretchStiffness: number;
+    get_stretchStiffness(): number;
+    set_stretchStiffness(stretchStiffness: number): void;
+    stretchHertz: number;
+    get_stretchHertz(): number;
+    set_stretchHertz(stretchHertz: number): void;
+    stretchDamping: number;
+    get_stretchDamping(): number;
+    set_stretchDamping(stretchDamping: number): void;
+    bendStiffness: number;
+    get_bendStiffness(): number;
+    set_bendStiffness(bendStiffness: number): void;
+    bendHertz: number;
+    get_bendHertz(): number;
+    set_bendHertz(bendHertz: number): void;
+    bendDamping: number;
+    get_bendDamping(): number;
+    set_bendDamping(bendDamping: number): void;
+    isometric: boolean;
+    get_isometric(): boolean;
+    set_isometric(isometric: boolean): void;
+    fixedEffectiveMass: boolean;
+    get_fixedEffectiveMass(): boolean;
+    set_fixedEffectiveMass(fixedEffectiveMass: boolean): void;
+    warmStart: boolean;
+    get_warmStart(): boolean;
+    set_warmStart(warmStart: boolean): void;
+  }
+  export class b2RopeDef extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2RopeDef;
+    };
+    protected readonly __class__: typeof b2RopeDef;
+    __destroy__(): void;
+    protected ptr: number;
+    position: b2Vec2;
+    get_position(): b2Vec2;
+    set_position(position: b2Vec2): void;
+    vertices: b2Vec2;
+    get_vertices(): b2Vec2;
+    set_vertices(vertices: b2Vec2): void;
+    count: number;
+    get_count(): number;
+    set_count(count: number): void;
+    gravity: b2Vec2;
+    get_gravity(): b2Vec2;
+    set_gravity(gravity: b2Vec2): void;
+    tuning: b2RopeTuning;
+    get_tuning(): b2RopeTuning;
+    set_tuning(tuning: b2RopeTuning): void;
+  }
+  export class b2Rope extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2Rope;
+    };
+    protected readonly __class__: typeof b2Rope;
+    __destroy__(): void;
+    protected ptr: number;
+    Create(def: b2RopeDef | number): void;
+    SetTuning(tuning: b2RopeTuning | number): void;
+    Step(timeStep: number, iterations: number, position: b2Vec2 | number): void;
+    Reset(position: b2Vec2 | number): void;
+    Draw(draw: b2Draw | number): void;
+  }
+  export class b2ClipVertex extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: b2ClipVertex;
+    };
+    protected readonly __class__: typeof b2ClipVertex;
+    __destroy__(): void;
+    protected ptr: number;
+    v: b2Vec2;
+    get_v(): b2Vec2;
+    set_v(v: b2Vec2): void;
+    id: b2ContactID;
+    get_id(): b2ContactID;
+    set_id(id: b2ContactID): void;
+  }
+  export class WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: WrapperObject;
+    };
+    protected readonly __class__: typeof WrapperObject;
+    protected ptr?: number;
+  }
+  export class VoidPtr extends WrapperObject {
+    protected static readonly __cache__: {
+      [ptr: number]: VoidPtr;
+    };
+    protected readonly __class__: typeof VoidPtr;
+    protected ptr?: number;
+  }
+  export const wrapPointer: <TargetClass extends typeof WrapperObject & {
+    new (...args: any[]): InstanceType<TargetClass>;
+  } = typeof WrapperObject>(
+    pointer: number,
+    targetType?: TargetClass
+  ) => InstanceType<TargetClass>;
+  export const getPointer: (instance: WrapperObject) => number;
+  export const castObject: <TargetClass extends typeof WrapperObject & {
+    new (...args: any[]): InstanceType<TargetClass>;
+  } = typeof WrapperObject>(
+    instance: WrapperObject,
+    targetType?: TargetClass
+  ) => InstanceType<TargetClass>;
+  export const compare: (
+    instance: WrapperObject,
+    instance2: WrapperObject
+  ) => boolean;
+  export const getCache: <Class extends typeof WrapperObject = typeof WrapperObject>(
+    type?: Class
+  ) => {
+    [ptr: number]: InstanceType<Class>;
+  };
+  export const destroy: (instance: { __destroy__(): void }) => void;
+  export const getClass: <Class extends typeof WrapperObject>(
+    instance: InstanceType<Class>
+  ) => Class;
+  export const NULL: WrapperObject;
+}