planck-v2 2.0.0

package/dist/planck.d.ts

@@ -0,0 +1,4343 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/** 2D vector */
+export interface Vec2Value {
+	x: number;
+	y: number;
+}
+/**
+ * 2D vector
+ *
+ * @deprecated Use Vec2Value and geo functions instead.
+ */
+export declare class Vec2 {
+	x: number;
+	y: number;
+	constructor(x: number, y: number);
+	constructor(obj: Vec2Value);
+	constructor();
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any): Vec2;
+	static zero(): Vec2;
+	/** @hidden */
+	static neo(x: number, y: number): Vec2;
+	static clone(v: Vec2Value): Vec2;
+	/** @hidden */
+	toString(): string;
+	/**
+	 * Does this vector contain finite coordinates?
+	 */
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	clone(): Vec2;
+	/**
+	 * Set this vector to all zeros.
+	 *
+	 * @returns this
+	 */
+	setZero(): Vec2;
+	set(x: number, y: number): Vec2;
+	set(value: Vec2Value): Vec2;
+	/**
+	 * Set this vector to some specified coordinates.
+	 *
+	 * @returns this
+	 */
+	setNum(x: number, y: number): this;
+	/**
+	 * Set this vector to some specified coordinates.
+	 *
+	 * @returns this
+	 */
+	setVec2(value: Vec2Value): this;
+	/**
+	 * Set linear combination of v and w: `a * v + b * w`
+	 */
+	setCombine(a: number, v: Vec2Value, b: number, w: Vec2Value): Vec2;
+	setMul(a: number, v: Vec2Value): Vec2;
+	/**
+	 * Add a vector to this vector.
+	 *
+	 * @returns this
+	 */
+	add(w: Vec2Value): Vec2;
+	/**
+	 * Add linear combination of v and w: `a * v + b * w`
+	 */
+	addCombine(a: number, v: Vec2Value, b: number, w: Vec2Value): Vec2;
+	addMul(a: number, v: Vec2Value): Vec2;
+	/**
+	 * @deprecated Use subCombine or subMul
+	 */
+	wSub(a: number, v: Vec2Value, b?: number, w?: Vec2Value): Vec2;
+	/**
+	 * Subtract linear combination of v and w: `a * v + b * w`
+	 */
+	subCombine(a: number, v: Vec2Value, b: number, w: Vec2Value): Vec2;
+	subMul(a: number, v: Vec2Value): Vec2;
+	/**
+	 * Subtract a vector from this vector
+	 *
+	 * @returns this
+	 */
+	sub(w: Vec2Value): Vec2;
+	/**
+	 * Multiply this vector by a scalar.
+	 *
+	 * @returns this
+	 */
+	mul(m: number): Vec2;
+	/**
+	 * Get the length of this vector (the norm).
+	 *
+	 * For performance, use this instead of lengthSquared (if possible).
+	 */
+	length(): number;
+	/**
+	 * Get the length squared.
+	 */
+	lengthSquared(): number;
+	/**
+	 * Convert this vector into a unit vector.
+	 *
+	 * @returns old length
+	 */
+	normalize(): number;
+	/**
+	 * Returns a new unit vector from the provided vector.
+	 *
+	 * @returns new unit vector
+	 */
+	static normalize(v: Vec2Value): Vec2;
+	/**
+	 * Get the length of this vector (the norm).
+	 *
+	 * For performance, use this instead of lengthSquared (if possible).
+	 */
+	static lengthOf(v: Vec2Value): number;
+	/**
+	 * Get the length squared.
+	 */
+	static lengthSquared(v: Vec2Value): number;
+	static distance(v: Vec2Value, w: Vec2Value): number;
+	static distanceSquared(v: Vec2Value, w: Vec2Value): number;
+	static areEqual(v: Vec2Value, w: Vec2Value): boolean;
+	/**
+	 * Get the skew vector such that dot(skew_vec, other) == cross(vec, other)
+	 */
+	static skew(v: Vec2Value): Vec2;
+	/** Dot product on two vectors */
+	static dot(v: Vec2Value, w: Vec2Value): number;
+	/** Cross product between two vectors */
+	static cross(v: Vec2Value, w: Vec2Value): number;
+	/** Cross product between a vector and a scalar */
+	static cross(v: Vec2Value, w: number): Vec2;
+	/** Cross product between a scalar and a vector */
+	static cross(v: number, w: Vec2Value): Vec2;
+	/** Cross product on two vectors */
+	static crossVec2Vec2(v: Vec2Value, w: Vec2Value): number;
+	/** Cross product on a vector and a scalar */
+	static crossVec2Num(v: Vec2Value, w: number): Vec2;
+	/** Cross product on a vector and a scalar */
+	static crossNumVec2(v: number, w: Vec2Value): Vec2;
+	/** Returns `a + (v x w)` */
+	static addCross(a: Vec2Value, v: Vec2Value, w: number): Vec2;
+	/** Returns `a + (v x w)` */
+	static addCross(a: Vec2Value, v: number, w: Vec2Value): Vec2;
+	/**
+	 * Returns `a + (v x w)`
+	 */
+	static addCrossVec2Num(a: Vec2Value, v: Vec2Value, w: number): Vec2;
+	/**
+	 * Returns `a + (v x w)`
+	 */
+	static addCrossNumVec2(a: Vec2Value, v: number, w: Vec2Value): Vec2;
+	static add(v: Vec2Value, w: Vec2Value): Vec2;
+	/** @hidden @deprecated */
+	static wAdd(a: number, v: Vec2Value, b: number, w: Vec2Value): Vec2;
+	static combine(a: number, v: Vec2Value, b: number, w: Vec2Value): Vec2;
+	static sub(v: Vec2Value, w: Vec2Value): Vec2;
+	static mul(a: Vec2Value, b: number): Vec2;
+	static mul(a: number, b: Vec2Value): Vec2;
+	static mulVec2Num(a: Vec2Value, b: number): Vec2;
+	static mulNumVec2(a: number, b: Vec2Value): Vec2;
+	neg(): Vec2;
+	static neg(v: Vec2Value): Vec2;
+	static abs(v: Vec2Value): Vec2;
+	static mid(v: Vec2Value, w: Vec2Value): Vec2;
+	static upper(v: Vec2Value, w: Vec2Value): Vec2;
+	static lower(v: Vec2Value, w: Vec2Value): Vec2;
+	clamp(max: number): Vec2;
+	static clamp(v: Vec2Value, max: number): Vec2;
+	/** @hidden */
+	static clampVec2(v: Vec2Value, min?: Vec2Value, max?: Vec2Value): Vec2Value;
+	/**  @hidden @deprecated */
+	static scaleFn(x: number, y: number): (v: Vec2Value) => Vec2;
+	/**  @hidden @deprecated */
+	static translateFn(x: number, y: number): (v: Vec2Value) => Vec2;
+}
+/**
+ * Rotation
+ */
+export interface RotValue {
+	/** sin(angle) */
+	s: number;
+	/** cos(angle) */
+	c: number;
+}
+/**
+ * Rotation
+ *
+ * @deprecated Use RotValue and geo functions instead.
+ * */
+export declare class Rot {
+	/** sin(angle) */
+	s: number;
+	/** cos(angle) */
+	c: number;
+	/** Initialize from an angle in radians. */
+	constructor(angle?: number | RotValue);
+	/** @hidden */
+	static neo(angle: number): Rot;
+	static clone(rot: RotValue): Rot;
+	static identity(): Rot;
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	/** Set to the identity rotation. */
+	setIdentity(): void;
+	set(angle: number | RotValue): void;
+	setRot(angle: RotValue): void;
+	/** Set using an angle in radians. */
+	setAngle(angle: number): void;
+	/** Get the angle in radians. */
+	getAngle(): number;
+	/** Get the x-axis. */
+	getXAxis(): Vec2;
+	/** Get the y-axis. */
+	getYAxis(): Vec2;
+	/** Multiply two rotations: q * r */
+	static mul(rot: RotValue, m: RotValue): Rot;
+	/** Rotate a vector */
+	static mul(rot: RotValue, m: Vec2Value): Vec2;
+	/** Multiply two rotations: q * r */
+	static mulRot(rot: RotValue, m: RotValue): Rot;
+	/** Rotate a vector */
+	static mulVec2(rot: RotValue, m: Vec2Value): Vec2;
+	static mulSub(rot: RotValue, v: Vec2Value, w: Vec2Value): Vec2;
+	/** Transpose multiply two rotations: qT * r */
+	static mulT(rot: RotValue, m: RotValue): Rot;
+	/** Inverse rotate a vector */
+	static mulT(rot: RotValue, m: Vec2Value): Vec2;
+	/** Transpose multiply two rotations: qT * r */
+	static mulTRot(rot: RotValue, m: RotValue): Rot;
+	/** Inverse rotate a vector */
+	static mulTVec2(rot: RotValue, m: Vec2Value): Vec2;
+}
+/**
+ * A transform contains translation and rotation. It is used to represent the
+ * position and orientation of rigid frames. Initialize using a position vector
+ * and a rotation.
+ */
+export interface TransformValue {
+	p: Vec2Value;
+	q: RotValue;
+}
+/**
+ * A transform contains translation and rotation. It is used to represent the
+ * position and orientation of rigid frames. Initialize using a position vector
+ * and a rotation.
+ *
+ * @deprecated Use TransformValue and geo functions instead.
+ */
+export declare class Transform {
+	/** position */
+	p: Vec2;
+	/** rotation */
+	q: Rot;
+	constructor(position?: Vec2Value, rotation?: number);
+	static clone(xf: Transform): Transform;
+	/** @hidden */
+	static neo(position: Vec2Value, rotation: Rot): Transform;
+	static identity(): Transform;
+	/** Set this to the identity transform */
+	setIdentity(): void;
+	/** Set position and angle */
+	set(position: Vec2Value, rotation: number): void;
+	/** Copy from another transform */
+	set(xf: TransformValue): void;
+	/** Set position and angle */
+	setNum(position: Vec2Value, rotation: number): void;
+	setTransform(xf: TransformValue): void;
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	static mul(a: TransformValue, b: Vec2Value): Vec2;
+	static mul(a: TransformValue, b: TransformValue): Transform;
+	static mulAll(a: Transform, b: Vec2Value[]): Vec2[];
+	static mulAll(a: Transform, b: Transform[]): Transform[];
+	/** @hidden @deprecated */
+	static mulFn(a: TransformValue): (b: Vec2Value) => Vec2;
+	static mulVec2(a: TransformValue, b: Vec2Value): Vec2;
+	static mulXf(a: TransformValue, b: TransformValue): Transform;
+	static mulT(a: TransformValue, b: Vec2Value): Vec2;
+	static mulT(a: TransformValue, b: TransformValue): Transform;
+	static mulTVec2(a: TransformValue, b: Vec2Value): Vec2;
+	static mulTXf(a: TransformValue, b: TransformValue): Transform;
+}
+/**
+ * Ray-cast input data. The ray extends from `p1` to `p1 + maxFraction * (p2 - p1)`.
+ */
+export interface RayCastInput {
+	p1: Vec2Value;
+	p2: Vec2Value;
+	maxFraction: number;
+}
+export type RayCastCallback = (subInput: RayCastInput, id: number) => number;
+/**
+ * Ray-cast output data. The ray hits at `p1 + fraction * (p2 - p1)`,
+ * where `p1` and `p2` come from RayCastInput.
+ */
+export interface RayCastOutput {
+	normal: Vec2Value;
+	fraction: number;
+}
+/** Axis-aligned bounding box */
+export interface AABBValue {
+	lowerBound: Vec2Value;
+	upperBound: Vec2Value;
+}
+/** Axis-aligned bounding box */
+export declare class AABB {
+	lowerBound: Vec2Value;
+	upperBound: Vec2Value;
+	constructor(lower?: Vec2Value, upper?: Vec2Value);
+	/**
+	 * Verify that the bounds are sorted.
+	 */
+	isValid(): boolean;
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	/**
+	 * Get the center of the AABB.
+	 */
+	getCenter(): Vec2Value;
+	/**
+	 * Get the extents of the AABB (half-widths).
+	 */
+	getExtents(): Vec2Value;
+	/**
+	 * Get the perimeter length.
+	 */
+	getPerimeter(): number;
+	/**
+	 * Combine one or two AABB into this one.
+	 */
+	combine(a: AABBValue, b?: AABBValue): void;
+	combinePoints(a: Vec2Value, b: Vec2Value): void;
+	set(aabb: AABBValue): void;
+	contains(aabb: AABBValue): boolean;
+	extend(value: number): AABB;
+	static extend(out: AABBValue, value: number): AABBValue;
+	static testOverlap(a: AABBValue, b: AABBValue): boolean;
+	static areEqual(a: AABBValue, b: AABBValue): boolean;
+	static diff(a: AABBValue, b: AABBValue): number;
+	rayCast(output: RayCastOutput, input: RayCastInput): boolean;
+	/** @hidden */
+	toString(): string;
+	static combinePoints(out: AABBValue, a: Vec2Value, b: Vec2Value): AABBValue;
+	static combinedPerimeter(a: AABBValue, b: AABBValue): number;
+}
+/**
+ * Input for Distance. You have to option to use the shape radii in the
+ * computation. Even
+ */
+export declare class DistanceInput {
+	readonly proxyA: DistanceProxy;
+	readonly proxyB: DistanceProxy;
+	readonly transformA: TransformValue;
+	readonly transformB: TransformValue;
+	useRadii: boolean;
+	recycle(): void;
+}
+/**
+ * Output for Distance.
+ */
+export declare class DistanceOutput {
+	/** closest point on shapeA */
+	pointA: Vec2Value;
+	/** closest point on shapeB */
+	pointB: Vec2Value;
+	distance: number;
+	/** iterations number of GJK iterations used */
+	iterations: number;
+	recycle(): void;
+}
+/**
+ * Used to warm start Distance. Set count to zero on first call.
+ */
+export declare class SimplexCache {
+	/** length or area */
+	metric: number;
+	/** vertices on shape A */
+	indexA: number[];
+	/** vertices on shape B */
+	indexB: number[];
+	count: number;
+	recycle(): void;
+}
+/**
+ * Compute the closest points between two shapes. Supports any combination of:
+ * CircleShape, PolygonShape, EdgeShape. The simplex cache is input/output. On
+ * the first call set SimplexCache.count to zero.
+ */
+export declare const Distance: {
+	(output: DistanceOutput, cache: SimplexCache, input: DistanceInput): void;
+	testOverlap: (shapeA: Shape, indexA: number, shapeB: Shape, indexB: number, xfA: TransformValue, xfB: TransformValue) => boolean;
+	Input: typeof DistanceInput;
+	Output: typeof DistanceOutput;
+	Proxy: typeof DistanceProxy;
+	Cache: typeof SimplexCache;
+};
+/**
+ * A distance proxy is used by the GJK algorithm. It encapsulates any shape.
+ */
+export declare class DistanceProxy {
+	recycle(): void;
+	/**
+	 * Get the vertex count.
+	 */
+	getVertexCount(): number;
+	/**
+	 * Get a vertex by index. Used by Distance.
+	 */
+	getVertex(index: number): Vec2Value;
+	/**
+	 * Get the supporting vertex index in the given direction.
+	 */
+	getSupport(d: Vec2Value): number;
+	/**
+	 * Get the supporting vertex in the given direction.
+	 */
+	getSupportVertex(d: Vec2Value): Vec2Value;
+	/**
+	 * Initialize the proxy using the given shape. The shape must remain in scope
+	 * while the proxy is in use.
+	 */
+	set(shape: Shape, index: number): void;
+	/**
+	 * Initialize the proxy using a vertex cloud and radius. The vertices
+	 * must remain in scope while the proxy is in use.
+	 */
+	setVertices(vertices: Vec2Value[], count: number, radius: number): void;
+}
+/**
+ * Determine if two generic shapes overlap.
+ */
+export declare const testOverlap: (shapeA: Shape, indexA: number, shapeB: Shape, indexB: number, xfA: TransformValue, xfB: TransformValue) => boolean;
+/**
+ * Input parameters for ShapeCast
+ */
+export declare class ShapeCastInput {
+	readonly proxyA: DistanceProxy;
+	readonly proxyB: DistanceProxy;
+	readonly transformA: TransformValue;
+	readonly transformB: TransformValue;
+	readonly translationB: Vec2Value;
+	recycle(): void;
+}
+/**
+ * Output results for b2ShapeCast
+ */
+export declare class ShapeCastOutput {
+	point: Vec2Value;
+	normal: Vec2Value;
+	lambda: number;
+	iterations: number;
+}
+/**
+ * Perform a linear shape cast of shape B moving and shape A fixed. Determines
+ * the hit point, normal, and translation fraction.
+ *
+ * @returns true if hit, false if there is no hit or an initial overlap
+ */
+export declare const ShapeCast: (output: ShapeCastOutput, input: ShapeCastInput) => boolean;
+/**
+ * A joint edge is used to connect bodies and joints together in a joint graph
+ * where each body is a node and each joint is an edge. A joint edge belongs to
+ * a doubly linked list maintained in each attached body. Each joint has two
+ * joint nodes, one for each attached body.
+ */
+export declare class JointEdge {
+	/**
+	 * provides quick access to the other body attached.
+	 */
+	other: Body$1 | null;
+	/**
+	 * the joint
+	 */
+	joint: Joint | null;
+	/**
+	 * prev the previous joint edge in the body's joint list
+	 */
+	prev: JointEdge | null;
+	/**
+	 * the next joint edge in the body's joint list
+	 */
+	next: JointEdge | null;
+}
+/**
+ * Joint definitions are used to construct joints.
+ */
+export interface JointOpt {
+	/**
+	 * Use this to attach application specific data to your joints.
+	 */
+	userData?: any;
+	/**
+	 * Set this flag to true if the attached bodies
+	 * should collide.
+	 */
+	collideConnected?: boolean;
+	/** Styling for dev-tools. */
+	style?: Style;
+}
+/**
+ * Joint definitions are used to construct joints.
+ */
+export interface JointDef extends JointOpt {
+	/**
+	 * The first attached body.
+	 */
+	bodyA: Body$1;
+	/**
+	 * The second attached body.
+	 */
+	bodyB: Body$1;
+}
+/**
+ * The base joint class. Joints are used to constraint two bodies together in
+ * various fashions. Some joints also feature limits and motors.
+ */
+export declare abstract class Joint {
+	/** Styling for dev-tools. */
+	style: Style;
+	/** @hidden @experimental Similar to userData, but used by dev-tools or runtime environment. */
+	appData: Record<string, any>;
+	constructor(def: JointDef);
+	constructor(def: JointOpt, bodyA: Body$1, bodyB: Body$1);
+	/**
+	 * Short-cut function to determine if either body is inactive.
+	 */
+	isActive(): boolean;
+	/**
+	 * Get the type of the concrete joint.
+	 */
+	getType(): string;
+	/**
+	 * Get the first body attached to this joint.
+	 */
+	getBodyA(): Body$1;
+	/**
+	 * Get the second body attached to this joint.
+	 */
+	getBodyB(): Body$1;
+	/**
+	 * Get the next joint the world joint list.
+	 */
+	getNext(): Joint;
+	getUserData(): unknown;
+	setUserData(data: unknown): void;
+	/**
+	 * Get collide connected. Note: modifying the collide connect flag won't work
+	 * correctly because the flag is only checked when fixture AABBs begin to
+	 * overlap.
+	 */
+	getCollideConnected(): boolean;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	abstract getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	abstract getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	abstract getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	abstract getReactionTorque(inv_dt: number): number;
+	/**
+	 * Shift the origin for any points stored in world coordinates.
+	 */
+	shiftOrigin(newOrigin: Vec2Value): void;
+	abstract initVelocityConstraints(step: TimeStep): void;
+	abstract solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	abstract solvePositionConstraints(step: TimeStep): boolean;
+	/**
+	 * @hidden @experimental
+	 * Update joint with new props.
+	 */
+	abstract _reset(def: Partial<JointDef>): void;
+}
+export interface Style {
+	stroke?: string;
+	fill?: string;
+	lineWidth?: number;
+}
+export type ActiveKeys = {
+	[key in KEY]?: boolean;
+};
+export type TestbedMountOptions = {
+	[key: string]: any;
+};
+export declare class Testbed {
+	/**
+	 * Mounts testbed. Call start with a world to start simulation and rendering.
+	 */
+	static mount(options?: TestbedMountOptions): TestbedInterface;
+	/**
+	 * Mounts testbed if needed, then starts simulation and rendering.
+	 *
+	 * If you need to customize testbed before starting, first run `const testbed = Testbed.mount()` and then `testbed.start()`.
+	 */
+	static start(world: World): TestbedInterface;
+}
+export interface TestbedInterface {
+	/** World viewbox width. */
+	width: number;
+	/** World viewbox height. */
+	height: number;
+	/** World viewbox center vertical offset. */
+	x: number;
+	/** World viewbox center horizontal offset. */
+	y: number;
+	/** @hidden */
+	scaleY: number;
+	/** World simulation step frequency */
+	hz: number;
+	/** World simulation speed, default is 1 */
+	speed: number;
+	background: string;
+	mouseForce?: number;
+	activeKeys: ActiveKeys;
+	/** callback, to be implemented by user */
+	step?: (dt: number, t: number) => void;
+	/** callback, to be implemented by user */
+	keydown?: (keyCode: number, label: string) => void;
+	/** callback, to be implemented by user */
+	keyup?: (keyCode: number, label: string) => void;
+	status(name: string, value: any): void;
+	status(value: object | string): void;
+	info(text: string): void;
+	color(r: number, g: number, b: number): string;
+	drawPoint(p: Vec2Value, r: any, color: string): void;
+	drawCircle(p: Vec2Value, r: number, color: string): void;
+	drawEdge(a: Vec2Value, b: Vec2Value, color: string): void;
+	drawSegment(a: Vec2Value, b: Vec2Value, color: string): void;
+	drawPolygon(points: Array<Vec2Value>, color: string): void;
+	drawChain(points: Array<Vec2Value>, color: string): void;
+	drawAABB(aabb: AABBValue, color: string): void;
+	start(world: World): void;
+	findOne(query: string): Body$1 | Joint | Fixture | null;
+	findAll(query: string): (Body$1 | Joint | Fixture)[];
+}
+export type TestbedFactoryOptions = string | TestbedMountOptions;
+/** @deprecated */
+export type TestbedCallback = (testbed: TestbedInterface) => World | undefined;
+/** @deprecated */
+export declare function testbed(callback: TestbedCallback): void;
+/** @deprecated */
+export declare function testbed(options: TestbedFactoryOptions, callback: TestbedCallback): void;
+export type KEY = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "right" | "left" | "up" | "down" | "fire";
+/**
+ * A shape is used for collision detection. You can create a shape however you
+ * like. Shapes used for simulation in World are created automatically when a
+ * Fixture is created. Shapes may encapsulate one or more child shapes.
+ */
+export declare abstract class Shape {
+	/** @hidden */ m_type: ShapeType;
+	/**
+	 * @hidden
+	 * Radius of a shape. For polygonal shapes this must be b2_polygonRadius.
+	 * There is no support for making rounded polygons.
+	 */
+	m_radius: number;
+	/** Styling for dev-tools. */
+	style: Style;
+	/** @hidden @experimental Similar to userData, but used by dev-tools or runtime environment. */
+	appData: Record<string, any>;
+	/** @hidden */
+	abstract _reset(): void;
+	static isValid(obj: any): boolean;
+	abstract getRadius(): number;
+	/**
+	 * Get the type of this shape. You can use this to down cast to the concrete
+	 * shape.
+	 *
+	 * @return the shape type.
+	 */
+	abstract getType(): ShapeType;
+	/**
+	 * Get the number of child primitives.
+	 */
+	abstract getChildCount(): number;
+	/**
+	 * Test a point for containment in this shape. This only works for convex
+	 * shapes.
+	 *
+	 * @param xf The shape world transform.
+	 * @param p A point in world coordinates.
+	 */
+	abstract testPoint(xf: TransformValue, p: Vec2Value): boolean;
+	/**
+	 * Cast a ray against a child shape.
+	 *
+	 * @param output The ray-cast results.
+	 * @param input The ray-cast input parameters.
+	 * @param xf The transform to be applied to the shape.
+	 * @param childIndex The child shape index
+	 */
+	abstract rayCast(output: RayCastOutput, input: RayCastInput, xf: TransformValue, childIndex: number): boolean;
+	/**
+	 * Given a transform, compute the associated axis aligned bounding box for a
+	 * child shape.
+	 *
+	 * @param aabb Returns the axis aligned box.
+	 * @param xf The world transform of the shape.
+	 * @param childIndex The child shape
+	 */
+	abstract computeAABB(aabb: AABBValue, xf: TransformValue, childIndex: number): void;
+	/**
+	 * Compute the mass properties of this shape using its dimensions and density.
+	 * The inertia tensor is computed about the local origin.
+	 *
+	 * @param massData Returns the mass data for this shape.
+	 * @param density The density in kilograms per meter squared.
+	 */
+	abstract computeMass(massData: MassData, density?: number): void;
+	abstract computeDistanceProxy(proxy: DistanceProxy, childIndex: number): void;
+}
+export type ShapeType = "circle" | "edge" | "polygon" | "chain";
+export type DynamicTreeQueryCallback = (nodeId: number) => boolean;
+/**
+ * A node in the dynamic tree. The client does not interact with this directly.
+ */
+export declare class TreeNode<T> {
+	id: number;
+	/** Enlarged AABB */
+	aabb: AABB;
+	userData: T;
+	parent: TreeNode<T>;
+	child1: TreeNode<T>;
+	child2: TreeNode<T>;
+	/** 0: leaf, -1: free node */
+	height: number;
+	constructor(id?: number);
+	isLeaf(): boolean;
+}
+/**
+ * A dynamic AABB tree broad-phase, inspired by Nathanael Presson's btDbvt. A
+ * dynamic tree arranges data in a binary tree to accelerate queries such as
+ * volume queries and ray casts. Leafs are proxies with an AABB. In the tree we
+ * expand the proxy AABB by `aabbExtension` so that the proxy AABB is bigger
+ * than the client object. This allows the client object to move by small
+ * amounts without triggering a tree update.
+ *
+ * Nodes are pooled and relocatable, so we use node indices rather than
+ * pointers.
+ */
+export declare class DynamicTree<T> {
+	m_root: TreeNode<T>;
+	m_lastProxyId: number;
+	m_nodes: {
+		[id: number]: TreeNode<T>;
+	};
+	constructor();
+	/**
+	 * Get proxy user data.
+	 *
+	 * @return the proxy user data or 0 if the id is invalid.
+	 */
+	getUserData(id: number): T;
+	/**
+	 * Get the fat AABB for a node id.
+	 *
+	 * @return the proxy user data or 0 if the id is invalid.
+	 */
+	getFatAABB(id: number): AABB;
+	allocateNode(): TreeNode<T>;
+	freeNode(node: TreeNode<T>): void;
+	/**
+	 * Create a proxy in the tree as a leaf node. We return the index of the node
+	 * instead of a pointer so that we can grow the node pool.
+	 *
+	 * Create a proxy. Provide a tight fitting AABB and a userData pointer.
+	 */
+	createProxy(aabb: AABBValue, userData: T): number;
+	/**
+	 * Destroy a proxy. This asserts if the id is invalid.
+	 */
+	destroyProxy(id: number): void;
+	/**
+	 * Move a proxy with a swepted AABB. If the proxy has moved outside of its
+	 * fattened AABB, then the proxy is removed from the tree and re-inserted.
+	 * Otherwise the function returns immediately.
+	 *
+	 * @param d Displacement
+	 *
+	 * @return true if the proxy was re-inserted.
+	 */
+	moveProxy(id: number, aabb: AABBValue, d: Vec2Value): boolean;
+	insertLeaf(leaf: TreeNode<T>): void;
+	removeLeaf(leaf: TreeNode<T>): void;
+	/**
+	 * Perform a left or right rotation if node A is imbalanced. Returns the new
+	 * root index.
+	 */
+	balance(iA: TreeNode<T>): TreeNode<T>;
+	/**
+	 * Compute the height of the binary tree in O(N) time. Should not be called
+	 * often.
+	 */
+	getHeight(): number;
+	/**
+	 * Get the ratio of the sum of the node areas to the root area.
+	 */
+	getAreaRatio(): number;
+	/**
+	 * Compute the height of a sub-tree.
+	 */
+	computeHeight(id?: number): number;
+	validateStructure(node: TreeNode<T>): void;
+	validateMetrics(node: TreeNode<T>): void;
+	/**
+	 * Validate this tree. For testing.
+	 */
+	validate(): void;
+	/**
+	 * Get the maximum balance of an node in the tree. The balance is the difference
+	 * in height of the two children of a node.
+	 */
+	getMaxBalance(): number;
+	/**
+	 * Build an optimal tree. Very expensive. For testing.
+	 */
+	rebuildBottomUp(): void;
+	/**
+	 * Shift the world origin. Useful for large worlds. The shift formula is:
+	 * position -= newOrigin
+	 *
+	 * @param newOrigin The new origin with respect to the old origin
+	 */
+	shiftOrigin(newOrigin: Vec2Value): void;
+	/**
+	 * Query an AABB for overlapping proxies. The callback class is called for each
+	 * proxy that overlaps the supplied AABB.
+	 */
+	query(aabb: AABBValue, queryCallback: DynamicTreeQueryCallback): void;
+	/**
+	 * Ray-cast against the proxies in the tree. This relies on the callback to
+	 * perform a exact ray-cast in the case were the proxy contains a shape. The
+	 * callback also performs the any collision filtering. This has performance
+	 * roughly equal to k * log(n), where k is the number of collisions and n is the
+	 * number of proxies in the tree.
+	 *
+	 * @param input The ray-cast input data. The ray extends from `p1` to `p1 + maxFraction * (p2 - p1)`.
+	 * @param rayCastCallback A function that is called for each proxy that is hit by the ray. If the return value is a positive number it will update the maxFraction of the ray cast input, and if it is zero it will terminate they ray cast.
+	 */
+	rayCast(input: RayCastInput, rayCastCallback: RayCastCallback): void;
+	private inputPool;
+	private stackPool;
+	private iteratorPool;
+}
+/**
+ * The broad-phase wraps and extends a dynamic-tree to keep track of moved
+ * objects and query them on update.
+ */
+export declare class BroadPhase {
+	m_tree: DynamicTree<FixtureProxy>;
+	m_moveBuffer: number[];
+	m_callback: (userDataA: any, userDataB: any) => void;
+	m_queryProxyId: number;
+	/**
+	 * Get user data from a proxy. Returns null if the id is invalid.
+	 */
+	getUserData(proxyId: number): FixtureProxy;
+	/**
+	 * Test overlap of fat AABBs.
+	 */
+	testOverlap(proxyIdA: number, proxyIdB: number): boolean;
+	/**
+	 * Get the fat AABB for a proxy.
+	 */
+	getFatAABB(proxyId: number): AABB;
+	/**
+	 * Get the number of proxies.
+	 */
+	getProxyCount(): number;
+	/**
+	 * Get the height of the embedded tree.
+	 */
+	getTreeHeight(): number;
+	/**
+	 * Get the balance (integer) of the embedded tree.
+	 */
+	getTreeBalance(): number;
+	/**
+	 * Get the quality metric of the embedded tree.
+	 */
+	getTreeQuality(): number;
+	/**
+	 * Query an AABB for overlapping proxies. The callback class is called for each
+	 * proxy that overlaps the supplied AABB.
+	 */
+	query: (aabb: AABBValue, queryCallback: DynamicTreeQueryCallback) => void;
+	/**
+	 * Ray-cast against the proxies in the tree. This relies on the callback to
+	 * perform a exact ray-cast in the case were the proxy contains a shape. The
+	 * callback also performs the any collision filtering. This has performance
+	 * roughly equal to k * log(n), where k is the number of collisions and n is the
+	 * number of proxies in the tree.
+	 *
+	 * @param input The ray-cast input data. The ray extends from `p1` to `p1 + maxFraction * (p2 - p1)`.
+	 * @param rayCastCallback A function that is called for each proxy that is hit by the ray. If the return value is a positive number it will update the maxFraction of the ray cast input, and if it is zero it will terminate they ray cast.
+	 */
+	rayCast(input: RayCastInput, rayCastCallback: RayCastCallback): void;
+	/**
+	 * Shift the world origin. Useful for large worlds. The shift formula is:
+	 * position -= newOrigin
+	 *
+	 * @param newOrigin The new origin with respect to the old origin
+	 */
+	shiftOrigin(newOrigin: Vec2Value): void;
+	/**
+	 * Create a proxy with an initial AABB. Pairs are not reported until UpdatePairs
+	 * is called.
+	 */
+	createProxy(aabb: AABBValue, userData: FixtureProxy): number;
+	/**
+	 * Destroy a proxy. It is up to the client to remove any pairs.
+	 */
+	destroyProxy(proxyId: number): void;
+	/**
+	 * Call moveProxy as many times as you like, then when you are done call
+	 * UpdatePairs to finalized the proxy pairs (for your time step).
+	 */
+	moveProxy(proxyId: number, aabb: AABB, displacement: Vec2Value): void;
+	/**
+	 * Call to trigger a re-processing of it's pairs on the next call to
+	 * UpdatePairs.
+	 */
+	touchProxy(proxyId: number): void;
+	bufferMove(proxyId: number): void;
+	unbufferMove(proxyId: number): void;
+	/**
+	 * Update the pairs. This results in pair callbacks. This can only add pairs.
+	 */
+	updatePairs(addPairCallback: (userDataA: FixtureProxy, userDataB: FixtureProxy) => void): void;
+	queryCallback: (proxyId: number) => boolean;
+}
+/**
+ * A fixture definition is used to create a fixture. This class defines an
+ * abstract fixture definition. You can reuse fixture definitions safely.
+ */
+export interface FixtureOpt {
+	userData?: unknown;
+	/**
+	 * The friction coefficient, usually in the range [0,1]
+	 */
+	friction?: number;
+	/**
+	 * The restitution (elasticity) usually in the range [0,1]
+	 */
+	restitution?: number;
+	/**
+	 * The density, usually in kg/m^2
+	 */
+	density?: number;
+	/**
+	 * A sensor shape collects contact information but never generates a collision response.
+	 */
+	isSensor?: boolean;
+	/**
+	 * Zero, positive or negative collision group.
+	 * Fixtures with same positive groupIndex always collide and fixtures with same negative groupIndex never collide.
+	 */
+	filterGroupIndex?: number;
+	/**
+	 * Collision category bit or bits that this fixture belongs to.
+	 * If groupIndex is zero or not matching, then at least one bit in this fixture categoryBits should match other fixture maskBits and vice versa.
+	 */
+	filterCategoryBits?: number;
+	/**
+	 * Collision category bit or bits that this fixture accept for collision.
+	 */
+	filterMaskBits?: number;
+	/** Styling for dev-tools. */
+	style?: Style;
+}
+export interface FixtureDef extends FixtureOpt {
+	shape: Shape;
+}
+/**
+ * This proxy is used internally to connect shape children to the broad-phase.
+ */
+export declare class FixtureProxy {
+	aabb: AABB;
+	fixture: Fixture;
+	childIndex: number;
+	proxyId: number;
+	constructor(fixture: Fixture, childIndex: number);
+}
+/**
+ * A fixture is used to attach a shape to a body for collision detection. A
+ * fixture inherits its transform from its parent. Fixtures hold additional
+ * non-geometric data such as friction, collision filters, etc.
+ *
+ * To create a new Fixture use {@link Body.createFixture}.
+ */
+export declare class Fixture {
+	/** Styling for dev-tools. */
+	style: Style;
+	/** @hidden @experimental Similar to userData, but used by dev-tools or runtime environment. */
+	appData: Record<string, any>;
+	constructor(body: Body$1, def: FixtureDef);
+	constructor(body: Body$1, shape: Shape, def?: FixtureOpt);
+	constructor(body: Body$1, shape: Shape, density?: number);
+	/** @hidden Re-setup fixture. */
+	_reset(): void;
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, body: any, restore: any): Fixture;
+	/**
+	 * Get the type of the child shape. You can use this to down cast to the
+	 * concrete shape.
+	 */
+	getType(): ShapeType;
+	/**
+	 * Get the child shape. You can modify the child shape, however you should not
+	 * change the number of vertices because this will crash some collision caching
+	 * mechanisms. Manipulating the shape may lead to non-physical behavior.
+	 */
+	getShape(): Shape;
+	/**
+	 * A sensor shape collects contact information but never generates a collision
+	 * response.
+	 */
+	isSensor(): boolean;
+	/**
+	 * Set if this fixture is a sensor.
+	 */
+	setSensor(sensor: boolean): void;
+	/**
+	 * Get the user data that was assigned in the fixture definition. Use this to
+	 * store your application specific data.
+	 */
+	getUserData(): unknown;
+	/**
+	 * Set the user data. Use this to store your application specific data.
+	 */
+	setUserData(data: unknown): void;
+	/**
+	 * Get the parent body of this fixture. This is null if the fixture is not
+	 * attached.
+	 */
+	getBody(): Body$1;
+	/**
+	 * Get the next fixture in the parent body's fixture list.
+	 */
+	getNext(): Fixture | null;
+	/**
+	 * Get the density of this fixture.
+	 */
+	getDensity(): number;
+	/**
+	 * Set the density of this fixture. This will _not_ automatically adjust the
+	 * mass of the body. You must call Body.resetMassData to update the body's mass.
+	 */
+	setDensity(density: number): void;
+	/**
+	 * Get the coefficient of friction, usually in the range [0,1].
+	 */
+	getFriction(): number;
+	/**
+	 * Set the coefficient of friction. This will not change the friction of
+	 * existing contacts.
+	 */
+	setFriction(friction: number): void;
+	/**
+	 * Get the coefficient of restitution.
+	 */
+	getRestitution(): number;
+	/**
+	 * Set the coefficient of restitution. This will not change the restitution of
+	 * existing contacts.
+	 */
+	setRestitution(restitution: number): void;
+	/**
+	 * Test a point in world coordinates for containment in this fixture.
+	 */
+	testPoint(p: Vec2Value): boolean;
+	/**
+	 * Cast a ray against this shape.
+	 */
+	rayCast(output: RayCastOutput, input: RayCastInput, childIndex: number): boolean;
+	/**
+	 * Get the mass data for this fixture. The mass data is based on the density and
+	 * the shape. The rotational inertia is about the shape's origin. This operation
+	 * may be expensive.
+	 */
+	getMassData(massData: MassData): void;
+	/**
+	 * Get the fixture's AABB. This AABB may be enlarge and/or stale. If you need a
+	 * more accurate AABB, compute it using the shape and the body transform.
+	 */
+	getAABB(childIndex: number): AABB;
+	/**
+	 * These support body activation/deactivation.
+	 */
+	createProxies(broadPhase: BroadPhase, xf: TransformValue): void;
+	destroyProxies(broadPhase: BroadPhase): void;
+	/**
+	 * Updates this fixture proxy in broad-phase (with combined AABB of current and
+	 * next transformation).
+	 */
+	synchronize(broadPhase: BroadPhase, xf1: TransformValue, xf2: TransformValue): void;
+	/**
+	 * Set the contact filtering data. This will not update contacts until the next
+	 * time step when either parent body is active and awake. This automatically
+	 * calls refilter.
+	 */
+	setFilterData(filter: {
+		groupIndex: number;
+		categoryBits: number;
+		maskBits: number;
+	}): void;
+	getFilterGroupIndex(): number;
+	setFilterGroupIndex(groupIndex: number): void;
+	getFilterCategoryBits(): number;
+	setFilterCategoryBits(categoryBits: number): void;
+	getFilterMaskBits(): number;
+	setFilterMaskBits(maskBits: number): void;
+	/**
+	 * Call this if you want to establish collision that was previously disabled by
+	 * ContactFilter.
+	 */
+	refilter(): void;
+	/**
+	 * Implement this method to provide collision filtering, if you want finer
+	 * control over contact creation.
+	 *
+	 * Return true if contact calculations should be performed between these two
+	 * fixtures.
+	 *
+	 * Warning: for performance reasons this is only called when the AABBs begin to
+	 * overlap.
+	 */
+	shouldCollide(that: Fixture): boolean;
+}
+export declare enum ManifoldType {
+	e_unset = -1,
+	e_circles = 0,
+	e_faceA = 1,
+	e_faceB = 2
+}
+export declare enum ContactFeatureType {
+	e_unset = -1,
+	e_vertex = 0,
+	e_face = 1
+}
+/**
+ * This is used for determining the state of contact points.
+ */
+export declare enum PointState {
+	/** Point does not exist */
+	nullState = 0,
+	/** Point was added in the update */
+	addState = 1,
+	/** Point persisted across the update */
+	persistState = 2,
+	/** Point was removed in the update */
+	removeState = 3
+}
+/**
+ * Used for computing contact manifolds.
+ */
+export declare class ClipVertex {
+	v: Vec2Value;
+	id: ContactID;
+	set(o: ClipVertex): void;
+	recycle(): void;
+}
+/**
+ * A manifold for two touching convex shapes. Manifolds are created in `evaluate`
+ * method of Contact subclasses.
+ *
+ * Supported manifold types are e_faceA or e_faceB for clip point versus plane
+ * with radius and e_circles point versus point with radius.
+ *
+ * We store contacts in this way so that position correction can account for
+ * movement, which is critical for continuous physics. All contact scenarios
+ * must be expressed in one of these types. This structure is stored across time
+ * steps, so we keep it small.
+ */
+export declare class Manifold {
+	type: ManifoldType;
+	/**
+	 * Usage depends on manifold type:
+	 * - circles: not used
+	 * - faceA: the normal on polygonA
+	 * - faceB: the normal on polygonB
+	 */
+	localNormal: Vec2Value;
+	/**
+	 * Usage depends on manifold type:
+	 * - circles: the local center of circleA
+	 * - faceA: the center of faceA
+	 * - faceB: the center of faceB
+	 */
+	localPoint: Vec2Value;
+	/** The points of contact */
+	points: ManifoldPoint[];
+	/** The number of manifold points */
+	pointCount: number;
+	set(that: Manifold): void;
+	recycle(): void;
+	/**
+	 * Evaluate the manifold with supplied transforms. This assumes modest motion
+	 * from the original state. This does not change the point count, impulses, etc.
+	 * The radii must come from the shapes that generated the manifold.
+	 */
+	getWorldManifold(wm: WorldManifold | null, xfA: TransformValue, radiusA: number, xfB: TransformValue, radiusB: number): WorldManifold;
+	static clipSegmentToLine: typeof clipSegmentToLine;
+	static ClipVertex: typeof ClipVertex;
+	static getPointStates: typeof getPointStates;
+	static PointState: typeof PointState;
+}
+/**
+ * A manifold point is a contact point belonging to a contact manifold. It holds
+ * details related to the geometry and dynamics of the contact points.
+ *
+ * This structure is stored across time steps, so we keep it small.
+ *
+ * Note: impulses are used for internal caching and may not provide reliable
+ * contact forces, especially for high speed collisions.
+ */
+export declare class ManifoldPoint {
+	/**
+	 * Usage depends on manifold type:
+	 * - circles: the local center of circleB
+	 * - faceA: the local center of circleB or the clip point of polygonB
+	 * - faceB: the clip point of polygonA
+	 */
+	localPoint: Vec2Value;
+	/**
+	 * The non-penetration impulse
+	 */
+	normalImpulse: number;
+	/**
+	 * The friction impulse
+	 */
+	tangentImpulse: number;
+	/**
+	 * Uniquely identifies a contact point between two shapes to facilitate warm starting
+	 */
+	readonly id: ContactID;
+	set(that: ManifoldPoint): void;
+	recycle(): void;
+}
+/**
+ * Contact ids to facilitate warm starting.
+ *
+ * ContactFeature: The features that intersect to form the contact point.
+ */
+export declare class ContactID {
+	/**
+	 * Used to quickly compare contact ids.
+	 */
+	key: number;
+	/** ContactFeature index on shapeA */
+	indexA: number;
+	/** ContactFeature index on shapeB */
+	indexB: number;
+	/** ContactFeature type on shapeA */
+	typeA: ContactFeatureType;
+	/** ContactFeature type on shapeB */
+	typeB: ContactFeatureType;
+	setFeatures(indexA: number, typeA: ContactFeatureType, indexB: number, typeB: ContactFeatureType): void;
+	set(that: ContactID): void;
+	swapFeatures(): void;
+	recycle(): void;
+}
+/**
+ * This is used to compute the current state of a contact manifold.
+ */
+export declare class WorldManifold {
+	/** World vector pointing from A to B */
+	normal: Vec2Value;
+	/** World contact point (point of intersection) */
+	points: Vec2Value[];
+	/** A negative value indicates overlap, in meters */
+	separations: number[];
+	/** The number of manifold points */
+	pointCount: number;
+	recycle(): void;
+}
+/**
+ * Compute the point states given two manifolds. The states pertain to the
+ * transition from manifold1 to manifold2. So state1 is either persist or remove
+ * while state2 is either add or persist.
+ */
+export declare function getPointStates(state1: PointState[], state2: PointState[], manifold1: Manifold, manifold2: Manifold): void;
+/**
+ * Clipping for contact manifolds. Sutherland-Hodgman clipping.
+ */
+export declare function clipSegmentToLine(vOut: ClipVertex[], vIn: ClipVertex[], normal: Vec2Value, offset: number, vertexIndexA: number): number;
+/**
+ * A contact edge is used to connect bodies and contacts together in a contact
+ * graph where each body is a node and each contact is an edge. A contact edge
+ * belongs to a doubly linked list maintained in each attached body. Each
+ * contact has two contact nodes, one for each attached body.
+ */
+export declare class ContactEdge {
+	contact: Contact;
+	prev: ContactEdge | null;
+	next: ContactEdge | null;
+	other: Body$1 | null;
+	constructor(contact: Contact);
+}
+export type EvaluateFunction = (manifold: Manifold, xfA: TransformValue, fixtureA: Fixture, indexA: number, xfB: TransformValue, fixtureB: Fixture, indexB: number) => void;
+/**
+ * Friction mixing law. The idea is to allow either fixture to drive the
+ * friction to zero. For example, anything slides on ice.
+ */
+export declare function mixFriction(friction1: number, friction2: number): number;
+/**
+ * Restitution mixing law. The idea is allow for anything to bounce off an
+ * inelastic surface. For example, a superball bounces on anything.
+ */
+export declare function mixRestitution(restitution1: number, restitution2: number): number;
+export declare class VelocityConstraintPoint {
+	rA: Vec2Value;
+	rB: Vec2Value;
+	normalImpulse: number;
+	tangentImpulse: number;
+	normalMass: number;
+	tangentMass: number;
+	velocityBias: number;
+	recycle(): void;
+}
+/**
+ * The class manages contact between two shapes. A contact exists for each
+ * overlapping AABB in the broad-phase (except if filtered). Therefore a contact
+ * object may exist that has no contact points.
+ */
+export declare class Contact {
+	initConstraint(step: TimeStep): void;
+	/**
+	 * Get the contact manifold. Do not modify the manifold unless you understand
+	 * the internals of the library.
+	 */
+	getManifold(): Manifold;
+	/**
+	 * Get the world manifold.
+	 */
+	getWorldManifold(worldManifold: WorldManifold | null): WorldManifold | undefined;
+	/**
+	 * Enable/disable this contact. This can be used inside the pre-solve contact
+	 * listener. The contact is only disabled for the current time step (or sub-step
+	 * in continuous collisions).
+	 */
+	setEnabled(flag: boolean): void;
+	/**
+	 * Has this contact been disabled?
+	 */
+	isEnabled(): boolean;
+	/**
+	 * Is this contact touching?
+	 */
+	isTouching(): boolean;
+	/**
+	 * Get the next contact in the world's contact list.
+	 */
+	getNext(): Contact | null;
+	/**
+	 * Get fixture A in this contact.
+	 */
+	getFixtureA(): Fixture;
+	/**
+	 * Get fixture B in this contact.
+	 */
+	getFixtureB(): Fixture;
+	/**
+	 * Get the child primitive index for fixture A.
+	 */
+	getChildIndexA(): number;
+	/**
+	 * Get the child primitive index for fixture B.
+	 */
+	getChildIndexB(): number;
+	/**
+	 * Flag this contact for filtering. Filtering will occur the next time step.
+	 */
+	flagForFiltering(): void;
+	/**
+	 * Override the default friction mixture. You can call this in
+	 * "pre-solve" callback. This value persists until set or reset.
+	 */
+	setFriction(friction: number): void;
+	/**
+	 * Get the friction.
+	 */
+	getFriction(): number;
+	/**
+	 * Reset the friction mixture to the default value.
+	 */
+	resetFriction(): void;
+	/**
+	 * Override the default restitution mixture. You can call this in
+	 * "pre-solve" callback. The value persists until you set or reset.
+	 */
+	setRestitution(restitution: number): void;
+	/**
+	 * Get the restitution.
+	 */
+	getRestitution(): number;
+	/**
+	 * Reset the restitution to the default value.
+	 */
+	resetRestitution(): void;
+	/**
+	 * Set the desired tangent speed for a conveyor belt behavior. In meters per
+	 * second.
+	 */
+	setTangentSpeed(speed: number): void;
+	/**
+	 * Get the desired tangent speed. In meters per second.
+	 */
+	getTangentSpeed(): number;
+	/**
+	 * Called by Update method, and implemented by subclasses.
+	 */
+	evaluate(manifold: Manifold, xfA: TransformValue, xfB: TransformValue): void;
+	/**
+	 * Updates the contact manifold and touching status.
+	 *
+	 * Note: do not assume the fixture AABBs are overlapping or are valid.
+	 *
+	 * @param listener.beginContact
+	 * @param listener.endContact
+	 * @param listener.preSolve
+	 */
+	update(listener?: {
+		beginContact(contact: Contact): void;
+		endContact(contact: Contact): void;
+		preSolve(contact: Contact, oldManifold: Manifold): void;
+	}): void;
+	solvePositionConstraint(step: TimeStep): number;
+	solvePositionConstraintTOI(step: TimeStep, toiA: Body$1, toiB: Body$1): number;
+	private _solvePositionConstraint;
+	initVelocityConstraint(step: TimeStep): void;
+	warmStartConstraint(step: TimeStep): void;
+	storeConstraintImpulses(step: TimeStep): void;
+	solveVelocityConstraint(step: TimeStep): void;
+}
+/**
+ * A static body does not move under simulation and behaves as if it has infinite mass.
+ * Internally, zero is stored for the mass and the inverse mass.
+ * Static bodies can be moved manually by the user.
+ * A static body has zero velocity.
+ * Static bodies do not collide with other static or kinematic bodies.
+ *
+ * A kinematic body moves under simulation according to its velocity.
+ * Kinematic bodies do not respond to forces.
+ * They can be moved manually by the user, but normally a kinematic body is moved by setting its velocity.
+ * A kinematic body behaves as if it has infinite mass, however, zero is stored for the mass and the inverse mass.
+ * Kinematic bodies do not collide with other kinematic or static bodies.
+ *
+ * A dynamic body is fully simulated.
+ * They can be moved manually by the user, but normally they move according to forces.
+ * A dynamic body can collide with all body types.
+ * A dynamic body always has finite, non-zero mass.
+ * If you try to set the mass of a dynamic body to zero, it will automatically acquire a mass of one kilogram and it won't rotate.
+ */
+export type BodyType = "static" | "kinematic" | "dynamic";
+export interface BodyDef {
+	/**
+	 * Body types are static, kinematic, or dynamic. Note: if a dynamic
+	 * body would have zero mass, the mass is set to one.
+	 */
+	type?: BodyType;
+	/**
+	 * The world position of the body. Avoid creating bodies at the
+	 * origin since this can lead to many overlapping shapes.
+	 */
+	position?: Vec2Value;
+	/**
+	 * The world angle of the body in radians.
+	 */
+	angle?: number;
+	/**
+	 * The linear velocity of the body's origin in world co-ordinates.
+	 */
+	linearVelocity?: Vec2Value;
+	angularVelocity?: number;
+	/**
+	 * Linear damping is use to reduce the linear velocity. The
+	 * damping parameter can be larger than 1.0 but the damping effect becomes
+	 * sensitive to the time step when the damping parameter is large.
+	 * Units are 1/time
+	 */
+	linearDamping?: number;
+	/**
+	 * Angular damping is use to reduce the angular velocity.
+	 * The damping parameter can be larger than 1.0 but the damping effect
+	 * becomes sensitive to the time step when the damping parameter is large.
+	 * Units are 1/time
+	 */
+	angularDamping?: number;
+	/**
+	 * Should this body be prevented from rotating? Useful for characters.
+	 */
+	fixedRotation?: boolean;
+	/**
+	 * Is this a fast moving body that should be prevented from
+	 * tunneling through other moving bodies? Note that all bodies are
+	 * prevented from tunneling through kinematic and static bodies. This
+	 * setting is only considered on dynamic bodies. Warning: You should use
+	 * this flag sparingly since it increases processing time.
+	 */
+	bullet?: boolean;
+	gravityScale?: number;
+	/**
+	 * Set this flag to false if this body should never fall asleep. Note that this increases CPU usage.
+	 */
+	allowSleep?: boolean;
+	/**
+	 * Is this body initially awake or sleeping?
+	 */
+	awake?: boolean;
+	/**
+	 * Does this body start out active?
+	 */
+	active?: boolean;
+	userData?: any;
+	/** Styling for dev-tools. */
+	style?: Style;
+}
+/**
+ * MassData This holds the mass data computed for a shape.
+ */
+export interface MassData {
+	/** The mass of the shape, usually in kilograms. */
+	mass: number;
+	/** The position of the shape's centroid relative to the shape's origin. */
+	center: Vec2Value;
+	/** The rotational inertia of the shape about the local origin. */
+	I: number;
+}
+/**
+ * A rigid body composed of one or more fixtures.
+ *
+ * To create a new Body use {@link World.createBody}.
+ */
+declare class Body$1 {
+	/** @hidden */
+	static readonly STATIC: BodyType;
+	/** @hidden */
+	static readonly KINEMATIC: BodyType;
+	/** @hidden */
+	static readonly DYNAMIC: BodyType;
+	/** Styling for dev-tools. */
+	style: Style;
+	/** @hidden @experimental Similar to userData, but used by dev-tools or runtime environment. */
+	appData: Record<string, any>;
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): Body$1;
+	isWorldLocked(): boolean;
+	getWorld(): World;
+	getNext(): Body$1 | null;
+	setUserData(data: any): void;
+	getUserData(): unknown;
+	getFixtureList(): Fixture | null;
+	getJointList(): JointEdge | null;
+	/**
+	 * Warning: this list changes during the time step and you may miss some
+	 * collisions if you don't use ContactListener.
+	 */
+	getContactList(): ContactEdge | null;
+	isStatic(): boolean;
+	isDynamic(): boolean;
+	isKinematic(): boolean;
+	/**
+	 * This will alter the mass and velocity.
+	 */
+	setStatic(): Body$1;
+	setDynamic(): Body$1;
+	setKinematic(): Body$1;
+	/**
+	 * Get the type of the body.
+	 */
+	getType(): BodyType;
+	/**
+	 * Set the type of the body to "static", "kinematic" or "dynamic".
+	 * @param type The type of the body.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	setType(type: BodyType): void;
+	isBullet(): boolean;
+	/**
+	 * Should this body be treated like a bullet for continuous collision detection?
+	 */
+	setBullet(flag: boolean): void;
+	isSleepingAllowed(): boolean;
+	setSleepingAllowed(flag: boolean): void;
+	isAwake(): boolean;
+	/**
+	 * Set the sleep state of the body. A sleeping body has very low CPU cost.
+	 *
+	 * @param flag Set to true to wake the body, false to put it to sleep.
+	 */
+	setAwake(flag: boolean): void;
+	isActive(): boolean;
+	/**
+	 * Set the active state of the body. An inactive body is not simulated and
+	 * cannot be collided with or woken up. If you pass a flag of true, all fixtures
+	 * will be added to the broad-phase. If you pass a flag of false, all fixtures
+	 * will be removed from the broad-phase and all contacts will be destroyed.
+	 * Fixtures and joints are otherwise unaffected.
+	 *
+	 * You may continue to create/destroy fixtures and joints on inactive bodies.
+	 * Fixtures on an inactive body are implicitly inactive and will not participate
+	 * in collisions, ray-casts, or queries. Joints connected to an inactive body
+	 * are implicitly inactive. An inactive body is still owned by a World object
+	 * and remains
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	setActive(flag: boolean): void;
+	isFixedRotation(): boolean;
+	/**
+	 * Set this body to have fixed rotation. This causes the mass to be reset.
+	 */
+	setFixedRotation(flag: boolean): void;
+	/**
+	 * Get the world transform for the body's origin.
+	 */
+	getTransform(): TransformValue;
+	/**
+	 * Set the position of the body's origin and rotation. Manipulating a body's
+	 * transform may cause non-physical behavior. Note: contacts are updated on the
+	 * next call to World.step.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 *
+	 * @param position The world position of the body's local origin.
+	 * @param angle The world rotation in radians.
+	 */
+	setTransform(position: Vec2Value, angle: number): void;
+	/**
+	 * Set the position of the body's origin and rotation. Manipulating a body's
+	 * transform may cause non-physical behavior. Note: contacts are updated on the
+	 * next call to World.step.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	setTransform(xf: TransformValue): void;
+	synchronizeTransform(): void;
+	/**
+	 * Update fixtures in broad-phase.
+	 */
+	synchronizeFixtures(): void;
+	/**
+	 * Used in TOI.
+	 */
+	advance(alpha: number): void;
+	/**
+	 * Get the world position for the body's origin.
+	 */
+	getPosition(): Vec2Value;
+	setPosition(p: Vec2Value): void;
+	/**
+	 * Get the current world rotation angle in radians.
+	 */
+	getAngle(): number;
+	setAngle(angle: number): void;
+	/**
+	 * Get the world position of the center of mass.
+	 */
+	getWorldCenter(): Vec2Value;
+	/**
+	 * Get the local position of the center of mass.
+	 */
+	getLocalCenter(): Vec2Value;
+	/**
+	 * Get the linear velocity of the center of mass.
+	 *
+	 * @return the linear velocity of the center of mass.
+	 */
+	getLinearVelocity(): Vec2Value;
+	/**
+	 * Get the world linear velocity of a world point attached to this body.
+	 *
+	 * @param worldPoint A point in world coordinates.
+	 */
+	getLinearVelocityFromWorldPoint(worldPoint: Vec2Value): Vec2Value;
+	/**
+	 * Get the world velocity of a local point.
+	 *
+	 * @param localPoint A point in local coordinates.
+	 */
+	getLinearVelocityFromLocalPoint(localPoint: Vec2Value): Vec2Value;
+	/**
+	 * Set the linear velocity of the center of mass.
+	 *
+	 * @param v The new linear velocity of the center of mass.
+	 */
+	setLinearVelocity(v: Vec2Value): void;
+	/**
+	 * Get the angular velocity.
+	 *
+	 * @returns the angular velocity in radians/second.
+	 */
+	getAngularVelocity(): number;
+	/**
+	 * Set the angular velocity.
+	 *
+	 * @param w The new angular velocity in radians/second.
+	 */
+	setAngularVelocity(w: number): void;
+	getLinearDamping(): number;
+	setLinearDamping(linearDamping: number): void;
+	getAngularDamping(): number;
+	setAngularDamping(angularDamping: number): void;
+	getGravityScale(): number;
+	/**
+	 * Scale the gravity applied to this body.
+	 */
+	setGravityScale(scale: number): void;
+	/**
+	 * Get the total mass of the body.
+	 *
+	 * @returns The mass, usually in kilograms (kg).
+	 */
+	getMass(): number;
+	/**
+	 * Get the rotational inertia of the body about the local origin.
+	 *
+	 * @return the rotational inertia, usually in kg-m^2.
+	 */
+	getInertia(): number;
+	/**
+	 * Copy the mass data of the body to data.
+	 */
+	getMassData(data: MassData): void;
+	/**
+	 * This resets the mass properties to the sum of the mass properties of the
+	 * fixtures. This normally does not need to be called unless you called
+	 * SetMassData to override the mass and you later want to reset the mass.
+	 */
+	resetMassData(): void;
+	/**
+	 * Set the mass properties to override the mass properties of the fixtures. Note
+	 * that this changes the center of mass position. Note that creating or
+	 * destroying fixtures can also alter the mass. This function has no effect if
+	 * the body isn't dynamic.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 *
+	 * @param massData The mass properties.
+	 */
+	setMassData(massData: MassData): void;
+	/**
+	 * Apply a force at a world point. If the force is not applied at the center of
+	 * mass, it will generate a torque and affect the angular velocity. This wakes
+	 * up the body.
+	 *
+	 * @param force The world force vector, usually in Newtons (N).
+	 * @param point The world position of the point of application.
+	 * @param wake Also wake up the body
+	 */
+	applyForce(force: Vec2Value, point: Vec2Value, wake?: boolean): void;
+	/**
+	 * Apply a force to the center of mass. This wakes up the body.
+	 *
+	 * @param force The world force vector, usually in Newtons (N).
+	 * @param wake Also wake up the body
+	 */
+	applyForceToCenter(force: Vec2Value, wake?: boolean): void;
+	/**
+	 * Apply a torque. This affects the angular velocity without affecting the
+	 * linear velocity of the center of mass. This wakes up the body.
+	 *
+	 * @param torque About the z-axis (out of the screen), usually in N-m.
+	 * @param wake Also wake up the body
+	 */
+	applyTorque(torque: number, wake?: boolean): void;
+	/**
+	 * Apply an impulse at a point. This immediately modifies the velocity. It also
+	 * modifies the angular velocity if the point of application is not at the
+	 * center of mass. This wakes up the body.
+	 *
+	 * @param impulse The world impulse vector, usually in N-seconds or kg-m/s.
+	 * @param point The world position of the point of application.
+	 * @param wake Also wake up the body
+	 */
+	applyLinearImpulse(impulse: Vec2Value, point: Vec2Value, wake?: boolean): void;
+	/**
+	 * Apply an angular impulse.
+	 *
+	 * @param impulse The angular impulse in units of kg*m*m/s
+	 * @param wake Also wake up the body
+	 */
+	applyAngularImpulse(impulse: number, wake?: boolean): void;
+	/**
+	 * This is used to test if two bodies should collide.
+	 *
+	 * Bodies do not collide when:
+	 * - Neither of them is dynamic
+	 * - They are connected by a joint with collideConnected == false
+	 */
+	shouldCollide(that: Body$1): boolean;
+	/**
+	 * Creates a fixture and attach it to this body.
+	 *
+	 * If the density is non-zero, this function automatically updates the mass of
+	 * the body.
+	 *
+	 * Contacts are not created until the next time step.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	createFixture(def: FixtureDef): Fixture;
+	createFixture(shape: Shape, opt?: FixtureOpt): Fixture;
+	createFixture(shape: Shape, density?: number): Fixture;
+	/**
+	 * Destroy a fixture. This removes the fixture from the broad-phase and destroys
+	 * all contacts associated with this fixture. This will automatically adjust the
+	 * mass of the body if the body is dynamic and the fixture has positive density.
+	 * All fixtures attached to a body are implicitly destroyed when the body is
+	 * destroyed.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 *
+	 * @param fixture The fixture to be removed.
+	 */
+	destroyFixture(fixture: Fixture): void;
+	/**
+	 * Get the corresponding world point of a local point.
+	 */
+	getWorldPoint(localPoint: Vec2Value): Vec2Value;
+	/**
+	 * Get the corresponding world vector of a local vector.
+	 */
+	getWorldVector(localVector: Vec2Value): Vec2Value;
+	/**
+	 * Gets the corresponding local point of a world point.
+	 */
+	getLocalPoint(worldPoint: Vec2Value): Vec2Value;
+	/**
+	 * Gets the corresponding local vector of a world vector.
+	 */
+	getLocalVector(worldVector: Vec2Value): Vec2Value;
+}
+export declare class TimeStep {
+	/** time step */
+	dt: number;
+	/** inverse time step (0 if dt == 0) */
+	inv_dt: number;
+	velocityIterations: number;
+	positionIterations: number;
+	warmStarting: boolean;
+	blockSolve: boolean;
+	/** timestep ratio for variable timestep */
+	inv_dt0: number;
+	/** dt * inv_dt0 */
+	dtRatio: number;
+	reset(dt: number): void;
+}
+/**
+ * Contact impulses for reporting. Impulses are used instead of forces because
+ * sub-step forces may approach infinity for rigid body collisions. These match
+ * up one-to-one with the contact points in Manifold.
+ */
+export declare class ContactImpulse {
+	private readonly contact;
+	private readonly normals;
+	private readonly tangents;
+	constructor(contact: Contact);
+	recycle(): void;
+	get normalImpulses(): number[];
+	get tangentImpulses(): number[];
+}
+/**
+ * Finds and solves islands. An island is a connected subset of the world.
+ */
+export declare class Solver {
+	m_world: World;
+	m_stack: Body$1[];
+	m_bodies: Body$1[];
+	m_contacts: Contact[];
+	m_joints: Joint[];
+	constructor(world: World);
+	clear(): void;
+	addBody(body: Body$1): void;
+	addContact(contact: Contact): void;
+	addJoint(joint: Joint): void;
+	solveWorld(step: TimeStep): void;
+	solveIsland(step: TimeStep): void;
+	/**
+	 * Find TOI contacts and solve them.
+	 */
+	solveWorldTOI(step: TimeStep): void;
+	solveIslandTOI(subStep: TimeStep, toiA: Body$1, toiB: Body$1): void;
+}
+export interface WorldDef {
+	/** [default: { x : 0, y : 0}] */
+	gravity?: Vec2Value;
+	/** [default: true] */
+	allowSleep?: boolean;
+	/** [default: true] */
+	warmStarting?: boolean;
+	/** [default: true] */
+	continuousPhysics?: boolean;
+	/** [default: false] */
+	subStepping?: boolean;
+	/** [default: true] */
+	blockSolve?: boolean;
+}
+/**
+ * Callback function for ray casts, see {@link World.rayCast}.
+ *
+ * Called for each fixture found in the query.
+ * The returned value replaces the ray-cast input maxFraction.
+ * You control how the ray cast proceeds by returning a numeric/float value.
+ *
+ * - `0` to terminate the ray cast
+ * - `fraction` to clip the ray cast at current point
+ * - `1` don't clip the ray and continue
+ * - `-1` (or anything else) to continue
+ *
+ * @param fixture The fixture hit by the ray
+ * @param point The point of initial intersection
+ * @param normal The normal vector at the point of intersection
+ * @param fraction The fraction along the ray at the point of intersection
+ *
+ * @returns A number to update the maxFraction
+ */
+export type WorldRayCastCallback = (fixture: Fixture, point: Vec2Value, normal: Vec2Value, fraction: number) => number;
+/**
+ * Called for each fixture found in the query AABB. It may return `false` to terminate the query.
+ */
+export type WorldAABBQueryCallback = (fixture: Fixture) => boolean;
+/**
+ * The `World` class contains the bodies and joints. It manages all aspects
+ * of the simulation and allows for asynchronous queries (like AABB queries
+ * and ray-casts). Much of your interactions with Planck.js will be with a
+ * World object.
+ */
+export declare class World {
+	/**
+	 * @param def World definition or gravity vector.
+	 */
+	constructor(def?: WorldDef | Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, context: any, restore: any): World;
+	/**
+	 * Get the world body list. With the returned body, use Body.getNext to get the
+	 * next body in the world list. A null body indicates the end of the list.
+	 *
+	 * @return the head of the world body list.
+	 */
+	getBodyList(): Body$1 | null;
+	/**
+	 * Get the world joint list. With the returned joint, use Joint.getNext to get
+	 * the next joint in the world list. A null joint indicates the end of the list.
+	 *
+	 * @return the head of the world joint list.
+	 */
+	getJointList(): Joint | null;
+	/**
+	 * Get the world contact list. With the returned contact, use Contact.getNext to
+	 * get the next contact in the world list. A null contact indicates the end of
+	 * the list.
+	 *
+	 * Warning: contacts are created and destroyed in the middle of a time step.
+	 * Use ContactListener to avoid missing contacts.
+	 *
+	 * @return the head of the world contact list.
+	 */
+	getContactList(): Contact | null;
+	getBodyCount(): number;
+	getJointCount(): number;
+	/**
+	 * Get the number of contacts (each may have 0 or more contact points).
+	 */
+	getContactCount(): number;
+	/**
+	 * Change the global gravity vector.
+	 */
+	setGravity(gravity: Vec2Value): void;
+	/**
+	 * Get the global gravity vector.
+	 */
+	getGravity(): Vec2Value;
+	/**
+	 * Is the world locked (in the middle of a time step).
+	 */
+	isLocked(): boolean;
+	/**
+	 * Enable/disable sleep.
+	 */
+	setAllowSleeping(flag: boolean): void;
+	getAllowSleeping(): boolean;
+	/**
+	 * Enable/disable warm starting. For testing.
+	 */
+	setWarmStarting(flag: boolean): void;
+	getWarmStarting(): boolean;
+	/**
+	 * Enable/disable continuous physics. For testing.
+	 */
+	setContinuousPhysics(flag: boolean): void;
+	getContinuousPhysics(): boolean;
+	/**
+	 * Enable/disable single stepped continuous physics. For testing.
+	 */
+	setSubStepping(flag: boolean): void;
+	getSubStepping(): boolean;
+	/**
+	 * Set flag to control automatic clearing of forces after each time step.
+	 */
+	setAutoClearForces(flag: boolean): void;
+	/**
+	 * Get the flag that controls automatic clearing of forces after each time step.
+	 */
+	getAutoClearForces(): boolean;
+	/**
+	 * Manually clear the force buffer on all bodies. By default, forces are cleared
+	 * automatically after each call to step. The default behavior is modified by
+	 * calling setAutoClearForces. The purpose of this function is to support
+	 * sub-stepping. Sub-stepping is often used to maintain a fixed sized time step
+	 * under a variable frame-rate. When you perform sub-stepping you will disable
+	 * auto clearing of forces and instead call clearForces after all sub-steps are
+	 * complete in one pass of your game loop.
+	 *
+	 * See {@link World.setAutoClearForces}
+	 */
+	clearForces(): void;
+	/**
+	 * Query the world for all fixtures that potentially overlap the provided AABB.
+	 *
+	 * @param aabb The query box.
+	 * @param callback Called for each fixture found in the query AABB. It may return `false` to terminate the query.
+	 */
+	queryAABB(aabb: AABBValue, callback: WorldAABBQueryCallback): void;
+	/**
+	 * Ray-cast the world for all fixtures in the path of the ray. Your callback
+	 * controls whether you get the closest point, any point, or n-points. The
+	 * ray-cast ignores shapes that contain the starting point.
+	 *
+	 * @param point1 The ray starting point
+	 * @param point2 The ray ending point
+	 * @param callback A function that is called for each fixture that is hit by the ray. You control how the ray cast proceeds by returning a numeric/float value.
+	 */
+	rayCast(point1: Vec2Value, point2: Vec2Value, callback: WorldRayCastCallback): void;
+	/**
+	 * Get the number of broad-phase proxies.
+	 */
+	getProxyCount(): number;
+	/**
+	 * Get the height of broad-phase dynamic tree.
+	 */
+	getTreeHeight(): number;
+	/**
+	 * Get the balance of broad-phase dynamic tree.
+	 */
+	getTreeBalance(): number;
+	/**
+	 * Get the quality metric of broad-phase dynamic tree. The smaller the better.
+	 * The minimum is 1.
+	 */
+	getTreeQuality(): number;
+	/**
+	 * Shift the world origin. Useful for large worlds. The body shift formula is:
+	 * position -= newOrigin
+	 *
+	 * @param newOrigin The new origin with respect to the old origin
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	shiftOrigin(newOrigin: Vec2Value): void;
+	/**
+	 * Create a rigid body given a definition. No reference to the definition is
+	 * retained.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	createBody(def?: BodyDef): Body$1;
+	createBody(position: Vec2Value, angle?: number): Body$1;
+	createDynamicBody(def?: BodyDef): Body$1;
+	createDynamicBody(position: Vec2Value, angle?: number): Body$1;
+	createKinematicBody(def?: BodyDef): Body$1;
+	createKinematicBody(position: Vec2Value, angle?: number): Body$1;
+	/**
+	 * Destroy a body from the world.
+	 *
+	 * Warning: This automatically deletes all associated shapes and joints.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	destroyBody(b: Body$1): boolean;
+	/**
+	 * Create a joint to constrain bodies together. No reference to the definition
+	 * is retained. This may cause the connected bodies to cease colliding.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	createJoint<T extends Joint>(joint: T): T | null;
+	/**
+	 * Destroy a joint.
+	 *
+	 * Warning: This may cause the connected bodies to begin colliding.
+	 *
+	 * Warning: This function is locked when a world simulation step is in progress. Use queueUpdate to schedule a function to be called after the step.
+	 */
+	destroyJoint(joint: Joint): void;
+	/**
+	 * Take a time step. This performs collision detection, integration, and
+	 * constraint solution.
+	 *
+	 * Broad-phase, narrow-phase, solve and solve time of impacts.
+	 *
+	 * @param timeStep Time step, this should not vary.
+	 */
+	step(timeStep: number, velocityIterations?: number, positionIterations?: number): void;
+	/**
+	 * Queue a function to be called after ongoing simulation step. If no simulation is in progress call it immediately.
+	 */
+	queueUpdate(callback: (world: World) => unknown): void;
+	/**
+	 * Called when two fixtures begin to touch.
+	 *
+	 * Implement contact callbacks to get contact information. You can use these
+	 * results for things like sounds and game logic. You can also get contact
+	 * results by traversing the contact lists after the time step. However, you
+	 * might miss some contacts because continuous physics leads to sub-stepping.
+	 * Additionally you may receive multiple callbacks for the same contact in a
+	 * single time step. You should strive to make your callbacks efficient because
+	 * there may be many callbacks per time step.
+	 *
+	 * Warning: You cannot create/destroy world entities inside these callbacks.
+	 */
+	on(name: "begin-contact", listener: (contact: Contact) => void): World;
+	/**
+	 * Called when two fixtures cease to touch.
+	 *
+	 * Implement contact callbacks to get contact information. You can use these
+	 * results for things like sounds and game logic. You can also get contact
+	 * results by traversing the contact lists after the time step. However, you
+	 * might miss some contacts because continuous physics leads to sub-stepping.
+	 * Additionally you may receive multiple callbacks for the same contact in a
+	 * single time step. You should strive to make your callbacks efficient because
+	 * there may be many callbacks per time step.
+	 *
+	 * Warning: You cannot create/destroy world entities inside these callbacks.
+	 */
+	on(name: "end-contact", listener: (contact: Contact) => void): World;
+	/**
+	 * This is called after a contact is updated. This allows you to inspect a
+	 * contact before it goes to the solver. If you are careful, you can modify the
+	 * contact manifold (e.g. disable contact). A copy of the old manifold is
+	 * provided so that you can detect changes. Note: this is called only for awake
+	 * bodies. Note: this is called even when the number of contact points is zero.
+	 * Note: this is not called for sensors. Note: if you set the number of contact
+	 * points to zero, you will not get an end-contact callback. However, you may get
+	 * a begin-contact callback the next step.
+	 *
+	 * Warning: You cannot create/destroy world entities inside these callbacks.
+	 */
+	on(name: "pre-solve", listener: (contact: Contact, oldManifold: Manifold) => void): World;
+	/**
+	 * This lets you inspect a contact after the solver is finished. This is useful
+	 * for inspecting impulses. Note: the contact manifold does not include time of
+	 * impact impulses, which can be arbitrarily large if the sub-step is small.
+	 * Hence the impulse is provided explicitly in a separate data structure. Note:
+	 * this is only called for contacts that are touching, solid, and awake.
+	 *
+	 * Warning: You cannot create/destroy world entities inside these callbacks.
+	 */
+	on(name: "post-solve", listener: (contact: Contact, impulse: ContactImpulse) => void): World;
+	/** Listener is called whenever a body is removed. */
+	on(name: "remove-body", listener: (body: Body$1) => void): World;
+	/** Listener is called whenever a joint is removed implicitly or explicitly. */
+	on(name: "remove-joint", listener: (joint: Joint) => void): World;
+	/** Listener is called whenever a fixture is removed implicitly or explicitly. */
+	on(name: "remove-fixture", listener: (fixture: Fixture) => void): World;
+	off(name: "begin-contact", listener: (contact: Contact) => void): World;
+	off(name: "end-contact", listener: (contact: Contact) => void): World;
+	off(name: "pre-solve", listener: (contact: Contact, oldManifold: Manifold) => void): World;
+	off(name: "post-solve", listener: (contact: Contact, impulse: ContactImpulse) => void): World;
+	off(name: "remove-body", listener: (body: Body$1) => void): World;
+	off(name: "remove-joint", listener: (joint: Joint) => void): World;
+	off(name: "remove-fixture", listener: (fixture: Fixture) => void): World;
+	publish(name: string, arg1?: any, arg2?: any, arg3?: any): number;
+}
+export type DataType = any;
+export type ObjectType = any;
+export type ClassName = any;
+export type SerializedType = object[];
+export type SerializerOptions = {
+	rootClass: ClassName;
+	preSerialize?: (obj: ObjectType) => DataType;
+	postSerialize?: (data: DataType, obj: any) => DataType;
+	preDeserialize?: (data: DataType) => DataType;
+	postDeserialize?: (obj: ObjectType, data: DataType) => ObjectType;
+};
+export declare class Serializer<T> {
+	private options;
+	constructor(options: SerializerOptions);
+	toJson: (root: T) => SerializedType;
+	fromJson: (json: SerializedType) => T;
+	static toJson: (root: World) => SerializedType;
+	static fromJson: (json: SerializedType) => World;
+}
+/** @ignore */
+declare const math: any;
+/** 3D vector */
+export interface Vec3Value {
+	x: number;
+	y: number;
+	z: number;
+}
+/**
+ * 3D vector
+ *
+ * @deprecated Use Vec3Value and geo functions instead.
+ */
+export declare class Vec3 {
+	x: number;
+	y: number;
+	z: number;
+	constructor(x: number, y: number, z: number);
+	constructor(obj: Vec3Value);
+	constructor();
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any): Vec3;
+	/** @hidden */
+	static neo(x: number, y: number, z: number): Vec3;
+	static zero(): Vec3;
+	static clone(v: Vec3Value): Vec3;
+	/** @hidden */
+	toString(): string;
+	/** Does this vector contain finite coordinates? */
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	setZero(): Vec3;
+	set(x: number, y: number, z: number): Vec3;
+	add(w: Vec3Value): Vec3;
+	sub(w: Vec3Value): Vec3;
+	mul(m: number): Vec3;
+	static areEqual(v: Vec3Value, w: Vec3Value): boolean;
+	/** Dot product on two vectors */
+	static dot(v: Vec3Value, w: Vec3Value): number;
+	/** Cross product on two vectors */
+	static cross(v: Vec3Value, w: Vec3Value): Vec3;
+	static add(v: Vec3Value, w: Vec3Value): Vec3;
+	static sub(v: Vec3Value, w: Vec3Value): Vec3;
+	static mul(v: Vec3Value, m: number): Vec3;
+	neg(): Vec3;
+	static neg(v: Vec3Value): Vec3;
+}
+/** A 2-by-2 matrix. Stored in column-major order. */
+export interface Mat22Value {
+	ex: Vec2Value;
+	ey: Vec2Value;
+}
+/**
+ * A 2-by-2 matrix. Stored in column-major order.
+ *
+ * @deprecated Use Mat22Value and geo functions instead.
+ */
+export declare class Mat22 {
+	ex: Vec2;
+	ey: Vec2;
+	constructor(a: number, b: number, c: number, d: number);
+	constructor(a: {
+		x: number;
+		y: number;
+	}, b: {
+		x: number;
+		y: number;
+	});
+	constructor();
+	/** @hidden */
+	toString(): string;
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	set(a: Mat22): void;
+	set(a: Vec2Value, b: Vec2Value): void;
+	set(a: number, b: number, c: number, d: number): void;
+	setIdentity(): void;
+	setZero(): void;
+	getInverse(): Mat22;
+	/**
+	 * Solve A * x = b, where b is a column vector. This is more efficient than
+	 * computing the inverse in one-shot cases.
+	 */
+	solve(v: Vec2Value): Vec2;
+	/**
+	 * Multiply a matrix times a vector. If a rotation matrix is provided, then this
+	 * transforms the vector from one frame to another.
+	 */
+	static mul(mx: Mat22, my: Mat22): Mat22;
+	static mul(mx: Mat22, v: Vec2Value): Vec2;
+	static mulVec2(mx: Mat22, v: Vec2Value): Vec2;
+	static mulMat22(mx: Mat22, v: Mat22): Mat22;
+	/**
+	 * Multiply a matrix transpose times a vector. If a rotation matrix is provided,
+	 * then this transforms the vector from one frame to another (inverse
+	 * transform).
+	 */
+	static mulT(mx: Mat22, my: Mat22): Mat22;
+	static mulT(mx: Mat22, v: Vec2Value): Vec2;
+	static mulTVec2(mx: Mat22, v: Vec2Value): Vec2;
+	static mulTMat22(mx: Mat22, v: Mat22): Mat22;
+	static abs(mx: Mat22): Mat22;
+	static add(mx1: Mat22, mx2: Mat22): Mat22;
+}
+/** A 3-by-3 matrix. Stored in column-major order. */
+export interface Mat33Value {
+	ex: Vec3Value;
+	ey: Vec3Value;
+	ez: Vec3Value;
+}
+/**
+ * A 3-by-3 matrix. Stored in column-major order.
+ *
+ * @deprecated Use Mat33Value and geo functions instead.
+ */
+export declare class Mat33 {
+	ex: Vec3;
+	ey: Vec3;
+	ez: Vec3;
+	constructor(a: Vec3Value, b: Vec3Value, c: Vec3Value);
+	constructor();
+	/** @hidden */
+	toString(): string;
+	static isValid(obj: any): boolean;
+	static assert(o: any): void;
+	/**
+	 * Set this matrix to all zeros.
+	 */
+	setZero(): Mat33;
+	/**
+	 * Solve A * x = b, where b is a column vector. This is more efficient than
+	 * computing the inverse in one-shot cases.
+	 */
+	solve33(v: Vec3Value): Vec3;
+	/**
+	 * Solve A * x = b, where b is a column vector. This is more efficient than
+	 * computing the inverse in one-shot cases. Solve only the upper 2-by-2 matrix
+	 * equation.
+	 */
+	solve22(v: Vec2Value): Vec2;
+	/**
+	 * Get the inverse of this matrix as a 2-by-2. Returns the zero matrix if
+	 * singular.
+	 */
+	getInverse22(M: Mat33): void;
+	/**
+	 * Get the symmetric inverse of this matrix as a 3-by-3. Returns the zero matrix
+	 * if singular.
+	 */
+	getSymInverse33(M: Mat33): void;
+	/**
+	 * Multiply a matrix times a vector.
+	 */
+	static mul(a: Mat33, b: Vec2Value): Vec2;
+	static mul(a: Mat33, b: Vec3Value): Vec3;
+	static mulVec3(a: Mat33, b: Vec3Value): Vec3;
+	static mulVec2(a: Mat33, b: Vec2Value): Vec2;
+	static add(a: Mat33, b: Mat33): Mat33;
+}
+declare function vec2(inx: number, iny: number): Vec2Value;
+declare function vec3(inx: number, iny: number, inz: number): Vec3Value;
+declare function rotation(angle: number): RotValue;
+declare function setVec2(out: Vec2Value, inx: number, iny: number): void;
+declare function setVec3(out: Vec3Value, x: number, y: number, z: number): void;
+declare function copyVec2(out: Vec2Value, w: Vec2Value): void;
+declare function copyVec3(out: Vec2Value, w: Vec2Value): void;
+declare function zeroVec2(out: Vec2Value): void;
+declare function zeroVec3(out: Vec3Value): void;
+declare function negVec2(out: Vec2Value): void;
+declare function negVec3(out: Vec3Value): void;
+declare function plusVec2(out: Vec2Value, w: Vec2Value): void;
+declare function plusVec3(out: Vec3Value, w: Vec3Value): void;
+declare function addVec2(out: Vec2Value, v: Vec2Value, w: Vec2Value): void;
+declare function clampVec2(out: Vec2Value, max: number): void;
+declare function minusVec2(out: Vec2Value, w: Vec2Value): void;
+declare function minusCrossNumVec2(out: Vec2Value, w: number, v: Vec2Value): void;
+declare function plusCrossNumVec2(out: Vec2Value, w: number, v: Vec2Value): void;
+declare function dotCrossNumVec2(i: Vec2Value, w: number, v: Vec2Value): number;
+declare function dotSubVec2(a: Vec2Value, b: Vec2Value, c: Vec2Value): number;
+declare function subVec2(out: Vec2Value, v: Vec2Value, w: Vec2Value): void;
+declare function absVec2(out: Vec2Value, v: Vec2Value): void;
+declare function mulVec2(out: Vec2Value, m: number): void;
+declare function mulVec3(out: Vec3Value, m: number): void;
+declare function scaleVec2(out: Vec2Value, m: number, w: Vec2Value): void;
+declare function plusScaleVec2(out: Vec2Value, m: number, w: Vec2Value): void;
+declare function minusScaleVec2(out: Vec2Value, m: number, w: Vec2Value): void;
+declare function crossSubVec2Num(out: Vec2Value, a: Vec2Value, b: Vec2Value, w: number): void;
+declare function combine2Vec2(out: Vec2Value, am: number, a: Vec2Value, bm: number, b: Vec2Value): void;
+declare function combine3Vec2(out: Vec2Value, am: number, a: Vec2Value, bm: number, b: Vec2Value, cm: number, c: Vec2Value): void;
+declare function combine4Vec2(out: Vec2Value, am: number, a: Vec2Value, bm: number, b: Vec2Value, cm: number, c: Vec2Value, dm: number, d: Vec2Value): void;
+declare function normalizeVec2Length(out: Vec2Value): number;
+declare function normalizeVec2(out: Vec2Value): void;
+declare function crossVec2Num(out: Vec2Value, v: Vec2Value, w: number): void;
+declare function crossNumVec2(out: Vec2Value, w: number, v: Vec2Value): void;
+declare function crossVec2Vec2(a: Vec2Value, b: Vec2Value): number;
+declare function dotVec2(a: Vec2Value, b: Vec2Value): number;
+declare function lengthVec2(a: Vec2Value): number;
+declare function lengthSqrVec2(a: Vec2Value): number;
+declare function distVec2(a: Vec2Value, b: Vec2Value): number;
+declare function distSqrVec2(a: Vec2Value, b: Vec2Value): number;
+declare function dotVec3(v: Vec3Value, w: Vec3Value): number;
+declare function setRotAngle(out: RotValue, a: number): void;
+declare function getRotAngle(out: RotValue): number;
+declare function rotVec2(out: Vec2Value, q: RotValue, v: Vec2Value): void;
+declare function rotSubVec2(out: Vec2Value, q: RotValue, v: Vec2Value, w: Vec2Value): void;
+declare function rotNegVec2(out: Vec2Value, q: RotValue, w: Vec2Value): void;
+declare function derotVec2(out: Vec2Value, q: RotValue, v: Vec2Value): void;
+declare function derotNegVec2(out: Vec2Value, q: RotValue, v: Vec2Value): void;
+declare function rerotVec2(out: Vec2Value, before: RotValue, after: RotValue, v: Vec2Value): void;
+declare function transform(inx: number, iny: number, ina: number): TransformValue;
+declare function setTransform(xf: TransformValue, inx: number, iny: number, ina: number): void;
+declare function copyTransform(out: TransformValue, transform: TransformValue): void;
+declare function transformVec2(out: Vec2Value, xf: TransformValue, v: Vec2Value): void;
+declare function detransformVec2(out: Vec2Value, xf: TransformValue, v: Vec2Value): void;
+declare function retransformVec2(out: Vec2Value, from: TransformValue, to: TransformValue, v: Vec2Value): void;
+declare function detransformTransform(out: TransformValue, a: TransformValue, b: TransformValue): void;
+declare function mat22(): Mat22Value;
+declare function mat33(): {
+	ex: {
+		x: number;
+		y: number;
+		z: number;
+	};
+	ey: {
+		x: number;
+		y: number;
+		z: number;
+	};
+	ez: {
+		x: number;
+		y: number;
+		z: number;
+	};
+};
+declare function zeroMat22(out: Mat22Value): void;
+declare function zeroMat33(out: Mat33Value): void;
+declare function mulMat22Vec2(out: Vec2Value, m: Mat22Value, v: Vec2Value): void;
+declare function mulMat33Vec2(out: Vec2Value, m: Mat33Value, v: Vec2Value): void;
+declare function mulMat33Vec3(out: Vec3Value, m: Mat33Value, v: Vec3Value): void;
+declare function inverseMat22(out: Mat22Value, m: Mat22Value): void;
+declare function symInverseMat33(out: Mat33Value, m: Mat33Value): void;
+declare function solveMat22Num(out: Vec2Value, m: Mat22Value, x: number, y: number): void;
+declare function solveMat33Num(out: Vec3Value, m: Mat33Value, x: number, y: number, z: number): void;
+declare function vp(out: Vec2Value, v: Vec2Value, w: number, r: Vec2Value): void;
+declare function dvp(out: Vec2Value, vB: Vec2Value, wB: number, rB: Vec2Value, vA: Vec2Value, wA: number, rA: Vec2Value): void;
+declare function isVec2(obj: any): boolean;
+/** Circle shape. */
+export declare class CircleShape extends Shape {
+	static TYPE: "circle";
+	/** @hidden */ m_type: "circle";
+	/** @hidden */ m_p: Vec2Value;
+	/** @hidden */ m_radius: number;
+	constructor(position: Vec2Value, radius?: number);
+	constructor(radius?: number);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any): CircleShape;
+	/** @hidden */
+	_reset(): void;
+	getType(): "circle";
+	getRadius(): number;
+	getCenter(): Vec2Value;
+	/**
+	 * Get the number of child primitives.
+	 */
+	getChildCount(): 1;
+	/**
+	 * Test a point for containment in this shape. This only works for convex
+	 * shapes.
+	 *
+	 * @param xf The shape world transform.
+	 * @param p A point in world coordinates.
+	 */
+	testPoint(xf: TransformValue, p: Vec2Value): boolean;
+	/**
+	 * Cast a ray against a child shape.
+	 *
+	 * @param output The ray-cast results.
+	 * @param input The ray-cast input parameters.
+	 * @param xf The transform to be applied to the shape.
+	 * @param childIndex The child shape index
+	 */
+	rayCast(output: RayCastOutput, input: RayCastInput, xf: TransformValue, childIndex: number): boolean;
+	/**
+	 * Given a transform, compute the associated axis aligned bounding box for a
+	 * child shape.
+	 *
+	 * @param aabb Returns the axis aligned box.
+	 * @param xf The world transform of the shape.
+	 * @param childIndex The child shape
+	 */
+	computeAABB(aabb: AABBValue, xf: TransformValue, childIndex: number): void;
+	/**
+	 * Compute the mass properties of this shape using its dimensions and density.
+	 * The inertia tensor is computed about the local origin.
+	 *
+	 * @param massData Returns the mass data for this shape.
+	 * @param density The density in kilograms per meter squared.
+	 */
+	computeMass(massData: MassData, density: number): void;
+	computeDistanceProxy(proxy: DistanceProxy): void;
+}
+/**
+ * A line segment (edge) shape. These can be connected in chains or loops to
+ * other edge shapes. The connectivity information is used to ensure correct
+ * contact normals.
+ */
+export declare class EdgeShape extends Shape {
+	static TYPE: "edge";
+	/** @hidden */ m_type: "edge";
+	/** @hidden */ m_radius: number;
+	/** @hidden */ m_vertex1: Vec2Value;
+	/** @hidden */ m_vertex2: Vec2Value;
+	/** @hidden */ m_vertex0: Vec2Value;
+	/** @hidden */ m_vertex3: Vec2Value;
+	/** @hidden */ m_hasVertex0: boolean;
+	/** @hidden */ m_hasVertex3: boolean;
+	constructor(v1?: Vec2Value, v2?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any): EdgeShape;
+	/** @hidden */
+	_reset(): void;
+	getRadius(): number;
+	getType(): "edge";
+	/**
+	 * Optional next vertex, used for smooth collision.
+	 */
+	setNextVertex(v?: Vec2Value): EdgeShape;
+	/**
+	 * Optional next vertex, used for smooth collision.
+	 */
+	getNextVertex(): Vec2Value;
+	/**
+	 * Optional prev vertex, used for smooth collision.
+	 */
+	setPrevVertex(v?: Vec2Value): EdgeShape;
+	/**
+	 * Optional prev vertex, used for smooth collision.
+	 */
+	getPrevVertex(): Vec2Value;
+	/**
+	 * Set this as an isolated edge.
+	 */
+	_set(v1: Vec2Value, v2: Vec2Value): EdgeShape;
+	/**
+	 * Get the number of child primitives.
+	 */
+	getChildCount(): 1;
+	/**
+	 * Test a point for containment in this shape. This only works for convex
+	 * shapes.
+	 *
+	 * @param xf The shape world transform.
+	 * @param p A point in world coordinates.
+	 */
+	testPoint(xf: TransformValue, p: Vec2Value): false;
+	/**
+	 * Cast a ray against a child shape.
+	 *
+	 * @param output The ray-cast results.
+	 * @param input The ray-cast input parameters.
+	 * @param xf The transform to be applied to the shape.
+	 * @param childIndex The child shape index
+	 */
+	rayCast(output: RayCastOutput, input: RayCastInput, xf: TransformValue, childIndex: number): boolean;
+	/**
+	 * Given a transform, compute the associated axis aligned bounding box for a
+	 * child shape.
+	 *
+	 * @param aabb Returns the axis aligned box.
+	 * @param xf The world transform of the shape.
+	 * @param childIndex The child shape
+	 */
+	computeAABB(aabb: AABBValue, xf: TransformValue, childIndex: number): void;
+	/**
+	 * Compute the mass properties of this shape using its dimensions and density.
+	 * The inertia tensor is computed about the local origin.
+	 *
+	 * @param massData Returns the mass data for this shape.
+	 * @param density The density in kilograms per meter squared.
+	 */
+	computeMass(massData: MassData, density?: number): void;
+	computeDistanceProxy(proxy: DistanceProxy): void;
+}
+/**
+ * A convex polygon. It is assumed that the interior of the polygon is to the
+ * left of each edge. Polygons have a maximum number of vertices equal to
+ * Settings.maxPolygonVertices. In most cases you should not need many vertices
+ * for a convex polygon. extends Shape
+ */
+export declare class PolygonShape extends Shape {
+	static TYPE: "polygon";
+	/** @hidden */ m_type: "polygon";
+	/** @hidden */ m_centroid: Vec2Value;
+	/** @hidden */ m_vertices: Vec2Value[];
+	/** @hidden */ m_normals: Vec2Value[];
+	/** @hidden */ m_count: number;
+	/** @hidden */ m_radius: number;
+	constructor(vertices?: Vec2Value[]);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, fixture: any, restore: any): PolygonShape;
+	getType(): "polygon";
+	getRadius(): number;
+	/**
+	 * Get the number of child primitives.
+	 */
+	getChildCount(): 1;
+	/** @hidden */
+	_reset(): void;
+	/**
+	 * Test a point for containment in this shape. This only works for convex
+	 * shapes.
+	 *
+	 * @param xf The shape world transform.
+	 * @param p A point in world coordinates.
+	 */
+	testPoint(xf: TransformValue, p: Vec2Value): boolean;
+	/**
+	 * Cast a ray against a child shape.
+	 *
+	 * @param output The ray-cast results.
+	 * @param input The ray-cast input parameters.
+	 * @param xf The transform to be applied to the shape.
+	 * @param childIndex The child shape index
+	 */
+	rayCast(output: RayCastOutput, input: RayCastInput, xf: TransformValue, childIndex: number): boolean;
+	/**
+	 * Given a transform, compute the associated axis aligned bounding box for a
+	 * child shape.
+	 *
+	 * @param aabb Returns the axis aligned box.
+	 * @param xf The world transform of the shape.
+	 * @param childIndex The child shape
+	 */
+	computeAABB(aabb: AABBValue, xf: TransformValue, childIndex: number): void;
+	/**
+	 * Compute the mass properties of this shape using its dimensions and density.
+	 * The inertia tensor is computed about the local origin.
+	 *
+	 * @param massData Returns the mass data for this shape.
+	 * @param density The density in kilograms per meter squared.
+	 */
+	computeMass(massData: MassData, density: number): void;
+	/**
+	 * Validate convexity. This is a very time consuming operation.
+	 * @returns true if valid
+	 */
+	validate(): boolean;
+	computeDistanceProxy(proxy: DistanceProxy): void;
+}
+/**
+ * A chain shape is a free form sequence of line segments. The chain has
+ * two-sided collision, so you can use inside and outside collision. Therefore,
+ * you may use any winding order. Connectivity information is used to create
+ * smooth collisions.
+ *
+ * WARNING: The chain will not collide properly if there are self-intersections.
+ */
+export declare class ChainShape extends Shape {
+	static TYPE: "chain";
+	/** @hidden */ m_type: "chain";
+	/** @hidden */ m_radius: number;
+	/** @hidden */ m_vertices: Vec2Value[];
+	/** @hidden */ m_count: number;
+	/** @hidden */ m_prevVertex: Vec2Value | null;
+	/** @hidden */ m_nextVertex: Vec2Value | null;
+	/** @hidden */ m_hasPrevVertex: boolean;
+	/** @hidden */ m_hasNextVertex: boolean;
+	/** @hidden */ m_isLoop: boolean;
+	constructor(vertices?: Vec2Value[], loop?: boolean);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, fixture: any, restore: any): ChainShape;
+	getType(): "chain";
+	getRadius(): number;
+	/** @hidden */
+	_reset(): void;
+	/**
+	 * Establish connectivity to a vertex that precedes the first vertex. Don't call
+	 * this for loops.
+	 */
+	setPrevVertex(prevVertex: Vec2Value): void;
+	getPrevVertex(): Vec2Value;
+	/**
+	 * Establish connectivity to a vertex that follows the last vertex. Don't call
+	 * this for loops.
+	 */
+	setNextVertex(nextVertex: Vec2Value): void;
+	getNextVertex(): Vec2Value;
+	/**
+	 * Get the number of child primitives.
+	 */
+	getChildCount(): number;
+	getChildEdge(edge: EdgeShape, childIndex: number): void;
+	getVertex(index: number): Vec2Value;
+	isLoop(): boolean;
+	/**
+	 * Test a point for containment in this shape. This only works for convex
+	 * shapes.
+	 *
+	 * This always return false.
+	 *
+	 * @param xf The shape world transform.
+	 * @param p A point in world coordinates.
+	 */
+	testPoint(xf: TransformValue, p: Vec2Value): false;
+	/**
+	 * Cast a ray against a child shape.
+	 *
+	 * @param output The ray-cast results.
+	 * @param input The ray-cast input parameters.
+	 * @param xf The transform to be applied to the shape.
+	 * @param childIndex The child shape index
+	 */
+	rayCast(output: RayCastOutput, input: RayCastInput, xf: TransformValue, childIndex: number): boolean;
+	/**
+	 * Given a transform, compute the associated axis aligned bounding box for a
+	 * child shape.
+	 *
+	 * @param aabb Returns the axis aligned box.
+	 * @param xf The world transform of the shape.
+	 * @param childIndex The child shape
+	 */
+	computeAABB(aabb: AABBValue, xf: TransformValue, childIndex: number): void;
+	/**
+	 * Compute the mass properties of this shape using its dimensions and density.
+	 * The inertia tensor is computed about the local origin.
+	 *
+	 * Chains have zero mass.
+	 *
+	 * @param massData Returns the mass data for this shape.
+	 * @param density The density in kilograms per meter squared.
+	 */
+	computeMass(massData: MassData, density?: number): void;
+	computeDistanceProxy(proxy: DistanceProxy, childIndex: number): void;
+}
+/**
+ * A rectangle polygon which extend PolygonShape.
+ */
+export declare class BoxShape extends PolygonShape {
+	static TYPE: "polygon";
+	/**
+	 *
+	 * @param halfWidth
+	 * @param halfHeight
+	 * @param center coordinate of the center of the box relative to the body
+	 * @param angle angle of the box relative to the body
+	 */
+	constructor(halfWidth: number, halfHeight: number, center?: Vec2Value, angle?: number);
+}
+export declare const CollideCircles: (manifold: Manifold, circleA: CircleShape, xfA: TransformValue, circleB: CircleShape, xfB: TransformValue) => void;
+export declare const CollideEdgeCircle: (manifold: Manifold, edgeA: EdgeShape, xfA: TransformValue, circleB: CircleShape, xfB: TransformValue) => void;
+/**
+ *
+ * Find edge normal of max separation on A - return if separating axis is found
+ * Find edge normal of max separation on B - return if separation axis is found
+ * Choose reference edge as min(minA, minB)
+ * Find incident edge
+ * Clip
+ *
+ * The normal points from 1 to 2
+ */
+export declare const CollidePolygons: (manifold: Manifold, polyA: PolygonShape, xfA: TransformValue, polyB: PolygonShape, xfB: TransformValue) => void;
+export declare const CollidePolygonCircle: (manifold: Manifold, polygonA: PolygonShape, xfA: TransformValue, circleB: CircleShape, xfB: TransformValue) => void;
+/**
+ * This function collides and edge and a polygon, taking into account edge
+ * adjacency.
+ */
+export declare const CollideEdgePolygon: (manifold: Manifold, edgeA: EdgeShape, xfA: TransformValue, polygonB: PolygonShape, xfB: TransformValue) => void;
+/**
+ * Distance joint definition. This requires defining an anchor point on both
+ * bodies and the non-zero length of the distance joint. The definition uses
+ * local anchor points so that the initial configuration can violate the
+ * constraint slightly. This helps when saving and loading a game. Warning: Do
+ * not use a zero or short length.
+ */
+export interface DistanceJointOpt extends JointOpt {
+	/**
+	 * The mass-spring-damper frequency in Hertz. A value of 0 disables softness.
+	 */
+	frequencyHz?: number;
+	/**
+	 * The damping ratio. 0 = no damping, 1 = critical damping.
+	 */
+	dampingRatio?: number;
+	/**
+	 * Distance length.
+	 */
+	length?: number;
+}
+/**
+ * Distance joint definition. This requires defining an anchor point on both
+ * bodies and the non-zero length of the distance joint. The definition uses
+ * local anchor points so that the initial configuration can violate the
+ * constraint slightly. This helps when saving and loading a game. Warning: Do
+ * not use a zero or short length.
+ */
+export interface DistanceJointDef extends JointDef, DistanceJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+}
+/**
+ * A distance joint constrains two points on two bodies to remain at a fixed
+ * distance from each other. You can view this as a massless, rigid rod.
+ */
+export declare class DistanceJoint extends Joint {
+	static TYPE: "distance-joint";
+	/**
+	 * @param def DistanceJoint definition.
+	 */
+	constructor(def: DistanceJointDef);
+	/**
+	 * @param anchorA Anchor A in global coordination.
+	 * @param anchorB Anchor B in global coordination.
+	 */
+	constructor(def: DistanceJointOpt, bodyA: Body$1, bodyB: Body$1, anchorA?: Vec2Value, anchorB?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): DistanceJoint;
+	/** @hidden */
+	_reset(def: Partial<DistanceJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * Set the natural length. Manipulating the length can lead to non-physical
+	 * behavior when the frequency is zero.
+	 */
+	setLength(length: number): void;
+	/**
+	 * Get the natural length.
+	 */
+	getLength(): number;
+	setFrequency(hz: number): void;
+	getFrequency(): number;
+	setDampingRatio(ratio: number): void;
+	getDampingRatio(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Friction joint definition.
+ */
+export interface FrictionJointOpt extends JointOpt {
+	/**
+	 * The maximum friction force in N.
+	 */
+	maxForce?: number;
+	/**
+	 * The maximum friction torque in N-m.
+	 */
+	maxTorque?: number;
+}
+/**
+ * Friction joint definition.
+ */
+export interface FrictionJointDef extends JointDef, FrictionJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+}
+/**
+ * Friction joint. This is used for top-down friction. It provides 2D
+ * translational friction and angular friction.
+ */
+export declare class FrictionJoint extends Joint {
+	static TYPE: "friction-joint";
+	constructor(def: FrictionJointDef);
+	/**
+	 * @param anchor Anchor in global coordination.
+	 */
+	constructor(def: FrictionJointOpt, bodyA: Body$1, bodyB: Body$1, anchor?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): FrictionJoint;
+	/** @hidden */
+	_reset(def: Partial<FrictionJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * Set the maximum friction force in N.
+	 */
+	setMaxForce(force: number): void;
+	/**
+	 * Get the maximum friction force in N.
+	 */
+	getMaxForce(): number;
+	/**
+	 * Set the maximum friction torque in N*m.
+	 */
+	setMaxTorque(torque: number): void;
+	/**
+	 * Get the maximum friction torque in N*m.
+	 */
+	getMaxTorque(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Revolute joint definition. This requires defining an anchor point where the
+ * bodies are joined. The definition uses local anchor points so that the
+ * initial configuration can violate the constraint slightly. You also need to
+ * specify the initial relative angle for joint limits. This helps when saving
+ * and loading a game.
+ *
+ * The local anchor points are measured from the body's origin rather than the
+ * center of mass because: 1. you might not know where the center of mass will
+ * be. 2. if you add/remove shapes from a body and recompute the mass, the
+ * joints will be broken.
+ */
+export interface RevoluteJointOpt extends JointOpt {
+	/**
+	 * The lower angle for the joint limit (radians).
+	 */
+	lowerAngle?: number;
+	/**
+	 * The upper angle for the joint limit (radians).
+	 */
+	upperAngle?: number;
+	/**
+	 * The maximum motor torque used to achieve the desired motor speed. Usually
+	 * in N-m.
+	 */
+	maxMotorTorque?: number;
+	/**
+	 * The desired motor speed. Usually in radians per second.
+	 */
+	motorSpeed?: number;
+	/**
+	 * A flag to enable joint limits.
+	 */
+	enableLimit?: boolean;
+	/**
+	 * A flag to enable the joint motor.
+	 */
+	enableMotor?: boolean;
+}
+/**
+ * Revolute joint definition. This requires defining an anchor point where the
+ * bodies are joined. The definition uses local anchor points so that the
+ * initial configuration can violate the constraint slightly. You also need to
+ * specify the initial relative angle for joint limits. This helps when saving
+ * and loading a game.
+ *
+ * The local anchor points are measured from the body's origin rather than the
+ * center of mass because: 1. you might not know where the center of mass will
+ * be. 2. if you add/remove shapes from a body and recompute the mass, the
+ * joints will be broken.
+ */
+export interface RevoluteJointDef extends JointDef, RevoluteJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+	/**
+	 * The bodyB angle minus bodyA angle in the reference state (radians).
+	 */
+	referenceAngle?: number;
+}
+/**
+ * A revolute joint constrains two bodies to share a common point while they are
+ * free to rotate about the point. The relative rotation about the shared point
+ * is the joint angle. You can limit the relative rotation with a joint limit
+ * that specifies a lower and upper angle. You can use a motor to drive the
+ * relative rotation about the shared point. A maximum motor torque is provided
+ * so that infinite forces are not generated.
+ */
+export declare class RevoluteJoint extends Joint {
+	static TYPE: "revolute-joint";
+	constructor(def: RevoluteJointDef);
+	constructor(def: RevoluteJointOpt, bodyA: Body$1, bodyB: Body$1, anchor?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): RevoluteJoint;
+	/** @hidden */
+	_reset(def: Partial<RevoluteJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * Get the reference angle.
+	 */
+	getReferenceAngle(): number;
+	/**
+	 * Get the current joint angle in radians.
+	 */
+	getJointAngle(): number;
+	/**
+	 * Get the current joint angle speed in radians per second.
+	 */
+	getJointSpeed(): number;
+	/**
+	 * Is the joint motor enabled?
+	 */
+	isMotorEnabled(): boolean;
+	/**
+	 * Enable/disable the joint motor.
+	 */
+	enableMotor(flag: boolean): void;
+	/**
+	 * Get the current motor torque given the inverse time step. Unit is N*m.
+	 */
+	getMotorTorque(inv_dt: number): number;
+	/**
+	 * Set the motor speed in radians per second.
+	 */
+	setMotorSpeed(speed: number): void;
+	/**
+	 * Get the motor speed in radians per second.
+	 */
+	getMotorSpeed(): number;
+	/**
+	 * Set the maximum motor torque, usually in N-m.
+	 */
+	setMaxMotorTorque(torque: number): void;
+	getMaxMotorTorque(): number;
+	/**
+	 * Is the joint limit enabled?
+	 */
+	isLimitEnabled(): boolean;
+	/**
+	 * Enable/disable the joint limit.
+	 */
+	enableLimit(flag: boolean): void;
+	/**
+	 * Get the lower joint limit in radians.
+	 */
+	getLowerLimit(): number;
+	/**
+	 * Get the upper joint limit in radians.
+	 */
+	getUpperLimit(): number;
+	/**
+	 * Set the joint limits in radians.
+	 */
+	setLimits(lower: number, upper: number): void;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force given the inverse time step. Unit is N.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque due to the joint limit given the inverse time step.
+	 * Unit is N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Prismatic joint definition. This requires defining a line of motion using an
+ * axis and an anchor point. The definition uses local anchor points and a local
+ * axis so that the initial configuration can violate the constraint slightly.
+ * The joint translation is zero when the local anchor points coincide in world
+ * space. Using local anchors and a local axis helps when saving and loading a
+ * game.
+ */
+export interface PrismaticJointOpt extends JointOpt {
+	/**
+	 * Enable/disable the joint limit.
+	 */
+	enableLimit?: boolean;
+	/**
+	 * The lower translation limit, usually in meters.
+	 */
+	lowerTranslation?: number;
+	/**
+	 * The upper translation limit, usually in meters.
+	 */
+	upperTranslation?: number;
+	/**
+	 * Enable/disable the joint motor.
+	 */
+	enableMotor?: boolean;
+	/**
+	 * The maximum motor torque, usually in N-m.
+	 */
+	maxMotorForce?: number;
+	/**
+	 * The desired motor speed in radians per second.
+	 */
+	motorSpeed?: number;
+}
+/**
+ * Prismatic joint definition. This requires defining a line of motion using an
+ * axis and an anchor point. The definition uses local anchor points and a local
+ * axis so that the initial configuration can violate the constraint slightly.
+ * The joint translation is zero when the local anchor points coincide in world
+ * space. Using local anchors and a local axis helps when saving and loading a
+ * game.
+ */
+export interface PrismaticJointDef extends JointDef, PrismaticJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+	/**
+	 * The local translation unit axis in bodyA.
+	 */
+	localAxisA: Vec2Value;
+	/**
+	 * referenceAngle The constrained angle between the bodies:
+	 * bodyB_angle - bodyA_angle.
+	 */
+	referenceAngle?: number;
+}
+/**
+ * A prismatic joint. This joint provides one degree of freedom: translation
+ * along an axis fixed in bodyA. Relative rotation is prevented. You can use a
+ * joint limit to restrict the range of motion and a joint motor to drive the
+ * motion or to model joint friction.
+ */
+export declare class PrismaticJoint extends Joint {
+	static TYPE: "prismatic-joint";
+	constructor(def: PrismaticJointDef);
+	constructor(def: PrismaticJointOpt, bodyA: Body$1, bodyB: Body$1, anchor?: Vec2Value, axis?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): PrismaticJoint;
+	/** @hidden */
+	_reset(def: Partial<PrismaticJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * The local joint axis relative to bodyA.
+	 */
+	getLocalAxisA(): Vec2Value;
+	/**
+	 * Get the reference angle.
+	 */
+	getReferenceAngle(): number;
+	/**
+	 * Get the current joint translation, usually in meters.
+	 */
+	getJointTranslation(): number;
+	/**
+	 * Get the current joint translation speed, usually in meters per second.
+	 */
+	getJointSpeed(): number;
+	/**
+	 * Is the joint limit enabled?
+	 */
+	isLimitEnabled(): boolean;
+	/**
+	 * Enable/disable the joint limit.
+	 */
+	enableLimit(flag: boolean): void;
+	/**
+	 * Get the lower joint limit, usually in meters.
+	 */
+	getLowerLimit(): number;
+	/**
+	 * Get the upper joint limit, usually in meters.
+	 */
+	getUpperLimit(): number;
+	/**
+	 * Set the joint limits, usually in meters.
+	 */
+	setLimits(lower: number, upper: number): void;
+	/**
+	 * Is the joint motor enabled?
+	 */
+	isMotorEnabled(): boolean;
+	/**
+	 * Enable/disable the joint motor.
+	 */
+	enableMotor(flag: boolean): void;
+	/**
+	 * Set the motor speed, usually in meters per second.
+	 */
+	setMotorSpeed(speed: number): void;
+	/**
+	 * Set the maximum motor force, usually in N.
+	 */
+	setMaxMotorForce(force: number): void;
+	getMaxMotorForce(): number;
+	/**
+	 * Get the motor speed, usually in meters per second.
+	 */
+	getMotorSpeed(): number;
+	/**
+	 * Get the current motor force given the inverse time step, usually in N.
+	 */
+	getMotorForce(inv_dt: number): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Gear joint definition.
+ */
+export interface GearJointOpt extends JointOpt {
+	/**
+	 * The gear ratio. See {@link GearJoint} for explanation.
+	 */
+	ratio?: number;
+}
+/**
+ * Gear joint definition.
+ */
+export interface GearJointDef extends JointDef, GearJointOpt {
+	/**
+	 * The first revolute/prismatic joint attached to the gear joint.
+	 */
+	joint1: RevoluteJoint | PrismaticJoint;
+	/**
+	 * The second prismatic/revolute joint attached to the gear joint.
+	 */
+	joint2: RevoluteJoint | PrismaticJoint;
+}
+/**
+ * A gear joint is used to connect two joints together. Either joint can be a
+ * revolute or prismatic joint. You specify a gear ratio to bind the motions
+ * together: coordinate1 + ratio * coordinate2 = constant
+ *
+ * The ratio can be negative or positive. If one joint is a revolute joint and
+ * the other joint is a prismatic joint, then the ratio will have units of
+ * length or units of 1/length. Warning: You have to manually destroy the gear
+ * joint if joint1 or joint2 is destroyed.
+ *
+ * This definition requires two existing revolute or prismatic joints (any
+ * combination will work).
+ */
+export declare class GearJoint extends Joint {
+	static TYPE: "gear-joint";
+	constructor(def: GearJointDef);
+	constructor(def: GearJointOpt, bodyA: Body$1, bodyB: Body$1, joint1: RevoluteJoint | PrismaticJoint, joint2: RevoluteJoint | PrismaticJoint, ratio?: number);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): GearJoint;
+	/** @hidden */
+	_reset(def: Partial<GearJointDef>): void;
+	/**
+	 * Get the first joint.
+	 */
+	getJoint1(): Joint;
+	/**
+	 * Get the second joint.
+	 */
+	getJoint2(): Joint;
+	/**
+	 * Set the gear ratio.
+	 */
+	setRatio(ratio: number): void;
+	/**
+	 * Get the gear ratio.
+	 */
+	getRatio(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Motor joint definition.
+ */
+export interface MotorJointOpt extends JointOpt {
+	/**
+	 * The bodyB angle minus bodyA angle in radians.
+	 */
+	angularOffset?: number;
+	/**
+	 * The maximum motor force in N.
+	 */
+	maxForce?: number;
+	/**
+	 * The maximum motor torque in N-m.
+	 */
+	maxTorque?: number;
+	/**
+	 * Position correction factor in the range [0,1].
+	 */
+	correctionFactor?: number;
+	/**
+	 * Position of bodyB minus the position of bodyA, in bodyA's frame, in meters.
+	 */
+	linearOffset?: Vec2Value;
+}
+/**
+ * Motor joint definition.
+ */
+export interface MotorJointDef extends JointDef, MotorJointOpt {
+}
+/**
+ * A motor joint is used to control the relative motion between two bodies. A
+ * typical usage is to control the movement of a dynamic body with respect to
+ * the ground.
+ */
+export declare class MotorJoint extends Joint {
+	static TYPE: "motor-joint";
+	constructor(def: MotorJointDef);
+	constructor(def: MotorJointOpt, bodyA: Body$1, bodyB: Body$1);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): MotorJoint;
+	/** @hidden */
+	_reset(def: Partial<MotorJointDef>): void;
+	/**
+	 * Set the maximum friction force in N.
+	 */
+	setMaxForce(force: number): void;
+	/**
+	 * Get the maximum friction force in N.
+	 */
+	getMaxForce(): number;
+	/**
+	 * Set the maximum friction torque in N*m.
+	 */
+	setMaxTorque(torque: number): void;
+	/**
+	 * Get the maximum friction torque in N*m.
+	 */
+	getMaxTorque(): number;
+	/**
+	 * Set the position correction factor in the range [0,1].
+	 */
+	setCorrectionFactor(factor: number): void;
+	/**
+	 * Get the position correction factor in the range [0,1].
+	 */
+	getCorrectionFactor(): number;
+	/**
+	 * Set/get the target linear offset, in frame A, in meters.
+	 */
+	setLinearOffset(linearOffset: Vec2Value): void;
+	getLinearOffset(): Vec2Value;
+	/**
+	 * Set/get the target angular offset, in radians.
+	 */
+	setAngularOffset(angularOffset: number): void;
+	getAngularOffset(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Mouse joint definition. This requires a world target point, tuning
+ * parameters, and the time step.
+ */
+export interface MouseJointOpt extends JointOpt {
+	/**
+	 * [maxForce = 0.0] The maximum constraint force that can be exerted to move
+	 * the candidate body. Usually you will express as some multiple of the
+	 * weight (multiplier * mass * gravity).
+	 */
+	maxForce?: number;
+	/**
+	 * [frequencyHz = 5.0] The response speed.
+	 */
+	frequencyHz?: number;
+	/**
+	 * [dampingRatio = 0.7] The damping ratio. 0 = no damping, 1 = critical
+	 * damping.
+	 */
+	dampingRatio?: number;
+}
+/**
+ * Mouse joint definition. This requires a world target point, tuning
+ * parameters, and the time step.
+ */
+export interface MouseJointDef extends JointDef, MouseJointOpt {
+	/**
+	 * The initial world target point. This is assumed to coincide with the body
+	 * anchor initially.
+	 */
+	target: Vec2Value;
+}
+/**
+ * A mouse joint is used to make a point on a body track a specified world
+ * point. This a soft constraint with a maximum force. This allows the
+ * constraint to stretch and without applying huge forces.
+ *
+ * You need to call setTarget(target) every time that mouse is
+ * moved, to track the new location of the mouse.
+ *
+ * NOTE: this joint is not documented in the manual because it was developed to
+ * be used in the testbed. If you want to learn how to use the mouse joint, look
+ * at the testbed.
+ */
+export declare class MouseJoint extends Joint {
+	static TYPE: "mouse-joint";
+	constructor(def: MouseJointDef);
+	constructor(def: MouseJointOpt, bodyA: Body$1, bodyB: Body$1, target?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): MouseJoint;
+	/** @hidden */
+	_reset(def: Partial<MouseJointDef>): void;
+	/**
+	 * Use this to update the target point.
+	 */
+	setTarget(target: Vec2Value): void;
+	getTarget(): Vec2Value;
+	/**
+	 * Set the maximum force in Newtons.
+	 */
+	setMaxForce(force: number): void;
+	/**
+	 * Get the maximum force in Newtons.
+	 */
+	getMaxForce(): number;
+	/**
+	 * Set the frequency in Hertz.
+	 */
+	setFrequency(hz: number): void;
+	/**
+	 * Get the frequency in Hertz.
+	 */
+	getFrequency(): number;
+	/**
+	 * Set the damping ratio (dimensionless).
+	 */
+	setDampingRatio(ratio: number): void;
+	/**
+	 * Get the damping ratio (dimensionless).
+	 */
+	getDampingRatio(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	/**
+	 * Shift the origin for any points stored in world coordinates.
+	 */
+	shiftOrigin(newOrigin: Vec2Value): void;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Pulley joint definition. This requires two ground anchors, two dynamic body
+ * anchor points, and a pulley ratio.
+ */
+export interface PulleyJointOpt extends JointOpt {
+}
+/**
+ * Pulley joint definition. This requires two ground anchors, two dynamic body
+ * anchor points, and a pulley ratio.
+ */
+export interface PulleyJointDef extends JointDef, PulleyJointOpt {
+	/**
+	 * The first ground anchor in world coordinates. This point never moves.
+	 */
+	groundAnchorA: Vec2Value;
+	/**
+	 * The second ground anchor in world coordinates. This point never moves.
+	 */
+	groundAnchorB: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+	/**
+	 * The reference length for the segment attached to bodyA.
+	 */
+	lengthA: number;
+	/**
+	 * The reference length for the segment attached to bodyB.
+	 */
+	lengthB: number;
+	/**
+	 * The pulley ratio, used to simulate a block-and-tackle.
+	 */
+	ratio: number;
+	/** @hidden */ anchorA?: Vec2Value;
+	/** @hidden */ anchorB?: Vec2Value;
+}
+/**
+ * The pulley joint is connected to two bodies and two fixed ground points. The
+ * pulley supports a ratio such that: length1 + ratio * length2 <= constant
+ *
+ * Yes, the force transmitted is scaled by the ratio.
+ *
+ * Warning: the pulley joint can get a bit squirrelly by itself. They often work
+ * better when combined with prismatic joints. You should also cover the the
+ * anchor points with static shapes to prevent one side from going to zero
+ * length.
+ */
+export declare class PulleyJoint extends Joint {
+	static TYPE: "pulley-joint";
+	constructor(def: PulleyJointDef);
+	constructor(def: PulleyJointOpt, bodyA: Body$1, bodyB: Body$1, groundA?: Vec2Value, groundB?: Vec2Value, anchorA?: Vec2Value, anchorB?: Vec2Value, ratio?: number);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): PulleyJoint;
+	/** @hidden */
+	_reset(def: Partial<PulleyJointDef>): void;
+	/**
+	 * Get the first ground anchor.
+	 */
+	getGroundAnchorA(): Vec2Value;
+	/**
+	 * Get the second ground anchor.
+	 */
+	getGroundAnchorB(): Vec2Value;
+	/**
+	 * Get the current length of the segment attached to bodyA.
+	 */
+	getLengthA(): number;
+	/**
+	 * Get the current length of the segment attached to bodyB.
+	 */
+	getLengthB(): number;
+	/**
+	 * Get the pulley ratio.
+	 */
+	getRatio(): number;
+	/**
+	 * Get the current length of the segment attached to bodyA.
+	 */
+	getCurrentLengthA(): number;
+	/**
+	 * Get the current length of the segment attached to bodyB.
+	 */
+	getCurrentLengthB(): number;
+	/**
+	 * Shift the origin for any points stored in world coordinates.
+	 *
+	 * @param newOrigin
+	 */
+	shiftOrigin(newOrigin: Vec2Value): void;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Rope joint definition. This requires two body anchor points and a maximum
+ * lengths. Note: by default the connected objects will not collide. see
+ * collideConnected in JointDef.
+ */
+export interface RopeJointOpt extends JointOpt {
+	/**
+	 * The maximum length of the rope.
+	 * Warning: this must be larger than linearSlop or the joint will have no effect.
+	 */
+	maxLength?: number;
+}
+/**
+ * Rope joint definition. This requires two body anchor points and a maximum
+ * lengths. Note: by default the connected objects will not collide. see
+ * collideConnected in JointDef.
+ */
+export interface RopeJointDef extends JointDef, RopeJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+}
+/**
+ * A rope joint enforces a maximum distance between two points on two bodies. It
+ * has no other effect.
+ *
+ * Warning: if you attempt to change the maximum length during the simulation
+ * you will get some non-physical behavior.
+ *
+ * A model that would allow you to dynamically modify the length would have some
+ * sponginess, so I chose not to implement it that way. See {@link DistanceJoint} if you
+ * want to dynamically control length.
+ */
+export declare class RopeJoint extends Joint {
+	static TYPE: "rope-joint";
+	constructor(def: RopeJointDef);
+	constructor(def: RopeJointOpt, bodyA: Body$1, bodyB: Body$1, anchor?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): RopeJoint;
+	/** @hidden */
+	_reset(def: Partial<RopeJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * Set the maximum length of the rope.
+	 */
+	setMaxLength(length: number): void;
+	/**
+	 * Get the maximum length of the rope.
+	 */
+	getMaxLength(): number;
+	getLimitState(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Weld joint definition. You need to specify local anchor points where they are
+ * attached and the relative body angle. The position of the anchor points is
+ * important for computing the reaction torque.
+ */
+export interface WeldJointOpt extends JointOpt {
+	/**
+	 * The mass-spring-damper frequency in Hertz. Rotation only. Disable softness
+	 * with a value of 0.
+	 */
+	frequencyHz?: number;
+	/**
+	 * The damping ratio. 0 = no damping, 1 = critical damping.
+	 */
+	dampingRatio?: number;
+	/**
+	 * The bodyB angle minus bodyA angle in the reference state (radians).
+	 */
+	referenceAngle?: number;
+}
+/**
+ * Weld joint definition. You need to specify local anchor points where they are
+ * attached and the relative body angle. The position of the anchor points is
+ * important for computing the reaction torque.
+ */
+export interface WeldJointDef extends JointDef, WeldJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+}
+/**
+ * A weld joint essentially glues two bodies together. A weld joint may distort
+ * somewhat because the island constraint solver is approximate.
+ */
+export declare class WeldJoint extends Joint {
+	static TYPE: "weld-joint";
+	constructor(def: WeldJointDef);
+	constructor(def: WeldJointOpt, bodyA: Body$1, bodyB: Body$1, anchor?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): WeldJoint;
+	/** @hidden */
+	_reset(def: Partial<WeldJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * Get the reference angle.
+	 */
+	getReferenceAngle(): number;
+	/**
+	 * Set frequency in Hz.
+	 */
+	setFrequency(hz: number): void;
+	/**
+	 * Get frequency in Hz.
+	 */
+	getFrequency(): number;
+	/**
+	 * Set damping ratio.
+	 */
+	setDampingRatio(ratio: number): void;
+	/**
+	 * Get damping ratio.
+	 */
+	getDampingRatio(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Wheel joint definition. This requires defining a line of motion using an axis
+ * and an anchor point. The definition uses local anchor points and a local axis
+ * so that the initial configuration can violate the constraint slightly. The
+ * joint translation is zero when the local anchor points coincide in world
+ * space. Using local anchors and a local axis helps when saving and loading a
+ * game.
+ */
+export interface WheelJointOpt extends JointOpt {
+	/**
+	 * Enable/disable the joint motor.
+	 */
+	enableMotor?: boolean;
+	/**
+	 * The maximum motor torque, usually in N-m.
+	 */
+	maxMotorTorque?: number;
+	/**
+	 * The desired motor speed in radians per second.
+	 */
+	motorSpeed?: number;
+	/**
+	 * Suspension frequency, zero indicates no suspension.
+	 */
+	frequencyHz?: number;
+	/**
+	 * Suspension damping ratio, one indicates critical damping.
+	 */
+	dampingRatio?: number;
+}
+/**
+ * Wheel joint definition. This requires defining a line of motion using an axis
+ * and an anchor point. The definition uses local anchor points and a local axis
+ * so that the initial configuration can violate the constraint slightly. The
+ * joint translation is zero when the local anchor points coincide in world
+ * space. Using local anchors and a local axis helps when saving and loading a
+ * game.
+ */
+export interface WheelJointDef extends JointDef, WheelJointOpt {
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	localAnchorA: Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	localAnchorB: Vec2Value;
+	/**
+	 * The local translation axis in bodyA.
+	 */
+	localAxisA: Vec2Value;
+}
+/**
+ * A wheel joint. This joint provides two degrees of freedom: translation along
+ * an axis fixed in bodyA and rotation in the plane. In other words, it is a
+ * point to line constraint with a rotational motor and a linear spring/damper.
+ * This joint is designed for vehicle suspensions.
+ */
+export declare class WheelJoint extends Joint {
+	static TYPE: "wheel-joint";
+	constructor(def: WheelJointDef);
+	constructor(def: WheelJointOpt, bodyA: Body$1, bodyB: Body$1, anchor?: Vec2Value, axis?: Vec2Value);
+	/** @hidden */
+	_serialize(): object;
+	/** @hidden */
+	static _deserialize(data: any, world: any, restore: any): WheelJoint;
+	/** @hidden */
+	_reset(def: Partial<WheelJointDef>): void;
+	/**
+	 * The local anchor point relative to bodyA's origin.
+	 */
+	getLocalAnchorA(): Vec2Value;
+	/**
+	 * The local anchor point relative to bodyB's origin.
+	 */
+	getLocalAnchorB(): Vec2Value;
+	/**
+	 * The local joint axis relative to bodyA.
+	 */
+	getLocalAxisA(): Vec2Value;
+	/**
+	 * Get the current joint translation, usually in meters.
+	 */
+	getJointTranslation(): number;
+	/**
+	 * Get the current joint translation speed, usually in meters per second.
+	 */
+	getJointSpeed(): number;
+	/**
+	 * Is the joint motor enabled?
+	 */
+	isMotorEnabled(): boolean;
+	/**
+	 * Enable/disable the joint motor.
+	 */
+	enableMotor(flag: boolean): void;
+	/**
+	 * Set the motor speed, usually in radians per second.
+	 */
+	setMotorSpeed(speed: number): void;
+	/**
+	 * Get the motor speed, usually in radians per second.
+	 */
+	getMotorSpeed(): number;
+	/**
+	 * Set/Get the maximum motor force, usually in N-m.
+	 */
+	setMaxMotorTorque(torque: number): void;
+	getMaxMotorTorque(): number;
+	/**
+	 * Get the current motor torque given the inverse time step, usually in N-m.
+	 */
+	getMotorTorque(inv_dt: number): number;
+	/**
+	 * Set/Get the spring frequency in hertz. Setting the frequency to zero disables
+	 * the spring.
+	 */
+	setSpringFrequencyHz(hz: number): void;
+	getSpringFrequencyHz(): number;
+	/**
+	 * Set/Get the spring damping ratio
+	 */
+	setSpringDampingRatio(ratio: number): void;
+	getSpringDampingRatio(): number;
+	/**
+	 * Get the anchor point on bodyA in world coordinates.
+	 */
+	getAnchorA(): Vec2Value;
+	/**
+	 * Get the anchor point on bodyB in world coordinates.
+	 */
+	getAnchorB(): Vec2Value;
+	/**
+	 * Get the reaction force on bodyB at the joint anchor in Newtons.
+	 */
+	getReactionForce(inv_dt: number): Vec2Value;
+	/**
+	 * Get the reaction torque on bodyB in N*m.
+	 */
+	getReactionTorque(inv_dt: number): number;
+	initVelocityConstraints(step: TimeStep): void;
+	solveVelocityConstraints(step: TimeStep): void;
+	/**
+	 * This returns true if the position errors are within tolerance.
+	 */
+	solvePositionConstraints(step: TimeStep): boolean;
+}
+/**
+ * Tuning constants based on meters-kilograms-seconds (MKS) units.
+ *
+ * Some tolerances are absolute and some are relative. Absolute tolerances use MKS units.
+ */
+export declare class Settings {
+	/**
+	 * You can use this to change the length scale used by your game.
+	 *
+	 * For example for inches you could use 39.4.
+	 */
+	static lengthUnitsPerMeter: number;
+	/**
+	 * The maximum number of contact points between two convex shapes. Do not change
+	 * this value.
+	 */
+	static maxManifoldPoints: number;
+	/**
+	 * The maximum number of vertices on a convex polygon. You cannot increase this
+	 * too much because BlockAllocator has a maximum object size.
+	 */
+	static maxPolygonVertices: number;
+	/**
+	 * This is used to fatten AABBs in the dynamic tree. This allows proxies to move
+	 * by a small amount without triggering a tree adjustment. This is in meters.
+	 */
+	static aabbExtension: number;
+	/**
+	 * This is used to fatten AABBs in the dynamic tree. This is used to predict the
+	 * future position based on the current displacement. This is a dimensionless
+	 * multiplier.
+	 */
+	static aabbMultiplier: number;
+	/**
+	 * A small length used as a collision and constraint tolerance. Usually it is
+	 * chosen to be numerically significant, but visually insignificant.
+	 */
+	static linearSlop: number;
+	/**
+	 * A small angle used as a collision and constraint tolerance. Usually it is
+	 * chosen to be numerically significant, but visually insignificant.
+	 */
+	static angularSlop: number;
+	/**
+	 * The radius of the polygon/edge shape skin. This should not be modified.
+	 * Making this smaller means polygons will have an insufficient buffer for
+	 * continuous collision. Making it larger may create artifacts for vertex
+	 * collision.
+	 */
+	static get polygonRadius(): number;
+	/**
+	 * Maximum number of sub-steps per contact in continuous physics simulation.
+	 */
+	static maxSubSteps: number;
+	/**
+	 * Maximum number of contacts to be handled to solve a TOI impact.
+	 */
+	static maxTOIContacts: number;
+	/**
+	 * Maximum iterations to solve a TOI.
+	 */
+	static maxTOIIterations: number;
+	/**
+	 * Maximum iterations to find Distance.
+	 */
+	static maxDistanceIterations: number;
+	/**
+	 * A velocity threshold for elastic collisions. Any collision with a relative
+	 * linear velocity below this threshold will be treated as inelastic.
+	 */
+	static velocityThreshold: number;
+	/**
+	 * The maximum linear position correction used when solving constraints. This
+	 * helps to prevent overshoot.
+	 */
+	static maxLinearCorrection: number;
+	/**
+	 * The maximum angular position correction used when solving constraints. This
+	 * helps to prevent overshoot.
+	 */
+	static maxAngularCorrection: number;
+	/**
+	 * The maximum linear velocity of a body. This limit is very large and is used
+	 * to prevent numerical problems. You shouldn't need to adjust Settings.
+	 */
+	static maxTranslation: number;
+	/**
+	 * The maximum angular velocity of a body. This limit is very large and is used
+	 * to prevent numerical problems. You shouldn't need to adjust Settings.
+	 */
+	static maxRotation: number;
+	/**
+	 * This scale factor controls how fast overlap is resolved. Ideally this would
+	 * be 1 so that overlap is removed in one time step. However using values close
+	 * to 1 often lead to overshoot.
+	 */
+	static baumgarte: number;
+	static toiBaugarte: number;
+	/**
+	 * The time that a body must be still before it will go to sleep.
+	 */
+	static timeToSleep: number;
+	/**
+	 * A body cannot sleep if its linear velocity is above this tolerance.
+	 */
+	static linearSleepTolerance: number;
+	/**
+	 * A body cannot sleep if its angular velocity is above this tolerance.
+	 */
+	static angularSleepTolerance: number;
+}
+/**
+ * This describes the motion of a body/shape for TOI computation. Shapes are
+ * defined with respect to the body origin, which may not coincide with the
+ * center of mass. However, to support dynamics we must interpolate the center
+ * of mass position.
+ */
+export declare class Sweep {
+	/** Local center of mass position */
+	localCenter: Vec2Value;
+	/** World center position */
+	c: Vec2Value;
+	/** World angle */
+	a: number;
+	/** Fraction of the current time step in the range [0,1], c0 and a0 are c and a at alpha0. */
+	alpha0: number;
+	c0: Vec2Value;
+	a0: number;
+	setTransform(xf: TransformValue): void;
+	setLocalCenter(localCenter: Vec2Value, xf: TransformValue): void;
+	/**
+	 * Get the interpolated transform at a specific time.
+	 *
+	 * @param xf
+	 * @param beta A factor in [0,1], where 0 indicates alpha0
+	 */
+	getTransform(xf: TransformValue, beta?: number): void;
+	/**
+	 * Advance the sweep forward, yielding a new initial state.
+	 *
+	 * @param alpha The new initial time
+	 */
+	advance(alpha: number): void;
+	forward(): void;
+	/**
+	 * normalize the angles in radians to be between -pi and pi.
+	 */
+	normalize(): void;
+	set(that: Sweep): void;
+}
+/**
+ * Input parameters for TimeOfImpact.
+ */
+export declare class TOIInput {
+	proxyA: DistanceProxy;
+	proxyB: DistanceProxy;
+	sweepA: Sweep;
+	sweepB: Sweep;
+	/** defines sweep interval [0, tMax] */
+	tMax: number;
+	recycle(): void;
+}
+export declare enum TOIOutputState {
+	e_unset = -1,
+	e_unknown = 0,
+	e_failed = 1,
+	e_overlapped = 2,
+	e_touching = 3,
+	e_separated = 4
+}
+/**
+ * Output parameters for TimeOfImpact.
+ */
+export declare class TOIOutput {
+	state: TOIOutputState;
+	t: number;
+	recycle(): void;
+}
+/**
+ * Compute the upper bound on time before two shapes penetrate. Time is
+ * represented as a fraction between [0,tMax]. This uses a swept separating axis
+ * and may miss some intermediate, non-tunneling collisions. If you change the
+ * time interval, you should call this function again.
+ *
+ * Note: use Distance to compute the contact point and normal at the time of
+ * impact.
+ *
+ * CCD via the local separating axis method. This seeks progression by computing
+ * the largest time at which separation is maintained.
+ */
+export declare const TimeOfImpact: {
+	(output: TOIOutput, input: TOIInput): void;
+	Input: typeof TOIInput;
+	Output: typeof TOIOutput;
+};
+/** @hidden */
+export declare const stats: {
+	gjkCalls: number;
+	gjkIters: number;
+	gjkMaxIters: number;
+	toiTime: number;
+	toiMaxTime: number;
+	toiCalls: number;
+	toiIters: number;
+	toiMaxIters: number;
+	toiRootIters: number;
+	toiMaxRootIters: number;
+	toString(newline?: string): string;
+};
+/** @hidden @deprecated Merged with main namespace */
+export declare const internal: {
+	CollidePolygons: (manifold: Manifold, polyA: PolygonShape, xfA: TransformValue, polyB: PolygonShape, xfB: TransformValue) => void;
+	Settings: typeof Settings;
+	Sweep: typeof Sweep;
+	Manifold: typeof Manifold;
+	Distance: {
+		(output: DistanceOutput, cache: SimplexCache, input: DistanceInput): void;
+		testOverlap: (shapeA: Shape, indexA: number, shapeB: Shape, indexB: number, xfA: TransformValue, xfB: TransformValue) => boolean;
+		Input: typeof DistanceInput;
+		Output: typeof DistanceOutput;
+		Proxy: typeof DistanceProxy;
+		Cache: typeof SimplexCache;
+	};
+	TimeOfImpact: {
+		(output: TOIOutput, input: TOIInput): void;
+		Input: typeof TOIInput;
+		Output: typeof TOIOutput;
+	};
+	DynamicTree: typeof DynamicTree;
+	stats: {
+		gjkCalls: number;
+		gjkIters: number;
+		gjkMaxIters: number;
+		toiTime: number;
+		toiMaxTime: number;
+		toiCalls: number;
+		toiIters: number;
+		toiMaxIters: number;
+		toiRootIters: number;
+		toiMaxRootIters: number;
+		toString(newline?: string): string;
+	};
+};
+
+declare namespace geo {
+	export { absVec2, addVec2, clampVec2, combine2Vec2, combine3Vec2, combine4Vec2, copyTransform, copyVec2, copyVec3, crossNumVec2, crossSubVec2Num, crossVec2Num, crossVec2Vec2, derotNegVec2, derotVec2, detransformTransform, detransformVec2, distSqrVec2, distVec2, dotCrossNumVec2, dotSubVec2, dotVec2, dotVec3, dvp, getRotAngle, inverseMat22, isVec2, lengthSqrVec2, lengthVec2, mat22, mat33, minusCrossNumVec2, minusScaleVec2, minusVec2, mulMat22Vec2, mulMat33Vec2, mulMat33Vec3, mulVec2, mulVec3, negVec2, negVec3, normalizeVec2, normalizeVec2Length, plusCrossNumVec2, plusScaleVec2, plusVec2, plusVec3, rerotVec2, retransformVec2, rotNegVec2, rotSubVec2, rotVec2, rotation, scaleVec2, setRotAngle, setTransform, setVec2, setVec3, solveMat22Num, solveMat33Num, subVec2, symInverseMat33, transform, transformVec2, vec2, vec3, vp, zeroMat22, zeroMat33, zeroVec2, zeroVec3 };
+}
+declare namespace planck$1 {
+	export { geo };
+}
+
+export {
+	Body$1 as Body,
+	BoxShape as Box,
+	ChainShape as Chain,
+	CircleShape as Circle,
+	EdgeShape as Edge,
+	PolygonShape as Polygon,
+	geo,
+	math as Math,
+	planck$1 as default,
+};
+
+export {};