// generated by idl_to_d.js
// input file was:   .\public\definitions\ammo.idl
// input namespace was:   Ammo
// you can recreate this file with the command: 
// node idl_to_d.js .\public\definitions\ammo.idl Ammo
declare namespace Ammo {

  // Linear Math

  export class btVector3 {
    constructor();
    constructor(x: number, y: number, z: number);
    length(): number;
    x(): number;
    y(): number;
    z(): number;
    setX(x: number);
    setY(y: number);
    setZ(z: number);
    setValue(x: number, y: number, z: number);
    normalize();
    rotate(wAxis: btVector3, angle: number): btVector3;
    dot(v: btVector3): number;
    op_mul(x: number): btVector3;
    op_add(v: btVector3): btVector3;
    op_sub(v: btVector3): btVector3;
  }

  export class btVector4 extends btVector3 {
    constructor();
    constructor(x: number, y: number, z: number, w: number);
    w(): number;
    setValue(x: number, y: number, z: number); // @BYHAND to fix override of btVector3
    setValue(x: number, y: number, z: number, w: number);
  }


  export class btQuadWord {
    x(): number;
    y(): number;
    z(): number;
    w(): number;
    setX(x: number);
    setY(y: number);
    setZ(z: number);
    setW(w: number);
  }

  export class btQuaternion extends btQuadWord {
    constructor(x: number, y: number, z: number, w: number);
    setValue(x: number, y: number, z: number, w: number);
    setEulerZYX(z: number, y: number, x: number);
    setRotation(axis: btVector3, angle: number);
    normalize();
    length2(): number;
    length(): number;
    dot(q: btQuaternion): number;
    normalized(): btQuaternion;
    getAxis(): btVector3;
    inverse(): btQuaternion;
    getAngle(): number;
    getAngleShortestPath(): number;
    angle(q: btQuaternion): number;
    angleShortestPath(q: btQuaternion): number;
    op_add(q: btQuaternion): btQuaternion;
    op_sub(q: btQuaternion): btQuaternion;
    op_mul(s: number): btQuaternion;
    op_mulq(q: btQuaternion): btQuaternion;
    op_div(s: number): btQuaternion;
  }


  export class btMatrix3x3 {
    setEulerZYX(ex: number, ey: number, ez: number);
    getRotation(q: btQuaternion);
    getRow(y: number): btVector3;
  }

  export class btTransform {
    constructor();
    constructor(q: btQuaternion, v: btVector3);

    setIdentity();
    setOrigin(origin: btVector3);
    setRotation(rotation: btQuaternion);
    getOrigin(): btVector3;
    getRotation(): btQuaternion;
    getBasis(): btMatrix3x3;
    setFromOpenGLMatrix(m: number);
  }

  export class btMotionState {
    getWorldTransform(worldTrans: btTransform);
    setWorldTransform(worldTrans: btTransform);
  }

  export class btDefaultMotionState extends btMotionState {
    constructor(startTrans?: btTransform, centerOfMassOffset?: btTransform);
    m_graphicsWorldTrans: btTransform;
  }


  // Collision

  export class btCollisionObject {
    setAnisotropicFriction(anisotropicFriction: btVector3, frictionMode: number);
    getCollisionShape(): btCollisionShape;
    setContactProcessingThreshold(contactProcessingThreshold: number);
    setActivationState(newState: number);
    forceActivationState(newState: number);
    activate(forceActivation?: boolean);
    isActive(): boolean;
    isKinematicObject(): boolean;
    isStaticObject(): boolean;
    isStaticOrKinematicObject(): boolean;
    setRestitution(rest: number);
    setFriction(frict: number);
    setRollingFriction(frict: number);
    getWorldTransform(): btTransform;
    getCollisionFlags(): number;
    setCollisionFlags(flags: number);
    setWorldTransform(worldTrans: btTransform);
    setCollisionShape(collisionShape: btCollisionShape);
    setCcdMotionThreshold(ccdMotionThreshold: number);
    setCcdSweptSphereRadius(radius: number);
    getUserIndex(): number;
    setUserIndex(index: number);
    getUserPointer(): number;
    setUserPointer(userPointer: number);
  }


