@nativewrappers/common 0.0.125 → 0.0.127

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

@@ -0,0 +1,116 @@
+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";
+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;
+    /**
+     * 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 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;
+    get Owner(): number;
+    get Speed(): number;
+    getSpeedVector(isRelative?: boolean): Vector3;
+    get ForwardVector(): Vector3;
+    get Matrix(): Vector3[];
+    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;
+    /**
+     * Returns if the entity is set as a mission entity and will not be cleaned up by the engine
+     */
+    get IsMissionEntity(): boolean;
+    /**
+     * Sets if the entity is a mission entity and will not be cleaned up by the engine
+     */
+    set IsMissionEntity(value: boolean);
+    set PositionNoOffset(position: Vector3);
+    get Rotation(): Vector3;
+    set Rotation(rotation: Vector3);
+    set Quaternion(quaternion: Quaternion);
+    get IsPositionFrozen(): boolean;
+    set IsPositionFrozen(value: boolean);
+    get Velocity(): Vector3;
+    set Velocity(velocity: Vector3);
+    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/common-game/entities/CommonBaseEntity.js

@@ -0,0 +1,266 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Vector3 } from "../common/utils/Vector";
+import cfx from "../cfx/cfx";
+import { CommonModel } from "../CommonModel";
+import { GlobalData } from "../common/GlobalData";
+import { IHandle } from "./IHandle";
+class CommonBaseEntity extends IHandle {
+  static {
+    __name(this, "CommonBaseEntity");
+  }
+  stateBagCookies = [];
+  netId = null;
+  constructor(handle) {
+    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;
+  }
+  /**
+   * 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);
+  }
+  set IsNetworked(networked) {
+    if (networked) {
+      NetworkRegisterEntityAsNetworked(this.handle);
+    } else {
+      if (GlobalData.IS_REDM) {
+        Citizen.invokeNative("0xE31A04513237DC89", this.handle);
+      } else {
+        NetworkUnregisterNetworkedEntity(this.handle);
+      }
+    }
+  }
+  get State() {
+    return cfx.Entity(this.handle).state;
+  }
+  AddStateBagChangeHandler(keyFilter, handler) {
+    const stateBagName = this.IsNetworked ? `entity:${this.NetworkId}` : `localEntity:${this.handle}`;
+    const cookie = AddStateBagChangeHandler(keyFilter, stateBagName, 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;
+    });
+  }
+  get Owner() {
+    return NetworkGetEntityOwner(this.handle);
+  }
+  get Speed() {
+    return GetEntitySpeed(this.handle);
+  }
+  getSpeedVector(isRelative = false) {
+    return Vector3.fromArray(GetEntitySpeedVector(this.handle, isRelative));
+  }
+  get ForwardVector() {
+    return Vector3.fromArray(GetEntityForwardVector(this.handle));
+  }
+  get Matrix() {
+    return Vector3.fromArrays(GetEntityMatrix(this.handle));
+  }
+  get MaxHealth() {
+    return GetEntityMaxHealth(this.handle);
+  }
+  set MaxHealth(amount) {
+    SetEntityMaxHealth(this.handle, amount);
+  }
+  set IsDead(value) {
+    if (value) {
+      SetEntityHealth(this.handle, 0);
+    } else {
+      SetEntityHealth(this.handle, 200);
+    }
+  }
+  /**
+   * @returns Returns true if the entity is dead
+   */
+  get IsDead() {
+    return IsEntityDead(this.handle);
+  }
+  get IsAlive() {
+    return !IsEntityDead(this.handle);
+  }
+  get Model() {
+    return new CommonModel(GetEntityModel(this.handle));
+  }
+  /**
+   * Returns if the entity is set as a mission entity and will not be cleaned up by the engine
+   */
+  get IsMissionEntity() {
+    return IsEntityAMissionEntity(this.handle);
+  }
+  /**
+   * Sets if the entity is a mission entity and will not be cleaned up by the engine
+   */
+  set IsMissionEntity(value) {
+    if (value) {
+      SetEntityAsMissionEntity(this.handle, false, false);
+    } else {
+      SetEntityAsNoLongerNeeded(this.handle);
+    }
+  }
+  set PositionNoOffset(position) {
+    SetEntityCoordsNoOffset(this.handle, position.x, position.y, position.z, true, true, true);
+  }
+  get Rotation() {
+    return Vector3.fromArray(GetEntityRotation(this.handle, 2));
+  }
+  set Rotation(rotation) {
+    SetEntityRotation(this.handle, rotation.x, rotation.y, rotation.z, 2, true);
+  }
+  set Quaternion(quaternion) {
+    SetEntityQuaternion(this.handle, quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+  }
+  get IsPositionFrozen() {
+    return IsEntityPositionFrozen(this.handle);
+  }
+  set IsPositionFrozen(value) {
+    FreezeEntityPosition(this.handle, value);
+  }
+  get Velocity() {
+    return Vector3.fromArray(GetEntityVelocity(this.handle));
+  }
+  set Velocity(velocity) {
+    SetEntityVelocity(this.handle, velocity.x, velocity.y, velocity.z);
+  }
+  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;
+    DeleteEntity(this.handle);
+    for (const cookie of this.stateBagCookies) {
+      RemoveStateBagChangeHandler(cookie);
+    }
+  }
+  /*
+   * Attaches an entity to another entity via a bone
+   * @example
+   * ```typescript
+   * const ply = Game.PlayerPed;
+   * const bag = await World.createProp(new Model('ba_prop_battle_bag_01b'), ply.Position, true, true, true);
+   * bag.attachToBone(
+   *     ply.Bones.getBone(64113),
+   *     new Vector3(0.12, -0.25, 0.0),
+   *     new Vector3(105.0, 50.0, 190.0)
+   * )
+   * ```
+   */
+  attachToBone(entityBone, position, rotation, collisions = false, unk9 = true, useSoftPinning = true, rotationOrder = 1) {
+    if (this.handle === entityBone.Owner.Handle) {
+      throw new Error("You cannot attach an entity to the same entity this will result in a crash!");
+    }
+    AttachEntityToEntity(
+      this.handle,
+      entityBone.Owner.Handle,
+      entityBone.Index,
+      position.x,
+      position.y,
+      position.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      unk9,
+      useSoftPinning,
+      collisions,
+      IsEntityAPed(entityBone.Owner.Handle),
+      rotationOrder,
+      true
+    );
+  }
+}
+export {
+  CommonBaseEntity
+};

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

