@nativewrappers/redm-codegen 0.0.3 → 0.0.4

package/src/classes/Entity.ts

@@ -152,195 +152,117 @@ export class Entity implements IHandle {
   }
 
   /**
-   * @param playerPedToIgnore 
-   * @param flags 
+   * @param pos1 
+   * @param pos2 
+   * @param p7 
+   * @param p8 
+   * @param p9 
    * @returns
    */
-  getNearestPlayerToEntity(playerPedToIgnore: Ped, flags: number): Player | null {
-    return createFromHandle<Player>('Player', inv<number>('0x990E294FC387FB88', this.handle, playerPedToIgnore.handle, flags, rai()));
+  isInArea(pos1: Vector3, pos2: Vector3, p7: boolean, p8: boolean, p9: any): boolean {
+    return inv<boolean>('0x0C2634C40A16193E', this.handle, f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), p7, p8, p9, rai());
   }
 
   /**
-   * Gets the Y-component of the entity's forward vector.
+   * Returns the coordinates of an entity-bone.
+   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
    *
+   * @param boneIndex 
    * @returns
    */
-  getForwardY(): number {
-    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
-  }
-
-  /**
-   * @param pitch 
-   * @param roll 
-   * @param yaw 
-   * @param rotationOrder 
-   * @param p5 
-   */
-  setRotation(pitch: number, roll: number, yaw: number, rotationOrder: number, p5: boolean): void {
-    inv<void>('0x9CC8314DFEDE441E', this.handle, f(pitch), f(roll), f(yaw), rotationOrder, p5);
-  }
-
-  /**
-   * @param p1 
-   * @param relationshipGroup 
-   */
-  setOnlyDamagedByRelationshipGroup(p1: boolean, relationshipGroup: string | number): void {
-    inv<void>('0x6C1F6AA2F0ADD104', this.handle, p1, _h(relationshipGroup));
+  getWorldPositionOfBone(boneIndex: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x82CFA50E34681CA5', this.handle, boneIndex, rav()));
   }
 
   /**
-   * https://github.com/femga/rdr3_discoveries/tree/master/AI/ENTITY_PROOFS
-   * BOOL p2: handles an additional special proofs flag, so it simply indicates whether it should be enabled or disabled, not sure what exactly it proofs the entity from though
+   * https://github.com/femga/rdr3_discoveries/tree/master/animations
    *
-   * @param proofsBitset 
-   * @param specialFlag 
-   */
-  setProofs(proofsBitset: number, specialFlag: boolean): void {
-    inv<void>('0xFAEE099C6F890BB8', this.handle, proofsBitset, specialFlag);
-  }
-
-  /**
-   * @returns
-   */
-  hasCollisionLoadedAroundEntity(): boolean {
-    return inv<boolean>('0xBEB1600952B9CF5C', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  getIsCarriablePelt(): any {
-    return inv<number>('0x255B6DB4E3AD3C3E', this.handle);
-  }
-
-  /**
-   * @param p1 
+   * @param animName 
+   * @param animDict 
+   * @param p3 
+   * @param loop 
+   * @param stayInAnim 
+   * @param p6 
+   * @param delta 
+   * @param bitset 
    * @returns
    */
-  getVelocity(p1: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x4805D2B1D8CF94A9', this.handle, p1, rav()));
-  }
-
-  /**
-   * @param toggle 
-   */
-  setCanAutoVaultOnEntity(toggle: boolean): void {
-    inv<void>('0x80646744FA88F9D7', this.handle, toggle);
+  playAnim(animName: string | null, animDict: string | null, p3: number, loop: boolean, stayInAnim: boolean, p6: boolean, delta: number, bitset: any): boolean {
+    return inv<boolean>('0xDC6D22FAB76D4874', this.handle, animName, animDict, f(p3), loop, stayInAnim, p6, f(delta), bitset, rai());
   }
 
   /**
-   * Sets the loot table an entity will carry. Returns true if loot table has been successfully set. Returns false if entity is not a ped or object.
-   * https://github.com/femga/rdr3_discoveries/blob/master/AI/EVENTS/loot_rewards.lua
+   * Returns false if entity is not a ped or object.
    *
-   * @param lootTable 
-   * @returns
-   */
-  scriptOverrideLootTablePermanent(lootTable: string | number): any {
-    return inv<number>('0x8C03CD6B5E0E85E8', this.handle, _h(lootTable));
-  }
-
-  /**
-   * @returns argStruct
+   * @returns lootTable
    */
-  getScript(): [number, number] {
-    const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
-    return [result[0] & 0xFFFFFFFF, result[1]];
+  getScriptOverrideLootTablePermanent(): [any, number] {
+    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
+    return [result[0], result[1]];
   }
 
   /**
-   * @param actionHash 
+   * @param animDict 
+   * @param animName 
+   * @param p3 
    * @returns
    */
-  hasAnimEventFired(actionHash: string | number): boolean {
-    return inv<boolean>('0x5851CC48405F4A07', this.handle, _h(actionHash), rai());
-  }
-
-  /**
-   * @param p1 
-   */
-  N_0xEF259AA1E097E0AD(p1: any): void {
-    inv<void>('0xEF259AA1E097E0AD', this.handle, p1);
+  hasAnimFinished(animDict: string | null, animName: string | null, p3: number): boolean {
+    return inv<boolean>('0xAEB40615337EF1E3', this.handle, animDict, animName, p3, rai());
   }
 
   /**
-   * Getter for FREEZE_ENTITY_POSITION
-   *
-   * @returns
+   * @param bCanBeDamaged 
+   * @param relGroup 
    */
-  isFrozen(): any {
-    return inv<number>('0x083D497D57B7400F', this.handle);
+  setCanBeDamagedByRelationshipGroup(bCanBeDamaged: boolean, relGroup: string | number): void {
+    inv<void>('0x0EF1AFB18649E015', this.handle, bCanBeDamaged, _h(relGroup));
   }
 
   /**
-   * Returns the entity that is looting a ped but only while the looting is active
-   *
    * @returns
    */
-  getLootingPed(): Ped | null {
-    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
+  getUprightValue(): number {
+    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
   }
 
   /**
-   * @returns
+   * @param pos 
+   * @param heading 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
    */
-  isWaitingForWorldCollision(): boolean {
-    return inv<boolean>('0x5E1CC2E8DC3111DD', this.handle, rai());
+  setCoordsAndHeading(pos: Vector3, heading: number, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
+    inv<void>('0x203BEFFDBE12E96A', this.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), xAxis, yAxis, zAxis);
   }
 
   /**
-   * Gets the X-component of the entity's forward vector.
+   * Returns zero if the entity is not a carriable
    *
    * @returns
    */
-  getForwardX(): number {
-    return inv<number>('0xDB0954E9960F6457', this.handle, raf());
-  }
-
-  /**
-   * @returns
-   */
-  isAPed(): boolean {
-    return inv<boolean>('0xCF8176912DDA4EA5', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  getPitch(): number {
-    return inv<number>('0xEF355ABEFF7F5005', this.handle, raf());
-  }
-
-  /**
-   * @returns
-   */
-  isStatic(): boolean {
-    return inv<boolean>('0x86468ADFA0F6B861', this.handle, rai());
+  getCarryConfig(): number {
+    return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * Returns the model hash from the entity
+   * tier: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityThreatTier
    *
-   * @returns
-   */
-  getModel(): number {
-    return (inv<number>('0xDA76A9F39210D365', this.handle, rai())) & 0xFFFFFFFF;
-  }
-
-  /**
-   * Deletes the specified entity, then sets the handle pointed to by the pointer to NULL.
+   * @param tier 
+   * @param p2 
    */
-  deleteEntity(): void {
-    inv<void>('0x4CD38C78BD19A497', this.handle);
+  setThreatTier(tier: number, p2: boolean): void {
+    inv<void>('0x4B436BAC8CBE9B07', this.handle, tier, p2);
   }
 
   /**
-   * @param team 
-   * @param playerPedToIgnore 
-   * @param flags 
+   * Returns the heading of the entity in degrees. Also know as the "Yaw" of an entity.
+   *
    * @returns
    */
-  getNearestPlayerToOnTeam(team: number, playerPedToIgnore: Ped, flags: number): Player | null {
-    return createFromHandle<Player>('Player', inv<number>('0xB2C30C3B4AFF718C', this.handle, team, playerPedToIgnore.handle, flags, rai()));
+  getHeading(): number {
+    return inv<number>('0xC230DD956E2F5507', this.handle, raf());
   }
 
   /**
@@ -521,179 +443,186 @@ export class Entity implements IHandle {
   }
 
   /**
-   * Returns entityType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityType
-   *
-   * @returns
+   * @param p1 
    */
-  getType(): number {
-    return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
+  N_0xA48E4801DEBDF7E4(p1: boolean): void {
+    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
   }
 
   /**
-   * @returns
+   * @param toggle 
+   * @param keepPhysics 
    */
-  isOwnedByPersistenceSystem(): any {
-    return inv<number>('0xA7E51B53309EAC97', this.handle);
+  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param animType 
-   * @returns
+   * @param p1 
    */
-  isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
-    return inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
+  N_0xCDB682BB47C02F0A(p1: string | number): void {
+    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
   }
 
   /**
-   * Marks the specified entity (ped, vehicle or object) as no longer needed, allowing the game engine to delete it whenever it sees fit.
+   * @param volume 
+   * @param p2 
+   * @param p3 
+   * @returns
    */
-  setAsNoLongerNeeded(): void {
-    inv<void>('0x4971D2F8162B9674', this.handle);
+  isInVolume(volume: number, p2: boolean, p3: number): boolean {
+    return inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
   }
 
   /**
-   * @returns
+   * @returns rightVector; forwardVector; upVector; position
    */
-  hasBeenDamagedByAnyVehicle(): boolean {
-    return inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
+  getMatrix(): [Vector3, Vector3, Vector3, Vector3] {
+    const result = inv<[number[], number[], number[], number[]]>('0x3A9B1120AF13FBF2', this.handle, pvv(), pvv(), pvv(), pvv());
+    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1]), Vector3.fromArray(result[2]), Vector3.fromArray(result[3])];
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param speedMultiplier 
+   * Called if entity is in water and submerged level is larger than 1f. If CARRYING_FLAG_FORCE_ALLOW_WARP_TO_SAFE_GROUND_LOCATION is true, it gets disabled as well.
    */
-  setAnimSpeed(animDict: string | null, animName: string | null, speedMultiplier: number): void {
-    inv<void>('0xEAA885BA3CEA4E4A', this.handle, animDict, animName, f(speedMultiplier));
-  }
-
-  unpinMapEntity(): void {
-    inv<void>('0xD2B9C78537ED5759', this.handle);
+  N_0x371D179701D9C082(): void {
+    inv<void>('0x371D179701D9C082', this.handle);
   }
 
   /**
-   * Get how much of the entity is submerged. 1.0f is whole entity.
-   *
+   * @param p1 
    * @returns
    */
-  getSubmergedLevel(): number {
-    return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
+  getMaxHealth(p1: boolean): number {
+    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
   }
 
   /**
-   * @returns
+   * @param animDict 
+   * @param animName 
+   * @param time 
    */
-  isAttached(): boolean {
-    return inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
+  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
+    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
   }
 
   /**
-   * SET_ENTITY_A*
+   * Gets the current coordinates for a specified entity.
+   * `entity` = The entity to get the coordinates from.
+   * `alive` = Unused by the game, potentially used by debug builds in order to assert whether or not an entity was alive. If entity is a ped and it's in a vehicle or on a mount the coords of that entity are returned. Set 'realCoords' to true when you need the true ped coords.
    *
-   * @param p1 
+   * @param alive 
+   * @param realCoords 
+   * @returns
    */
-  N_0xC0EDEF16D90661EE(p1: number): void {
-    inv<void>('0xC0EDEF16D90661EE', this.handle, f(p1));
+  getCoords(alive?: boolean, realCoords?: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
   }
 
   /**
-   * @param looted 
+   * @returns
    */
-  setFullyLooted(looted: boolean): void {
-    inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
+  isAnObject(): boolean {
+    return inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  isAttachedToAnyVehicle(): boolean {
-    return inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
+  isUpsidedown(): boolean {
+    return inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
   }
 
   /**
    * @param p1 
+   * @returns
    */
-  N_0xA48E4801DEBDF7E4(p1: boolean): void {
-    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
+  doesBelongToThisScript(p1: boolean): boolean {
+    return inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
+  }
+
+  /**
+   * Returns a hash of an entity's name. (Alternative Name: _GET_ENTITY_PROMPT_NAME_HASH)
+   *
+   * @returns
+   */
+  getCarriableFromEntity(): number {
+    return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
    * @param toggle 
    * @param keepPhysics 
    */
-  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
-    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
+  setCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xF66F820909453B8C', this.handle, toggle, keepPhysics);
   }
 
   /**
    * @param p1 
+   * @returns
    */
-  N_0xCDB682BB47C02F0A(p1: string | number): void {
-    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
+  placeOnGroundProperly(p1: boolean): any {
+    return inv<number>('0x9587913B9E772D29', this.handle, p1);
   }
 
   /**
-   * @param volume 
-   * @param p2 
-   * @param p3 
    * @returns
    */
-  isInVolume(volume: number, p2: boolean, p3: number): boolean {
-    return inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
+  isInWater(): boolean {
+    return inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
   }
 
   /**
-   * @returns rightVector; forwardVector; upVector; position
+   * @returns Returns `true` if the entity exists
    */
-  getMatrix(): [Vector3, Vector3, Vector3, Vector3] {
-    const result = inv<[number[], number[], number[], number[]]>('0x3A9B1120AF13FBF2', this.handle, pvv(), pvv(), pvv(), pvv());
-    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1]), Vector3.fromArray(result[2]), Vector3.fromArray(result[3])];
+  doesExist(): boolean {
+    return inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
   }
 
   /**
-   * Called if entity is in water and submerged level is larger than 1f. If CARRYING_FLAG_FORCE_ALLOW_WARP_TO_SAFE_GROUND_LOCATION is true, it gets disabled as well.
+   * @returns
    */
-  N_0x371D179701D9C082(): void {
-    inv<void>('0x371D179701D9C082', this.handle);
+  getAlpha(): number {
+    return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
   }
 
   /**
-   * @param p1 
+   * This native only works on `Ped` and `Object` entity types
+   *
+   * @param flagId Refer to [enum: eCarryingFlags]
    * @returns
    */
-  getMaxHealth(p1: boolean): number {
-    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
+  getCarryingFlag(flagId: eCarryingFlags): number {
+    return inv<number>('0x808077647856DE62', this.handle, flagId, rai());
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param time 
+   * @param p1 
    */
-  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
-    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
+  forceAiAndAnimationUpdate(p1: boolean): void {
+    inv<void>('0x4C9E96473D4F1A88', this.handle, p1);
   }
 
   /**
-   * Gets the current coordinates for a specified entity.
-   * `entity` = The entity to get the coordinates from.
-   * `alive` = Unused by the game, potentially used by debug builds in order to assert whether or not an entity was alive. If entity is a ped and it's in a vehicle or on a mount the coords of that entity are returned. Set 'realCoords' to true when you need the true ped coords.
+   * Axis - Invert Axis Flags
    *
-   * @param alive 
-   * @param realCoords 
-   * @returns
+   * @param pos 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
    */
-  getCoords(alive: boolean, realCoords: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
+  setCoordsNoOffset(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
+    inv<void>('0x239A3351AC1DA385', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis);
   }
 
   /**
+   * Returns (CUR_HEALTH / MAX_HEALTH)
+   *
    * @returns
    */
-  isAnObject(): boolean {
-    return inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
+  getHealthFloat(): number {
+    return inv<number>('0x96C638784DB4C815', this.handle, raf());
   }
 
   /**
@@ -934,117 +863,195 @@ export class Entity implements IHandle {
   }
 
   /**
-   * @param pos1 
-   * @param pos2 
-   * @param p7 
-   * @param p8 
-   * @param p9 
+   * @param playerPedToIgnore 
+   * @param flags 
    * @returns
    */
-  isInArea(pos1: Vector3, pos2: Vector3, p7: boolean, p8: boolean, p9: any): boolean {
-    return inv<boolean>('0x0C2634C40A16193E', this.handle, f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), p7, p8, p9, rai());
+  getNearestPlayerToEntity(playerPedToIgnore: Ped, flags: number): Player | null {
+    return createFromHandle<Player>('Player', inv<number>('0x990E294FC387FB88', this.handle, playerPedToIgnore.handle, flags, rai()));
+  }
+
+  /**
+   * Gets the Y-component of the entity's forward vector.
+   *
+   * @returns
+   */
+  getForwardY(): number {
+    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
+  }
+
+  /**
+   * @param pitch 
+   * @param roll 
+   * @param yaw 
+   * @param rotationOrder 
+   * @param p5 
+   */
+  setRotation(pitch: number, roll: number, yaw: number, rotationOrder: number, p5: boolean): void {
+    inv<void>('0x9CC8314DFEDE441E', this.handle, f(pitch), f(roll), f(yaw), rotationOrder, p5);
+  }
+
+  /**
+   * @param p1 
+   * @param relationshipGroup 
+   */
+  setOnlyDamagedByRelationshipGroup(p1: boolean, relationshipGroup: string | number): void {
+    inv<void>('0x6C1F6AA2F0ADD104', this.handle, p1, _h(relationshipGroup));
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/tree/master/AI/ENTITY_PROOFS
+   * BOOL p2: handles an additional special proofs flag, so it simply indicates whether it should be enabled or disabled, not sure what exactly it proofs the entity from though
+   *
+   * @param proofsBitset 
+   * @param specialFlag 
+   */
+  setProofs(proofsBitset: number, specialFlag: boolean): void {
+    inv<void>('0xFAEE099C6F890BB8', this.handle, proofsBitset, specialFlag);
+  }
+
+  /**
+   * @returns
+   */
+  hasCollisionLoadedAroundEntity(): boolean {
+    return inv<boolean>('0xBEB1600952B9CF5C', this.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  getIsCarriablePelt(): any {
+    return inv<number>('0x255B6DB4E3AD3C3E', this.handle);
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  getVelocity(p1: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x4805D2B1D8CF94A9', this.handle, p1, rav()));
+  }
+
+  /**
+   * @param toggle 
+   */
+  setCanAutoVaultOnEntity(toggle: boolean): void {
+    inv<void>('0x80646744FA88F9D7', this.handle, toggle);
+  }
+
+  /**
+   * Sets the loot table an entity will carry. Returns true if loot table has been successfully set. Returns false if entity is not a ped or object.
+   * https://github.com/femga/rdr3_discoveries/blob/master/AI/EVENTS/loot_rewards.lua
+   *
+   * @param lootTable 
+   * @returns
+   */
+  scriptOverrideLootTablePermanent(lootTable: string | number): any {
+    return inv<number>('0x8C03CD6B5E0E85E8', this.handle, _h(lootTable));
+  }
+
+  /**
+   * @returns argStruct
+   */
+  getScript(): [number, number] {
+    const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
+    return [result[0] & 0xFFFFFFFF, result[1]];
+  }
+
+  /**
+   * @param actionHash 
+   * @returns
+   */
+  hasAnimEventFired(actionHash: string | number): boolean {
+    return inv<boolean>('0x5851CC48405F4A07', this.handle, _h(actionHash), rai());
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0xEF259AA1E097E0AD(p1: any): void {
+    inv<void>('0xEF259AA1E097E0AD', this.handle, p1);
   }
 
   /**
-   * Returns the coordinates of an entity-bone.
-   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
+   * Getter for FREEZE_ENTITY_POSITION
    *
-   * @param boneIndex 
    * @returns
    */
-  getWorldPositionOfBone(boneIndex: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x82CFA50E34681CA5', this.handle, boneIndex, rav()));
+  isFrozen(): any {
+    return inv<number>('0x083D497D57B7400F', this.handle);
   }
 
   /**
-   * https://github.com/femga/rdr3_discoveries/tree/master/animations
+   * Returns the entity that is looting a ped but only while the looting is active
    *
-   * @param animName 
-   * @param animDict 
-   * @param p3 
-   * @param loop 
-   * @param stayInAnim 
-   * @param p6 
-   * @param delta 
-   * @param bitset 
    * @returns
    */
-  playAnim(animName: string | null, animDict: string | null, p3: number, loop: boolean, stayInAnim: boolean, p6: boolean, delta: number, bitset: any): boolean {
-    return inv<boolean>('0xDC6D22FAB76D4874', this.handle, animName, animDict, f(p3), loop, stayInAnim, p6, f(delta), bitset, rai());
+  getLootingPed(): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
   }
 
   /**
-   * Returns false if entity is not a ped or object.
-   *
-   * @returns lootTable
+   * @returns
    */
-  getScriptOverrideLootTablePermanent(): [any, number] {
-    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
-    return [result[0], result[1]];
+  isWaitingForWorldCollision(): boolean {
+    return inv<boolean>('0x5E1CC2E8DC3111DD', this.handle, rai());
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param p3 
+   * Gets the X-component of the entity's forward vector.
+   *
    * @returns
    */
-  hasAnimFinished(animDict: string | null, animName: string | null, p3: number): boolean {
-    return inv<boolean>('0xAEB40615337EF1E3', this.handle, animDict, animName, p3, rai());
+  getForwardX(): number {
+    return inv<number>('0xDB0954E9960F6457', this.handle, raf());
   }
 
   /**
-   * @param bCanBeDamaged 
-   * @param relGroup 
+   * @returns
    */
-  setCanBeDamagedByRelationshipGroup(bCanBeDamaged: boolean, relGroup: string | number): void {
-    inv<void>('0x0EF1AFB18649E015', this.handle, bCanBeDamaged, _h(relGroup));
+  isAPed(): boolean {
+    return inv<boolean>('0xCF8176912DDA4EA5', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  getUprightValue(): number {
-    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
+  getPitch(): number {
+    return inv<number>('0xEF355ABEFF7F5005', this.handle, raf());
   }
 
   /**
-   * @param pos 
-   * @param heading 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
+   * @returns
    */
-  setCoordsAndHeading(pos: Vector3, heading: number, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
-    inv<void>('0x203BEFFDBE12E96A', this.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), xAxis, yAxis, zAxis);
+  isStatic(): boolean {
+    return inv<boolean>('0x86468ADFA0F6B861', this.handle, rai());
   }
 
   /**
-   * Returns zero if the entity is not a carriable
+   * Returns the model hash from the entity
    *
    * @returns
    */
-  getCarryConfig(): number {
-    return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
+  getModel(): number {
+    return (inv<number>('0xDA76A9F39210D365', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * tier: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityThreatTier
-   *
-   * @param tier 
-   * @param p2 
+   * Deletes the specified entity, then sets the handle pointed to by the pointer to NULL.
    */
-  setThreatTier(tier: number, p2: boolean): void {
-    inv<void>('0x4B436BAC8CBE9B07', this.handle, tier, p2);
+  deleteEntity(): void {
+    inv<void>('0x4CD38C78BD19A497', this.handle);
   }
 
   /**
-   * Returns the heading of the entity in degrees. Also know as the "Yaw" of an entity.
-   *
+   * @param team 
+   * @param playerPedToIgnore 
+   * @param flags 
    * @returns
    */
-  getHeading(): number {
-    return inv<number>('0xC230DD956E2F5507', this.handle, raf());
+  getNearestPlayerToOnTeam(team: number, playerPedToIgnore: Ped, flags: number): Player | null {
+    return createFromHandle<Player>('Player', inv<number>('0xB2C30C3B4AFF718C', this.handle, team, playerPedToIgnore.handle, flags, rai()));
   }
 
   /**
@@ -1358,193 +1365,186 @@ export class Entity implements IHandle {
   }
 
   /**
-   * Used in Script Function DUELING_DID_PLAYER_DISARM_OPPONENT
+   * Returns entityType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityType
    *
-   * @param entity2 
-   * @param p2 
-   * @param p3 
    * @returns
    */
-  N_0x3EC28DA1FFAC9DDD(entity2: Entity, p2: any, p3: any): boolean {
-    return inv<boolean>('0x3EC28DA1FFAC9DDD', this.handle, entity2.handle, p2, p3, rai());
+  getType(): number {
+    return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
   }
 
   /**
-   * Must be called from a background script, otherwise it will do nothing.
+   * @returns
    */
-  delete2(): void {
-    inv<void>('0x5E94EA09E7207C16', this.handle);
+  isOwnedByPersistenceSystem(): any {
+    return inv<number>('0xA7E51B53309EAC97', this.handle);
   }
 
   /**
-   * @param p1 
+   * @param animDict 
+   * @param animName 
+   * @param animType 
    * @returns
    */
-  isInAir(p1: any): boolean {
-    return inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
+  isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
+    return inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
   }
 
   /**
-   * @returns
+   * Marks the specified entity (ped, vehicle or object) as no longer needed, allowing the game engine to delete it whenever it sees fit.
    */
-  isAMissionEntity(): boolean {
-    return inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
+  setAsNoLongerNeeded(): void {
+    inv<void>('0x4971D2F8162B9674', this.handle);
   }
 
   /**
    * @returns
    */
-  isAttachedToAnyPed(): boolean {
-    return inv<boolean>('0xC841153DED2CA89A', this.handle, rai());
+  hasBeenDamagedByAnyVehicle(): boolean {
+    return inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
   }
 
   /**
-   * @param to 
-   * @returns
+   * @param animDict 
+   * @param animName 
+   * @param speedMultiplier 
    */
-  isAttachedToEntity(to: Entity): boolean {
-    return inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
+  setAnimSpeed(animDict: string | null, animName: string | null, speedMultiplier: number): void {
+    inv<void>('0xEAA885BA3CEA4E4A', this.handle, animDict, animName, f(speedMultiplier));
   }
 
-  /**
-   * @returns
-   */
-  hasBeenDamagedByAnyObject(): boolean {
-    return inv<boolean>('0x73BB763880CD23A6', this.handle, rai());
+  unpinMapEntity(): void {
+    inv<void>('0xD2B9C78537ED5759', this.handle);
   }
 
   /**
-   * @param rotationOrder 
+   * Get how much of the entity is submerged. 1.0f is whole entity.
+   *
    * @returns
    */
-  getRotation(rotationOrder: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
+  getSubmergedLevel(): number {
+    return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setMotionBlur(toggle: boolean): void {
-    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
-  }
-
-  resetAlpha(): void {
-    inv<void>('0x744B9EF44779D9AB', this.handle);
+  isAttached(): boolean {
+    return inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
   }
 
   /**
-   * Checks if entity is within x/y/zSize distance of x/y/z. Last three are unknown ints, almost always p7 = 0, p8 = 1, p9 = 0
+   * SET_ENTITY_A*
    *
-   * @param pos 
-   * @param xSize 
-   * @param ySize 
-   * @param zSize 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @returns
+   * @param p1 
    */
-  isAtCoord(pos: Vector3, xSize: number, ySize: number, zSize: number, p7: boolean, p8: boolean, p9: number): boolean {
-    return inv<boolean>('0x5E58342602E94718', this.handle, f(pos.x), f(pos.y), f(pos.z), f(xSize), f(ySize), f(zSize), p7, p8, p9, rai());
+  N_0xC0EDEF16D90661EE(p1: number): void {
+    inv<void>('0xC0EDEF16D90661EE', this.handle, f(p1));
   }
 
   /**
-   * @returns
+   * @param looted 
    */
-  isUpsidedown(): boolean {
-    return inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
+  setFullyLooted(looted: boolean): void {
+    inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
   }
 
   /**
-   * @param p1 
    * @returns
    */
-  doesBelongToThisScript(p1: boolean): boolean {
-    return inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
+  isAttachedToAnyVehicle(): boolean {
+    return inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
   }
 
   /**
-   * Returns a hash of an entity's name. (Alternative Name: _GET_ENTITY_PROMPT_NAME_HASH)
+   * Used in Script Function DUELING_DID_PLAYER_DISARM_OPPONENT
    *
+   * @param entity2 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  getCarriableFromEntity(): number {
-    return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
+  N_0x3EC28DA1FFAC9DDD(entity2: Entity, p2: any, p3: any): boolean {
+    return inv<boolean>('0x3EC28DA1FFAC9DDD', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
-   * @param toggle 
-   * @param keepPhysics 
+   * Must be called from a background script, otherwise it will do nothing.
    */
-  setCollision(toggle: boolean, keepPhysics: boolean): void {
-    inv<void>('0xF66F820909453B8C', this.handle, toggle, keepPhysics);
+  delete2(): void {
+    inv<void>('0x5E94EA09E7207C16', this.handle);
   }
 
   /**
    * @param p1 
    * @returns
    */
-  placeOnGroundProperly(p1: boolean): any {
-    return inv<number>('0x9587913B9E772D29', this.handle, p1);
+  isInAir(p1: any): boolean {
+    return inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
   }
 
   /**
    * @returns
    */
-  isInWater(): boolean {
-    return inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
+  isAMissionEntity(): boolean {
+    return inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
   }
 
   /**
-   * @returns Returns `true` if the entity exists
+   * @returns
    */
-  doesExist(): boolean {
-    return inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
+  isAttachedToAnyPed(): boolean {
+    return inv<boolean>('0xC841153DED2CA89A', this.handle, rai());
   }
 
   /**
+   * @param to 
    * @returns
    */
-  getAlpha(): number {
-    return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
+  isAttachedToEntity(to: Entity): boolean {
+    return inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
   }
 
   /**
-   * This native only works on `Ped` and `Object` entity types
-   *
-   * @param flagId Refer to [enum: eCarryingFlags]
    * @returns
    */
-  getCarryingFlag(flagId: eCarryingFlags): number {
-    return inv<number>('0x808077647856DE62', this.handle, flagId, rai());
+  hasBeenDamagedByAnyObject(): boolean {
+    return inv<boolean>('0x73BB763880CD23A6', this.handle, rai());
   }
 
   /**
-   * @param p1 
+   * @param rotationOrder 
+   * @returns
    */
-  forceAiAndAnimationUpdate(p1: boolean): void {
-    inv<void>('0x4C9E96473D4F1A88', this.handle, p1);
+  getRotation(rotationOrder: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
   }
 
   /**
-   * Axis - Invert Axis Flags
-   *
-   * @param pos 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
+   * @param toggle 
    */
-  setCoordsNoOffset(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
-    inv<void>('0x239A3351AC1DA385', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis);
+  setMotionBlur(toggle: boolean): void {
+    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
+  }
+
+  resetAlpha(): void {
+    inv<void>('0x744B9EF44779D9AB', this.handle);
   }
 
   /**
-   * Returns (CUR_HEALTH / MAX_HEALTH)
+   * Checks if entity is within x/y/zSize distance of x/y/z. Last three are unknown ints, almost always p7 = 0, p8 = 1, p9 = 0
    *
+   * @param pos 
+   * @param xSize 
+   * @param ySize 
+   * @param zSize 
+   * @param p7 
+   * @param p8 
+   * @param p9 
    * @returns
    */
-  getHealthFloat(): number {
-    return inv<number>('0x96C638784DB4C815', this.handle, raf());
+  isAtCoord(pos: Vector3, xSize: number, ySize: number, zSize: number, p7: boolean, p8: boolean, p9: number): boolean {
+    return inv<boolean>('0x5E58342602E94718', this.handle, f(pos.x), f(pos.y), f(pos.z), f(xSize), f(ySize), f(zSize), p7, p8, p9, rai());
   }
 
   /**