  export class btCollisionObjectWrapper {
  }


  export class RayResultCallback {
    // abstract class: base, no constructor
    hasHit(): boolean;
    m_collisionFilterGroup: number;
    m_collisionFilterMask: number;
    m_collisionObject: btCollisionObject;
  }


  export class ClosestRayResultCallback extends RayResultCallback {
    constructor(from: btVector3, to: btVector3);

    m_rayFromWorld: btVector3;
    m_rayToWorld: btVector3;
    m_hitNormalWorld: btVector3;
    m_hitPointWorld: btVector3;
  }


  export class btManifoldPoint {
    getPositionWorldOnA(): btVector3;
    getPositionWorldOnB(): btVector3;
    getAppliedImpulse(): number;
    getDistance(): number;
    m_localPointA: btVector3;
    m_localPointB: btVector3;
    m_positionWorldOnB: btVector3;
    m_positionWorldOnA: btVector3;
    m_normalWorldOnB: btVector3;
  }


  export class ContactResultCallback {
    addSingleResult(cp: btManifoldPoint, colObj0Wrap: btCollisionObjectWrapper, partId0: number, index0: number, colObj1Wrap: btCollisionObjectWrapper, partId1: number, index1: number): number;
  }


  export class ConcreteContactResultCallback {
    constructor();
    addSingleResult(cp: btManifoldPoint, colObj0Wrap: btCollisionObjectWrapper, partId0: number, index0: number, colObj1Wrap: btCollisionObjectWrapper, partId1: number, index1: number): number;
  }


  export class LocalShapeInfo {
    m_shapePart: number;
    m_triangleIndex: number;
  }


  export class LocalConvexResult {
    constructor(hitCollisionObject: btCollisionObject, localShapeInfo: LocalShapeInfo, hitNormalLocal: btVector3, hitPointLocal: btVector3, hitFraction: number);
    m_hitCollisionObject: btCollisionObject;
    m_localShapeInfo: LocalShapeInfo;
    m_hitNormalLocal: btVector3;
    m_hitPointLocal: btVector3;
    m_hitFraction: number;
  }


  export class ConvexResultCallback {
    // abstract class: base, no constructor
    hasHit(): boolean;
    m_collisionFilterGroup: number;
    m_collisionFilterMask: number;
    m_closestHitFraction: number;
  }


  export class ClosestConvexResultCallback extends ConvexResultCallback {
    constructor(convexFromWorld: btVector3, convexToWorld: btVector3);

    m_convexFromWorld: btVector3;
    m_convexToWorld: btVector3;
    m_hitNormalWorld: btVector3;
    m_hitPointWorld: btVector3;
  }


  export class btCollisionShape {
    setLocalScaling(scaling: btVector3);
    calculateLocalInertia(mass: number, inertia: btVector3);
    setMargin(margin: number);
    getMargin(): number;
  }

  export class btConvexShape extends btCollisionShape {
  }


  export class btConvexTriangleMeshShape extends btConvexShape {
    constructor(meshInterface: btStridingMeshInterface, calcAabb?: boolean);
  }


