@schmoker/rageenginebridge 0.1.0 → 0.2.0

package/dist/ragemp.cjs

@@ -234,6 +234,217 @@ var RageMpEntity = class {
   isVisible() {
     return mp.game.entity.isVisible(this.raw.handle);
   }
+  // --- Rotation / Transform ---
+  getRotation(rotationOrder = 2) {
+    const r = mp.game.entity.getRotation(this.raw.handle, rotationOrder);
+    return { x: r.x, y: r.y, z: r.z };
+  }
+  getQuaternion() {
+    const q = mp.game.entity.getQuaternion(this.raw.handle);
+    return { x: q.x, y: q.y, z: q.z, w: q.w };
+  }
+  setQuaternion(x, y, z, w) {
+    mp.game.entity.setQuaternion(this.raw.handle, x, y, z, w);
+  }
+  setCoordsNoOffset(x, y, z, alive = false, deadFlag = false, ragdollFlag = false) {
+    mp.game.entity.setCoordsNoOffset(this.raw.handle, x, y, z, alive, deadFlag, ragdollFlag);
+  }
+  // --- Attachment ---
+  attachTo(entity, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+    mp.game.entity.attachToEntity(
+      this.raw.handle,
+      entity,
+      boneIndex,
+      xPos,
+      yPos,
+      zPos,
+      xRot,
+      yRot,
+      zRot,
+      false,
+      useSoftPinning,
+      collision,
+      isPed,
+      vertexIndex,
+      fixedRot
+    );
+  }
+  attachToPhysically(entity, boneIndex1, boneIndex2, xOff1, yOff1, zOff1, xOff2, yOff2, zOff2, xRot, yRot, zRot, breakForce, fixedRot, collision, teleport, order) {
+    mp.game.entity.attachToEntityPhysically(
+      this.raw.handle,
+      entity,
+      boneIndex1,
+      boneIndex2,
+      xOff1,
+      yOff1,
+      zOff1,
+      xOff2,
+      yOff2,
+      zOff2,
+      xRot,
+      yRot,
+      zRot,
+      breakForce,
+      fixedRot,
+      false,
+      collision,
+      teleport,
+      order
+    );
+  }
+  detach(dynamic, collision) {
+    mp.game.entity.detach(this.raw.handle, dynamic, collision);
+  }
+  isAttached() {
+    return mp.game.entity.isAttached(this.raw.handle);
+  }
+  isAttachedTo(entity) {
+    return mp.game.entity.isAttachedToEntity(this.raw.handle, entity);
+  }
+  // --- Physics / Forces ---
+  applyForceTo(forceType, x, y, z, offX, offY, offZ, boneIndex, isDirectionRel, ignoreUpVec, isForceRel, p12, p13) {
+    mp.game.entity.applyForceTo(
+      this.raw.handle,
+      forceType,
+      x,
+      y,
+      z,
+      offX,
+      offY,
+      offZ,
+      boneIndex,
+      isDirectionRel,
+      ignoreUpVec,
+      isForceRel,
+      p12,
+      p13
+    );
+  }
+  applyForceToCenterOfMass(forceType, x, y, z, p5, isDirectionRel, isForceRel, p8) {
+    mp.game.entity.applyForceToCenterOfMass(
+      this.raw.handle,
+      forceType,
+      x,
+      y,
+      z,
+      p5,
+      isDirectionRel,
+      isForceRel,
+      p8
+    );
+  }
+  setHasGravity(toggle) {
+    mp.game.entity.setHasGravity(this.raw.handle, toggle);
+  }
+  setDynamic(toggle) {
+    mp.game.entity.setDynamic(this.raw.handle, toggle);
+  }
+  // --- Collision / Interaction ---
+  hasCollidedWithAnything() {
+    return mp.game.entity.hasCollidedWithAnything(this.raw.handle);
+  }
+  isTouching(entity) {
+    return mp.game.entity.isTouchingEntity(this.raw.handle, entity);
+  }
+  isTouchingModel(modelHash) {
+    return mp.game.entity.isTouchingModel(this.raw.handle, modelHash);
+  }
+  setNoCollision(entity, toggle) {
+    mp.game.entity.setNoCollisionEntity(this.raw.handle, entity, toggle);
+  }
+  // --- Animation ---
+  isPlayingAnim(animDict, animName, taskFlag) {
+    return mp.game.entity.isPlayingAnim(this.raw.handle, animDict, animName, taskFlag);
+  }
+  stopAnim(animDict, animName, p3) {
+    mp.game.entity.stopAnim(this.raw.handle, animDict, animName, p3);
+  }
+  // --- Rendering / LOD ---
+  setLodDist(value) {
+    mp.game.entity.setLodDist(this.raw.handle, value);
+  }
+  getLodDist() {
+    return mp.game.entity.getLodDist(this.raw.handle);
+  }
+  isOccluded() {
+    return mp.game.entity.isOccluded(this.raw.handle);
+  }
+  setMotionBlur(toggle) {
+    mp.game.entity.setMotionBlur(this.raw.handle, toggle);
+  }
+  setAlwaysPrerender(toggle) {
+    mp.game.entity.setAlwaysPrerender(this.raw.handle, toggle);
+  }
+  // --- Proofs ---
+  setProofs(bulletProof, fireProof, explosionProof, collisionProof, meleeProof, p6, p7, drownProof) {
+    mp.game.entity.setProofs(
+      this.raw.handle,
+      bulletProof,
+      fireProof,
+      explosionProof,
+      collisionProof,
+      meleeProof,
+      p6,
+      p7,
+      drownProof
+    );
+  }
+  // --- Height / Submersion ---
+  getHeightAboveGround() {
+    return mp.game.entity.getHeightAboveGround(this.raw.handle);
+  }
+  getSubmergedLevel() {
+    return mp.game.entity.getSubmergedLevel(this.raw.handle);
+  }
+  // --- Rotation Velocity ---
+  getRotationVelocity() {
+    const v = mp.game.entity.getRotationVelocity(this.raw.handle);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  // --- Animation (extended) ---
+  getAnimCurrentTime(animDict, animName) {
+    return mp.game.entity.getAnimCurrentTime(this.raw.handle, animDict, animName);
+  }
+  getAnimTotalTime(animDict, animName) {
+    return mp.game.entity.getAnimTotalTime(this.raw.handle, animDict, animName);
+  }
+  setAnimCurrentTime(animDict, animName, time) {
+    mp.game.entity.setAnimCurrentTime(this.raw.handle, animDict, animName, time);
+  }
+  setAnimSpeed(animDict, animName, speedMultiplier) {
+    mp.game.entity.setAnimSpeed(this.raw.handle, animDict, animName, speedMultiplier);
+  }
+  // --- Damage Tracking ---
+  hasBeenDamagedByEntity(entity, p2 = true) {
+    return mp.game.entity.hasBeenDamagedByEntity(this.raw.handle, entity, p2);
+  }
+  clearLastDamageEntity() {
+    mp.game.entity.clearLastDamageEntity(this.raw.handle);
+  }
+  // --- Line of Sight ---
+  hasClearLosToEntity(entity, traceType = 17) {
+    return mp.game.entity.hasClearLosToEntity(this.raw.handle, entity, traceType);
+  }
+  // --- Offset / Position ---
+  getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+    const v = mp.game.entity.getOffsetFromInWorldCoords(this.raw.handle, offsetX, offsetY, offsetZ);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  // --- Orientation Checks ---
+  isUpright(angle) {
+    return mp.game.entity.isUpright(this.raw.handle, angle);
+  }
+  isUpsidedown() {
+    return mp.game.entity.isUpsidedown(this.raw.handle);
+  }
+  // --- Physics Check ---
+  doesHavePhysics() {
+    return mp.game.entity.doesHavePhysics(this.raw.handle);
+  }
+  // --- Mission Entity ---
+  setAsMissionEntity(p1 = true, p2 = false) {
+    mp.game.entity.setAsMissionEntity(this.raw.handle, p1, p2);
+  }
 };
 
 // src/ragemp/RageMpPlayer.ts
@@ -417,6 +628,142 @@ var RageMpPlayer = class extends RageMpEntity {
   setRagdollOnCollision(toggle) {
     mp.game.ped.setRagdollOnCollision(this.raw.handle, toggle);
   }
+  // --- Wanted Level ---
+  setWantedLevel(level) {
+    mp.game.player.setWantedLevel(level, false);
+  }
+  getWantedLevel() {
+    return mp.game.player.getWantedLevel();
+  }
+  clearWantedLevel() {
+    mp.game.player.clearWantedLevel();
+  }
+  // --- Control ---
+  setControl(toggle, flags = 0) {
+    mp.game.player.setControl(toggle, flags);
+  }
+  isControlOn() {
+    return mp.game.player.isControlOn();
+  }
+  // --- Ignore ---
+  setEveryoneIgnore(toggle) {
+    mp.game.player.setEveryoneIgnore(toggle);
+  }
+  setPoliceIgnore(toggle) {
+    mp.game.player.setPoliceIgnore(toggle);
+  }
+  // --- Damage Modifiers ---
+  setWeaponDamageModifier(modifier) {
+    mp.game.player.setWeaponDamageModifier(modifier);
+  }
+  setVehicleDamageModifier(modifier) {
+    mp.game.player.setVehicleDamageModifier(modifier);
+  }
+  setMeleeWeaponDamageModifier(modifier) {
+    mp.game.player.setMeleeWeaponDamageModifier(modifier, false);
+  }
+  // --- Abilities ---
+  resetStamina() {
+    mp.game.player.resetStamina();
+  }
+  setCanDoDriveBy(toggle) {
+    mp.game.player.setCanDoDriveBy(toggle);
+  }
+  setCanUseCover(toggle) {
+    mp.game.player.setCanUseCover(toggle);
+  }
+  // --- Armour (extended) ---
+  getMaxArmour() {
+    return mp.game.player.getMaxArmour();
+  }
+  setMaxArmour(value) {
+    mp.game.player.setMaxArmour(value);
+  }
+  // --- Misc ---
+  getInvincible() {
+    return mp.game.player.getInvincible();
+  }
+  setParachuteTintIndex(tintIndex) {
+    mp.game.player.setParachuteTintIndex(tintIndex);
+  }
+  getParachuteTintIndex() {
+    return mp.game.player.getParachuteTintIndex();
+  }
+  // --- Wanted Level (extended) ---
+  setMaxWantedLevel(maxWantedLevel) {
+    mp.game.player.setMaxWantedLevel(maxWantedLevel);
+  }
+  setWantedLevelNow(p1 = false) {
+    mp.game.player.setWantedLevelNow(p1);
+  }
+  // --- Police ---
+  setDispatchCopsFor(toggle) {
+    mp.game.player.setDispatchCopsFor(toggle);
+  }
+  setAllRandomPedsFlee(toggle) {
+    mp.game.player.setAllRandomPedsFlee(toggle);
+  }
+  setAllRandomPedsFleeThisFrame() {
+    mp.game.player.setAllRandomPedsFleeThisFrame();
+  }
+  // --- Aiming / Targeting ---
+  isFreeAiming() {
+    return mp.game.player.isFreeAiming();
+  }
+  isFreeAimingAtEntity(entity) {
+    return mp.game.player.isFreeAimingAtEntity(entity);
+  }
+  getTargetEntity() {
+    return mp.game.player.getTargetEntity();
+  }
+  // --- Movement Multipliers ---
+  setRunSprintMultiplierFor(multiplier) {
+    mp.game.player.setRunSprintMultiplierFor(multiplier);
+  }
+  setSwimMultiplierFor(multiplier) {
+    mp.game.player.setSwimMultiplierFor(multiplier);
+  }
+  // --- Health Regen ---
+  setHealthRechargeMultiplier(regenRate) {
+    mp.game.player.setHealthRechargeMultiplier(regenRate);
+  }
+  getHealthRechargeLimit() {
+    return mp.game.player.getHealthRechargeLimit();
+  }
+  setHealthRechargeLimit(limit) {
+    mp.game.player.setHealthRechargeLimit(limit);
+  }
+  // --- Defense Modifiers ---
+  setWeaponDefenseModifier(modifier) {
+    mp.game.player.setWeaponDefenseModifier(modifier);
+  }
+  setMeleeWeaponDefenseModifier(modifier) {
+    mp.game.player.setMeleeWeaponDefenseModifier(modifier);
+  }
+  setVehicleDefenseModifier(modifier) {
+    mp.game.player.setVehicleDefenseModifier(modifier);
+  }
+  // --- Firing ---
+  disableFiring(toggle) {
+    mp.game.player.disableFiring(toggle);
+  }
+  setForcedAim(toggle) {
+    mp.game.player.setForcedAim(toggle);
+  }
+  // --- Timestamps ---
+  getTimeSinceLastArrest() {
+    return mp.game.player.getTimeSinceLastArrest();
+  }
+  getTimeSinceLastDeath() {
+    return mp.game.player.getTimeSinceLastDeath();
+  }
+  // --- Vehicle / Group ---
+  getPlayersLastVehicle() {
+    return mp.game.player.getPlayersLastVehicle();
+  }
+  getGroup() {
+    return mp.game.player.getGroup();
+  }
 };
 
 // src/ragemp/RageMpVehicle.ts
@@ -653,6 +1000,246 @@ var RageMpVehicle = class extends RageMpEntity {
   setSuspensionHeight(height) {
     mp.game.vehicle.setSuspensionHeight(this.raw.handle, height);
   }
+  // --- Windows ---
+  smashWindow(index) {
+    mp.game.vehicle.smashWindow(this.raw.handle, index);
+  }
+  fixWindow(index) {
+    mp.game.vehicle.fixWindow(this.raw.handle, index);
+  }
+  removeWindow(index) {
+    mp.game.vehicle.removeWindow(this.raw.handle, index);
+  }
+  rollDownWindow(index) {
+    mp.game.vehicle.rollDownWindow(this.raw.handle, index);
+  }
+  rollUpWindow(index) {
+    mp.game.vehicle.rollUpWindow(this.raw.handle, index);
+  }
+  rollDownWindows() {
+    mp.game.vehicle.rollDownWindows(this.raw.handle);
+  }
+  isWindowIntact(index) {
+    return mp.game.vehicle.isWindowIntact(this.raw.handle, index);
+  }
+  areAllWindowsIntact() {
+    return mp.game.vehicle.areAllWindowsIntact(this.raw.handle);
+  }
+  // --- Door Locking ---
+  setDoorsLocked(lockStatus) {
+    mp.game.vehicle.setDoorsLocked(this.raw.handle, lockStatus);
+  }
+  getDoorLockStatus() {
+    return mp.game.vehicle.getDoorLockStatus(this.raw.handle);
+  }
+  setDoorControl(doorIndex, speed, angle) {
+    mp.game.vehicle.setDoorControl(this.raw.handle, doorIndex, speed, angle);
+  }
+  setDoorsShut(closeInstantly) {
+    mp.game.vehicle.setDoorsShut(this.raw.handle, closeInstantly);
+  }
+  // --- Siren / Alarm ---
+  isSirenOn() {
+    return mp.game.vehicle.isSirenOn(this.raw.handle);
+  }
+  setSiren(toggle) {
+    mp.game.vehicle.setSiren(this.raw.handle, toggle);
+  }
+  isAlarmActivated() {
+    return mp.game.vehicle.isAlarmActivated(this.raw.handle);
+  }
+  setAlarm(toggle) {
+    mp.game.vehicle.setAlarm(this.raw.handle, toggle);
+  }
+  // --- Convertible ---
+  isConvertible() {
+    return mp.game.vehicle.isAConvertible(this.raw.handle, false);
+  }
+  lowerConvertibleRoof(instantly = false) {
+    mp.game.vehicle.lowerConvertibleRoof(this.raw.handle, instantly);
+  }
+  raiseConvertibleRoof(instantly = false) {
+    mp.game.vehicle.raiseConvertibleRoof(this.raw.handle, instantly);
+  }
+  // --- Speed / Movement ---
+  setForwardSpeed(speed) {
+    mp.game.vehicle.setForwardSpeed(this.raw.handle, speed);
+  }
+  setMaxSpeed(maxSpeed) {
+    mp.game.vehicle.setMaxSpeed(this.raw.handle, maxSpeed);
+  }
+  setHandbrake(toggle) {
+    mp.game.vehicle.setHandbrake(this.raw.handle, toggle);
+  }
+  // --- Lights (extended) ---
+  setIndicatorLights(index, toggle) {
+    mp.game.vehicle.setIndicatorLights(this.raw.handle, index, toggle);
+  }
+  setInteriorLight(toggle) {
+    mp.game.vehicle.setInteriorlight(this.raw.handle, toggle);
+  }
+  setFullbeam(toggle) {
+    mp.game.vehicle.setFullbeam(this.raw.handle, toggle);
+  }
+  setSearchlight(toggle, canBeUsedByAI) {
+    mp.game.vehicle.setSearchlight(this.raw.handle, toggle, canBeUsedByAI);
+  }
+  setLightMultiplier(multiplier) {
+    mp.game.vehicle.setLightMultiplier(this.raw.handle, multiplier);
+  }
+  // --- Colours (extended) ---
+  setExtraColours(pearlescent, wheel) {
+    mp.game.vehicle.setExtraColours(this.raw.handle, pearlescent, wheel);
+  }
+  getExtraColours() {
+    const c = mp.game.vehicle.getExtraColours(this.raw.handle);
+    return { pearlescent: _nullishCoalesce(c.pearlescentColor, () => ( c[0])), wheel: _nullishCoalesce(c.wheelColor, () => ( c[1])) };
+  }
+  setTyreSmokeColor(r, g, b) {
+    mp.game.vehicle.setTyreSmokeColor(this.raw.handle, r, g, b);
+  }
+  getTyreSmokeColor() {
+    const c = mp.game.vehicle.getTyreSmokeColor(this.raw.handle);
+    return { r: _nullishCoalesce(c.r, () => ( c[0])), g: _nullishCoalesce(c.g, () => ( c[1])), b: _nullishCoalesce(c.b, () => ( c[2])) };
+  }
+  // --- Vehicle State ---
+  getClass() {
+    return mp.game.vehicle.getClass(this.raw.handle);
+  }
+  explode(isAudible, isInvisible) {
+    mp.game.vehicle.explode(this.raw.handle, isAudible, isInvisible);
+  }
+  isDamaged() {
+    return mp.game.vehicle.isDamaged(this.raw.handle);
+  }
+  isStolen() {
+    return mp.game.vehicle.isStolen(this.raw.handle);
+  }
+  setIsStolen(toggle) {
+    mp.game.vehicle.setIsStolen(this.raw.handle, toggle);
+  }
+  isStopped() {
+    return mp.game.vehicle.isStopped(this.raw.handle);
+  }
+  setOnGroundProperly() {
+    return mp.game.vehicle.setOnGroundProperly(this.raw.handle, 5);
+  }
+  setDeformationFixed() {
+    mp.game.vehicle.setDeformationFixed(this.raw.handle);
+  }
+  isBumperBrokenOff(front) {
+    return mp.game.vehicle.isBumperBrokenOff(this.raw.handle, front);
+  }
+  // --- Towing ---
+  attachToTowTruck(towTruck, rear, hookOffsetX, hookOffsetY, hookOffsetZ) {
+    mp.game.vehicle.attachToTowTruck(towTruck, this.raw.handle, rear, hookOffsetX, hookOffsetY, hookOffsetZ);
+  }
+  detachFromTowTruck(towTruck) {
+    mp.game.vehicle.detachFromTowTruck(towTruck, this.raw.handle);
+  }
+  detachFromAnyTowTruck() {
+    mp.game.vehicle.detachFromAnyTowTruck(this.raw.handle);
+  }
+  // --- Cargobob ---
+  attachToCargobob(cargobob, p1, x, y, z) {
+    mp.game.vehicle.attachToCargobob(this.raw.handle, cargobob, p1, x, y, z);
+  }
+  detachFromCargobob(cargobob) {
+    mp.game.vehicle.detachFromCargobob(this.raw.handle, cargobob);
+  }
+  detachFromAnyCargobob() {
+    mp.game.vehicle.detachFromAnyCargobob(this.raw.handle);
+  }
+  // --- Train ---
+  setTrainSpeed(speed) {
+    mp.game.vehicle.setTrainSpeed(this.raw.handle, speed);
+  }
+  setTrainCruiseSpeed(speed) {
+    mp.game.vehicle.setTrainCruiseSpeed(this.raw.handle, speed);
+  }
+  // --- Performance Stats ---
+  getAcceleration() {
+    return mp.game.vehicle.getAcceleration(this.raw.handle);
+  }
+  getMaxBraking() {
+    return mp.game.vehicle.getMaxBraking(this.raw.handle);
+  }
+  getMaxTraction() {
+    return mp.game.vehicle.getMaxTraction(this.raw.handle);
+  }
+  // --- Headlight Damage ---
+  getIsLeftHeadlightDamaged() {
+    return mp.game.vehicle.getIsLeftHeadlightDamaged(this.raw.handle);
+  }
+  getIsRightHeadlightDamaged() {
+    return mp.game.vehicle.getIsRightHeadlightDamaged(this.raw.handle);
+  }
+  // --- Mod Colors ---
+  getModColor1() {
+    const c = mp.game.vehicle.getModColor1(this.raw.handle);
+    return { paintType: _nullishCoalesce(c.paintType, () => ( c[0])), color: _nullishCoalesce(c.color, () => ( c[1])), pearlescentColor: _nullishCoalesce(c.pearlescentColor, () => ( c[2])) };
+  }
+  getModColor2() {
+    const c = mp.game.vehicle.getModColor2(this.raw.handle);
+    return { paintType: _nullishCoalesce(c.paintType, () => ( c[0])), color: _nullishCoalesce(c.color, () => ( c[1])) };
+  }
+  // --- Convertible (extended) ---
+  getConvertibleRoofState() {
+    return mp.game.vehicle.getConvertibleRoofState(this.raw.handle);
+  }
+  // --- Wheel Contact / Driveable ---
+  isOnAllWheels() {
+    return mp.game.vehicle.isOnAllWheels(this.raw.handle);
+  }
+  isDriveable(isOnFireCheck = false) {
+    return mp.game.vehicle.isDriveable(this.raw.handle, isOnFireCheck);
+  }
+  // --- Trailer ---
+  detachFromTrailer() {
+    mp.game.vehicle.detachFromTrailer(this.raw.handle);
+  }
+  isAttachedToTrailer() {
+    return mp.game.vehicle.isAttachedToTrailer(this.raw.handle);
+  }
+  getTrailerVehicle() {
+    return mp.game.vehicle.getTrailerVehicle(this.raw.handle);
+  }
+  // --- Helicopter ---
+  getHeliMainRotorHealth() {
+    return mp.game.vehicle.getHeliMainRotorHealth(this.raw.handle);
+  }
+  getHeliTailRotorHealth() {
+    return mp.game.vehicle.getHeliTailRotorHealth(this.raw.handle);
+  }
+  // --- Landing Gear ---
+  getLandingGearState() {
+    return mp.game.vehicle.getLandingGearState(this.raw.handle);
+  }
+  // --- Deformation ---
+  getDeformationAtPos(offsetX, offsetY, offsetZ) {
+    const v = mp.game.vehicle.getDeformationAtPos(this.raw.handle, offsetX, offsetY, offsetZ);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  // --- Boat ---
+  setBoatAnchor(toggle) {
+    mp.game.vehicle.setBoatAnchor(this.raw.handle, toggle);
+  }
+  isBoatAnchoredAndFrozen() {
+    return mp.game.vehicle.isBoatAnchoredAndFrozen(this.raw.handle);
+  }
+  // --- Vehicle Info ---
+  getLayoutHash() {
+    return mp.game.vehicle.getLayoutHash(this.raw.handle);
+  }
+  isBig() {
+    return mp.game.vehicle.isBig(this.raw.handle);
+  }
+  isInBurnout() {
+    return mp.game.vehicle.isInBurnout(this.raw.handle);
+  }
+  doesHaveRoof() {
+    return mp.game.vehicle.doesHaveRoof(this.raw.handle);
+  }
 };
 
 // src/ragemp/RageMpPed.ts
@@ -750,6 +1337,280 @@ var RageMpPed = class extends RageMpEntity {
   setRagdollOnCollision(toggle) {
     mp.game.ped.setRagdollOnCollision(this.raw.handle, toggle);
   }
+  // --- State Checks ---
+  isDucking() {
+    return mp.game.ped.isDucking(this.raw.handle);
+  }
+  isProne() {
+    return mp.game.ped.isProne(this.raw.handle);
+  }
+  isOnFoot() {
+    return mp.game.ped.isOnFoot(this.raw.handle);
+  }
+  isRunning() {
+    return mp.game.ped.isRunning(this.raw.handle);
+  }
+  isWalking() {
+    return mp.game.ped.isWalking(this.raw.handle);
+  }
+  isSprinting() {
+    return mp.game.ped.isSprinting(this.raw.handle);
+  }
+  isStopped() {
+    return mp.game.ped.isStopped(this.raw.handle);
+  }
+  // --- Combat Tasks ---
+  taskCombat(targetPed, p2 = 0, p3 = 16) {
+    mp.game.task.combatPed(this.raw.handle, targetPed, p2, p3);
+  }
+  taskCombatHatedTargetsInArea(x, y, z, radius, p5 = 0) {
+    mp.game.task.combatHatedTargetsInArea(this.raw.handle, x, y, z, radius, p5);
+  }
+  taskAimGunAtCoord(x, y, z, time, p5 = false, p6 = false) {
+    mp.game.task.aimGunAtCoord(this.raw.handle, x, y, z, time, p5, p6);
+  }
+  taskAimGunAtEntity(entity, duration, p3 = false) {
+    mp.game.task.aimGunAtEntity(this.raw.handle, entity, duration, p3);
+  }
+  // --- Movement Tasks ---
+  taskFollowNavMeshToCoord(x, y, z, speed, timeout, stoppingRange, persistFollowing, unk) {
+    mp.game.task.followNavMeshToCoord(this.raw.handle, x, y, z, speed, timeout, stoppingRange, persistFollowing, unk);
+  }
+  taskGoToCoordAnyMeans(x, y, z, speed, p5, p6, walkingStyle, p8) {
+    mp.game.task.goToCoordAnyMeans(this.raw.handle, x, y, z, speed, p5, p6, walkingStyle, p8);
+  }
+  // --- Vehicle Tasks ---
+  taskEnterVehicle(vehicle, timeout, seat, speed, p5, p6) {
+    mp.game.task.enterVehicle(this.raw.handle, vehicle, timeout, seat, speed, p5, p6);
+  }
+  taskLeaveVehicle(vehicle, flags) {
+    mp.game.task.leaveVehicle(this.raw.handle, vehicle, flags);
+  }
+  // --- Scenario Tasks ---
+  taskStartScenarioAtPosition(scenarioName, x, y, z, heading, duration, sittingScenario, teleport) {
+    mp.game.task.startScenarioAtPosition(this.raw.handle, scenarioName, x, y, z, heading, duration, sittingScenario, teleport);
+  }
+  taskStartScenarioInPlace(scenarioName, unkDelay, playEnterAnim) {
+    mp.game.task.startScenarioInPlace(this.raw.handle, scenarioName, unkDelay, playEnterAnim);
+  }
+  // --- Look Tasks ---
+  taskLookAtCoord(x, y, z, duration, p5, p6) {
+    mp.game.task.lookAtCoord(this.raw.handle, x, y, z, duration, p5, p6);
+  }
+  taskLookAtEntity(entity, duration, p3, p4) {
+    mp.game.task.lookAtEntity(this.raw.handle, entity, duration, p3, p4);
+  }
+  // --- Relationship Groups ---
+  setRelationshipGroupHash(groupHash) {
+    mp.game.ped.setRelationshipGroupHash(this.raw.handle, groupHash);
+  }
+  getRelationshipGroupHash() {
+    return mp.game.ped.getRelationshipGroupHash(this.raw.handle);
+  }
+  // --- Decorations / Blood ---
+  addDecorationFromHashes(collection, overlay) {
+    mp.game.ped.addDecorationFromHashes(this.raw.handle, collection, overlay);
+  }
+  clearDecorations() {
+    mp.game.ped.clearDecorations(this.raw.handle);
+  }
+  applyBlood(boneIndex, xRot, yRot, zRot, woundType) {
+    mp.game.ped.applyBlood(this.raw.handle, boneIndex, xRot, yRot, zRot, woundType);
+  }
+  clearBloodDamage() {
+    mp.game.ped.clearBloodDamage(this.raw.handle);
+  }
+  applyDamageTo(damageAmount, p2, p3) {
+    mp.game.ped.applyDamageTo(this.raw.handle, damageAmount, p2, p3);
+  }
+  // --- Ragdoll (extended) ---
+  setToRagdoll(time1, time2, ragdollType, p4, p5, p6) {
+    return mp.game.ped.setToRagdoll(this.raw.handle, time1, time2, ragdollType, p4, p5, p6);
+  }
+  isRagdoll() {
+    return mp.game.ped.isRagdoll(this.raw.handle);
+  }
+  // --- Cover / Combat State ---
+  isInCover(exceptUseWeapon = false) {
+    return mp.game.ped.isInCover(this.raw.handle, exceptUseWeapon);
+  }
+  isGoingIntoCover() {
+    return mp.game.ped.isGoingIntoCover(this.raw.handle);
+  }
+  isInMeleeCombat() {
+    return mp.game.ped.isInMeleeCombat(this.raw.handle);
+  }
+  isDoingDriveby() {
+    return mp.game.ped.isDoingDriveby(this.raw.handle);
+  }
+  isFleeing() {
+    return mp.game.ped.isFleeing(this.raw.handle);
+  }
+  // --- Injury / Death ---
+  isFatallyInjured() {
+    return mp.game.ped.isFatallyInjured(this.raw.handle);
+  }
+  isInjured() {
+    return mp.game.ped.isInjured(this.raw.handle);
+  }
+  isDeadOrDying(p1 = true) {
+    return mp.game.ped.isDeadOrDying(this.raw.handle, p1);
+  }
+  getSourceOfDeath() {
+    return mp.game.ped.getSourceOfDeath(this.raw.handle);
+  }
+  getCauseOfDeath() {
+    return mp.game.ped.getCauseOfDeath(this.raw.handle);
+  }
+  getLastDamageBone() {
+    return mp.game.ped.getLastDamageBone(this.raw.handle);
+  }
+  clearLastDamageBone() {
+    mp.game.ped.clearLastDamageBone(this.raw.handle);
+  }
+  // --- Accuracy / Firing ---
+  setAccuracy(accuracy) {
+    mp.game.ped.setAccuracy(this.raw.handle, accuracy);
+  }
+  getAccuracy() {
+    return mp.game.ped.getAccuracy(this.raw.handle);
+  }
+  setFiringPattern(patternHash) {
+    mp.game.ped.setFiringPattern(this.raw.handle, patternHash);
+  }
+  setShootRate(shootRate) {
+    mp.game.ped.setShootRate(this.raw.handle, shootRate);
+  }
+  // --- Targeting ---
+  setCanBeTargetted(toggle) {
+    mp.game.ped.setCanBeTargetted(this.raw.handle, toggle);
+  }
+  setCanBeTargettedByTeam(team, toggle) {
+    mp.game.ped.setCanBeTargettedByTeam(this.raw.handle, team, toggle);
+  }
+  setCanBeTargettedByPlayer(player, toggle) {
+    mp.game.ped.setCanBeTargettedByPlayer(this.raw.handle, player, toggle);
+  }
+  // --- Damage Conditions ---
+  setSuffersCriticalHits(toggle) {
+    mp.game.ped.setSuffersCriticalHits(this.raw.handle, toggle);
+  }
+  setDiesInWater(toggle) {
+    mp.game.ped.setDiesInWater(this.raw.handle, toggle);
+  }
+  setDiesInSinkingVehicle(toggle) {
+    mp.game.ped.setDiesInSinkingVehicle(this.raw.handle, toggle);
+  }
+  // --- Type Checks ---
+  isMale() {
+    return mp.game.ped.isMale(this.raw.handle);
+  }
+  isHuman() {
+    return mp.game.ped.isHuman(this.raw.handle);
+  }
+  // --- Perception ---
+  setSeeingRange(value) {
+    mp.game.ped.setSeeingRange(this.raw.handle, value);
+  }
+  setHearingRange(value) {
+    mp.game.ped.setHearingRange(this.raw.handle, value);
+  }
+  // --- Ducking ---
+  setDucking(toggle) {
+    mp.game.ped.setDucking(this.raw.handle, toggle);
+  }
+  // --- Money ---
+  getMoney() {
+    return mp.game.ped.getMoney(this.raw.handle);
+  }
+  setMoney(amount) {
+    mp.game.ped.setMoney(this.raw.handle, amount);
+  }
+  // --- Stealth ---
+  setStealthMovement(p1, action) {
+    mp.game.ped.setStealthMovement(this.raw.handle, p1, action);
+  }
+  getStealthMovement() {
+    return mp.game.ped.getStealthMovement(this.raw.handle);
+  }
+  // --- Vehicle Intent ---
+  getSeatIsTryingToEnter() {
+    return mp.game.ped.getSeatIsTryingToEnter(this.raw.handle);
+  }
+  getVehicleIsTryingToEnter() {
+    return mp.game.ped.getVehicleIsTryingToEnter(this.raw.handle);
+  }
+  getVehicleIsUsing() {
+    return mp.game.ped.getVehicleIsUsing(this.raw.handle);
+  }
+  // --- Group System ---
+  setAsGroupLeader(groupId) {
+    mp.game.ped.setAsGroupLeader(this.raw.handle, groupId);
+  }
+  setAsGroupMember(groupId) {
+    mp.game.ped.setAsGroupMember(this.raw.handle, groupId);
+  }
+  removeFromGroup() {
+    mp.game.ped.removeFromGroup(this.raw.handle);
+  }
+  isGroupMember(groupId) {
+    return mp.game.ped.isGroupMember(this.raw.handle, groupId);
+  }
+  isInGroup() {
+    return mp.game.ped.isInGroup(this.raw.handle);
+  }
+  // --- Additional Tasks ---
+  taskStandStill(time) {
+    mp.game.task.standStill(this.raw.handle, time);
+  }
+  taskWanderStandard(p1 = 10, p2 = 10) {
+    mp.game.task.wanderStandard(this.raw.handle, p1, p2);
+  }
+  taskWanderInArea(x, y, z, radius, minimalLength, timeBetweenWalks) {
+    mp.game.task.wanderInArea(this.raw.handle, x, y, z, radius, minimalLength, timeBetweenWalks);
+  }
+  taskSmartFleeCoord(x, y, z, distance, time, p6 = false, p7 = false) {
+    mp.game.task.smartFleeCoord(this.raw.handle, x, y, z, distance, time, p6, p7);
+  }
+  taskPatrol(p1, p2, p3, p4) {
+    mp.game.task.patrol(this.raw.handle, p1, p2, p3, p4);
+  }
+  taskHandsUp(duration, facingPed, p3, p4) {
+    mp.game.task.handsUp(this.raw.handle, duration, facingPed, p3, p4);
+  }
+  taskPlayPhoneGestureAnimation(animDict, animation, boneMaskType, p4, p5, p6, p7) {
+    mp.game.task.playPhoneGestureAnimation(this.raw.handle, animDict, animation, boneMaskType, p4, p5, p6, p7);
+  }
+  taskStopPhoneGestureAnimation(p1 = 0) {
+    mp.game.task.stopPhoneGestureAnimation(this.raw.handle, p1);
+  }
+  taskClimbLadder(p1) {
+    mp.game.task.climbLadder(this.raw.handle, p1);
+  }
+  taskSwapWeapon(p1) {
+    mp.game.task.swapWeapon(this.raw.handle, p1);
+  }
+  taskReloadWeapon(unused) {
+    mp.game.task.reloadWeapon(this.raw.handle, unused);
+  }
+  taskUseMobilePhone(p1, p2 = 0) {
+    mp.game.task.useMobilePhone(this.raw.handle, p1, p2);
+  }
+  taskUseMobilePhoneTimed(duration) {
+    mp.game.task.useMobilePhoneTimed(this.raw.handle, duration);
+  }
+  // --- Movement Blend ---
+  setMaxMoveBlendRatio(value) {
+    mp.game.ped.setMaxMoveBlendRatio(this.raw.handle, value);
+  }
+  // --- Resurrect ---
+  resurrect() {
+    mp.game.ped.resurrect(this.raw.handle);
+  }
+  // --- Secondary Task ---
+  clearSecondaryTask() {
+    mp.game.ped.clearSecondaryTask(this.raw.handle);
+  }
 };
 
 // src/ragemp/RageMpObject.ts
@@ -769,6 +1630,27 @@ var RageMpObject = class extends RageMpEntity {
   setTargetable(targetable) {
     mp.game.object.setTargettable(this.raw.handle, targetable);
   }
+  // --- Physics ---
+  setPhysicsParams(weight, p1, p2, p3, p4, gravity, p6, p7, p8, p9, buoyancy) {
+    mp.game.object.setPhysicsParams(
+      this.raw.handle,
+      weight,
+      p1,
+      p2,
+      p3,
+      p4,
+      gravity,
+      p6,
+      p7,
+      p8,
+      p9,
+      buoyancy
+    );
+  }
+  // --- Lifecycle ---
+  markForDeletion() {
+    mp.game.object.markForDeletion(this.raw.handle);
+  }
 };
 
 // src/ragemp/RageMpBlip.ts
@@ -1445,19 +2327,831 @@ var RageMpNativesBridge = class {
   }
 };
 
-// src/ragemp/RageMpEngine.ts
-var RageMpEngine = (_class4 = class {
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
+// src/ragemp/RageMpWeapon.ts
+var RageMpWeapon = class {
+  // --- Give / Remove ---
+  giveComponentToPed(ped, weaponHash, componentHash) {
+    mp.game.weapon.giveComponentToPed(ped, weaponHash, componentHash);
+  }
+  removeComponentFromPed(ped, weaponHash, componentHash) {
+    mp.game.weapon.removeComponentFromPed(ped, weaponHash, componentHash);
+  }
+  hasPedGotComponent(ped, weaponHash, componentHash) {
+    return mp.game.weapon.hasPedGotComponent(ped, weaponHash, componentHash);
+  }
+  isPedComponentActive(ped, weaponHash, componentHash) {
+    return mp.game.weapon.isPedComponentActive(ped, weaponHash, componentHash);
+  }
+  removeFromPed(ped, weaponHash) {
+    mp.game.weapon.removeFromPed(ped, weaponHash);
+  }
+  // --- Ammo ---
+  setPedInfiniteAmmo(ped, toggle, weaponHash) {
+    mp.game.weapon.setPedInfiniteAmmo(ped, toggle, weaponHash);
+  }
+  setPedInfiniteAmmoClip(ped, toggle) {
+    mp.game.weapon.setPedInfiniteAmmoClip(ped, toggle);
+  }
+  getMaxAmmo(ped, weaponHash) {
+    return mp.game.weapon.getMaxAmmo(ped, weaponHash);
+  }
+  getMaxAmmoInClip(ped, weaponHash, p2 = false) {
+    return mp.game.weapon.getMaxAmmoInClip(ped, weaponHash, p2);
+  }
+  getClipSize(weaponHash) {
+    return mp.game.weapon.getClipSize(weaponHash);
+  }
+  getAmmoInPed(ped, weaponHash) {
+    return mp.game.weapon.getAmmoInPed(ped, weaponHash);
+  }
+  addAmmoToPed(ped, weaponHash, ammo) {
+    mp.game.weapon.addAmmoToPed(ped, weaponHash, ammo);
+  }
+  setPedAmmo(ped, weaponHash, ammo, p3 = false) {
+    mp.game.weapon.setPedAmmo(ped, weaponHash, ammo, p3);
+  }
+  // --- Current Weapon ---
+  getCurrentPed(ped, p2 = true) {
+    return mp.game.weapon.getCurrentPed(ped, p2);
+  }
+  setCurrentPed(ped, weaponHash, bForceInHand = true) {
+    mp.game.weapon.setCurrentPed(ped, weaponHash, bForceInHand);
+  }
+  // --- Tint ---
+  setPedTintIndex(ped, weaponHash, tintIndex) {
+    mp.game.weapon.setPedTintIndex(ped, weaponHash, tintIndex);
+  }
+  getPedTintIndex(ped, weaponHash) {
+    return mp.game.weapon.getPedTintIndex(ped, weaponHash);
+  }
+  // --- Damage ---
+  hasPedBeenDamagedBy(ped, weaponHash, weaponType) {
+    return mp.game.weapon.hasPedBeenDamagedBy(ped, weaponHash, weaponType);
+  }
+  clearPedLastDamage(ped) {
+    mp.game.weapon.clearPedLastDamage(ped);
+  }
+  getDamage(weaponHash, componentHash) {
+    return mp.game.weapon.getDamage(weaponHash, componentHash);
+  }
+  getTimeBetweenShots(weaponHash) {
+    return mp.game.weapon.getTimeBetweenShots(weaponHash);
+  }
+  // --- Drops ---
+  setPedDropsWeaponsWhenDead(ped, toggle) {
+    mp.game.weapon.setPedDropsWeaponsWhenDead(ped, toggle);
+  }
+  setPedDrops(ped) {
+    mp.game.weapon.setPedDrops(ped);
+  }
+  // --- Actions ---
+  makePedReload(ped) {
+    return mp.game.weapon.makePedReload(ped);
+  }
+  isPedArmed(ped, typeFlags) {
+    return mp.game.weapon.isPedArmed(ped, typeFlags);
+  }
+  // --- Weapon Info ---
+  hasPedGot(ped, weaponHash, p2 = false) {
+    return mp.game.weapon.hasPedGot(ped, weaponHash, p2);
+  }
+  getWeapontypeGroup(weaponHash) {
+    return mp.game.weapon.getWeapontypeGroup(weaponHash);
+  }
+  setCurrentDamageEventAmount(amount) {
+    mp.game.weapon.setCurrentDamageEventAmount(amount);
+  }
+};
+
+// src/ragemp/RageMpStreaming.ts
+var RageMpStreaming = class {
+  // --- Model Loading ---
+  requestModel(model) {
+    mp.game.streaming.requestModel(model);
+  }
+  hasModelLoaded(model) {
+    return mp.game.streaming.hasModelLoaded(model);
+  }
+  setModelAsNoLongerNeeded(model) {
+    mp.game.streaming.setModelAsNoLongerNeeded(model);
+  }
+  isModelValid(model) {
+    return mp.game.streaming.isModelValid(model);
+  }
+  isModelAPed(model) {
+    return mp.game.streaming.isModelAPed(model);
+  }
+  isModelAVehicle(model) {
+    return mp.game.streaming.isModelAVehicle(model);
+  }
+  // --- Animation Dicts ---
+  requestAnimDict(animDict) {
+    mp.game.streaming.requestAnimDict(animDict);
+  }
+  hasAnimDictLoaded(animDict) {
+    return mp.game.streaming.hasAnimDictLoaded(animDict);
+  }
+  removeAnimDict(animDict) {
+    mp.game.streaming.removeAnimDict(animDict);
+  }
+  // --- Animation Sets ---
+  requestAnimSet(animSet) {
+    mp.game.streaming.requestAnimSet(animSet);
+  }
+  hasAnimSetLoaded(animSet) {
+    return mp.game.streaming.hasAnimSetLoaded(animSet);
+  }
+  removeAnimSet(animSet) {
+    mp.game.streaming.removeAnimSet(animSet);
+  }
+  // --- Clip Sets ---
+  requestClipSet(clipSet) {
+    mp.game.streaming.requestClipSet(clipSet);
+  }
+  hasClipSetLoaded(clipSet) {
+    return mp.game.streaming.hasClipSetLoaded(clipSet);
+  }
+  removeClipSet(clipSet) {
+    mp.game.streaming.removeClipSet(clipSet);
+  }
+  // --- IPL ---
+  requestIpl(iplName) {
+    mp.game.streaming.requestIpl(iplName);
+  }
+  removeIpl(iplName) {
+    mp.game.streaming.removeIpl(iplName);
+  }
+  isIplActive(iplName) {
+    return mp.game.streaming.isIplActive(iplName);
+  }
+  // --- Particle Effects ---
+  requestNamedPtfxAsset(fxName) {
+    mp.game.streaming.requestNamedPtfxAsset(fxName);
+  }
+  hasNamedPtfxAssetLoaded(fxName) {
+    return mp.game.streaming.hasNamedPtfxAssetLoaded(fxName);
+  }
+  removeNamedPtfxAsset(fxName) {
+    mp.game.streaming.removeNamedPtfxAsset(fxName);
+  }
+  // --- Collision ---
+  requestCollisionAtCoord(x, y, z) {
+    mp.game.streaming.requestCollisionAtCoord(x, y, z);
+  }
+  hasCollisionForModelLoaded(model) {
+    return mp.game.streaming.hasCollisionForModelLoaded(model);
+  }
+};
+
+// src/ragemp/RageMpWorld.ts
+var RageMpWorld = class {
+  // --- Clock ---
+  setClockTime(hour, minute, second) {
+    mp.game.clock.setTime(hour, minute, second);
+  }
+  getClockHours() {
+    return mp.game.clock.getHours();
+  }
+  getClockMinutes() {
+    return mp.game.clock.getMinutes();
+  }
+  getClockSeconds() {
+    return mp.game.clock.getSeconds();
+  }
+  setClockDate(day, month, year) {
+    mp.game.clock.setDate(day, month, year);
+  }
+  getClockDayOfWeek() {
+    return mp.game.clock.getDayOfWeek();
+  }
+  getClockDayOfMonth() {
+    return mp.game.clock.getDayOfMonth();
+  }
+  getClockMonth() {
+    return mp.game.clock.getMonth();
+  }
+  getClockYear() {
+    return mp.game.clock.getYear();
+  }
+  pauseClock(toggle) {
+    mp.game.clock.pause(toggle);
+  }
+  advanceClockTimeTo(hour, minute, second) {
+    mp.game.clock.advanceTimeTo(hour, minute, second);
+  }
+  addToClockTime(hours, minutes, seconds) {
+    mp.game.clock.addToTime(hours, minutes, seconds);
+  }
+  getMillisecondsPerGameMinute() {
+    return mp.game.clock.getMillisecondsPerGameMinute();
+  }
+  // --- Fire ---
+  addExplosion(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake, noDamage) {
+    mp.game.fire.addExplosion(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake, noDamage);
+  }
+  addOwnedExplosion(ped, x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake) {
+    mp.game.fire.addOwnedExplosion(ped, x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake);
+  }
+  startEntityFire(entity) {
+    return mp.game.fire.startEntity(entity);
+  }
+  stopEntityFire(entity) {
+    mp.game.fire.stopEntity(entity);
+  }
+  isEntityOnFire(entity) {
+    return mp.game.fire.isEntityOn(entity);
+  }
+  getNumberOfFiresInRange(x, y, z, radius) {
+    return mp.game.fire.getNumberOfFiresInRange(x, y, z, radius);
+  }
+  stopFireInRange(x, y, z, radius) {
+    mp.game.fire.stopInRange(x, y, z, radius);
+  }
+  isExplosionInArea(explosionType, x1, y1, z1, x2, y2, z2) {
+    return mp.game.fire.isExplosionInArea(explosionType, x1, y1, z1, x2, y2, z2);
+  }
+  isExplosionInSphere(explosionType, x, y, z, radius) {
+    return mp.game.fire.isExplosionInSphere(explosionType, x, y, z, radius);
+  }
+  // --- Water ---
+  getWaterHeight(x, y, z) {
+    return mp.game.water.getHeight(x, y, z);
+  }
+  getWaterHeightNoWaves(x, y, z) {
+    return mp.game.water.getHeightNoWaves(x, y, z);
+  }
+  testVerticalProbeAgainstAllWater(x, y, z, p3) {
+    return mp.game.water.testVerticalProbeAgainstAll(x, y, z, p3);
+  }
+  // --- Interior ---
+  getInteriorAtCoords(x, y, z) {
+    return mp.game.interior.getAtCoords(x, y, z);
+  }
+  getInteriorAtCoordsWithType(x, y, z, interiorType) {
+    return mp.game.interior.getAtCoordsWithType(x, y, z, interiorType);
+  }
+  getInteriorFromEntity(entity) {
+    return mp.game.interior.getFromEntity(entity);
+  }
+  activateInteriorEntitySet(interior, entitySetName) {
+    mp.game.interior.activateEntitySet(interior, entitySetName);
+  }
+  deactivateInteriorEntitySet(interior, entitySetName) {
+    mp.game.interior.deactivateEntitySet(interior, entitySetName);
+  }
+  isInteriorEntitySetActive(interior, entitySetName) {
+    return mp.game.interior.isEntitySetActive(interior, entitySetName);
+  }
+  pinInteriorInMemory(interior) {
+    mp.game.interior.pinInMemory(interior);
+  }
+  unpinInterior(interior) {
+    mp.game.interior.unpin(interior);
+  }
+  isInteriorReady(interior) {
+    return mp.game.interior.isReady(interior);
+  }
+  refreshInterior(interior) {
+    mp.game.interior.refresh(interior);
+  }
+  // --- Zone ---
+  getZoneAtCoords(x, y, z) {
+    return mp.game.zone.getAtCoords(x, y, z);
+  }
+  getZoneFromNameId(zoneName) {
+    return mp.game.zone.getFromNameId(zoneName);
+  }
+  getNameOfZone(x, y, z) {
+    return mp.game.zone.getNameOf(x, y, z);
+  }
+  // --- Weather ---
+  setWeatherTypeNow(weatherType) {
+    mp.game.misc.setWeatherTypeNow(weatherType);
+  }
+  setWeatherTypePersist(weatherType) {
+    mp.game.misc.setWeatherTypePersist(weatherType);
+  }
+  setWeatherTypeOverTime(weatherType, time) {
+    mp.game.misc.setWeatherTypeOverTime(weatherType, time);
+  }
+  clearWeatherTypePersist() {
+    mp.game.misc.clearWeatherTypePersist();
+  }
+  setOverrideWeather(weatherType) {
+    mp.game.misc.setOverrideWeather(weatherType);
+  }
+  clearOverrideWeather() {
+    mp.game.misc.clearOverrideWeather();
+  }
+  setWindSpeed(speed) {
+    mp.game.misc.setWindSpeed(speed);
+  }
+  getWindSpeed() {
+    return mp.game.misc.getWindSpeed();
+  }
+  getWindDirection() {
+    const v = mp.game.misc.getWindDirection();
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  getRainLevel() {
+    return mp.game.misc.getRainLevel();
+  }
+  getSnowLevel() {
+    return mp.game.misc.getSnowLevel();
+  }
+  // --- Water (extended) ---
+  setDeepOceanScaler(intensity) {
+    mp.game.water.setDeepOceanScaler(intensity);
+  }
+  // --- Interior (extended) ---
+  enableInteriorProp(interior, propName) {
+    mp.game.interior.enableInteriorProp(interior, propName);
+  }
+  // --- Scenario ---
+  setScenarioTypeEnabled(scenarioType, toggle) {
+    mp.game.task.setScenarioTypeEnabled(scenarioType, toggle);
+  }
+  // --- GXT ---
+  setGxtEntry(labelNameOrHash, newLabelValue) {
+    mp.game.gxt.set(labelNameOrHash, newLabelValue);
+  }
+  // --- Stats ---
+  statSetInt(statName, value, save = true) {
+    return mp.game.stats.statSetInt(statName, value, save);
+  }
+  // --- Object Natives ---
+  createObject(modelHash, x, y, z, isNetwork, bScriptHostObj, dynamic) {
+    return mp.game.object.createObject(modelHash, x, y, z, isNetwork, bScriptHostObj, dynamic);
+  }
+  deleteObject(object) {
+    mp.game.object.deleteObject(object);
+  }
+  getObjectOffsetFromCoords(xPos, yPos, zPos, heading, xOffset, yOffset, zOffset) {
+    const v = mp.game.object.getObjectOffsetFromCoords(xPos, yPos, zPos, heading, xOffset, yOffset, zOffset);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  // --- Shapetest ---
+  startShapeTestLosProbe(x1, y1, z1, x2, y2, z2, flags, entity, p8) {
+    return mp.game.shapetest.startExpensiveSynchronousShapeTestLosProbe(x1, y1, z1, x2, y2, z2, flags, entity, p8);
+  }
+  getShapeTestResult(shapeTestHandle) {
+    const r = mp.game.shapetest.getShapeTestResult(shapeTestHandle);
+    return {
+      hit: _nullishCoalesce(r.hit, () => ( false)),
+      endCoords: { x: _nullishCoalesce(_optionalChain([r, 'access', _4 => _4.endCoords, 'optionalAccess', _5 => _5.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([r, 'access', _6 => _6.endCoords, 'optionalAccess', _7 => _7.y]), () => ( 0)), z: _nullishCoalesce(_optionalChain([r, 'access', _8 => _8.endCoords, 'optionalAccess', _9 => _9.z]), () => ( 0)) },
+      surfaceNormal: { x: _nullishCoalesce(_optionalChain([r, 'access', _10 => _10.surfaceNormal, 'optionalAccess', _11 => _11.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([r, 'access', _12 => _12.surfaceNormal, 'optionalAccess', _13 => _13.y]), () => ( 0)), z: _nullishCoalesce(_optionalChain([r, 'access', _14 => _14.surfaceNormal, 'optionalAccess', _15 => _15.z]), () => ( 0)) },
+      entityHit: _nullishCoalesce(r.entityHit, () => ( 0)),
+      result: _nullishCoalesce(r.result, () => ( 0))
+    };
+  }
+  // --- Graphics ---
+  getScreenCoordFromWorldCoord(worldX, worldY, worldZ) {
+    const result = mp.game.graphics.getScreenCoordFromWorldCoord(worldX, worldY, worldZ);
+    if (typeof result === "boolean") {
+      return { success: false, screenX: 0, screenY: 0 };
+    }
+    return { success: true, screenX: _nullishCoalesce(result.x, () => ( result[0])), screenY: _nullishCoalesce(result.y, () => ( result[1])) };
+  }
+  getActiveScreenResolution() {
+    const r = mp.game.graphics.getActiveScreenResolution();
+    return { x: _nullishCoalesce(r.x, () => ( r[0])), y: _nullishCoalesce(r.y, () => ( r[1])) };
+  }
+  getScreenResolution() {
+    const r = mp.game.graphics.getScreenResolution();
+    return { x: _nullishCoalesce(r.x, () => ( r[0])), y: _nullishCoalesce(r.y, () => ( r[1])) };
+  }
+};
+
+// src/ragemp/RageMpGameplay.ts
+var RageMpGameplay = class {
+  // --- Hashing ---
+  getHashKey(string) {
+    return mp.game.misc.getHashKey(string);
+  }
+  // --- Distance ---
+  getDistanceBetweenCoords(x1, y1, z1, x2, y2, z2, useZ) {
+    return mp.game.misc.getDistanceBetweenCoords(x1, y1, z1, x2, y2, z2, useZ);
+  }
+  // --- Ground ---
+  getGroundZFor3dCoord(x, y, z, ignoreWater = false, p5 = false) {
+    return mp.game.misc.getGroundZFor3dCoord(x, y, z, ignoreWater, p5);
+  }
+  // --- Timer ---
+  getGameTimer() {
+    return mp.game.misc.getGameTimer();
+  }
+  getFrameTime() {
+    return mp.game.misc.getFrameTime();
+  }
+  getFrameCount() {
+    return mp.game.misc.getFrameCount();
+  }
+  // --- Bullets ---
+  shootSingleBulletBetweenCoords(x1, y1, z1, x2, y2, z2, damage, p7, weaponHash, ownerPed, isAudible, isInvisible, speed) {
+    mp.game.misc.shootSingleBulletBetweenCoords(x1, y1, z1, x2, y2, z2, damage, p7, weaponHash, ownerPed, isAudible, isInvisible, speed);
+  }
+  // --- Clear Area ---
+  clearAreaOfEverything(x, y, z, radius, p4 = false, p5 = false, p6 = false, p7 = false) {
+    mp.game.misc.clearAreaOfEverything(x, y, z, radius, p4, p5, p6, p7);
+  }
+  clearAreaOfVehicles(x, y, z, radius, p4 = false, p5 = false, p6 = false, p7 = false, p8 = false, p9 = false) {
+    mp.game.misc.clearAreaOfVehicles(x, y, z, radius, p4, p5, p6, p7, p8, p9);
+  }
+  clearAreaOfPeds(x, y, z, radius, flags = 0) {
+    mp.game.misc.clearAreaOfPeds(x, y, z, radius, flags);
+  }
+  clearAreaOfObjects(x, y, z, radius, flags = 0) {
+    mp.game.misc.clearAreaOfObjects(x, y, z, radius, flags);
+  }
+  // --- Heading ---
+  getHeadingFromVector2d(dx, dy) {
+    return mp.game.misc.getHeadingFromVector2d(dx, dy);
+  }
+  // --- Death ---
+  setFadeOutAfterDeath(toggle) {
+    mp.game.misc.setFadeOutAfterDeath(toggle);
+  }
+  // --- Random Events ---
+  setRandomEventFlag(toggle) {
+    mp.game.misc.setRandomEventFlag(toggle);
+  }
+};
+
+// src/ragemp/RageMpHUD.ts
+var RageMpHUD = class {
+  // --- Display Control ---
+  displayHud(toggle) {
+    mp.game.hud.displayHud(toggle);
+  }
+  displayRadar(toggle) {
+    mp.game.hud.displayRadar(toggle);
+  }
+  isRadarHidden() {
+    return mp.game.hud.isRadarHidden();
+  }
+  isMinimapRendering() {
+    return mp.game.hud.isMinimapRendering();
+  }
+  setRadarBigmapEnabled(toggleBigMap, showFullMap) {
+    mp.game.hud.setRadarBigmapEnabled(toggleBigMap, showFullMap);
+  }
+  // --- HUD Components ---
+  isHudComponentActive(id) {
+    return mp.game.hud.isHudComponentActive(id);
+  }
+  hideHudComponentThisFrame(id) {
+    mp.game.hud.hideHudComponentThisFrame(id);
+  }
+  showHudComponentThisFrame(id) {
+    mp.game.hud.showHudComponentThisFrame(id);
+  }
+  // --- Waypoint ---
+  isWaypointActive() {
+    return mp.game.hud.isWaypointActive();
+  }
+  deleteWaypoint() {
+    mp.game.hud.deleteWaypoint();
+  }
+  setNewWaypoint(x, y) {
+    mp.game.hud.setNewWaypoint(x, y);
+  }
+  // --- Text Rendering ---
+  beginTextCommandDisplayText(text) {
+    mp.game.hud.beginTextCommandDisplayText(text);
+  }
+  endTextCommandDisplayText(x, y, p2 = 0) {
+    mp.game.hud.endTextCommandDisplayText(x, y, p2);
+  }
+  addTextComponentSubstringPlayerName(text) {
+    mp.game.hud.addTextComponentSubstringPlayerName(text);
+  }
+  setTextScale(scale, size) {
+    mp.game.hud.setTextScale(scale, size);
+  }
+  setTextFont(fontType) {
+    mp.game.hud.setTextFont(fontType);
+  }
+  setTextColour(red, green, blue, alpha) {
+    mp.game.hud.setTextColour(red, green, blue, alpha);
+  }
+  setTextCentre(align) {
+    mp.game.hud.setTextCentre(align);
+  }
+  setTextDropShadow() {
+    mp.game.hud.setTextDropShadow();
+  }
+  setTextOutline() {
+    mp.game.hud.setTextOutline();
+  }
+  setTextWrap(start, end) {
+    mp.game.hud.setTextWrap(start, end);
+  }
+  // --- Notifications ---
+  beginTextCommandThefeedPost(text) {
+    mp.game.hud.beginTextCommandThefeedPost(text);
+  }
+  endTextCommandThefeedPostMessagetext(txdName, textureName, flash, iconType, sender, subject) {
+    return mp.game.hud.endTextCommandThefeedPostMessagetext(txdName, textureName, flash, iconType, sender, subject);
+  }
+  endTextCommandThefeedPostMessagetextTu(txdName, textureName, flash, iconType, sender, subject, duration) {
+    return mp.game.hud.endTextCommandThefeedPostMessagetextTu(txdName, textureName, flash, iconType, sender, subject, duration);
+  }
+  // --- Labels ---
+  getLabelText(labelName) {
+    return mp.game.hud.getLabelText(labelName);
+  }
+  // --- Text (extended) ---
+  setTextJustification(justifyType) {
+    mp.game.hud.setTextJustification(justifyType);
+  }
+  setTextRightJustify(toggle) {
+    mp.game.hud.setTextRightJustify(toggle);
+  }
+  // --- HUD Colours ---
+  replaceColour(hudColorIndex, hudColorIndex2) {
+    mp.game.hud.replaceColour(hudColorIndex, hudColorIndex2);
+  }
+};
+
+// src/ragemp/RageMpAudio.ts
+var RageMpAudio = class {
+  // --- Sound IDs ---
+  getSoundId() {
+    return mp.game.audio.getSoundId();
+  }
+  releaseSoundId(soundId) {
+    mp.game.audio.releaseSoundId(soundId);
+  }
+  // --- Sound Playback ---
+  playSoundFrontend(soundId, audioName, audioRef, p3 = false) {
+    mp.game.audio.playSoundFrontend(soundId, audioName, audioRef, p3);
+  }
+  playSound(soundId, audioName, audioRef, p3 = false, p4 = 0, p5 = false) {
+    mp.game.audio.playSound(soundId, audioName, audioRef, p3, p4, p5);
+  }
+  stopSound(soundId) {
+    mp.game.audio.stopSound(soundId);
+  }
+  hasSoundFinished(soundId) {
+    return mp.game.audio.hasSoundFinished(soundId);
+  }
+  // --- Speech ---
+  playAmbientSpeechWithVoice(ped, speechName, voiceName, speechParam, p4 = false) {
+    mp.game.audio.playAmbientSpeechWithVoice(ped, speechName, voiceName, speechParam, p4);
+  }
+  // --- Audio Banks ---
+  requestScriptAudioBank(p0, p1 = false, p2 = -1) {
+    return mp.game.audio.requestScriptAudioBank(p0, p1, p2);
+  }
+  releaseNamedScriptAudioBank(audioBank) {
+    mp.game.audio.releaseNamedScriptAudioBank(audioBank);
+  }
+  // --- Audio Scenes ---
+  startAudioScene(scene) {
+    return mp.game.audio.startAudioScene(scene);
+  }
+  stopAudioScene(scene) {
+    mp.game.audio.stopAudioScene(scene);
+  }
+  isAudioSceneActive(scene) {
+    return mp.game.audio.isAudioSceneActive(scene);
+  }
+  // --- Audio Flags ---
+  setAudioFlag(flagName, toggle) {
+    mp.game.audio.setAudioFlag(flagName, toggle);
+  }
+  // --- Ringtones ---
+  playPedRingtone(ringtoneName, ped, p2 = false) {
+    mp.game.audio.playPedRingtone(ringtoneName, ped, p2);
+  }
+  stopPedRingtone(ped) {
+    mp.game.audio.stopPedRingtone(ped);
+  }
+  // --- Ambient Zones ---
+  setAmbientZoneListStatePersistent(ambientZone, p1, p2) {
+    mp.game.audio.setAmbientZoneListStatePersistent(ambientZone, p1, p2);
+  }
+  setAmbientZoneState(zoneName, p1, p2) {
+    mp.game.audio.setAmbientZoneState(zoneName, p1, p2);
+  }
+  setStaticEmitterEnabled(emitterName, toggle) {
+    mp.game.audio.setStaticEmitterEnabled(emitterName, toggle);
+  }
+};
+
+// src/ragemp/RageMpGraphics.ts
+var RageMpGraphics = class {
+  // --- Particle Effects ---
+  useParticleFxAsset(name) {
+    mp.game.graphics.useParticleFxAsset(name);
+  }
+  startParticleFxNonLoopedAtCoord(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis = false, yAxis = false, zAxis = false) {
+    return mp.game.graphics.startParticleFxNonLoopedAtCoord(effectName, xPos, yPos, zPos, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis);
+  }
+  startParticleFxNonLoopedOnEntity(effectName, entity, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scale, axisX = false, axisY = false, axisZ = false) {
+    return mp.game.graphics.startParticleFxNonLoopedOnEntity(effectName, entity, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scale, axisX, axisY, axisZ);
+  }
+  startParticleFxLoopedAtCoord(effectName, x, y, z, xRot, yRot, zRot, scale, xAxis = false, yAxis = false, zAxis = false, p11 = false) {
+    return mp.game.graphics.startParticleFxLoopedAtCoord(effectName, x, y, z, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis, p11);
+  }
+  startParticleFxLoopedOnEntity(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, scale, xAxis = false, yAxis = false, zAxis = false) {
+    return mp.game.graphics.startParticleFxLoopedOnEntity(effectName, entity, xOffset, yOffset, zOffset, xRot, yRot, zRot, scale, xAxis, yAxis, zAxis);
+  }
+  stopParticleFxLooped(ptfxHandle, p1 = false) {
+    mp.game.graphics.stopParticleFxLooped(ptfxHandle, p1);
+  }
+  removeParticleFx(ptfxHandle, p1 = false) {
+    mp.game.graphics.removeParticleFx(ptfxHandle, p1);
+  }
+  doesParticleFxLoopedExist(ptfxHandle) {
+    return mp.game.graphics.doesParticleFxLoopedExist(ptfxHandle);
+  }
+  setParticleFxLoopedColour(ptfxHandle, r, g, b, p4 = false) {
+    mp.game.graphics.setParticleFxLoopedColour(ptfxHandle, r, g, b, p4);
+  }
+  setParticleFxLoopedAlpha(ptfxHandle, alpha) {
+    mp.game.graphics.setParticleFxLoopedAlpha(ptfxHandle, alpha);
+  }
+  setParticleFxLoopedScale(ptfxHandle, scale) {
+    mp.game.graphics.setParticleFxLoopedScale(ptfxHandle, scale);
+  }
+  // --- Drawing ---
+  drawLine(x1, y1, z1, x2, y2, z2, red, green, blue, alpha) {
+    mp.game.graphics.drawLine(x1, y1, z1, x2, y2, z2, red, green, blue, alpha);
+  }
+  drawPoly(x1, y1, z1, x2, y2, z2, x3, y3, z3, red, green, blue, alpha) {
+    mp.game.graphics.drawPoly(x1, y1, z1, x2, y2, z2, x3, y3, z3, red, green, blue, alpha);
+  }
+  drawRect(x, y, width, height, r, g, b, a, p8 = false) {
+    mp.game.graphics.drawRect(x, y, width, height, r, g, b, a, p8);
+  }
+  drawSprite(textureDict, textureName, screenX, screenY, width, height, heading, red, green, blue, alpha, p11 = false) {
+    mp.game.graphics.drawSprite(textureDict, textureName, screenX, screenY, width, height, heading, red, green, blue, alpha, p11);
+  }
+  // --- Screen Effects ---
+  animpostfxPlay(effectName, duration, looped) {
+    mp.game.graphics.animpostfxPlay(effectName, duration, looped);
+  }
+  animpostfxStop(effectName) {
+    mp.game.graphics.animpostfxStop(effectName);
+  }
+  animpostfxIsRunning(effectName) {
+    return mp.game.graphics.animpostfxIsRunning(effectName);
+  }
+  animpostfxStopAll() {
+    mp.game.graphics.animpostfxStopAll();
+  }
+  // --- Timecycle ---
+  setTimecycleModifier(modifierName) {
+    mp.game.graphics.setTimecycleModifier(modifierName);
+  }
+  setTimecycleModifierStrength(strength) {
+    mp.game.graphics.setTimecycleModifierStrength(strength);
+  }
+  clearTimecycleModifier() {
+    mp.game.graphics.clearTimecycleModifier();
+  }
+  // --- Markers ---
+  drawMarker(type, posX, posY, posZ, dirX, dirY, dirZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ, red, green, blue, alpha, bobUpAndDown, faceCamera, p19, rotate, textureDict, textureName, drawOnEnts) {
+    mp.game.graphics.drawMarker(type, posX, posY, posZ, dirX, dirY, dirZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ, red, green, blue, alpha, bobUpAndDown, faceCamera, p19, rotate, textureDict, textureName, drawOnEnts);
+  }
+  // --- Screen ---
+  getAspectRatio(b = false) {
+    return mp.game.graphics.getAspectRatio(b);
+  }
+  getSafeZoneSize() {
+    return mp.game.graphics.getSafeZoneSize();
+  }
+  // --- Scaleform ---
+  requestScaleformMovie(scaleformName) {
+    return mp.game.graphics.requestScaleformMovie(scaleformName);
+  }
+  beginScaleformMovieMethod(scaleform, methodName) {
+    return mp.game.graphics.beginScaleformMovieMethod(scaleform, methodName);
+  }
+  endScaleformMovieMethod() {
+    mp.game.graphics.endScaleformMovieMethod();
+  }
+  scaleformMovieMethodAddParamInt(value) {
+    mp.game.graphics.scaleformMovieMethodAddParamInt(value);
+  }
+  // --- Textures ---
+  requestStreamedTextureDict(textureDict, p1 = false) {
+    mp.game.graphics.requestStreamedTextureDict(textureDict, p1);
+  }
+  hasStreamedTextureDictLoaded(textureDict) {
+    return mp.game.graphics.hasStreamedTextureDictLoaded(textureDict);
+  }
+};
+
+// src/ragemp/RageMpGameplayCamera.ts
+var RageMpGameplayCamera = class {
+  // --- Position / Rotation / FOV ---
+  getCoord() {
+    const v = mp.game.cam.getGameplayCoord();
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  getRot(rotationOrder = 2) {
+    const v = mp.game.cam.getGameplayRot(rotationOrder);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  getFov() {
+    return mp.game.cam.getGameplayFov();
+  }
+  // --- Relative Heading/Pitch ---
+  getRelativeHeading() {
+    return mp.game.cam.getGameplayCamRelativeHeading();
+  }
+  setRelativeHeading(heading) {
+    mp.game.cam.setGameplayCamRelativeHeading(heading);
+  }
+  getRelativePitch() {
+    return mp.game.cam.getGameplayCamRelativePitch();
+  }
+  setRelativePitch(angle, scalingFactor = 1) {
+    mp.game.cam.setGameplayCamRelativePitch(angle, scalingFactor);
+  }
+  // --- Shaking ---
+  shake(shakeName, intensity) {
+    mp.game.cam.shakeGameplayCam(shakeName, intensity);
+  }
+  isShaking() {
+    return mp.game.cam.isGameplayShaking();
+  }
+  setShakeAmplitude(amplitude) {
+    mp.game.cam.setGameplayCamShakeAmplitude(amplitude);
+  }
+  stopShaking(p0 = true) {
+    mp.game.cam.stopGameplayCamShaking(p0);
+  }
+  // --- Script Camera Rendering ---
+  renderScriptCams(render, ease, easeTime, p3, p4) {
+    mp.game.cam.renderScriptCams(render, ease, easeTime, p3, p4);
+  }
+  stopRenderingScriptCamsUsingCatchUp(render, p1, p2, p3) {
+    mp.game.cam.stopRenderingScriptCamsUsingCatchUp(render, p1, p2, p3);
+  }
+  // --- Final Rendered Camera ---
+  getFinalRenderedCoord() {
+    const v = mp.game.cam.getFinalRenderedCoord();
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  getFinalRenderedRot(rotationOrder = 2) {
+    const v = mp.game.cam.getFinalRenderedRot(rotationOrder);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  getFinalRenderedFov() {
+    return mp.game.cam.getFinalRenderedFov();
+  }
+};
+
+// src/ragemp/RageMpControls.ts
+var RageMpControls = class {
+  disableAllControlActions(padIndex) {
+    mp.game.controls.disableAllControlActions(padIndex);
+  }
+  disableControlAction(padIndex, control, disable) {
+    mp.game.controls.disableControlAction(padIndex, control, disable);
+  }
+  enableControlAction(padIndex, control, enable) {
+    mp.game.controls.enableControlAction(padIndex, control, enable);
+  }
+  isControlPressed(padIndex, control) {
+    return mp.game.controls.isControlPressed(padIndex, control);
+  }
+  isDisabledControlJustPressed(padIndex, control) {
+    return mp.game.controls.isDisabledControlJustPressed(padIndex, control);
+  }
+  isDisabledControlPressed(padIndex, control) {
+    return mp.game.controls.isDisabledControlPressed(padIndex, control);
+  }
+  getDisabledControlNormal(padIndex, control) {
+    return mp.game.controls.getDisabledControlNormal(padIndex, control);
+  }
+};
+
+// src/ragemp/RageMpEngine.ts
+var RageMpEngine = (_class4 = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
   
   
   
@@ -1584,6 +3278,15 @@ var RageMpEngine = (_class4 = class {
     this.system = new RageMpSystem();
     this.user = new RageMpUser();
     this.natives = new RageMpNativesBridge();
+    this.weapon = new RageMpWeapon();
+    this.streaming = new RageMpStreaming();
+    this.world = new RageMpWorld();
+    this.gameplay = new RageMpGameplay();
+    this.hud = new RageMpHUD();
+    this.audio = new RageMpAudio();
+    this.graphics = new RageMpGraphics();
+    this.gameplayCamera = new RageMpGameplayCamera();
+    this.controls = new RageMpControls();
   }
   get localPlayer() {
     if (!this._localPlayer) {
@@ -1609,5 +3312,14 @@ var RageMpEngine = (_class4 = class {
 
 
 
-exports.RageMpBlip = RageMpBlip; exports.RageMpBrowser = RageMpBrowser; exports.RageMpCamera = RageMpCamera; exports.RageMpCheckpoint = RageMpCheckpoint; exports.RageMpColshape = RageMpColshape; exports.RageMpCreatablePool = RageMpCreatablePool; exports.RageMpEngine = RageMpEngine; exports.RageMpEntity = RageMpEntity; exports.RageMpEntityPool = RageMpEntityPool; exports.RageMpMarker = RageMpMarker; exports.RageMpObject = RageMpObject; exports.RageMpPed = RageMpPed; exports.RageMpPickup = RageMpPickup; exports.RageMpPlayer = RageMpPlayer; exports.RageMpTextLabel = RageMpTextLabel; exports.RageMpVehicle = RageMpVehicle;
+
+
+
+
+
+
+
+
+
+exports.RageMpAudio = RageMpAudio; exports.RageMpBlip = RageMpBlip; exports.RageMpBrowser = RageMpBrowser; exports.RageMpCamera = RageMpCamera; exports.RageMpCheckpoint = RageMpCheckpoint; exports.RageMpColshape = RageMpColshape; exports.RageMpControls = RageMpControls; exports.RageMpCreatablePool = RageMpCreatablePool; exports.RageMpEngine = RageMpEngine; exports.RageMpEntity = RageMpEntity; exports.RageMpEntityPool = RageMpEntityPool; exports.RageMpGameplay = RageMpGameplay; exports.RageMpGameplayCamera = RageMpGameplayCamera; exports.RageMpGraphics = RageMpGraphics; exports.RageMpHUD = RageMpHUD; exports.RageMpMarker = RageMpMarker; exports.RageMpObject = RageMpObject; exports.RageMpPed = RageMpPed; exports.RageMpPickup = RageMpPickup; exports.RageMpPlayer = RageMpPlayer; exports.RageMpStreaming = RageMpStreaming; exports.RageMpTextLabel = RageMpTextLabel; exports.RageMpVehicle = RageMpVehicle; exports.RageMpWeapon = RageMpWeapon; exports.RageMpWorld = RageMpWorld;
 //# sourceMappingURL=ragemp.cjs.map