@nativewrappers/redm 0.0.121 → 0.0.123

package/common-game/entities/CommonPlayer.d.ts

@@ -0,0 +1,61 @@
+import type { StateBagChangeHandler } from "../cfx/StateBagChangeHandler";
+import { CommonPed } from "./CommonPed";
+import type { CommonEntity } from "./CommonEntityType";
+export declare class CommonPlayer {
+    private handle;
+    private ped?;
+    private pvp;
+    private stateBagCookies;
+    private source;
+    private type;
+    static AllPlayers(excludeLocalPlayer?: boolean): IterableIterator<CommonPlayer>;
+    /**
+     * @param handle the handoe of the ped to get the player of
+     * @returns the player, or null if the player doesn't exist
+     */
+    static fromPedHandle(handle: number): CommonPlayer | null;
+    /**
+     * @param serverId the server id to get the player of
+     * @returns the player, or null if the player doesn't exist
+     */
+    static fromServerId(serverId: number): CommonPlayer | null;
+    /**
+     * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+     * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+     * @returns the closest player from {@param fromPlayer} and the distance the player was
+     */
+    static getClosestPlayerPedWithDistance(minimumDistance?: number, fromPlayer?: CommonPlayer): [CommonPed | null, number];
+    /**
+     * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+     * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+     * @returns the closest player from {@param fromPlayer} and the distance the player was
+     */
+    static getClosestPlayerPed(minimumDistance?: number, fromPlayer?: CommonPlayer): CommonPed | null;
+    /**
+     * @param handle the player handle, or if on the server, their source.
+     */
+    constructor(handle?: number);
+    get Handle(): number;
+    /**
+     * This is here for compatibility with older versions.
+     */
+    get Character(): CommonPed;
+    get Ped(): CommonPed;
+    get ServerId(): number;
+    get State(): StateBagInterface;
+    AddStateBagChangeHandler(keyFilter: string | null, handler: StateBagChangeHandler<unknown>): number;
+    /**
+     * A short hand function for AddStateBagChangeHandler, this gets automatically cleaned up on entity deletion.
+     * @param keyFilter the key to filter for or null
+     * @param handler the function to handle the change
+     * @returns a cookie to be used in RemoveStateBagChangeHandler
+     */
+    listenForStateChange(keyFilter: string | null, handler: StateBagChangeHandler<unknown>): number;
+    removeStateListener(tgtCookie: number): void;
+    removeAllStateListeners(): void;
+    get Name(): string;
+    get IsDead(): boolean;
+    set DisableFiring(value: boolean);
+    get EntityPlayerIsAimingAt(): CommonEntity | null;
+    get StealthNoise(): number;
+}

package/common-game/entities/CommonPlayer.js