@@ -0,0 +1,11 @@
+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(): IHandle;
+    get Position(): Vector3;
+    get IsValid(): boolean;
+}

package/common-game/entities/CommonBaseEntityBone.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+  }
+  get Owner() {
+    return this.owner;
+  }
+  get Position() {
+    return Vector3.fromArray(GetWorldPositionOfEntityBone(this.owner.Handle, this.index));
+  }
+  // public get Rotation(): Vector3 {
+  //   return Vector3.fromArray(GetEntityBoneRotation(this.owner.Handle, this.index));
+  // }
+  get IsValid() {
+    return this.owner.exists() && this.index !== -1;
+  }
+}
+export {
+  CommonBaseEntityBone
+};

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

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

package/common-game/entities/CommonBaseEntityBoneCollection.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class CommonBaseEntityBoneCollection {
+  static {
+    __name(this, "CommonBaseEntityBoneCollection");
+  }
+  owner;
+  constructor(owner) {
+    this.owner = owner;
+  }
+  hasBone(name) {
+    return GetEntityBoneIndexByName(this.owner.Handle, name) !== -1;
+  }
+}
+export {
+  CommonBaseEntityBoneCollection
+};

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

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

package/common-game/entities/CommonEntityBone.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+class CommonEntityBone extends CommonBaseEntityBone {
+  static {
+    __name(this, "CommonEntityBone");
+  }
+  constructor(owner, boneIndex, boneName) {
+    super(owner, boneIndex, boneName);
+  }
+}
+export {
+  CommonEntityBone
+};

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

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