  export class btBoxShape extends btCollisionShape {
    constructor(boxHalfExtents: btVector3);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btCapsuleShape extends btCollisionShape {
    constructor(radius: number, height: number);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btCapsuleShapeX extends btCapsuleShape {
    constructor(radius: number, height: number);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btCapsuleShapeZ extends btCapsuleShape {
    constructor(radius: number, height: number);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btCylinderShape extends btCollisionShape {
    constructor(halfExtents: btVector3);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btCylinderShapeX extends btCylinderShape {
    constructor(halfExtents: btVector3);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btCylinderShapeZ extends btCylinderShape {
    constructor(halfExtents: btVector3);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btSphereShape extends btCollisionShape {
    constructor(radius: number);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btConeShape extends btCollisionShape {
    constructor(radius: number, height: number);
  }


  export class btConvexHullShape extends btCollisionShape {
    constructor();
    addPoint(point: btVector3, recalculateLocalAABB?: boolean);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btConeShapeX extends btConeShape {
    constructor(radius: number, height: number);
  }


  export class btConeShapeZ extends btConeShape {
    constructor(radius: number, height: number);
  }


  export class btCompoundShape extends btCollisionShape {
    constructor(enableDynamicAabbTree?: boolean);
    addChildShape(localTransform: btTransform, shape: btCollisionShape);
    removeChildShapeByIndex(childShapeindex: number);
    getNumChildShapes(): number;
    getChildShape(index: number): btCollisionShape;
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btStridingMeshInterface {
  }

  export class btTriangleMesh extends btStridingMeshInterface {
    constructor(use32bitIndices?: boolean, use4componentVertices?: boolean);
    addTriangle(vertex0: btVector3, vertex1: btVector3, vertex2: btVector3, removeDuplicateVertices?: boolean);
  }


  enum PHY_ScalarType {
    "PHY_FLOAT",
    "PHY_DOUBLE",
    "PHY_INTEGER",
    "PHY_SHORT",
    "PHY_FIXEDPOINT88",
    "PHY_UCHAR"
  }

  export class btConcaveShape extends btCollisionShape {
  }


  export class btStaticPlaneShape extends btConcaveShape {
    constructor(planeNormal: btVector3, planeConstant: number);
  }


  export class btTriangleMeshShape extends btConcaveShape {
  }


  export class btBvhTriangleMeshShape extends btTriangleMeshShape {
    constructor(meshInterface: btStridingMeshInterface, useQuantizedAabbCompression: boolean, buildBvh?: boolean);
  }


  export class btHeightfieldTerrainShape extends btConcaveShape {
    constructor(heightStickWidth: number, heightStickLength: number, heightfieldData: number, heightScale: number, minHeight: number, maxHeight: number, upAxis: number, hdt: PHY_ScalarType, flipQuadEdges: boolean);
    setMargin(margin: number);
    getMargin(): number;
  }


  export class btDefaultCollisionConstructionInfo {
    constructor();
  }

  export class btDefaultCollisionConfiguration {
    constructor(info?: btDefaultCollisionConstructionInfo);
  }

  export class btPersistentManifold {
    constructor();
    getBody0(): btCollisionObject;
    getBody1(): btCollisionObject;
    getNumContacts(): number;
    getContactPoint(index: number): btManifoldPoint;
  }

  export class btDispatcher {
    getNumManifolds(): number;
    getManifoldByIndexInternal(index: number): btPersistentManifold;
  }

  export class btCollisionDispatcher extends btDispatcher {
    constructor(conf: btDefaultCollisionConfiguration);
  }


  export class btOverlappingPairCallback {
  }

  export class btOverlappingPairCache {
    setInternalGhostPairCallback(ghostPairCallback: btOverlappingPairCallback);
  }

  export class btAxisSweep3 {
    constructor(worldAabbMin: btVector3, worldAabbMax: btVector3, maxHandles?: number, pairCache?: btOverlappingPairCache, disableRaycastAccelerator?: boolean);
  }

  export class btBroadphaseInterface {
  }

  export class btCollisionConfiguration {
  }

  export class btDbvtBroadphase {
    constructor();
  }


  // Dynamics


  export class btRigidBodyConstructionInfo {
    constructor(mass: number, motionState: btMotionState, collisionShape: btCollisionShape, localInertia?: btVector3);
    m_linearDamping: number;
    m_angularDamping: number;
    m_friction: number;
    m_rollingFriction: number;
    m_restitution: number;
    m_linearSleepingThreshold: number;
    m_angularSleepingThreshold: number;
    m_additionalDamping: boolean;
    m_additionalDampingFactor: number;
    m_additionalLinearDampingThresholdSqr: number;
    m_additionalAngularDampingThresholdSqr: number;
    m_additionalAngularDampingFactor: number;
  }

  export class btRigidBody extends btCollisionObject {
    constructor(constructionInfo: btRigidBodyConstructionInfo);

    getCenterOfMassTransform(): btTransform;
    setCenterOfMassTransform(xform: btTransform);
    setSleepingThresholds(linear: number, angular: number);
    setDamping(lin_damping: number, ang_damping: number);
    setMassProps(mass: number, inertia: btVector3);
    setLinearFactor(linearFactor: btVector3);
    applyTorque(torque: btVector3);
    applyLocalTorque(torque: btVector3);
    applyForce(force: btVector3, rel_pos: btVector3);
    applyCentralForce(force: btVector3);
    applyCentralLocalForce(force: btVector3);
    applyTorqueImpulse(torque: btVector3);
    applyImpulse(impulse: btVector3, rel_pos: btVector3);
    applyCentralImpulse(impulse: btVector3);
    updateInertiaTensor();
    getLinearVelocity(): btVector3;
    getAngularVelocity(): btVector3;
    setLinearVelocity(lin_vel: btVector3);
    setAngularVelocity(ang_vel: btVector3);
    getMotionState(): btMotionState;
    setMotionState(motionState: btMotionState);
    setAngularFactor(angularFactor: btVector3);
    upcast(colObj: btCollisionObject): btRigidBody;
  }


  export class btConstraintSetting {
    constructor();
    m_tau: number;
    m_damping: number;
    m_impulseClamp: number;
  }

  export class btTypedConstraint {
    enableFeedback(needsFeedback: boolean);
    getBreakingImpulseThreshold(): number;
    setBreakingImpulseThreshold(threshold: number);
  }

  export class btPoint2PointConstraint extends btTypedConstraint {
    constructor(rbA: btRigidBody, rbB: btRigidBody, pivotInA: btVector3, pivotInB: btVector3);
    constructor(rbA: btRigidBody, pivotInA: btVector3);
    setPivotA(pivotA: btVector3);
    setPivotB(pivotB: btVector3);
    getPivotInA(): btVector3;
    getPivotInB(): btVector3;

    m_setting: btConstraintSetting;
  }


  export class btGeneric6DofConstraint extends btTypedConstraint {
    constructor(rbA: btRigidBody, rbB: btRigidBody, frameInA: btTransform, frameInB: btTransform, useLinearFrameReferenceFrameA: boolean);
    constructor(rbB: btRigidBody, frameInB: btTransform, useLinearFrameReferenceFrameB: boolean);
    setLinearLowerLimit(linearLower: btVector3);
    setLinearUpperLimit(linearUpper: btVector3);
    setAngularLowerLimit(angularLower: btVector3);
    setAngularUpperLimit(angularUpper: btVector3);
  }


  export class btGeneric6DofSpringConstraint extends btGeneric6DofConstraint {
    constructor(rbA: btRigidBody, rbB: btRigidBody, frameInA: btTransform, frameInB: btTransform, useLinearFrameReferenceFrameA: boolean);
    constructor(rbB: btRigidBody, frameInB: btTransform, useLinearFrameReferenceFrameB: boolean);
    enableSpring(index: number, onOff: boolean);
    setStiffness(index: number, stiffness: number);
    setDamping(index: number, damping: number);
  }


  export class btSequentialImpulseConstraintSolver {
    constructor();
  }

  export class btConeTwistConstraint extends btTypedConstraint {
    constructor(rbA: btRigidBody, rbB: btRigidBody, rbAFrame: btTransform, rbBFrame: btTransform);
    constructor(rbA: btRigidBody, rbAFrame: btTransform);

    setLimit(limitIndex: number, limitValue: number);
    setAngularOnly(angularOnly: boolean);
    setDamping(damping: number);
    enableMotor(b: boolean);
    setMaxMotorImpulse(maxMotorImpulse: number);
    setMaxMotorImpulseNormalized(maxMotorImpulse: number);
    setMotorTarget(q: btQuaternion);
    setMotorTargetInConstraintSpace(q: btQuaternion);
  }


  export class btHingeConstraint extends btTypedConstraint {
    btHingeConstraint(rbA: btRigidBody, rbB: btRigidBody, pivotInA: btVector3, pivotInB: btVector3, axisInA: btVector3, axisInB: btVector3, useReferenceFrameA?: boolean);
    // btHingeConstraint ( rbA: btRigidBody,  pivotInA: btVector3,  axisInA: btVector3, useReferenceFrameA?: boolean);
    btHingeConstraint(rbA: btRigidBody, rbB: btRigidBody, rbAFrame: btTransform, rbBFrame: btTransform, useReferenceFrameA?: boolean);
    btHingeConstraint(rbA: btRigidBody, rbAFrame: btTransform, useReferenceFrameA?: boolean);

    setLimit(low: number, high: number, softness: number, biasFactor: number, relaxationFactor?: number);
    enableAngularMotor(enableMotor: boolean, targetVelocity: number, maxMotorImpulse: number);
    setAngularOnly(angularOnly: boolean);

    enableMotor(enableMotor: boolean);
    setMaxMotorImpulse(maxMotorImpulse: number);
    // setMotorTarget( qAinB: btQuaternion, dt: number);
    setMotorTarget(targetAngle: number, dt: number);
  }


  export class btSliderConstraint extends btTypedConstraint {
    constructor(rbA: btRigidBody, rbB: btRigidBody, frameInA: btTransform, frameInB: btTransform, useLinearReferenceFrameA: boolean);
    constructor(rbB: btRigidBody, frameInB: btTransform, useLinearReferenceFrameA: boolean);
    setLowerLinLimit(lowerLimit: number);
    setUpperLinLimit(upperLimit: number);
    setLowerAngLimit(lowerAngLimit: number);
    setUpperAngLimit(upperAngLimit: number);
  }


  export class btConstraintSolver {
  }

  export class btDispatcherInfo {
    m_timeStep: number;
    m_stepCount: number;
    m_dispatchFunc: number;
    m_timeOfImpact: number;
    m_useContinuous: boolean;
    m_enableSatConvex: boolean;
    m_enableSPU: boolean;
    m_useEpa: boolean;
    m_allowedCcdPenetration: number;
    m_useConvexConservativeDistanceUtil: boolean;
    m_convexConservativeDistanceThreshold: number;
  }

  export class btCollisionWorld {
    getDispatcher(): btDispatcher;
    rayTest(rayFromWorld: btVector3, rayToWorld: btVector3, resultCallback: RayResultCallback);
    getPairCache(): btOverlappingPairCache;
    getDispatchInfo(): btDispatcherInfo;
    addCollisionObject(collisionObject: btCollisionObject, collisionFilterGroup?: number, collisionFilterMask?: number);
    getBroadphase(): btBroadphaseInterface;
    convexSweepTest(castShape: btConvexShape, from: btTransform, to: btTransform, resultCallback: ConvexResultCallback, allowedCcdPenetration: number);
    contactPairTest(colObjA: btCollisionObject, colObjB: btCollisionObject, resultCallback: ContactResultCallback);
    contactTest(colObj: btCollisionObject, resultCallback: ContactResultCallback);
  }

  export class btContactSolverInfo {
    m_splitImpulse: boolean;
    m_splitImpulsePenetrationThreshold: number;
    m_numIterations: number;
  }

  export class btDynamicsWorld extends btCollisionWorld {
    addAction(action: btActionInterface);
    removeAction(action: btActionInterface);
    getSolverInfo(): btContactSolverInfo;
  }


  export class btDiscreteDynamicsWorld extends btDynamicsWorld {
    constructor(dispatcher: btDispatcher, pairCache: btBroadphaseInterface, constraintSolver: btConstraintSolver, collisionConfiguration: btCollisionConfiguration);

    setGravity(gravity: btVector3);
    getGravity(): btVector3;

    addRigidBody(body: btRigidBody);
    addRigidBody(body: btRigidBody, group: number, mask: number);
    removeRigidBody(body: btRigidBody);

    addConstraint(constraint: btTypedConstraint, disableCollisionsBetweenLinkedBodies?: boolean);
    removeConstraint(constraint: btTypedConstraint);

    stepSimulation(timeStep: number, maxSubSteps?: number, fixedTimeStep?: number): number;
  }



  export class btVehicleTuning {
    constructor();
    m_suspensionStiffness: number;
    m_suspensionCompression: number;
    m_suspensionDamping: number;
    m_maxSuspensionTravelCm: number;
    m_frictionSlip: number;
    m_maxSuspensionForce: number;
  }


  export class btVehicleRaycasterResult {
    m_hitPointInWorld: btVector3;
    m_hitNormalInWorld: btVector3;
    m_distFraction: number;
  }

  export class btVehicleRaycaster {
    castRay(from: btVector3, to: btVector3, result: btVehicleRaycasterResult);
  }

  export class btDefaultVehicleRaycaster extends btVehicleRaycaster {
    constructor(world: btDynamicsWorld);
  }



  export class RaycastInfo {
    m_contactNormalWS: btVector3;
    m_contactPointWS: btVector3;
    m_suspensionLength: number;
    m_hardPointWS: btVector3;
    m_wheelDirectionWS: btVector3;
    m_wheelAxleWS: btVector3;
    m_isInContact: boolean;
    m_groundObject: any;
  }

  export class btWheelInfoConstructionInfo {
    m_chassisConnectionCS: btVector3;
    m_wheelDirectionCS: btVector3;
    m_wheelAxleCS: btVector3;
    m_suspensionRestLength: number;
    m_maxSuspensionTravelCm: number;
    m_wheelRadius: number;
    m_suspensionStiffness: number;
    m_wheelsDampingCompression: number;
    m_wheelsDampingRelaxation: number;
    m_frictionSlip: number;
    m_maxSuspensionForce: number;
    m_bIsFrontWheel: boolean;
  }

  export class btWheelInfo {
    m_suspensionStiffness: number;
    m_frictionSlip: number;
    m_engineForce: number;
    m_rollInfluence: number;
    m_suspensionRestLength1: number;
    m_wheelsRadius: number;
    m_wheelsDampingCompression: number;
    m_wheelsDampingRelaxation: number;
    m_steering: number;
    m_maxSuspensionForce: number;
    m_maxSuspensionTravelCm: number;
    m_wheelsSuspensionForce: number;
    m_bIsFrontWheel: boolean;
    m_raycastInfo: RaycastInfo;
    m_chassisConnectionPointCS: btVector3;
    constructor(ci: btWheelInfoConstructionInfo);
    getSuspensionRestLength(): number;
    updateWheel(chassis: btRigidBody, raycastInfo: RaycastInfo);
    m_worldTransform: btTransform;
    m_wheelDirectionCS: btVector3;
    m_wheelAxleCS: btVector3;
    m_rotation: number;
    m_deltaRotation: number;
    m_brake: number;
    m_clippedInvContactDotSuspension: number;
    m_suspensionRelativeVelocity: number;
    m_skidInfo: number;
  }

  export class btActionInterface {
    updateAction(collisionWorld: btCollisionWorld, deltaTimeStep: number);
  }

  export class btKinematicCharacterController extends btActionInterface {
    constructor(ghostObject: btPairCachingGhostObject, convexShape: btConvexShape, stepHeight: number, upAxis?: number);

    setUpAxis(axis: number);
    setWalkDirection(walkDirection: btVector3);
    setVelocityForTimeInterval(velocity: btVector3, timeInterval: number);
    // reset ();
    warp(origin: btVector3);
    preStep(collisionWorld: btCollisionWorld);
    playerStep(collisionWorld: btCollisionWorld, dt: number);
    setFallSpeed(fallSpeed: number);
    setJumpSpeed(jumpSpeed: number);
    setMaxJumpHeight(maxJumpHeight: number);
    canJump(): boolean;
    jump();
    setGravity(gravity: number);
    getGravity(): number;
    setMaxSlope(slopeRadians: number);
    getMaxSlope(): number;
    getGhostObject(): btPairCachingGhostObject;
    setUseGhostSweepTest(useGhostObjectSweepTest: boolean);
    onGround(): boolean;
  }


  export class btRaycastVehicle extends btActionInterface {
    constructor(tuning: btVehicleTuning, chassis: btRigidBody, raycaster: btVehicleRaycaster);
    applyEngineForce(force: number, wheel: number);
    setSteeringValue(steering: number, wheel: number);
    getWheelTransformWS(wheelIndex: number): btTransform;
    updateWheelTransform(wheelIndex: number, interpolatedTransform: boolean);
    addWheel(connectionPointCS0: btVector3, wheelDirectionCS0: btVector3, wheelAxleCS: btVector3, suspensionRestLength: number, wheelRadius: number, tuning: btVehicleTuning, isFrontWheel: boolean): btWheelInfo;
    getNumWheels(): number;
    getRigidBody(): btRigidBody;
    getWheelInfo(index: number): btWheelInfo;
    setBrake(brake: number, wheelIndex: number);
    setCoordinateSystem(rightIndex: number, upIndex: number, forwardIndex: number);
    getCurrentSpeedKmHour(): number;
    getChassisWorldTransform(): btTransform;
    rayCast(wheel: btWheelInfo): number;
    updateVehicle(step: number);
    resetSuspension();
    getSteeringValue(wheel: number): number;
    updateWheelTransformsWS(wheel: btWheelInfo, interpolatedTransform?: boolean);
    setPitchControl(pitch: number);
    updateSuspension(deltaTime: number);
    updateFriction(timeStep: number);
    getRightAxis(): number;
    getUpAxis(): number;
    getForwardAxis(): number;
    getForwardVector(): btVector3;
    getUserConstraintType(): number;
    setUserConstraintType(userConstraintType: number);
    setUserConstraintId(uid: number);
    getUserConstraintId(): number;
  }


  export class btGhostObject extends btCollisionObject {
    constructor();
    getNumOverlappingObjects(): number;
    getOverlappingObject(index: number): btCollisionObject;
  }


  export class btPairCachingGhostObject extends btGhostObject {
    constructor();
  }


  export class btGhostPairCallback {
    constructor();
  }


  // soft bodies

  export class btSoftBodyWorldInfo {
    constructor();
    air_density: number;
    water_density: number;
    water_offset: number;
    m_maxDisplacement: number;
    water_normal: btVector3;
    m_broadphase: btBroadphaseInterface;
    m_dispatcher: btDispatcher;
    m_gravity: btVector3;
  }


  export class Node {
    m_x: btVector3;
    m_n: btVector3;
  }


  export class tNodeArray {
    size(): number;
    at(n: number): Node;
  }


  export class Material {
    m_kLST: number;
    m_kAST: number;
    m_kVST: number;
    m_flags: number;
  }


  export class tMaterialArray {
    size(): number;
    at(n: number): Material;
  }


  export class Config {
    kVCF: number;
    kDP: number;
    kDG: number;
    kLF: number;
    kPR: number;
    kVC: number;
    kDF: number;
    kMT: number;
    kCHR: number;
    kKHR: number;
    kSHR: number;
    kAHR: number;
    kSRHR_CL: number;
    kSKHR_CL: number;
    kSSHR_CL: number;
    kSR_SPLT_CL: number;
    kSK_SPLT_CL: number;
    kSS_SPLT_CL: number;
    maxvolume: number;
    timescale: number;
    viterations: number;
    piterations: number;
    diterations: number;
    citerations: number;
    collisions: number;
  }

  export class btSoftBody extends btCollisionObject {
    constructor(worldInfo: btSoftBodyWorldInfo, node_count: number, x: btVector3, m: number);

    m_cfg: Config;
    m_nodes: tNodeArray;
    m_materials: tMaterialArray;

    checkLink(node0: number, node1: number): boolean;
    checkFace(node0: number, node1: number, node2: number): boolean;
    appendMaterial(): Material;
    appendNode(x: btVector3, m: number);
    appendLink(node0: number, node1: number, mat: Material, bcheckexist: boolean);
    appendFace(node0: number, node1: number, node2: number, mat: Material);
    appendTetra(node0: number, node1: number, node2: number, node3: number, mat: Material);
    appendAnchor(node: number, body: btRigidBody, disableCollisionBetweenLinkedBodies: boolean, influence: number);
    getTotalMass(): number;
    setTotalMass(mass: number, fromfaces: boolean);
    setMass(node: number, mass: number);
    transform(trs: btTransform);
    translate(trs: btVector3);
    rotate(rot: btQuaternion);
    scale(scl: btVector3);
    generateClusters(k: number, maxiterations?: number): number;
    upcast(colObj: btCollisionObject): btSoftBody;
  }


  export class btSoftBodyRigidBodyCollisionConfiguration extends btDefaultCollisionConfiguration {
    constructor(info?: btDefaultCollisionConstructionInfo);
  }


  export class btSoftBodySolver {
  }

  export class btDefaultSoftBodySolver extends btSoftBodySolver {
    btDefaultSoftBodySolver();
  }


  export class btSoftBodyArray {
    size(): number;
    at(n: number): btSoftBody;
  }

  export class btSoftRigidDynamicsWorld extends btDiscreteDynamicsWorld {
    constructor(dispatcher: btDispatcher, pairCache: btBroadphaseInterface, constraintSolver: btConstraintSolver, collisionConfiguration: btCollisionConfiguration, softBodySolver: btSoftBodySolver);

    addSoftBody(body: btSoftBody, collisionFilterGroup: number, collisionFilterMask: number);
    removeSoftBody(body: btSoftBody);
    removeCollisionObject(collisionObject: btCollisionObject);

    getWorldInfo(): btSoftBodyWorldInfo;
    getSoftBodyArray(): btSoftBodyArray;
  }


  export class btSoftBodyHelpers {
    constructor();

    CreateRope(worldInfo: btSoftBodyWorldInfo, from: btVector3, to: btVector3, res: number, fixeds: number): btSoftBody;
    CreatePatch(worldInfo: btSoftBodyWorldInfo, corner00: btVector3, corner10: btVector3, corner01: btVector3, corner11: btVector3, resx: number, resy: number, fixeds: number, gendiags: boolean): btSoftBody;
    CreatePatchUV(worldInfo: btSoftBodyWorldInfo, corner00: btVector3, corner10: btVector3, corner01: btVector3, corner11: btVector3, resx: number, resy: number, fixeds: number, gendiags: boolean, tex_coords: number): btSoftBody;
    CreateEllipsoid(worldInfo: btSoftBodyWorldInfo, center: btVector3, radius: btVector3, res: number): btSoftBody;
    CreateFromTriMesh(worldInfo: btSoftBodyWorldInfo, vertices: number, triangles: number, ntriangles: number, randomizeConstraints: boolean): btSoftBody;
    CreateFromConvexHull(worldInfo: btSoftBodyWorldInfo, vertices: btVector3, nvertices: number, randomizeConstraints: boolean): btSoftBody;
  }

}