@@ -0,0 +1,156 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonPed } from "./CommonPed";
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { GetEntityClassFromHandle } from "./GetEntityClassIdFromHandle";
+import cfx from "../cfx/cfx";
+import { GameConstants } from "../CommonGameConstants";
+class CommonPlayer {
+  static {
+    __name(this, "CommonPlayer");
+  }
+  handle;
+  ped;
+  pvp = false;
+  stateBagCookies = [];
+  source;
+  type = ClassTypes.Player;
+  static *AllPlayers(excludeLocalPlayer = true) {
+    for (const ply of GetActivePlayers()) {
+      if (excludeLocalPlayer && ply === GameConstants.PlayerId) {
+        continue;
+      }
+      yield new CommonPlayer(ply);
+    }
+  }
+  /**
+   * @param handle the handoe of the ped to get the player of
+   * @returns the player, or null if the player doesn't exist
+   */
+  static fromPedHandle(handle) {
+    const playerHandle = NetworkGetPlayerIndexFromPed(handle);
+    if (!handle) {
+      return null;
+    }
+    return new CommonPlayer(playerHandle);
+  }
+  /**
+   * @param serverId the server id to get the player of
+   * @returns the player, or null if the player doesn't exist
+   */
+  static fromServerId(serverId) {
+    const player = GetPlayerFromServerId(serverId);
+    if (player === -1) {
+      return null;
+    }
+    return new CommonPlayer(player);
+  }
+  /**
+   * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+   * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+   * @returns the closest player from {@param fromPlayer} and the distance the player was
+   */
+  static getClosestPlayerPedWithDistance(minimumDistance = Number.MAX_VALUE, fromPlayer = GameConstants.Player) {
+    const ped = fromPlayer.Ped;
+    const pos = ped.Position;
+    const data = [null, Number.MAX_VALUE];
+    for (const ply of CommonPlayer.AllPlayers(true)) {
+      const tgtPed = ply.Ped;
+      const dist = pos.distance(tgtPed.Position);
+      if (dist < data[1] && dist < minimumDistance) {
+        data[0] = tgtPed;
+        data[1] = dist;
+      }
+    }
+    return data;
+  }
+  /**
+   * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+   * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+   * @returns the closest player from {@param fromPlayer} and the distance the player was
+   */
+  static getClosestPlayerPed(minimumDistance = Number.MAX_VALUE, fromPlayer = GameConstants.Player) {
+    const data = this.getClosestPlayerPedWithDistance(minimumDistance, fromPlayer);
+    return data[0];
+  }
+  /**
+   * @param handle the player handle, or if on the server, their source.
+   */
+  constructor(handle = -1) {
+    this.handle = handle;
+    this.source = this.ServerId;
+  }
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * This is here for compatibility with older versions.
+   */
+  get Character() {
+    return this.Ped;
+  }
+  get Ped() {
+    const handle = GetPlayerPed(this.handle);
+    if (typeof this.ped === "undefined" || handle !== this.ped.Handle) {
+      this.ped = new CommonPed(handle);
+    }
+    return this.ped;
+  }
+  get ServerId() {
+    if (this.source) {
+      return this.source;
+    }
+    return GetPlayerServerId(this.handle);
+  }
+  get State() {
+    return cfx.Player(this.ServerId).state;
+  }
+  AddStateBagChangeHandler(keyFilter, handler) {
+    const cookie = AddStateBagChangeHandler(keyFilter, `player:${this.ServerId}`, handler);
+    this.stateBagCookies.push(cookie);
+    return cookie;
+  }
+  /**
+   * A short hand function for AddStateBagChangeHandler, this gets automatically cleaned up on entity deletion.
+   * @param keyFilter the key to filter for or null
+   * @param handler the function to handle the change
+   * @returns a cookie to be used in RemoveStateBagChangeHandler
+   */
+  listenForStateChange(keyFilter, handler) {
+    return this.AddStateBagChangeHandler(keyFilter, handler);
+  }
+  removeStateListener(tgtCookie) {
+    this.stateBagCookies = this.stateBagCookies.filter((cookie) => {
+      const isCookie = cookie === tgtCookie;
+      if (isCookie) RemoveStateBagChangeHandler(cookie);
+      return isCookie;
+    });
+  }
+  removeAllStateListeners() {
+    for (const cookie of this.stateBagCookies) {
+      RemoveStateBagChangeHandler(cookie);
+    }
+  }
+  get Name() {
+    return GetPlayerName(this.handle);
+  }
+  get IsDead() {
+    return IsPlayerDead(this.handle);
+  }
+  set DisableFiring(value) {
+    DisablePlayerFiring(this.handle, value);
+  }
+  get EntityPlayerIsAimingAt() {
+    const [entityHit, entity] = GetEntityPlayerIsFreeAimingAt(this.handle);
+    if (entityHit) {
+      return GetEntityClassFromHandle(entity);
+    }
+    return null;
+  }
+  get StealthNoise() {
+    return GetPlayerCurrentStealthNoise(this.handle);
+  }
+}
+export {
+  CommonPlayer
+};

package/common-game/entities/CommonProp.d.ts

