@schmoker/rageenginebridge 0.1.0

package/dist/ragemp.js

@@ -0,0 +1,1613 @@
+// src/ragemp/RageMpEntityPool.ts
+var RageMpEntityPool = class {
+  constructor(pool, wrap) {
+    this.pool = pool;
+    this.wrap = wrap;
+  }
+  cache = /* @__PURE__ */ new WeakMap();
+  getWrapped(raw) {
+    const key = raw;
+    let wrapped = this.cache.get(key);
+    if (!wrapped) {
+      wrapped = this.wrap(raw);
+      this.cache.set(key, wrapped);
+    }
+    return wrapped;
+  }
+  get length() {
+    return this.pool.length;
+  }
+  get size() {
+    return this.pool.length;
+  }
+  get streamed() {
+    return this.pool.streamed.map((raw) => this.getWrapped(raw));
+  }
+  at(id) {
+    const raw = this.pool.at(id);
+    return raw ? this.getWrapped(raw) : void 0;
+  }
+  atRemoteId(remoteId) {
+    const raw = this.pool.atRemoteId(remoteId);
+    return raw ? this.getWrapped(raw) : void 0;
+  }
+  atHandle(handle) {
+    const raw = this.pool.atHandle(handle);
+    return raw ? this.getWrapped(raw) : void 0;
+  }
+  exists(entity) {
+    return this.pool.exists(entity);
+  }
+  forEach(callback) {
+    this.pool.forEach((raw) => callback(this.getWrapped(raw)));
+  }
+  forEachInRange(position, range, callbackOrDimension, callback) {
+    const pos = new mp.Vector3(position.x, position.y, position.z);
+    if (typeof callbackOrDimension === "function") {
+      this.pool.forEachInRange(pos, range, (raw) => callbackOrDimension(this.getWrapped(raw)));
+    } else {
+      this.pool.forEachInRange(pos, range, callbackOrDimension, (raw) => callback(this.getWrapped(raw)));
+    }
+  }
+  forEachInStreamRange(callback) {
+    this.pool.forEachInStreamRange((raw) => callback(this.getWrapped(raw)));
+  }
+  forEachInDimension(dimension, callback) {
+    this.pool.forEachInDimension(dimension, (raw) => callback(this.getWrapped(raw)));
+  }
+  getClosest(position) {
+    let closest;
+    let closestDist = Infinity;
+    this.pool.forEach((raw) => {
+      const wrapped = this.getWrapped(raw);
+      const entity = wrapped;
+      if (entity.position) {
+        const dx = entity.position.x - position.x;
+        const dy = entity.position.y - position.y;
+        const dz = entity.position.z - position.z;
+        const dist = dx * dx + dy * dy + dz * dz;
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = wrapped;
+        }
+      }
+    });
+    return closest;
+  }
+  toArray() {
+    return this.pool.toArray().map((raw) => this.getWrapped(raw));
+  }
+};
+var RageMpCreatablePool = class extends RageMpEntityPool {
+  constructor(pool, wrap, createFn) {
+    super(pool, wrap);
+    this.createFn = createFn;
+  }
+  create(opts) {
+    const raw = this.createFn(opts);
+    return this.getWrapped(raw);
+  }
+};
+
+// src/ragemp/RageMpEntity.ts
+var RageMpEntity = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  get id() {
+    return this.raw.id;
+  }
+  get remoteId() {
+    return this.raw.remoteId;
+  }
+  get type() {
+    return this.raw.type;
+  }
+  get handle() {
+    return this.raw.handle;
+  }
+  get alpha() {
+    return this.raw.alpha;
+  }
+  set alpha(value) {
+    this.raw.alpha = value;
+  }
+  get data() {
+    return this.raw.data;
+  }
+  set data(value) {
+    this.raw.data = value;
+  }
+  get dimension() {
+    return this.raw.dimension;
+  }
+  set dimension(value) {
+    this.raw.dimension = value;
+  }
+  get model() {
+    return this.raw.model;
+  }
+  set model(value) {
+    this.raw.model = value;
+  }
+  get position() {
+    const p = this.raw.position;
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  set position(value) {
+    this.raw.position = new mp.Vector3(value.x, value.y, value.z);
+  }
+  get rotation() {
+    const r = this.raw.rotation;
+    return { x: r.x, y: r.y, z: r.z };
+  }
+  set rotation(value) {
+    this.raw.rotation = new mp.Vector3(value.x, value.y, value.z);
+  }
+  destroy() {
+    this.raw.destroy();
+  }
+  doesExist() {
+    return this.raw.doesExist();
+  }
+  dist(position) {
+    return this.raw.dist(new mp.Vector3(position.x, position.y, position.z));
+  }
+  distSquared(position) {
+    const p = this.position;
+    const dx = p.x - position.x;
+    const dy = p.y - position.y;
+    const dz = p.z - position.z;
+    return dx * dx + dy * dy + dz * dz;
+  }
+  getVariable(name) {
+    return this.raw.getVariable(name);
+  }
+  hasVariable(name) {
+    return this.raw.hasVariable(name);
+  }
+  setCoords(x, y, z) {
+    mp.game.entity.setCoords(this.raw.handle, x, y, z, false, false, false, false);
+  }
+  setRotation(x, y, z) {
+    mp.game.entity.setRotation(this.raw.handle, x, y, z, 2, true);
+  }
+  freezePosition(toggle) {
+    mp.game.entity.freezePosition(this.raw.handle, toggle);
+  }
+  setVelocity(x, y, z) {
+    mp.game.entity.setVelocity(this.raw.handle, x, y, z);
+  }
+  getVelocity() {
+    const v = mp.game.entity.getVelocity(this.raw.handle);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  setAlpha(alpha) {
+    mp.game.entity.setAlpha(this.raw.handle, alpha, false);
+  }
+  setVisible(visible) {
+    mp.game.entity.setVisible(this.raw.handle, visible, false);
+  }
+  setCollision(toggle) {
+    mp.game.entity.setCollision(this.raw.handle, toggle, true);
+  }
+  setInvincible(toggle) {
+    mp.game.entity.setInvincible(this.raw.handle, toggle);
+  }
+  getHealth() {
+    return mp.game.entity.getHealth(this.raw.handle);
+  }
+  setHealth(health) {
+    mp.game.entity.setHealth(this.raw.handle, health, 0);
+  }
+  getMaxHealth() {
+    return mp.game.entity.getMaxHealth(this.raw.handle);
+  }
+  setMaxHealth(health) {
+    mp.game.entity.setMaxHealth(this.raw.handle, health);
+  }
+  getSpeed() {
+    return mp.game.entity.getSpeed(this.raw.handle);
+  }
+  getForwardVector() {
+    const v = mp.game.entity.getForwardVector(this.raw.handle);
+    return { x: v.x, y: v.y, z: v.z };
+  }
+  getHeading() {
+    return mp.game.entity.getHeading(this.raw.handle);
+  }
+  setHeading(heading) {
+    mp.game.entity.setHeading(this.raw.handle, heading);
+  }
+  isOnScreen() {
+    return mp.game.entity.isOnScreen(this.raw.handle);
+  }
+  isDead() {
+    return mp.game.entity.isDead(this.raw.handle, false);
+  }
+  isInWater() {
+    return mp.game.entity.isInWater(this.raw.handle);
+  }
+  isInAir() {
+    return mp.game.entity.isInAir(this.raw.handle);
+  }
+  isVisible() {
+    return mp.game.entity.isVisible(this.raw.handle);
+  }
+};
+
+// src/ragemp/RageMpPlayer.ts
+var RageMpPlayer = class extends RageMpEntity {
+  get armour() {
+    return this.raw.armour;
+  }
+  get eyeColour() {
+    return this.raw.eyeColour;
+  }
+  get hairColour() {
+    return this.raw.hairColour;
+  }
+  get hairHighlightColour() {
+    return this.raw.hairHighlightColour;
+  }
+  get heading() {
+    return this.raw.heading;
+  }
+  get health() {
+    return this.raw.health;
+  }
+  get name() {
+    return this.raw.name;
+  }
+  get weapon() {
+    return this.raw.weapon;
+  }
+  get weaponAmmo() {
+    return this.raw.weaponAmmo;
+  }
+  get action() {
+    return this.raw.action;
+  }
+  get aimTarget() {
+    return this.raw.aimTarget;
+  }
+  get ip() {
+    return this.raw.ip;
+  }
+  get isTypingInTextChat() {
+    return this.raw.isTypingInTextChat;
+  }
+  get isVoiceActive() {
+    return this.raw.isVoiceActive;
+  }
+  get ping() {
+    return this.raw.ping;
+  }
+  get vehicle() {
+    return this.raw.vehicle?.handle ?? null;
+  }
+  setComponentVariation(component, drawable, texture, palette) {
+    mp.game.ped.setComponentVariation(this.raw.handle, component, drawable, texture, palette);
+  }
+  setHeadBlendData(shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix) {
+    mp.game.ped.setHeadBlendData(this.raw.handle, shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix, false);
+  }
+  setHeadOverlay(overlayId, index, opacity, firstColor, secondColor) {
+    mp.game.ped.setHeadOverlay(this.raw.handle, overlayId, index, opacity);
+    if (firstColor !== void 0 && secondColor !== void 0) {
+      mp.game.ped.setHeadOverlayTint(this.raw.handle, overlayId, 1, firstColor, secondColor);
+    }
+  }
+  setHairColor(color, highlight) {
+    mp.game.ped.setHairTint(this.raw.handle, color, highlight);
+  }
+  setEyeColor(color) {
+    mp.game.ped.setEyeColor(this.raw.handle, color);
+  }
+  setFaceFeature(index, scale) {
+    mp.game.ped.setFaceFeature(this.raw.handle, index, scale);
+  }
+  setPropIndex(propId, drawableId, textureId, attach) {
+    mp.game.ped.setPropIndex(this.raw.handle, propId, drawableId, textureId, attach);
+  }
+  clearProp(propId) {
+    mp.game.ped.clearProp(this.raw.handle, propId);
+  }
+  getDrawableVariation(component) {
+    return mp.game.ped.getDrawableVariation(this.raw.handle, component);
+  }
+  getTextureVariation(component) {
+    return mp.game.ped.getTextureVariation(this.raw.handle, component);
+  }
+  getPropIndex(propId) {
+    return mp.game.ped.getPropIndex(this.raw.handle, propId);
+  }
+  getPropTextureIndex(propId) {
+    return mp.game.ped.getPropTextureIndex(this.raw.handle, propId);
+  }
+  getBonePosition(boneId) {
+    const p = mp.game.ped.getBoneCoords(this.raw.handle, boneId, 0, 0, 0);
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  getWorldPositionOfBone(boneIndex) {
+    const p = mp.game.entity.getWorldPositionOfBone(this.raw.handle, boneIndex);
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  getBoneIndex(boneName) {
+    return mp.game.ped.getBoneIndex(this.raw.handle, boneName);
+  }
+  giveWeapon(hash, ammo) {
+    mp.game.weapon.giveWeaponToPed(this.raw.handle, hash, ammo, false, true);
+  }
+  removeAllWeapons() {
+    mp.game.weapon.removeAllPedS(this.raw.handle, true);
+  }
+  getAmmoInClip(weapon) {
+    return mp.game.weapon.getAmmoInClip(this.raw.handle, weapon);
+  }
+  setAmmoInClip(weapon, ammo) {
+    mp.game.weapon.setAmmoInClip(this.raw.handle, weapon, ammo);
+  }
+  getWeaponTintIndex(weapon) {
+    return mp.game.weapon.getPedTintIndex(this.raw.handle, weapon);
+  }
+  isJumping() {
+    return mp.game.ped.isJumping(this.raw.handle);
+  }
+  isFalling() {
+    return mp.game.ped.isFalling(this.raw.handle);
+  }
+  isShooting() {
+    return mp.game.ped.isShooting(this.raw.handle);
+  }
+  isReloading() {
+    return mp.game.ped.isReloading(this.raw.handle);
+  }
+  isSprinting() {
+    return mp.game.ped.isSprinting(this.raw.handle);
+  }
+  isSwimming() {
+    return mp.game.ped.isSwimming(this.raw.handle);
+  }
+  isSwimmingUnderWater() {
+    return mp.game.ped.isSwimmingUnderWater(this.raw.handle);
+  }
+  isClimbing() {
+    return mp.game.ped.isClimbing(this.raw.handle);
+  }
+  isGettingIntoVehicle() {
+    return mp.game.ped.isGettingIntoAVehicle(this.raw.handle);
+  }
+  isDiving() {
+    return mp.game.ped.isDiving(this.raw.handle);
+  }
+  isParachuting() {
+    return mp.game.ped.isParachuting(this.raw.handle);
+  }
+  isInAnyVehicle() {
+    return mp.game.ped.isInAnyVehicle(this.raw.handle, false);
+  }
+  isSittingInVehicle(vehicle) {
+    return mp.game.ped.isSittingInVehicle(this.raw.handle, vehicle);
+  }
+  setIntoVehicle(vehicle, seat) {
+    mp.game.ped.setIntoVehicle(this.raw.handle, vehicle, seat);
+  }
+  setArmour(armour) {
+    mp.game.ped.setArmour(this.raw.handle, armour);
+  }
+  getArmour() {
+    return mp.game.ped.getArmour(this.raw.handle);
+  }
+  taskPlayAnim(dict, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ) {
+    mp.game.task.playAnim(this.raw.handle, dict, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ);
+  }
+  clearTasks() {
+    mp.game.task.clearTasks(this.raw.handle);
+  }
+  clearTasksImmediately() {
+    mp.game.task.clearPedTasksImmediately(this.raw.handle);
+  }
+  canRagdoll() {
+    return mp.game.ped.canRagdoll(this.raw.handle);
+  }
+  setCanRagdoll(toggle) {
+    mp.game.ped.setCanRagdoll(this.raw.handle, toggle);
+  }
+  setRagdollOnCollision(toggle) {
+    mp.game.ped.setRagdollOnCollision(this.raw.handle, toggle);
+  }
+};
+
+// src/ragemp/RageMpVehicle.ts
+var RageMpVehicle = class extends RageMpEntity {
+  get gear() {
+    return this.raw.gear;
+  }
+  get rpm() {
+    return this.raw.rpm;
+  }
+  get steeringAngle() {
+    return this.raw.steeringAngle;
+  }
+  get isPositionFrozen() {
+    return this.raw.isPositionFrozen;
+  }
+  set isPositionFrozen(value) {
+    this.raw.isPositionFrozen = value;
+  }
+  get gravity() {
+    return this.raw.gravity;
+  }
+  set gravity(value) {
+    this.raw.gravity = value;
+  }
+  setEngineOn(toggle, instantly, noAutoTurnOn) {
+    mp.game.vehicle.setEngineOn(this.raw.handle, toggle, instantly, noAutoTurnOn);
+  }
+  isEngineRunning() {
+    return mp.game.vehicle.getIsEngineRunning(this.raw.handle);
+  }
+  getEngineHealth() {
+    return mp.game.vehicle.getEngineHealth(this.raw.handle);
+  }
+  setEngineHealth(health) {
+    mp.game.vehicle.setEngineHealth(this.raw.handle, health);
+  }
+  setEnginePowerMultiplier(multiplier) {
+    mp.game.vehicle.setEnginePowerMultiplier(this.raw.handle, multiplier);
+  }
+  setEngineTorqueMultiplier(multiplier) {
+    mp.game.vehicle.setEngineTorqueMultiplier(this.raw.handle, multiplier);
+  }
+  getBodyHealth() {
+    return mp.game.vehicle.getBodyHealth(this.raw.handle);
+  }
+  setBodyHealth(health) {
+    mp.game.vehicle.setBodyHealth(this.raw.handle, health);
+  }
+  getPetrolTankHealth() {
+    return mp.game.vehicle.getPetrolTankHealth(this.raw.handle);
+  }
+  setPetrolTankHealth(health) {
+    mp.game.vehicle.setPetrolTankHealth(this.raw.handle, health);
+  }
+  setDirtLevel(level) {
+    mp.game.vehicle.setDirtLevel(this.raw.handle, level);
+  }
+  setCustomPrimaryColour(r, g, b) {
+    mp.game.vehicle.setCustomPrimaryColour(this.raw.handle, r, g, b);
+  }
+  setCustomSecondaryColour(r, g, b) {
+    mp.game.vehicle.setCustomSecondaryColour(this.raw.handle, r, g, b);
+  }
+  getCustomPrimaryColour() {
+    const c = mp.game.vehicle.getCustomPrimaryColour(this.raw.handle);
+    return { r: c.r ?? c[0], g: c.g ?? c[1], b: c.b ?? c[2] };
+  }
+  getCustomSecondaryColour() {
+    const c = mp.game.vehicle.getCustomSecondaryColour(this.raw.handle);
+    return { r: c.r ?? c[0], g: c.g ?? c[1], b: c.b ?? c[2] };
+  }
+  setColours(primary, secondary) {
+    mp.game.vehicle.setColours(this.raw.handle, primary, secondary);
+  }
+  setNeonLightEnabled(index, toggle) {
+    mp.game.vehicle.setNeonLightEnabled(this.raw.handle, index, toggle);
+  }
+  isNeonLightEnabled(index) {
+    return mp.game.vehicle.isNeonLightEnabled(this.raw.handle, index);
+  }
+  setNeonLightsColour(r, g, b) {
+    mp.game.vehicle.setNeonLightsColour(this.raw.handle, r, g, b);
+  }
+  getNeonLightsColour() {
+    const c = mp.game.vehicle.getNeonLightsColour(this.raw.handle);
+    return { r: c.r ?? c[0], g: c.g ?? c[1], b: c.b ?? c[2] };
+  }
+  setMod(modType, modIndex) {
+    mp.game.vehicle.setMod(this.raw.handle, modType, modIndex, false);
+  }
+  getMod(modType) {
+    return mp.game.vehicle.getMod(this.raw.handle, modType);
+  }
+  setModKit(modKit) {
+    mp.game.vehicle.setModKit(this.raw.handle, modKit);
+  }
+  getModKit() {
+    return mp.game.vehicle.getModKit(this.raw.handle);
+  }
+  getNumMods(modType) {
+    return mp.game.vehicle.getNumMods(this.raw.handle, modType);
+  }
+  setWindowTint(tint) {
+    mp.game.vehicle.setWindowTint(this.raw.handle, tint);
+  }
+  getWindowTint() {
+    return mp.game.vehicle.getWindowTint(this.raw.handle);
+  }
+  setNumberPlateText(text) {
+    mp.game.vehicle.setNumberPlateText(this.raw.handle, text);
+  }
+  getNumberPlateText() {
+    return mp.game.vehicle.getNumberPlateText(this.raw.handle);
+  }
+  setNumberPlateTextIndex(index) {
+    mp.game.vehicle.setNumberPlateTextIndex(this.raw.handle, index);
+  }
+  getNumberPlateTextIndex() {
+    return mp.game.vehicle.getNumberPlateTextIndex(this.raw.handle);
+  }
+  setTyreBurst(index, onRim, p2) {
+    mp.game.vehicle.setTyreBurst(this.raw.handle, index, onRim, p2);
+  }
+  isTyreBurst(wheelId) {
+    return mp.game.vehicle.isTyreBurst(this.raw.handle, wheelId, false);
+  }
+  setTyresCanBurst(toggle) {
+    mp.game.vehicle.setTyresCanBurst(this.raw.handle, toggle);
+  }
+  getTyresCanBurst() {
+    return mp.game.vehicle.getTyresCanBurst(this.raw.handle);
+  }
+  setTyreFixed(index) {
+    mp.game.vehicle.setTyreFixed(this.raw.handle, index);
+  }
+  setDoorOpen(doorIndex, loose, openInstantly) {
+    mp.game.vehicle.setDoorOpen(this.raw.handle, doorIndex, loose, openInstantly);
+  }
+  setDoorShut(doorIndex, closeInstantly) {
+    mp.game.vehicle.setDoorShut(this.raw.handle, doorIndex, closeInstantly);
+  }
+  setDoorBroken(doorIndex, deleteDoor) {
+    mp.game.vehicle.setDoorBroken(this.raw.handle, doorIndex, deleteDoor);
+  }
+  isDoorDamaged(doorIndex) {
+    return mp.game.vehicle.isDoorDamaged(this.raw.handle, doorIndex);
+  }
+  isDoorFullyOpen(doorIndex) {
+    return mp.game.vehicle.isDoorFullyOpen(this.raw.handle, doorIndex);
+  }
+  getDoorAngleRatio(doorIndex) {
+    return mp.game.vehicle.getDoorAngleRatio(this.raw.handle, doorIndex);
+  }
+  setLight(lightIndex, toggle) {
+    mp.game.vehicle.setLights(this.raw.handle, lightIndex);
+  }
+  setLights(toggle) {
+    mp.game.vehicle.setLights(this.raw.handle, toggle ? 2 : 1);
+  }
+  getLightsState() {
+    return mp.game.vehicle.getLightsState(this.raw.handle);
+  }
+  setXenonHeadlights(toggle) {
+    mp.game.vehicle.toggleMod(this.raw.handle, 22, toggle);
+  }
+  isXenonHeadlightsEnabled() {
+    return mp.game.vehicle.isToggleModOn(this.raw.handle, 22);
+  }
+  setExtra(extraId, toggle) {
+    mp.game.vehicle.setExtra(this.raw.handle, extraId, toggle ? 0 : 1);
+  }
+  doesExtraExist(extraId) {
+    return mp.game.vehicle.doesExtraExist(this.raw.handle, extraId);
+  }
+  isExtraTurnedOn(extraId) {
+    return mp.game.vehicle.isExtraTurnedOn(this.raw.handle, extraId);
+  }
+  isSeatFree(seatIndex) {
+    return mp.game.vehicle.isSeatFree(this.raw.handle, seatIndex, false);
+  }
+  getPedInSeat(seatIndex) {
+    return mp.game.vehicle.getPedInSeat(this.raw.handle, seatIndex, false);
+  }
+  getMaxNumberOfPassengers() {
+    return mp.game.vehicle.getMaxNumberOfPassengers(this.raw.handle);
+  }
+  setFixed() {
+    mp.game.vehicle.setFixed(this.raw.handle);
+  }
+  setUndriveable(toggle) {
+    mp.game.vehicle.setUndriveable(this.raw.handle, toggle);
+  }
+  setCanBeDamaged(toggle) {
+    mp.game.vehicle.setCanBeDamaged(this.raw.handle, toggle);
+  }
+  setCanBeVisiblyDamaged(toggle) {
+    mp.game.vehicle.setCanBeVisiblyDamaged(this.raw.handle, toggle);
+  }
+  getWheelType() {
+    return mp.game.vehicle.getWheelType(this.raw.handle);
+  }
+  setWheelType(type) {
+    mp.game.vehicle.setWheelType(this.raw.handle, type);
+  }
+  setLivery(livery) {
+    mp.game.vehicle.setLivery(this.raw.handle, livery);
+  }
+  getLivery() {
+    return mp.game.vehicle.getLivery(this.raw.handle);
+  }
+  getLiveryCount() {
+    return mp.game.vehicle.getLiveryCount(this.raw.handle);
+  }
+  setRoofOpened(toggle) {
+    if (toggle) {
+      mp.game.vehicle.openRoof(this.raw.handle);
+    } else {
+      mp.game.vehicle.closeRoof(this.raw.handle);
+    }
+  }
+  isRoofOpened() {
+    return mp.game.vehicle.isRoofOpened(this.raw.handle);
+  }
+  setHandling(field, value) {
+    this.raw.setHandling(field, value);
+  }
+  getHandling(field) {
+    return this.raw.getHandling(field);
+  }
+  resetHandling() {
+    this.raw.resetHandling();
+  }
+  setSuspensionHeight(height) {
+    mp.game.vehicle.setSuspensionHeight(this.raw.handle, height);
+  }
+};
+
+// src/ragemp/RageMpPed.ts
+var RageMpPed = class extends RageMpEntity {
+  get isDynamic() {
+    return this.raw.isDynamic;
+  }
+  get spawnPosition() {
+    const p = this.raw.spawnPosition;
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  get weapon() {
+    return this.raw.weapon;
+  }
+  get weaponAmmo() {
+    return this.raw.weaponAmmo;
+  }
+  setComponentVariation(component, drawable, texture, palette) {
+    mp.game.ped.setComponentVariation(this.raw.handle, component, drawable, texture, palette);
+  }
+  setHeadBlendData(shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix) {
+    mp.game.ped.setHeadBlendData(this.raw.handle, shapeFirst, shapeSecond, shapeThird, skinFirst, skinSecond, skinThird, shapeMix, skinMix, thirdMix, false);
+  }
+  setHeadOverlay(overlayId, index, opacity, firstColor, secondColor) {
+    mp.game.ped.setHeadOverlay(this.raw.handle, overlayId, index, opacity);
+    if (firstColor !== void 0 && secondColor !== void 0) {
+      mp.game.ped.setHeadOverlayTint(this.raw.handle, overlayId, 1, firstColor, secondColor);
+    }
+  }
+  setHairColor(color, highlight) {
+    mp.game.ped.setHairTint(this.raw.handle, color, highlight);
+  }
+  setEyeColor(color) {
+    mp.game.ped.setEyeColor(this.raw.handle, color);
+  }
+  setFaceFeature(index, scale) {
+    mp.game.ped.setFaceFeature(this.raw.handle, index, scale);
+  }
+  setPropIndex(propId, drawableId, textureId, attach) {
+    mp.game.ped.setPropIndex(this.raw.handle, propId, drawableId, textureId, attach);
+  }
+  clearProp(propId) {
+    mp.game.ped.clearProp(this.raw.handle, propId);
+  }
+  getDrawableVariation(component) {
+    return mp.game.ped.getDrawableVariation(this.raw.handle, component);
+  }
+  getTextureVariation(component) {
+    return mp.game.ped.getTextureVariation(this.raw.handle, component);
+  }
+  getPropIndex(propId) {
+    return mp.game.ped.getPropIndex(this.raw.handle, propId);
+  }
+  getPropTextureIndex(propId) {
+    return mp.game.ped.getPropTextureIndex(this.raw.handle, propId);
+  }
+  getBonePosition(boneId) {
+    const p = mp.game.ped.getBoneCoords(this.raw.handle, boneId, 0, 0, 0);
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  getWorldPositionOfBone(boneIndex) {
+    const p = mp.game.entity.getWorldPositionOfBone(this.raw.handle, boneIndex);
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  getBoneIndex(boneName) {
+    return mp.game.ped.getBoneIndex(this.raw.handle, boneName);
+  }
+  giveWeapon(hash, ammo) {
+    mp.game.weapon.giveWeaponToPed(this.raw.handle, hash, ammo, false, true);
+  }
+  removeAllWeapons() {
+    mp.game.weapon.removeAllPedS(this.raw.handle, true);
+  }
+  getAmmoInClip(weapon) {
+    return mp.game.weapon.getAmmoInClip(this.raw.handle, weapon);
+  }
+  setAmmoInClip(weapon, ammo) {
+    mp.game.weapon.setAmmoInClip(this.raw.handle, weapon, ammo);
+  }
+  taskPlayAnim(dict, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ) {
+    mp.game.task.playAnim(this.raw.handle, dict, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate, lockX, lockY, lockZ);
+  }
+  clearTasks() {
+    mp.game.task.clearTasks(this.raw.handle);
+  }
+  clearTasksImmediately() {
+    mp.game.task.clearPedTasksImmediately(this.raw.handle);
+  }
+  canRagdoll() {
+    return mp.game.ped.canRagdoll(this.raw.handle);
+  }
+  setCanRagdoll(toggle) {
+    mp.game.ped.setCanRagdoll(this.raw.handle, toggle);
+  }
+  setRagdollOnCollision(toggle) {
+    mp.game.ped.setRagdollOnCollision(this.raw.handle, toggle);
+  }
+};
+
+// src/ragemp/RageMpObject.ts
+var RageMpObject = class extends RageMpEntity {
+  setActivatePhysicsAsSoonAsItIsUnfrozen(toggle) {
+    mp.game.object.setActivatePhysicsAsSoonAsItIsUnfrozen(this.raw.handle, toggle);
+  }
+  hasBeenBroken() {
+    return mp.game.object.hasBeenBroken(this.raw.handle, 0);
+  }
+  placeOnGroundProperly() {
+    return mp.game.object.placeOnGroundProperly(this.raw.handle);
+  }
+  slide(toX, toY, toZ, speedX, speedY, speedZ) {
+    return mp.game.object.slide(this.raw.handle, toX, toY, toZ, speedX, speedY, speedZ, false);
+  }
+  setTargetable(targetable) {
+    mp.game.object.setTargettable(this.raw.handle, targetable);
+  }
+};
+
+// src/ragemp/RageMpBlip.ts
+var RageMpBlip = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  get id() {
+    return this.raw.id;
+  }
+  get remoteId() {
+    return this.raw.remoteId;
+  }
+  get type() {
+    return this.raw.type;
+  }
+  get handle() {
+    return this.raw.handle;
+  }
+  get dimension() {
+    return this.raw.dimension;
+  }
+  set dimension(value) {
+    this.raw.dimension = value;
+  }
+  get position() {
+    const p = this.raw.position;
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  set position(value) {
+    this.raw.position = new mp.Vector3(value.x, value.y, value.z);
+  }
+  destroy() {
+    this.raw.destroy();
+  }
+  setSprite(sprite) {
+    mp.game.ui.setBlipSprite(this.raw.handle, sprite);
+  }
+  getSprite() {
+    return mp.game.ui.getBlipSprite(this.raw.handle);
+  }
+  setColour(colour) {
+    mp.game.ui.setBlipColour(this.raw.handle, colour);
+  }
+  getColour() {
+    return mp.game.ui.getBlipColour(this.raw.handle);
+  }
+  setScale(scale) {
+    mp.game.ui.setBlipScale(this.raw.handle, scale);
+  }
+  getScale() {
+    return mp.game.ui.getBlipScale(this.raw.handle);
+  }
+  setAlpha(alpha) {
+    mp.game.ui.setBlipAlpha(this.raw.handle, alpha);
+  }
+  getAlpha() {
+    return mp.game.ui.getBlipAlpha(this.raw.handle);
+  }
+  setRotation(rotation) {
+    mp.game.ui.setBlipRotation(this.raw.handle, rotation);
+  }
+  getRotation() {
+    return mp.game.ui.getBlipRotation(this.raw.handle);
+  }
+  setName(name) {
+    mp.game.ui.setBlipNameFromTextFile(this.raw.handle, name);
+  }
+  getName() {
+    return mp.game.ui.getBlipName(this.raw.handle);
+  }
+  setRoute(toggle) {
+    mp.game.ui.setBlipRoute(this.raw.handle, toggle);
+  }
+  setRouteColour(colour) {
+    mp.game.ui.setBlipRouteColour(this.raw.handle, colour);
+  }
+  setFlashes(toggle) {
+    mp.game.ui.setBlipFlashes(this.raw.handle, toggle);
+  }
+  setFlashTimer(duration) {
+    mp.game.ui.setBlipFlashTimer(this.raw.handle, duration);
+  }
+  setFlashInterval(interval) {
+    mp.game.ui.setBlipFlashInterval(this.raw.handle, interval);
+  }
+  setCategory(category) {
+    mp.game.ui.setBlipCategory(this.raw.handle, category);
+  }
+  setPriority(priority) {
+    mp.game.ui.setBlipPriority(this.raw.handle, priority);
+  }
+  setDisplay(display) {
+    mp.game.ui.setBlipDisplay(this.raw.handle, display);
+  }
+  setAsShortRange(toggle) {
+    mp.game.ui.setBlipAsShortRange(this.raw.handle, toggle);
+  }
+  setHighDetail(toggle) {
+    mp.game.ui.setBlipHighDetail(this.raw.handle, toggle);
+  }
+  setBright(toggle) {
+    mp.game.ui.setBlipBright(this.raw.handle, toggle);
+  }
+  setAsFriendly(toggle) {
+    mp.game.ui.setBlipAsFriendly(this.raw.handle, toggle);
+  }
+  setShowCone(toggle) {
+    mp.game.ui.setBlipShowCone(this.raw.handle, toggle, 0);
+  }
+  setShowHeadingIndicator(toggle) {
+    mp.game.ui.showHeadingIndicatorOnBlip(this.raw.handle, toggle);
+  }
+  setSecondaryColour(r, g, b) {
+    mp.game.ui.setBlipSecondaryColour(this.raw.handle, r, g, b);
+  }
+  pulse() {
+    mp.game.ui.pulseBlip(this.raw.handle);
+  }
+  setFade(opacity, duration) {
+    mp.game.ui.setBlipFade(this.raw.handle, opacity, duration);
+  }
+};
+
+// src/ragemp/RageMpCheckpoint.ts
+var RageMpCheckpoint = class extends RageMpEntity {
+  get visible() {
+    return this.raw.visible;
+  }
+  set visible(value) {
+    this.raw.visible = value;
+  }
+};
+
+// src/ragemp/RageMpColshape.ts
+var RageMpColshape = class extends RageMpEntity {
+  get triggered() {
+    return this.raw.triggered;
+  }
+  set triggered(value) {
+    this.raw.triggered = value;
+  }
+};
+
+// src/ragemp/RageMpCamera.ts
+var RageMpCamera = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  get handle() {
+    return this.raw.handle;
+  }
+  getCoord() {
+    const p = mp.game.cam.getCoord(this.raw.handle);
+    return { x: p.x, y: p.y, z: p.z };
+  }
+  setCoord(x, y, z) {
+    mp.game.cam.setCoord(this.raw.handle, x, y, z);
+  }
+  getRot() {
+    const r = mp.game.cam.getRot(this.raw.handle, 2);
+    return { x: r.x, y: r.y, z: r.z };
+  }
+  setRot(x, y, z, rotationOrder) {
+    mp.game.cam.setRot(this.raw.handle, x, y, z, rotationOrder);
+  }
+  getFov() {
+    return mp.game.cam.getFov(this.raw.handle);
+  }
+  setFov(fov) {
+    mp.game.cam.setFov(this.raw.handle, fov);
+  }
+  isActive() {
+    return mp.game.cam.isActive(this.raw.handle);
+  }
+  setActive(toggle) {
+    mp.game.cam.setActive(this.raw.handle, toggle);
+  }
+  setActiveWithInterp(camFrom, duration, easeLocation, easeRotation) {
+    mp.game.cam.setActiveWithInterp(this.raw.handle, camFrom, duration, easeLocation, easeRotation);
+  }
+  pointAtCoord(x, y, z) {
+    mp.game.cam.pointAtCoord(this.raw.handle, x, y, z);
+  }
+  pointAt(entity) {
+    mp.game.cam.pointAtEntity(this.raw.handle, entity, 0, 0, 0, true);
+  }
+  stopPointing() {
+    mp.game.cam.stopPointing(this.raw.handle);
+  }
+  shake(type, amplitude) {
+    mp.game.cam.shake(this.raw.handle, type, amplitude);
+  }
+  isShaking() {
+    return mp.game.cam.isShaking(this.raw.handle);
+  }
+  setShakeAmplitude(amplitude) {
+    mp.game.cam.setShakeAmplitude(this.raw.handle, amplitude);
+  }
+  stopShaking(p0) {
+    mp.game.cam.stopShaking(this.raw.handle, p0);
+  }
+  isRendering() {
+    return mp.game.cam.isRendering(this.raw.handle);
+  }
+  isInterpolating() {
+    return mp.game.cam.isInterpolating(this.raw.handle);
+  }
+  setFarClip(farClip) {
+    mp.game.cam.setFarClip(this.raw.handle, farClip);
+  }
+  setNearClip(nearClip) {
+    mp.game.cam.setNearClip(this.raw.handle, nearClip);
+  }
+  setFarDof(farDof) {
+    mp.game.cam.setFarDof(this.raw.handle, farDof);
+  }
+  setNearDof(nearDof) {
+    mp.game.cam.setNearDof(this.raw.handle, nearDof);
+  }
+  setDofStrength(strength) {
+    mp.game.cam.setDofStrength(this.raw.handle, strength);
+  }
+  setUseShallowDofMode(toggle) {
+    mp.game.cam.setUseShallowDofMode(this.raw.handle, toggle);
+  }
+  setMotionBlurStrength(strength) {
+    mp.game.cam.setMotionBlurStrength(this.raw.handle, strength);
+  }
+  attachTo(entity, xOffset, yOffset, zOffset, isRelative) {
+    mp.game.cam.attachToEntity(this.raw.handle, entity, xOffset, yOffset, zOffset, isRelative);
+  }
+  detach() {
+    mp.game.cam.detach(this.raw.handle);
+  }
+  destroy() {
+    mp.game.cam.destroy(this.raw.handle, false);
+  }
+};
+
+// src/ragemp/RageMpBrowser.ts
+var RageMpBrowser = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  get active() {
+    return this.raw.active;
+  }
+  set active(value) {
+    this.raw.active = value;
+  }
+  get url() {
+    return this.raw.url;
+  }
+  set url(value) {
+    this.raw.url = value;
+  }
+  get inputEnabled() {
+    return this.raw.inputEnabled;
+  }
+  set inputEnabled(value) {
+    this.raw.inputEnabled = value;
+  }
+  get orderId() {
+    return this.raw.orderId;
+  }
+  set orderId(value) {
+    this.raw.orderId = value;
+  }
+  destroy() {
+    this.raw.destroy();
+  }
+  execute(code) {
+    this.raw.execute(code);
+  }
+  executeCached(code) {
+    this.raw.executeCached(code);
+  }
+  call(eventName, ...args) {
+    this.raw.call(eventName, ...args);
+  }
+  callProc(procName, ...args) {
+    return this.raw.callProc(procName, ...args);
+  }
+  reload(ignoreCache) {
+    this.raw.reload(ignoreCache);
+  }
+  sendMouseMoveEvent(x, y) {
+    this.raw.sendMouseMoveEvent(x, y);
+  }
+  sendMouseClickEvent(x, y, button, isUp) {
+    this.raw.sendMouseClickEvent(x, y, button, isUp);
+  }
+};
+
+// src/ragemp/RageMpTextLabel.ts
+var RageMpTextLabel = class extends RageMpEntity {
+  get color() {
+    return this.raw.color;
+  }
+  set color(value) {
+    this.raw.color = value;
+  }
+  get drawDistance() {
+    return this.raw.drawDistance;
+  }
+  set drawDistance(value) {
+    this.raw.drawDistance = value;
+  }
+  get los() {
+    return this.raw.los;
+  }
+  set los(value) {
+    this.raw.los = value;
+  }
+  get text() {
+    return this.raw.text;
+  }
+  set text(value) {
+    this.raw.text = value;
+  }
+};
+
+// src/ragemp/RageMpMarker.ts
+var RageMpMarker = class extends RageMpEntity {
+};
+
+// src/ragemp/RageMpPickup.ts
+var RageMpPickup = class extends RageMpEntity {
+};
+
+// src/ragemp/RageMpEvents.ts
+var RageMpEvents = class {
+  add(eventNameOrEvents, callback) {
+    if (typeof eventNameOrEvents === "string") {
+      mp.events.add(eventNameOrEvents, callback);
+    } else {
+      for (const [name, cb] of Object.entries(eventNameOrEvents)) {
+        mp.events.add(name, cb);
+      }
+    }
+  }
+  remove(eventName, callback) {
+    mp.events.remove(eventName, callback);
+  }
+  call(eventName, ...args) {
+    mp.events.call(eventName, ...args);
+  }
+  callRemote(eventName, ...args) {
+    mp.events.callRemote(eventName, ...args);
+  }
+  callRemoteProc(procName, ...args) {
+    return mp.events.callRemoteProc(procName, ...args);
+  }
+  callRemoteUnreliable(eventName, ...args) {
+    mp.events.callRemoteUnreliable(eventName, ...args);
+  }
+  addProc(procName, callback) {
+    mp.events.addProc(procName, callback);
+  }
+  addDataHandler(key, callback) {
+    mp.events.addDataHandler(key, callback);
+  }
+  cancelPendingProc(procName) {
+    mp.events.cancelPendingProc(procName);
+  }
+  hasPendingProc(procName) {
+    return mp.events.hasPendingProc(procName);
+  }
+};
+
+// src/ragemp/RageMpGui.ts
+var RageMpGuiChat = class {
+  get colors() {
+    return mp.gui.chat.colors;
+  }
+  set colors(value) {
+    mp.gui.chat.colors = value;
+  }
+  get safeMode() {
+    return mp.gui.chat.safeMode;
+  }
+  set safeMode(value) {
+    mp.gui.chat.safeMode = value;
+  }
+  activate(toggle) {
+    mp.gui.chat.activate(toggle);
+  }
+  push(text) {
+    mp.gui.chat.push(text);
+  }
+  show(toggle) {
+    mp.gui.chat.show(toggle);
+  }
+};
+var RageMpGuiCursor = class {
+  get position() {
+    return mp.gui.cursor.position;
+  }
+  set position(value) {
+    mp.gui.cursor.position = value;
+  }
+  get visible() {
+    return mp.gui.cursor.visible;
+  }
+  set visible(value) {
+    mp.gui.cursor.visible = value;
+  }
+  show(freezeControls, toggle) {
+    mp.gui.cursor.show(freezeControls, toggle);
+  }
+};
+var RageMpGui = class {
+  chat = new RageMpGuiChat();
+  cursor = new RageMpGuiCursor();
+  get isGpuRenderingEnabled() {
+    return mp.gui.isGpuRenderingEnabled;
+  }
+  takeScreenshot(name, type, quality, compressionQuality) {
+    mp.gui.takeScreenshot(name, type, quality, compressionQuality);
+  }
+  execute(code) {
+    mp.gui.execute(code);
+  }
+};
+
+// src/ragemp/RageMpKeys.ts
+var RageMpKeys = class {
+  bind(keyCode, keyHold, callback) {
+    mp.keys.bind(keyCode, keyHold, callback);
+  }
+  unbind(keyCode, keyHold, callback) {
+    mp.keys.unbind(keyCode, keyHold, callback);
+  }
+  isUp(keyCode) {
+    return mp.keys.isUp(keyCode);
+  }
+  isDown(keyCode) {
+    return mp.keys.isDown(keyCode);
+  }
+};
+
+// src/ragemp/RageMpStorage.ts
+var RageMpStorage = class {
+  get data() {
+    return mp.storage.data;
+  }
+  set data(value) {
+    mp.storage.data = value;
+  }
+  get sessionData() {
+    return mp.storage.sessionData;
+  }
+  set sessionData(value) {
+    mp.storage.sessionData = value;
+  }
+  flush() {
+    mp.storage.flush();
+  }
+};
+
+// src/ragemp/RageMpVoiceChat.ts
+var RageMpVoiceChat = class {
+  get isAllowed() {
+    return mp.voiceChat.isAllowed;
+  }
+  get lastVad() {
+    return mp.voiceChat.lastVad;
+  }
+  get muted() {
+    return mp.voiceChat.muted;
+  }
+  set muted(value) {
+    mp.voiceChat.muted = value;
+  }
+  get minVad() {
+    return mp.voiceChat.minVad;
+  }
+  set minVad(value) {
+    mp.voiceChat.minVad = value;
+  }
+  get advancedNoiseSuppression() {
+    return mp.voiceChat.advancedNoiseSuppression;
+  }
+  set advancedNoiseSuppression(value) {
+    mp.voiceChat.advancedNoiseSuppression = value;
+  }
+  get networkOptimisations() {
+    return mp.voiceChat.networkOptimisations;
+  }
+  set networkOptimisations(value) {
+    mp.voiceChat.networkOptimisations = value;
+  }
+  get bitrate() {
+    return mp.voiceChat.bitrate;
+  }
+  set bitrate(value) {
+    mp.voiceChat.bitrate = value;
+  }
+  get defaultVolume() {
+    return mp.voiceChat.defaultVolume;
+  }
+  set defaultVolume(value) {
+    mp.voiceChat.defaultVolume = value;
+  }
+  get gameOutputEnabled() {
+    return mp.voiceChat.gameOutputEnabled;
+  }
+  set gameOutputEnabled(value) {
+    mp.voiceChat.gameOutputEnabled = value;
+  }
+  get gameOutputCategory() {
+    return mp.voiceChat.gameOutputCategory;
+  }
+  set gameOutputCategory(value) {
+    mp.voiceChat.gameOutputCategory = value;
+  }
+  getPreprocessingParam(param) {
+    return mp.voiceChat.getPreprocessingParam(param);
+  }
+  setPreprocessingParam(param, value) {
+    mp.voiceChat.setPreprocessingParam(param, value);
+  }
+  cleanupAndReload(force, clearTemporary) {
+    mp.voiceChat.cleanupAndReload(force, clearTemporary, false);
+  }
+};
+
+// src/ragemp/RageMpNametags.ts
+var RageMpNametags = class {
+  get enabled() {
+    return mp.nametags.enabled;
+  }
+  set enabled(value) {
+    mp.nametags.enabled = value;
+  }
+  set(style) {
+    mp.nametags.set({
+      ...style,
+      veh_offset: style.vehOffset
+    });
+  }
+  useScreen2dCoords(toggle) {
+    mp.nametags.useScreen2dCoords(toggle);
+  }
+  orderByDistance(toggle) {
+    mp.nametags.orderByDistance(toggle);
+  }
+};
+
+// src/ragemp/RageMpRaycasting.ts
+var RageMpRaycasting = class {
+  testPointToPoint(startPos, endPos, ignoreEntity, flags) {
+    const result = mp.raycasting.testPointToPoint(
+      new mp.Vector3(startPos.x, startPos.y, startPos.z),
+      new mp.Vector3(endPos.x, endPos.y, endPos.z),
+      ignoreEntity,
+      flags
+    );
+    return {
+      entity: result.entity,
+      position: { x: result.position.x, y: result.position.y, z: result.position.z },
+      surfaceNormal: { x: result.surfaceNormal.x, y: result.surfaceNormal.y, z: result.surfaceNormal.z }
+    };
+  }
+  async testPointToPointAsync(startPos, endPos, ignoreEntity, flags) {
+    const result = await mp.raycasting.testPointToPointAsync(
+      new mp.Vector3(startPos.x, startPos.y, startPos.z),
+      new mp.Vector3(endPos.x, endPos.y, endPos.z),
+      ignoreEntity,
+      flags
+    );
+    return {
+      entity: result.entity,
+      position: { x: result.position.x, y: result.position.y, z: result.position.z },
+      surfaceNormal: { x: result.surfaceNormal.x, y: result.surfaceNormal.y, z: result.surfaceNormal.z }
+    };
+  }
+  testCapsule(startPos, endPos, radius, ignoreEntity, flags) {
+    const result = mp.raycasting.testCapsule(
+      new mp.Vector3(startPos.x, startPos.y, startPos.z),
+      new mp.Vector3(endPos.x, endPos.y, endPos.z),
+      radius,
+      ignoreEntity,
+      flags
+    );
+    return {
+      entity: result.entity,
+      position: { x: result.position.x, y: result.position.y, z: result.position.z },
+      surfaceNormal: { x: result.surfaceNormal.x, y: result.surfaceNormal.y, z: result.surfaceNormal.z }
+    };
+  }
+};
+
+// src/ragemp/RageMpConsole.ts
+var RageMpConsole = class {
+  get verbosity() {
+    return mp.console.verbosity;
+  }
+  set verbosity(value) {
+    mp.console.verbosity = value;
+  }
+  logInfo(message) {
+    mp.console.logInfo(message);
+  }
+  logWarning(message) {
+    mp.console.logWarning(message);
+  }
+  logError(message) {
+    mp.console.logError(message);
+  }
+  logFatal(message) {
+    mp.console.logFatal(message);
+  }
+  clear() {
+    mp.console.clear();
+  }
+  reset() {
+    mp.console.reset();
+  }
+};
+
+// src/ragemp/RageMpDiscord.ts
+var RageMpDiscord = class {
+  update(details, state) {
+    mp.discord.update(details, state);
+  }
+  requestOAuth2(appId, scopes) {
+    return mp.discord.requestOAuth2(appId);
+  }
+};
+
+// src/ragemp/RageMpSystem.ts
+var RageMpSystem = class {
+  get isFullscreen() {
+    return mp.system.isFullscreen;
+  }
+  get isFocused() {
+    return mp.system.isFocused;
+  }
+  notify(args) {
+    mp.system.notify(args);
+  }
+};
+
+// src/ragemp/RageMpUser.ts
+var RageMpUserPreferences = class {
+  get lowQualityAssets() {
+    return mp.user.preferences.lowQualityAssets;
+  }
+  get language() {
+    return mp.user.preferences.language;
+  }
+  get serverAddress() {
+    return mp.user.preferences.serverAddress;
+  }
+};
+var RageMpUser = class {
+  preferences = new RageMpUserPreferences();
+};
+
+// src/ragemp/RageMpNativesBridge.ts
+var RageMpNativesBridge = class {
+  invoke(namespace, name, ...args) {
+    const ns = mp.game[namespace];
+    if (!ns) {
+      throw new Error(`Native namespace "${namespace}" not found`);
+    }
+    const fn = ns[name];
+    if (typeof fn !== "function") {
+      throw new Error(`Native "${namespace}.${name}" is not a function`);
+    }
+    return fn(...args);
+  }
+};
+
+// src/ragemp/RageMpEngine.ts
+var RageMpEngine = class {
+  players;
+  vehicles;
+  peds;
+  objects;
+  blips;
+  checkpoints;
+  colshapes;
+  cameras;
+  browsers;
+  labels;
+  markers;
+  pickups;
+  events;
+  gui;
+  keys;
+  storage;
+  voiceChat;
+  nametags;
+  raycasting;
+  console;
+  discord;
+  system;
+  user;
+  natives;
+  _localPlayer = null;
+  constructor() {
+    this.players = new RageMpEntityPool(mp.players, (raw) => new RageMpPlayer(raw));
+    this.vehicles = new RageMpEntityPool(mp.vehicles, (raw) => new RageMpVehicle(raw));
+    this.objects = new RageMpEntityPool(mp.objects, (raw) => new RageMpObject(raw));
+    this.markers = new RageMpEntityPool(mp.markers, (raw) => new RageMpMarker(raw));
+    this.pickups = new RageMpEntityPool(mp.pickups, (raw) => new RageMpPickup(raw));
+    this.peds = new RageMpCreatablePool(
+      mp.peds,
+      (raw) => new RageMpPed(raw),
+      (opts) => mp.peds.new(
+        opts.model,
+        new mp.Vector3(opts.position.x, opts.position.y, opts.position.z),
+        opts.heading,
+        opts.dimension ?? 0
+      )
+    );
+    this.blips = new RageMpCreatablePool(
+      mp.blips,
+      (raw) => new RageMpBlip(raw),
+      (opts) => mp.blips.new(
+        opts.sprite,
+        new mp.Vector3(opts.position.x, opts.position.y, opts.position.z),
+        {
+          name: opts.name,
+          scale: opts.scale,
+          color: opts.color,
+          alpha: opts.alpha,
+          drawDistance: opts.drawDistance,
+          shortRange: opts.shortRange,
+          rotation: opts.rotation,
+          dimension: opts.dimension
+        }
+      )
+    );
+    this.checkpoints = new RageMpCreatablePool(
+      mp.checkpoints,
+      (raw) => new RageMpCheckpoint(raw),
+      (opts) => mp.checkpoints.new(
+        opts.type,
+        new mp.Vector3(opts.position.x, opts.position.y, opts.position.z),
+        opts.radius,
+        {
+          direction: opts.direction ? new mp.Vector3(opts.direction.x, opts.direction.y, opts.direction.z) : void 0,
+          color: opts.color ? [opts.color.r, opts.color.g, opts.color.b, opts.color.a] : void 0,
+          visible: opts.visible,
+          dimension: opts.dimension
+        }
+      )
+    );
+    this.colshapes = new RageMpCreatablePool(
+      mp.colshapes,
+      (raw) => new RageMpColshape(raw),
+      (opts) => {
+        switch (opts.shape) {
+          case "sphere":
+            return mp.colshapes.newSphere(opts.x, opts.y, opts.z, opts.radius, opts.dimension);
+          case "tube":
+            return mp.colshapes.newTube(opts.x, opts.y, opts.z, opts.radius, opts.height, opts.dimension);
+          case "circle":
+            return mp.colshapes.newCircle(opts.x, opts.y, opts.radius, opts.dimension);
+          case "cuboid":
+            return mp.colshapes.newCuboid(opts.x, opts.y, opts.z, opts.width, opts.height, opts.depth, opts.dimension);
+          case "rectangle":
+            return mp.colshapes.newRectangle(opts.x, opts.y, opts.width, opts.height, opts.dimension);
+          case "polygon":
+          default:
+            return mp.colshapes.newSphere(opts.x, opts.y, opts.z, opts.radius ?? 1, opts.dimension);
+        }
+      }
+    );
+    this.cameras = new RageMpCreatablePool(
+      mp.cameras,
+      (raw) => new RageMpCamera(raw),
+      (opts) => mp.cameras.new(
+        opts.name,
+        opts.position ? new mp.Vector3(opts.position.x, opts.position.y, opts.position.z) : void 0,
+        opts.rotation ? new mp.Vector3(opts.rotation.x, opts.rotation.y, opts.rotation.z) : void 0,
+        opts.fov
+      )
+    );
+    this.browsers = new RageMpCreatablePool(
+      mp.browsers,
+      (raw) => new RageMpBrowser(raw),
+      (opts) => mp.browsers.new(opts.url)
+    );
+    this.labels = new RageMpCreatablePool(
+      mp.labels,
+      (raw) => new RageMpTextLabel(raw),
+      (opts) => mp.labels.new(
+        opts.text,
+        new mp.Vector3(opts.position.x, opts.position.y, opts.position.z),
+        {
+          font: opts.font,
+          color: opts.color ? [opts.color.r, opts.color.g, opts.color.b, opts.color.a] : void 0,
+          drawDistance: opts.drawDistance,
+          los: opts.los,
+          dimension: opts.dimension
+        }
+      )
+    );
+    this.events = new RageMpEvents();
+    this.gui = new RageMpGui();
+    this.keys = new RageMpKeys();
+    this.storage = new RageMpStorage();
+    this.voiceChat = new RageMpVoiceChat();
+    this.nametags = new RageMpNametags();
+    this.raycasting = new RageMpRaycasting();
+    this.console = new RageMpConsole();
+    this.discord = new RageMpDiscord();
+    this.system = new RageMpSystem();
+    this.user = new RageMpUser();
+    this.natives = new RageMpNativesBridge();
+  }
+  get localPlayer() {
+    if (!this._localPlayer) {
+      this._localPlayer = new RageMpPlayer(mp.players.local);
+    }
+    return this._localPlayer;
+  }
+};
+export {
+  RageMpBlip,
+  RageMpBrowser,
+  RageMpCamera,
+  RageMpCheckpoint,
+  RageMpColshape,
+  RageMpCreatablePool,
+  RageMpEngine,
+  RageMpEntity,
+  RageMpEntityPool,
+  RageMpMarker,
+  RageMpObject,
+  RageMpPed,
+  RageMpPickup,
+  RageMpPlayer,
+  RageMpTextLabel,
+  RageMpVehicle
+};
+//# sourceMappingURL=ragemp.js.map