package/common-game/entities/CommonEntityBoneCollection.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import { CommonEntityBone } from "./CommonEntityBone";
+class CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
+  static {
+    __name(this, "CommonEntityBoneCollection");
+  }
+  constructor(owner) {
+    super(owner);
+  }
+  getBone(bone) {
+    return new CommonEntityBone(
+      this.owner,
+      typeof bone === "number" ? bone : GetEntityBoneIndexByName(this.owner.Handle, bone ?? "")
+    );
+  }
+  get Core() {
+    return new CommonEntityBone(this.owner, -1);
+  }
+}
+export {
+  CommonEntityBoneCollection
+};

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

@@ -0,0 +1,4 @@
+import type { CommonPed } from "./CommonPed";
+import type { CommonProp } from "./CommonProp";
+import type { CommonVehicle } from "./CommonVehicle";
+export type CommonEntity = CommonProp | CommonPed | CommonVehicle | null;

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

@@ -0,0 +1,16 @@
+import { CommonBaseEntity } from "./CommonBaseEntity";
+import { CommonPlayer } from "./CommonPlayer";
+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 fromHandle(handle: number): CommonPed | null;
+    static fromNetworkId(networkId: number): CommonPed | null;
+    constructor(handle: number);
+    get Player(): CommonPlayer | null;
+    get Task(): CommonTasks;
+    get Bones(): CommonPedBoneCollection;
+}

package/common-game/entities/CommonPed.js

@@ -0,0 +1,52 @@
+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 { CommonPedBoneCollection } from "./CommonPedBoneCollection";
+import { CommonTasks } from "../CommonTasks";
+class CommonPed extends CommonBaseEntity {
+  static {
+    __name(this, "CommonPed");
+  }
+  tasks;
+  type = ClassTypes.Ped;
+  bones;
+  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));
+  }
+  constructor(handle) {
+    super(handle);
+  }
+  get Player() {
+    const playerIndex = NetworkGetPlayerIndexFromPed(this.handle);
+    if (playerIndex === -1) {
+      return null;
+    }
+    return new CommonPlayer(playerIndex);
+  }
+  get Task() {
+    if (!this.tasks) {
+      this.tasks = new CommonTasks(this);
+    }
+    return this.tasks;
+  }
+  get Bones() {
+    if (!this.bones) {
+      this.bones = new CommonPedBoneCollection(this);
+    }
+    return this.bones;
+  }
+}
+export {
+  CommonPed
+};

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

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

package/common-game/entities/CommonPedBone.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
+class CommonPedBone extends CommonBaseEntityBone {
+  static {
+    __name(this, "CommonPedBone");
+  }
+  constructor(owner, boneId) {
+    super(owner, GetPedBoneIndex(owner.Handle, Number(boneId)));
+  }
+  get IsValid() {
+    return this.Owner.exists() && this.Index !== -1;
+  }
+}
+export {
+  CommonPedBone
+};

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

@@ -0,0 +1,10 @@
+import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import { CommonPedBone } from "./CommonPedBone";
+import type { IHandle } from "./IHandle";
+export declare class CommonPedBoneCollection extends CommonBaseEntityBoneCollection {
+    constructor(owner: IHandle);
+    get Core(): CommonPedBone;
+    get LastDamaged(): CommonPedBone;
+    clearLastDamaged(): void;
+    getBone(boneIndex?: number, boneName?: string): CommonPedBone;
+}

package/common-game/entities/CommonPedBoneCollection.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
+import { CommonPedBone } from "./CommonPedBone";
+class CommonPedBoneCollection extends CommonBaseEntityBoneCollection {
+  static {
+    __name(this, "CommonPedBoneCollection");
+  }
+  constructor(owner) {
+    super(owner);
+  }
+  get Core() {
+    return new CommonPedBone(this.owner, -1);
+  }
+  get LastDamaged() {
+    const [, outBone] = GetPedLastDamageBone(this.owner.Handle, 0);
+    return CommonPedBone[outBone];
+  }
+  clearLastDamaged() {
+    ClearPedLastDamageBone(this.owner.Handle);
+  }
+  getBone(boneIndex, boneName) {
+    return new CommonPedBone(
+      this.owner,
+      boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "")
+    );
+  }
+}
+export {
+  CommonPedBoneCollection
+};