@@ -0,0 +1,15 @@
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+import type { CommonEntity } from "./CommonEntityType";
+export declare class CommonProp extends CommonBaseEntity {
+    static fromHandle(handle: number): CommonProp | null;
+    static fromNetworkId(networkId: number): CommonProp | null;
+    protected type: ClassTypes;
+    protected bones?: CommonEntityBoneCollection | undefined;
+    constructor(handle: number);
+    exists(): boolean;
+    placeOnGround(): void;
+    getEntityAttachedTo(): CommonEntity;
+    get Bones(): CommonEntityBoneCollection;
+}

package/common-game/entities/CommonProp.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+import { GetEntityClassFromHandle } from "./GetEntityClassIdFromHandle";
+class CommonProp extends CommonBaseEntity {
+  static {
+    __name(this, "CommonProp");
+  }
+  static fromHandle(handle) {
+    return new this(handle);
+  }
+  static fromNetworkId(networkId) {
+    if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+      return null;
+    }
+    return new this(NetworkGetEntityFromNetworkId(networkId));
+  }
+  type = ClassTypes.Prop;
+  bones;
+  constructor(handle) {
+    super(handle);
+  }
+  exists() {
+    return super.exists() && GetEntityType(this.handle) === 3;
+  }
+  placeOnGround() {
+    PlaceObjectOnGroundProperly(this.handle);
+  }
+  getEntityAttachedTo() {
+    return GetEntityClassFromHandle(this.handle);
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new CommonEntityBoneCollection(this);
+    }
+    return this.bones;
+  }
+}
+export {
+  CommonProp
+};

package/common-game/entities/CommonVehicle.d.ts

@@ -0,0 +1,11 @@
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+export declare class CommonVehicle extends CommonBaseEntity {
+    static fromHandle(handle: number): CommonVehicle | null;
+    static fromNetworkId(networkId: number): CommonVehicle | null;
+    protected type: ClassTypes;
+    protected bones?: CommonEntityBoneCollection;
+    constructor(handle: number);
+    get Bones(): CommonEntityBoneCollection;
+}

package/common-game/entities/CommonVehicle.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
+class CommonVehicle extends CommonBaseEntity {
+  static {
+    __name(this, "CommonVehicle");
+  }
+  static fromHandle(handle) {
+    if (handle === 0 || !DoesEntityExist(handle)) {
+      return null;
+    }
+    return new this(handle);
+  }
+  static fromNetworkId(networkId) {
+    if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+      return null;
+    }
+    return new this(NetworkGetEntityFromNetworkId(networkId));
+  }
+  type = ClassTypes.Vehicle;
+  bones;
+  constructor(handle) {
+    super(handle);
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new CommonEntityBoneCollection(this);
+    }
+    return this.bones;
+  }
+}
+export {
+  CommonVehicle
+};

package/common-game/entities/GetEntityClassIdFromHandle.d.ts

@@ -0,0 +1,2 @@
+import type { CommonEntity } from "./CommonEntityType";
+export declare function GetEntityClassFromHandle(entityId: number): CommonEntity;

package/common-game/entities/GetEntityClassIdFromHandle.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonPed } from "./CommonPed";
+import { CommonProp } from "./CommonProp";
+import { CommonVehicle } from "./CommonVehicle";
+function GetEntityClassFromHandle(entityId) {
+  switch (GetEntityType(entityId)) {
+    case 1: {
+      return CommonPed.fromHandle(entityId);
+    }
+    case 2: {
+      return CommonVehicle.fromHandle(entityId);
+    }
+    case 3: {
+      return CommonProp.fromHandle(entityId);
+    }
+  }
+  return null;
+}
+__name(GetEntityClassFromHandle, "GetEntityClassFromHandle");
+export {
+  GetEntityClassFromHandle
+};

package/common-game/entities/IHandle.d.ts

@@ -0,0 +1,6 @@
+export declare class IHandle {
+    protected handle: number;
+    constructor(handle: number);
+    exists(): boolean;
+    get Handle(): number;
+}

