@nativewrappers/common-game 0.0.121 → 0.0.123

package/CommonModel.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { Delay } from "./common/utils/Delay";
-import { Vector3 } from "./common/utils/Vector";
+import { Delay } from "@common/utils/Delay";
+import { Vector3 } from "@common/utils/Vector";
 class CommonModel {
   static {
     __name(this, "CommonModel");

package/CommonTasks.d.ts

@@ -1,11 +1,12 @@
-import { Vector3 } from "./common/utils/Vector";
+import { Vector3 } from "@common/utils/Vector";
 import { CommonBaseEntity } from "./entities/CommonBaseEntity";
 import { CommonPed } from "./entities/CommonPed";
 import type { CommonVehicle } from "./entities/CommonVehicle";
 import { VehicleSeat } from "./enums/VehicleSeat";
+import { IHandle } from "./entities/IHandle";
 export declare class CommonTasks {
-    private ped;
-    constructor(ped: CommonPed | null);
+    protected ped: IHandle;
+    constructor(ped: IHandle | null);
     achieveHeading(heading: number, timeout?: number): void;
     blockTemporaryEvents(block?: boolean): void;
     aimAt(target: CommonBaseEntity | Vector3, duration: number): void;
@@ -17,7 +18,7 @@ export declare class CommonTasks {
     static everyoneLeaveVehicle(vehicle: CommonVehicle): void;
     fightAgainst(target: CommonPed, duration?: number): void;
     fightAgainstHatedTargets(radius: number, duration?: number): void;
-    fleeFrom(pedOrPosition: CommonPed | Vector3, distance?: number, duration?: number, fleeType?: number, fleeSpeed?: number, fleeFrom?: CommonPed): void;
+    fleeFrom(pedOrPosition: CommonPed | Vector3, distance?: number, duration?: number, fleeType?: number, fleeSpeed?: number, fleeFrom?: IHandle): void;
     goTo(position: Vector3, ignorePaths?: boolean, timeout?: number, speed?: number, targetHeading?: number, distanceToSlide?: number, flags?: number): void;
     goToEntity(target: CommonBaseEntity, offset?: Vector3, timeout?: number): void;
     guardCurrentPosition(): void;
@@ -25,7 +26,7 @@ export declare class CommonTasks {
     lookAt(targetOrPosition: CommonBaseEntity | Vector3, duration?: number): void;
     playAnimation(animDict: string, animName: string, blendInSpeed: number, blendOutSpeed: number, duration: number, playbackRate: number, animFlags: number, ikFlags?: number): Promise<void>;
     reloadWeapon(): void;
-    shootAt(targetOrPosition: CommonPed | Vector3, duration?: number, pattern?: number, affectCockedState?: boolean): void;
+    shootAt(targetOrPosition: IHandle | Vector3, duration?: number, pattern?: number, affectCockedState?: boolean): void;
     shuffleToNextVehicleSeat(vehicle: CommonVehicle): void;
     slideTo(position: Vector3, heading: number, duration?: number): void;
     standStill(duration: number): void;

package/CommonTasks.js

@@ -1,11 +1,12 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { Vector3 } from "./common/utils/Vector";
+import { Vector3 } from "@common/utils/Vector";
 import { CommonBaseEntity } from "./entities/CommonBaseEntity";
 import { CommonPed } from "./entities/CommonPed";
 import { VehicleSeat } from "./enums/VehicleSeat";
 import { LoadAnimDict } from "./utils/Animations";
-import { GlobalData } from "./common/GlobalData";
+import { GlobalData } from "@common/GlobalData";
+import { IHandle } from "./entities/IHandle";
 class CommonTasks {
   static {
     __name(this, "CommonTasks");
@@ -166,7 +167,7 @@ class CommonTasks {
     TaskReloadWeapon(this.ped.Handle, true);
   }
   shootAt(targetOrPosition, duration = -1, pattern = 0, affectCockedState = false) {
-    if (targetOrPosition instanceof CommonPed) {
+    if (targetOrPosition instanceof IHandle) {
       TaskShootAtEntity(this.ped.Handle, targetOrPosition.Handle, duration, pattern, affectCockedState);
     } else {
       TaskShootAtCoord(

package/entities/CommonBaseEntity.d.ts

@@ -1,24 +1,50 @@
-import type { ClassTypes } from "../common/utils/ClassTypes";
-import type { Quaternion } from "../common/utils/Quaternion";
-import { Vector3 } from "../common/utils/Vector";
+import type { ClassTypes } from "@common/utils/ClassTypes";
+import type { Quaternion } from "@common/utils/Quaternion";
+import { Vector3 } from "@common/utils/Vector";
 import type { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
 import type { StateBagChangeHandler } from "../cfx/StateBagChangeHandler";
 import { CommonModel } from "../CommonModel";
 import type { CommonBaseEntityBone } from "./CommonBaseEntityBone";
-export declare abstract class CommonBaseEntity {
-    protected handle: number;
+import { IHandle } from "./IHandle";
+export declare abstract class CommonBaseEntity extends IHandle {
     protected stateBagCookies: number[];
     protected netId: number | null;
     protected abstract type: ClassTypes;
     protected abstract bones?: CommonBaseEntityBoneCollection;
     constructor(handle: number);
+    /**
+      * Replaces the current handle for the entity used on, this should 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;
+    get Exists(): boolean;
     get Handle(): number;
     /**
-     * @returns if the entity is a networked entity or local entity
+     * This will return a warning if the the entity is not networked, you should always use {@link IsNetworked} prior to calling thisl
+     * @returns the network for the specified entity
+     */
+    get NetworkId(): number;
+    /**
+     * @returns `true` if the current entity is networked, false otherwise
      */
     get IsNetworked(): boolean;
     set IsNetworked(networked: boolean);
-    get NetworkId(): number;
     get State(): StateBagInterface;
     AddStateBagChangeHandler(keyFilter: string | null, handler: StateBagChangeHandler<unknown>): number;
     /**
@@ -34,11 +60,12 @@ export declare abstract class CommonBaseEntity {
     getSpeedVector(isRelative?: boolean): Vector3;
     get ForwardVector(): Vector3;
     get Matrix(): Vector3[];
-    get Health(): number;
-    set Health(amount: number);
     get MaxHealth(): number;
     set MaxHealth(amount: number);
     set IsDead(value: boolean);
+    /**
+     * @returns Returns true if the entity is dead
+     */
     get IsDead(): boolean;
     get IsAlive(): boolean;
     get Model(): CommonModel;
@@ -50,19 +77,40 @@ export declare abstract class CommonBaseEntity {
      * Sets if the entity is a mission entity and will not be cleaned up by the engine
      */
     set IsMissionEntity(value: boolean);
-    get Position(): Vector3;
-    set Position(position: Vector3);
     set PositionNoOffset(position: Vector3);
     get Rotation(): Vector3;
     set Rotation(rotation: Vector3);
     set Quaternion(quaternion: Quaternion);
-    get Heading(): number;
-    set Heading(heading: number);
     get IsPositionFrozen(): boolean;
     set IsPositionFrozen(value: boolean);
     get Velocity(): Vector3;
     set Velocity(velocity: Vector3);
-    exists(): boolean;
+    get IsVisible(): boolean;
+    /**
+     * @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 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);
     delete(): void;
     attachToBone(entityBone: CommonBaseEntityBone, position: Vector3, rotation: Vector3, collisions?: boolean, unk9?: boolean, useSoftPinning?: boolean, rotationOrder?: number): void;
 }

package/entities/CommonBaseEntity.js

@@ -1,27 +1,63 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { Vector3 } from "../common/utils/Vector";
+import { Vector3 } from "@common/utils/Vector";
 import cfx from "../cfx/cfx";
 import { CommonModel } from "../CommonModel";
-import { GlobalData } from "../common/GlobalData";
-class CommonBaseEntity {
+import { GlobalData } from "@common/GlobalData";
+import { IHandle } from "./IHandle";
+class CommonBaseEntity extends IHandle {
   static {
     __name(this, "CommonBaseEntity");
   }
-  handle;
   stateBagCookies = [];
   netId = null;
   constructor(handle) {
-    this.handle = handle;
-    if (this.IsNetworked) {
-      this.netId = this.NetworkId;
-    }
+    super(handle);
+  }
+  /**
+    * Replaces the current handle for the entity used on, this should 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 `true` if the entity exists, `false` otherwise.
+   */
+  get Exists() {
+    return DoesEntityExist(this.handle);
   }
+  /*
+   * @returns the handle of the specified entity
+   */
   get Handle() {
     return this.handle;
   }
   /**
-   * @returns if the entity is a networked entity or local entity
+   * This will return a warning if the the entity is not networked, you should always use {@link IsNetworked} prior to calling thisl
+   * @returns the network for the specified entity
+   */
+  get NetworkId() {
+    return NetworkGetNetworkIdFromEntity(this.handle);
+  }
+  /**
+   * @returns `true` if the current entity is networked, false otherwise
    */
   get IsNetworked() {
     return NetworkGetEntityIsNetworked(this.handle);
@@ -30,19 +66,13 @@ class CommonBaseEntity {
     if (networked) {
       NetworkRegisterEntityAsNetworked(this.handle);
     } else {
-      if (GlobalData.GameName === "redm") {
+      if (GlobalData.IS_REDM) {
         Citizen.invokeNative("0xE31A04513237DC89", this.handle);
       } else {
         NetworkUnregisterNetworkedEntity(this.handle);
       }
     }
   }
-  get NetworkId() {
-    if (this.netId) {
-      return this.netId;
-    }
-    return NetworkGetNetworkIdFromEntity(this.handle);
-  }
   get State() {
     return cfx.Entity(this.handle).state;
   }
@@ -83,12 +113,6 @@ class CommonBaseEntity {
   get Matrix() {
     return Vector3.fromArrays(GetEntityMatrix(this.handle));
   }
-  get Health() {
-    return GetEntityHealth(this.handle);
-  }
-  set Health(amount) {
-    SetEntityHealth(this.handle, amount);
-  }
   get MaxHealth() {
     return GetEntityMaxHealth(this.handle);
   }
@@ -102,6 +126,9 @@ class CommonBaseEntity {
       SetEntityHealth(this.handle, 200);
     }
   }
+  /**
+   * @returns Returns true if the entity is dead
+   */
   get IsDead() {
     return IsEntityDead(this.handle);
   }
@@ -127,12 +154,6 @@ class CommonBaseEntity {
       SetEntityAsNoLongerNeeded(this.handle);
     }
   }
-  get Position() {
-    return Vector3.fromArray(GetEntityCoords(this.handle, false));
-  }
-  set Position(position) {
-    SetEntityCoords(this.handle, position.x, position.y, position.z, false, false, false, true);
-  }
   set PositionNoOffset(position) {
     SetEntityCoordsNoOffset(this.handle, position.x, position.y, position.z, true, true, true);
   }
@@ -145,12 +166,6 @@ class CommonBaseEntity {
   set Quaternion(quaternion) {
     SetEntityQuaternion(this.handle, quaternion.x, quaternion.y, quaternion.z, quaternion.w);
   }
-  get Heading() {
-    return GetEntityHeading(this.handle);
-  }
-  set Heading(heading) {
-    SetEntityHeading(this.handle, heading);
-  }
   get IsPositionFrozen() {
     return IsEntityPositionFrozen(this.handle);
   }
@@ -163,8 +178,45 @@ class CommonBaseEntity {
   set Velocity(velocity) {
     SetEntityVelocity(this.handle, velocity.x, velocity.y, velocity.z);
   }
-  exists() {
-    return DoesEntityExist(this.handle);
+  get IsVisible() {
+    return IsEntityVisible(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 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);
   }
   delete() {
     this.IsMissionEntity = true;

package/entities/CommonBaseEntityBone.d.ts

@@ -1,11 +1,11 @@
-import { Vector3 } from "../common/utils/Vector";
-import type { CommonBaseEntity } from "./CommonBaseEntity";
+import { Vector3 } from "@common/utils/Vector";
+import type { IHandle } from "./IHandle";
 export declare abstract class CommonBaseEntityBone {
+    protected readonly owner: IHandle;
+    protected readonly index: number;
+    constructor(owner: IHandle, boneIndex?: number, boneName?: string);
     get Index(): number;
-    get Owner(): CommonBaseEntity;
+    get Owner(): IHandle;
     get Position(): Vector3;
     get IsValid(): boolean;
-    protected readonly owner: CommonBaseEntity;
-    protected readonly index: number;
-    constructor(owner: CommonBaseEntity, boneIndex?: number, boneName?: string);
 }

package/entities/CommonBaseEntityBone.js

@@ -1,10 +1,16 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { Vector3 } from "../common/utils/Vector";
+import { Vector3 } from "@common/utils/Vector";
 class CommonBaseEntityBone {
   static {
     __name(this, "CommonBaseEntityBone");
   }
+  owner;
+  index;
+  constructor(owner, boneIndex, boneName) {
+    this.owner = owner;
+    this.index = boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "");
+  }
   get Index() {
     return this.index;
   }
@@ -20,12 +26,6 @@ class CommonBaseEntityBone {
   get IsValid() {
     return this.owner.exists() && this.index !== -1;
   }
-  owner;
-  index;
-  constructor(owner, boneIndex, boneName) {
-    this.owner = owner;
-    this.index = boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "");
-  }
 }
 export {
   CommonBaseEntityBone

package/entities/CommonBaseEntityBoneCollection.d.ts

@@ -1,8 +1,8 @@
-import type { CommonBaseEntity } from "./CommonBaseEntity";
 import type { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+import type { IHandle } from "./IHandle";
 export declare abstract class CommonBaseEntityBoneCollection {
-    protected readonly owner: CommonBaseEntity;
-    constructor(owner: CommonBaseEntity);
+    protected readonly owner: IHandle;
+    constructor(owner: IHandle);
     hasBone(name: string): boolean;
     abstract getBone(boneIndex?: number, boneName?: string): CommonBaseEntityBone;
     abstract get Core(): CommonBaseEntityBone;

package/entities/CommonEntityBone.d.ts

@@ -1,5 +1,5 @@
-import type { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+import type { IHandle } from "./IHandle";
 export declare class CommonEntityBone extends CommonBaseEntityBone {
-    constructor(owner: CommonBaseEntity, boneIndex?: number, boneName?: string);
+    constructor(owner: IHandle, boneIndex?: number, boneName?: string);
 }

package/entities/CommonEntityBoneCollection.d.ts

@@ -1,8 +1,8 @@
-import type { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
 import { CommonEntityBone } from "./CommonEntityBone";
+import type { IHandle } from "./IHandle";
 export declare class CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
-    constructor(owner: CommonBaseEntity);
+    constructor(owner: IHandle);
     getBone(boneIndex: number): CommonEntityBone;
     getBone(boneName: string): CommonEntityBone;
     get Core(): CommonEntityBone;

package/entities/CommonPed.d.ts

@@ -1,13 +1,12 @@
 import { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonPlayer } from "./CommonPlayer";
-import { ClassTypes } from "../common/utils/ClassTypes";
+import { ClassTypes } from "@common/utils/ClassTypes";
 import { CommonPedBoneCollection } from "./CommonPedBoneCollection";
 import { CommonTasks } from "../CommonTasks";
 export declare class CommonPed extends CommonBaseEntity {
     private tasks;
     protected type: ClassTypes;
     protected bones?: CommonPedBoneCollection;
-    static exists(ped: CommonPed): boolean;
     static fromHandle(handle: number): CommonPed | null;
     static fromNetworkId(networkId: number): CommonPed | null;
     constructor(handle: number);

package/entities/CommonPed.js

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonPlayer } from "./CommonPlayer";
-import { ClassTypes } from "../common/utils/ClassTypes";
+import { ClassTypes } from "@common/utils/ClassTypes";
 import { CommonPedBoneCollection } from "./CommonPedBoneCollection";
 import { CommonTasks } from "../CommonTasks";
 class CommonPed extends CommonBaseEntity {
@@ -12,9 +12,6 @@ class CommonPed extends CommonBaseEntity {
   tasks;
   type = ClassTypes.Ped;
   bones;
-  static exists(ped) {
-    return typeof ped !== "undefined" && ped.exists();
-  }
   static fromHandle(handle) {
     if (handle === 0 || !DoesEntityExist(handle)) {
       return null;

package/entities/CommonPedBone.d.ts

@@ -1,6 +1,6 @@
 import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
-import type { CommonPed } from "./CommonPed";
+import type { IHandle } from "./IHandle";
 export declare class CommonPedBone extends CommonBaseEntityBone {
-    constructor(owner: CommonPed, boneId: number);
+    constructor(owner: IHandle, boneId: number);
     get IsValid(): boolean;
 }

package/entities/CommonPedBoneCollection.d.ts

@@ -1,8 +1,8 @@
 import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
-import type { CommonPed } from "./CommonPed";
 import { CommonPedBone } from "./CommonPedBone";
+import type { IHandle } from "./IHandle";
 export declare class CommonPedBoneCollection extends CommonBaseEntityBoneCollection {
-    constructor(owner: CommonPed);
+    constructor(owner: IHandle);
     get Core(): CommonPedBone;
     get LastDamaged(): CommonPedBone;
     clearLastDamaged(): void;

package/entities/CommonPlayer.js

@@ -1,7 +1,7 @@
 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 { ClassTypes } from "@common/utils/ClassTypes";
 import { GetEntityClassFromHandle } from "./GetEntityClassIdFromHandle";
 import cfx from "../cfx/cfx";
 import { GameConstants } from "../CommonGameConstants";

package/entities/CommonProp.d.ts

@@ -1,9 +1,8 @@
-import { ClassTypes } from "../common/utils/ClassTypes";
+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 exists(prop: CommonProp): boolean;
     static fromHandle(handle: number): CommonProp | null;
     static fromNetworkId(networkId: number): CommonProp | null;
     protected type: ClassTypes;

package/entities/CommonProp.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { ClassTypes } from "../common/utils/ClassTypes";
+import { ClassTypes } from "@common/utils/ClassTypes";
 import { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
 import { GetEntityClassFromHandle } from "./GetEntityClassIdFromHandle";
@@ -8,9 +8,6 @@ class CommonProp extends CommonBaseEntity {
   static {
     __name(this, "CommonProp");
   }
-  static exists(prop) {
-    return typeof prop !== "undefined" && prop.exists();
-  }
   static fromHandle(handle) {
     return new this(handle);
   }

package/entities/CommonVehicle.d.ts

@@ -1,8 +1,7 @@
-import { ClassTypes } from "../common/utils/ClassTypes";
+import { ClassTypes } from "@common/utils/ClassTypes";
 import { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
 export declare class CommonVehicle extends CommonBaseEntity {
-    static exists(vehicle: CommonVehicle): boolean;
     static fromHandle(handle: number): CommonVehicle | null;
     static fromNetworkId(networkId: number): CommonVehicle | null;
     protected type: ClassTypes;

package/entities/CommonVehicle.js

@@ -1,15 +1,12 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { ClassTypes } from "../common/utils/ClassTypes";
+import { ClassTypes } from "@common/utils/ClassTypes";
 import { CommonBaseEntity } from "./CommonBaseEntity";
 import { CommonEntityBoneCollection } from "./CommonEntityBoneCollection";
 class CommonVehicle extends CommonBaseEntity {
   static {
     __name(this, "CommonVehicle");
   }
-  static exists(vehicle) {
-    return typeof vehicle !== "undefined" && vehicle.exists();
-  }
   static fromHandle(handle) {
     if (handle === 0 || !DoesEntityExist(handle)) {
       return null;

package/entities/IHandle.d.ts

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

package/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/index.d.ts

@@ -17,28 +17,8 @@ export * from "./entities/CommonPlayer";
 export * from "./entities/CommonProp";
 export * from "./entities/CommonVehicle";
 export * from "./entities/GetEntityClassIdFromHandle";
+export * from "./entities/IHandle";
 export * from "./definitions/index.d";
 export * from "./definitions/redm.d";
-export * from "./common/Command";
-export * from "./common/Convar";
-export * from "./common/GlobalData";
-export * from "./common/Kvp";
-export * from "./common/Resource";
-export * from "./common/types";
-export * from "./common/utils/ClassTypes";
-export * from "./common/utils/Color";
-export * from "./common/utils/Delay";
-export * from "./common/utils/Maths";
-export * from "./common/utils/Point";
-export * from "./common/utils/PointF";
-export * from "./common/utils/Quaternion";
-export * from "./common/utils/Vector";
-export * from "./common/utils/cleanPlayerName";
-export * from "./common/utils/enumValues";
-export * from "./common/utils/getStringFromUInt8Array";
-export * from "./common/utils/getUInt32FromUint8Array";
-export * from "./common/utils/randomInt";
-export * from "./common/net/NetworkedMap";
-export * from "./common/decors/Events";
 export * from "./cfx/StateBagChangeHandler";
 export * from "./cfx/cfx";