package/common-game/entities/IHandle.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class IHandle {
+  static {
+    __name(this, "IHandle");
+  }
+  handle;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  exists() {
+    return DoesEntityExist(this.handle);
+  }
+  get Handle() {
+    return this.handle;
+  }
+}
+export {
+  IHandle
+};

package/common-game/enums/VehicleSeat.d.ts

@@ -0,0 +1,13 @@
+export declare enum VehicleSeat {
+    AnyPassenger = -2,
+    Driver = -1,
+    FrontRight = 0,
+    BackLeft = 1,
+    BackRight = 2,
+    ExtraLeft1 = 3,
+    ExtraRight1 = 4,
+    ExtraLeft2 = 5,
+    ExtraRight2 = 6,
+    ExtraLeft3 = 7,
+    ExtraRight3 = 8
+}

package/common-game/enums/VehicleSeat.js

@@ -0,0 +1,17 @@
+var VehicleSeat = /* @__PURE__ */ ((VehicleSeat2) => {
+  VehicleSeat2[VehicleSeat2["AnyPassenger"] = -2] = "AnyPassenger";
+  VehicleSeat2[VehicleSeat2["Driver"] = -1] = "Driver";
+  VehicleSeat2[VehicleSeat2["FrontRight"] = 0] = "FrontRight";
+  VehicleSeat2[VehicleSeat2["BackLeft"] = 1] = "BackLeft";
+  VehicleSeat2[VehicleSeat2["BackRight"] = 2] = "BackRight";
+  VehicleSeat2[VehicleSeat2["ExtraLeft1"] = 3] = "ExtraLeft1";
+  VehicleSeat2[VehicleSeat2["ExtraRight1"] = 4] = "ExtraRight1";
+  VehicleSeat2[VehicleSeat2["ExtraLeft2"] = 5] = "ExtraLeft2";
+  VehicleSeat2[VehicleSeat2["ExtraRight2"] = 6] = "ExtraRight2";
+  VehicleSeat2[VehicleSeat2["ExtraLeft3"] = 7] = "ExtraLeft3";
+  VehicleSeat2[VehicleSeat2["ExtraRight3"] = 8] = "ExtraRight3";
+  return VehicleSeat2;
+})(VehicleSeat || {});
+export {
+  VehicleSeat
+};

package/common-game/interfaces/Dimension.d.ts

@@ -0,0 +1,5 @@
+import type { Vector3 } from "../../common/utils/Vector";
+export interface Dimensions {
+    min: Vector3;
+    max: Vector3;
+}

package/common-game/utils/Animations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A utility to load an animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns {boolean} if the animation successfully loaded
+ */
+export declare const LoadAnimDict: (animDict: string, waitTime?: number) => Promise<boolean>;
+/**
+ * A utility to load multiple animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns if the animation successfully loaded, if the animation failed to load it will return an array of animations that failed to load
+ */
+export declare const LoadAnimDictArray: (animDict: string[], waitTime?: number) => Promise<[boolean, string[] | null]>;
+/**
+ * A utility to unload multiple animation dictionary
+ * @param animDict the animation dictionaries to unload
+ */
+export declare const RemoveAnimDictArray: (animDict: string[]) => void;

package/common-game/utils/Animations.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Delay } from "../../common/utils/Delay";
+const LoadAnimDict = /* @__PURE__ */ __name(async (animDict, waitTime = 1e3) => {
+  const start = GetGameTimer();
+  if (!HasAnimDictLoaded(animDict)) {
+    RequestAnimDict(animDict);
+  }
+  while (!HasAnimDictLoaded(animDict)) {
+    if (GetGameTimer() - start >= waitTime) return false;
+    await Delay(0);
+  }
+  return true;
+}, "LoadAnimDict");
+const LoadAnimDictArray = /* @__PURE__ */ __name(async (animDict, waitTime = 1e3) => {
+  const start = GetGameTimer();
+  for (const dict of animDict) {
+    if (!HasAnimDictLoaded(dict)) {
+      RequestAnimDict(dict);
+    }
+  }
+  const animsLoaded = /* @__PURE__ */ new Set();
+  while (animsLoaded.size !== animDict.length) {
+    for (const dict of animDict) {
+      if (!animsLoaded.has(dict) && HasAnimDictLoaded(dict)) {
+        animsLoaded.add(dict);
+      }
+    }
+    if (GetGameTimer() - start >= waitTime) return [false, animDict.filter((dict) => !animsLoaded.has(dict))];
+    await Delay(0);
+  }
+  return [true, null];
+}, "LoadAnimDictArray");
+const RemoveAnimDictArray = /* @__PURE__ */ __name((animDict) => {
+  for (const dict of animDict) {
+    RemoveAnimDict(dict);
+  }
+}, "RemoveAnimDictArray");
+export {
+  LoadAnimDict,
+  LoadAnimDictArray,
+  RemoveAnimDictArray
+};

package/entities/BaseEntity.d.ts

@@ -1,71 +1,3 @@
-import { Vector3 } from "../common/utils/Vector";
-export declare class BaseEntity {
-    protected handle: number;
-    constructor(entHandle: number);
-    /**
-      * Replaces the current handle for the entity used on, this hsould be used sparringly, mainly
-      * in situations where you're going to reuse an entity over and over and don't want to make a
-      * new entity every time.
-      *
-      *  **WARNING**: This does no checks, if you provide it an invalid entity it will use it
-      *
-      * ```ts
-      * const REUSABLE_ENTITY = new Entity(entityHandle);
-      *
-      * onNet("entityHandler", (entNetId: number) => {
-      *  // if no net entity we should ignore
-      *  if (!NetworkDoesEntityExistWithNetworkId(entNetId)) return;
-      *
-      *  // Reuse our entity so we don't have to initialize a new one
-      *  REUSABLE_ENTITY.replaceHandle(NetworkGetEntityFromNetworkId(entNetId));
-      *  // Do something with REUSABLE_ENTITY entity
-      * })
-      ```
-      */
-    replaceHandle(newHandle: number): void;
-    /**
-     * @returns the network for the specified entity, this doesn't check if the entity is networked, you should use {@link IsNetworked}
-     */
-    get NetworkId(): number;
-    /**
-     * @returns `true` if the current entity is networked, false otherwise
-     */
-    get IsNetworked(): boolean;
-    /**
-     * @returns Returns true if the entity handle is not 0 and exists in the game engine
-     */
-    get Exists(): boolean;
-    /**
-     * @returns Returns true if the entity is dead
-     */
-    get IsDead(): boolean;
-    /**
-     * @returns The entitys current handle.
-     */
-    get Handle(): number;
-    /**
-     * @param amount the health to set the health to, setting to `0` will kill the entity, if using on a {@link Ped} you should check the MaxHealth before setting.
-     */
-    set Health(amount: number);
-    /**
-     * @returns the amount of health the current {@link BaseEntity} has
-     */
-    get Health(): number;
-    /**
-     * @returns the heading of the current {@link BaseEntity}
-     */
-    get Heading(): number;
-    /**
-     * @param heading sets the entitys heading to the specified heading, this can be in the range of 0..360
-     */
-    set Heading(heading: number);
-    /**
-     * @returns the position of the current Entity
-     */
-    get Position(): Vector3;
-    /**
-     * You should (almost) always try to load the collisions before setting the entitys position if going a long distance.
-     * @param pos sets the position for the current ped
-     */
-    set Position(pos: Vector3);
+import { CommonBaseEntity } from "../common-game/entities/CommonBaseEntity";
+export declare abstract class BaseEntity extends CommonBaseEntity {
 }

package/entities/BaseEntity.js

@@ -1,104 +1,11 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { Vector3 } from "../common/utils/Vector";
-class BaseEntity {
+import { CommonBaseEntity } from "../common-game/entities/CommonBaseEntity";
+class BaseEntity extends CommonBaseEntity {
   static {
     __name(this, "BaseEntity");
   }
-  handle;
-  constructor(entHandle) {
-    this.handle = entHandle;
-  }
-  /**
-    * Replaces the current handle for the entity used on, this hsould be used sparringly, mainly
-    * in situations where you're going to reuse an entity over and over and don't want to make a
-    * new entity every time.
-    *
-    *  **WARNING**: This does no checks, if you provide it an invalid entity it will use it
-    *
-    * ```ts
-    * const REUSABLE_ENTITY = new Entity(entityHandle);
-    *
-    * onNet("entityHandler", (entNetId: number) => {
-    *  // if no net entity we should ignore
-    *  if (!NetworkDoesEntityExistWithNetworkId(entNetId)) return;
-    *
-    *  // Reuse our entity so we don't have to initialize a new one
-    *  REUSABLE_ENTITY.replaceHandle(NetworkGetEntityFromNetworkId(entNetId));
-    *  // Do something with REUSABLE_ENTITY entity
-    * })
-    ```
-    */
-  replaceHandle(newHandle) {
-    this.handle = newHandle;
-  }
-  /**
-   * @returns the network for the specified entity, this doesn't check if the entity is networked, you should use {@link IsNetworked}
-   */
-  get NetworkId() {
-    return NetworkGetNetworkIdFromEntity(this.handle);
-  }
-  /**
-   * @returns `true` if the current entity is networked, false otherwise
-   */
-  get IsNetworked() {
-    return NetworkGetEntityIsNetworked(this.handle);
-  }
-  /**
-   * @returns Returns true if the entity handle is not 0 and exists in the game engine
-   */
-  get Exists() {
-    return this.handle !== 0 && DoesEntityExist(this.handle);
-  }
-  /**
-   * @returns Returns true if the entity is dead
-   */
-  get IsDead() {
-    return IsEntityDead(this.handle);
-  }
-  /**
-   * @returns The entitys current handle.
-   */
-  get Handle() {
-    return this.handle;
-  }
-  /**
-   * @param amount the health to set the health to, setting to `0` will kill the entity, if using on a {@link Ped} you should check the MaxHealth before setting.
-   */
-  set Health(amount) {
-    SetEntityHealth(this.handle, amount, 0);
-  }
-  /**
-   * @returns the amount of health the current {@link BaseEntity} has
-   */
-  get Health() {
-    return GetEntityHealth(this.handle);
-  }
-  /**
-   * @returns the heading of the current {@link BaseEntity}
-   */
-  get Heading() {
-    return GetEntityHeading(this.handle);
-  }
-  /**
-   * @param heading sets the entitys heading to the specified heading, this can be in the range of 0..360
-   */
-  set Heading(heading) {
-    SetEntityHeading(this.handle, heading);
-  }
-  /**
-   * @returns the position of the current Entity
-   */
-  get Position() {
-    return Vector3.fromArray(GetEntityCoords(this.handle, true, true));
-  }
-  /**
-   * You should (almost) always try to load the collisions before setting the entitys position if going a long distance.
-   * @param pos sets the position for the current ped
-   */
-  set Position(pos) {
-    SetEntityCoords(this.handle, pos.x, pos.y, pos.z, false, false, false, false);
-  }
 }
 export {
   BaseEntity

package/entities/Entity.d.ts

@@ -2,7 +2,11 @@ import type { Vector3 } from "../common/utils/Vector";
 import { type BoneIndex, EntityType, ForceType } from "../enums/Entity";
 import type { Throwable } from "../types/Throwable";
 import { BaseEntity } from "./BaseEntity";
+import type { CommonBaseEntityBoneCollection } from "../common-game/entities/CommonBaseEntityBoneCollection";
+import { ClassTypes } from "../common/utils/ClassTypes";
 export declare class Entity extends BaseEntity {
+    protected type: ClassTypes;
+    protected bones?: CommonBaseEntityBoneCollection | undefined;
     constructor(handle: number);
     addTrackingTrails(): void;
     get EntityType(): EntityType;