@nativewrappers/redm-codegen 0.0.5 → 0.0.6

package/src/classes/Entity.ts

@@ -41,323 +41,285 @@ export class Entity implements IHandle {
   }
 
   /**
-   * @param pos 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
-   * @param clearArea 
+   * @param targetEntity 
+   * @returns
    */
-  setCoords(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean, clearArea: boolean): void {
-    inv<void>('0x06843DA7060A026B', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis, clearArea);
+  isTouchingEntity(targetEntity: Entity): boolean {
+    return !!inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
+  }
+
+  deleteCarriable(): void {
+    inv<void>('0x0D0DB2B6AF19A987', this.handle);
   }
 
   /**
-   * @param boneName 
+   * Returns a normalized value between 0.0f and 1.0f. You can get the actual anim time by multiplying this by GET_ANIM_DURATION
+   *
+   * @param animDict 
+   * @param animName 
    * @returns
    */
-  getBoneIndexByName(boneName: string | null): number {
-    return inv<number>('0xBACA8FE9C76C124E', this.handle, boneName, rai());
+  getAnimCurrentTime(animDict: string | null, animName: string | null): number {
+    return inv<number>('0x627520389E288A73', this.handle, animDict, animName, raf());
   }
 
   /**
-   * @param pause 
+   * @param entity2 
+   * @param thisFrameOnly 
    */
-  pauseTracking(pause: boolean): void {
-    inv<void>('0x36EB4D34D4A092C5', this.handle, pause);
+  setNoCollisionEntity(entity2: Entity, thisFrameOnly: boolean): void {
+    inv<void>('0xE037BF068223C38D', this.handle, entity2.handle, thisFrameOnly);
   }
 
   /**
-   * @param toggle 
+   * Result is in meters per second (m/s)
+   *
+   * @returns
    */
-  set LoadCollisionFlag(toggle: boolean) {
-    inv<void>('0x9B9EE31AED48072E', this.handle, toggle);
+  get Speed(): number {
+    return inv<number>('0xFB6BA510A533DF81', this.handle, raf());
   }
 
   /**
-   * Changes type and quality of skins
-   * type hashes: https://pastebin.com/C1WvQjCy
-   *
-   * @param type 
+   * @param bOnlyDamagedWhenRunningScript 
    */
-  set CarcassType(type: string | number) {
-    inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
+  set CanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean) {
+    inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  set HasGravity(toggle: boolean) {
-    inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
+  get IsTrackedVisible(): any {
+    return inv<number>('0xC8CCDB712FBCBA92', this.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param collision 
+   */
+  detachEntity(p1: boolean, collision: boolean): void {
+    inv<void>('0x64CDE9D6BF8ECAD3', this.handle, p1, collision);
   }
 
   /**
-   * @param relative 
    * @returns
    */
-  getSpeedVector(relative: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xF2DB09816A419DC5', this.handle, relative, rav()));
+  get IsVisibleToScript(): boolean {
+    return !!inv<boolean>('0xF213C724E77F321A', this.handle, rai());
   }
 
   /**
    * @param entity2 
-   * @param p2 
-   * @param p3 
+   * @param traceType 
    * @returns
    */
-  hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
-    return !!inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
+  hasClearLosToEntity(entity2: Entity, traceType: number): boolean {
+    return !!inv<boolean>('0xFCDFF7B72D23A1AC', this.handle, entity2.handle, traceType, rai());
   }
 
   /**
+   * Used in Script Function GENERIC_ITEM_HAS_ANIM_COMPLETED
+   * *GET_ENTITY**
+   *
+   * @param animDict 
+   * @param animClip 
    * @returns
    */
-  get IsFullyLooted(): any {
-    return inv<number>('0x8DE41E9902E85756', this.handle);
+  N_0x8E46E18AA828334F(animDict: string | null, animClip: string | null): number {
+    return inv<number>('0x8E46E18AA828334F', this.handle, animDict, animClip, raf());
   }
 
   /**
+   * @param playerPedToIgnore 
+   * @param flags 
    * @returns
    */
-  get IsOccluded(): boolean {
-    return !!inv<boolean>('0x140188E884645624', this.handle, rai());
+  getNearestPlayerToEntity(playerPedToIgnore: Ped, flags: number): Player | null {
+    return createFromHandle<Player>('Player', inv<number>('0x990E294FC387FB88', this.handle, playerPedToIgnore.handle, flags, rai()));
   }
 
   /**
-   * @param toggle 
+   * Gets the Y-component of the entity's forward vector.
+   *
+   * @returns
    */
-  set CanBeDamaged(toggle: boolean) {
-    inv<void>('0x0D06D522B90E861F', this.handle, toggle);
+  get ForwardY(): number {
+    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
   }
 
   /**
-   * @param forceFlags 
-   * @param pos 
-   * @param offset 
-   * @param boneIndex 
-   * @param isDirectionRel 
-   * @param ignoreUpVec 
-   * @param isForceRel 
-   * @param p12 
-   * @param p13 
+   * @param pitch 
+   * @param roll 
+   * @param yaw 
+   * @param rotationOrder 
+   * @param p5 
    */
-  applyForceToEntity(forceFlags: number, pos: Vector3, offset: Vector3, boneIndex: number, isDirectionRel: boolean, ignoreUpVec: boolean, isForceRel: boolean, p12: boolean, p13: boolean): void {
-    inv<void>('0xF15E8F5D333F09C4', this.handle, forceFlags, f(pos.x), f(pos.y), f(pos.z), f(offset.x), f(offset.y), f(offset.z), boneIndex, isDirectionRel, ignoreUpVec, isForceRel, p12, p13);
+  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);
   }
 
   /**
-   * @returns
+   * @param p1 
+   * @param relationshipGroup 
    */
-  get IsDead(): boolean {
-    return !!inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
+  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);
   }
 
   /**
-   * @param pos1 
-   * @param pos2 
-   * @param p7 
-   * @param p8 
-   * @param p9 
    * @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());
+  hasCollisionLoadedAroundEntity(): boolean {
+    return !!inv<boolean>('0xBEB1600952B9CF5C', this.handle, rai());
   }
 
   /**
-   * Returns the coordinates of an entity-bone.
-   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
-   *
-   * @param boneIndex 
    * @returns
    */
-  getWorldPositionOfBone(boneIndex: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x82CFA50E34681CA5', this.handle, boneIndex, rav()));
+  get IsCarriablePelt(): any {
+    return inv<number>('0x255B6DB4E3AD3C3E', this.handle);
   }
 
   /**
-   * https://github.com/femga/rdr3_discoveries/tree/master/animations
-   *
-   * @param animName 
-   * @param animDict 
-   * @param p3 
-   * @param loop 
-   * @param stayInAnim 
-   * @param p6 
-   * @param delta 
-   * @param bitset 
+   * @param p1 
    * @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());
+  getVelocity(p1: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x4805D2B1D8CF94A9', this.handle, p1, rav()));
   }
 
   /**
-   * Returns false if entity is not a ped or object.
-   *
-   * @returns lootTable
+   * @param toggle 
    */
-  get ScriptOverrideLootTablePermanent(): [any, number] {
-    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
-    return [result[0], result[1]];
+  set CanAutoVaultOnEntity(toggle: boolean) {
+    inv<void>('0x80646744FA88F9D7', this.handle, toggle);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param p3 
+   * 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
    */
-  hasAnimFinished(animDict: string | null, animName: string | null, p3: number): boolean {
-    return !!inv<boolean>('0xAEB40615337EF1E3', this.handle, animDict, animName, p3, rai());
+  scriptOverrideLootTablePermanent(lootTable: string | number): any {
+    return inv<number>('0x8C03CD6B5E0E85E8', this.handle, _h(lootTable));
   }
 
   /**
-   * @param bCanBeDamaged 
-   * @param relGroup 
+   * @returns argStruct
    */
-  setCanBeDamagedByRelationshipGroup(bCanBeDamaged: boolean, relGroup: string | number): void {
-    inv<void>('0x0EF1AFB18649E015', this.handle, bCanBeDamaged, _h(relGroup));
+  get Script(): [number, number] {
+    const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
+    return [result[0] & 0xFFFFFFFF, result[1]];
   }
 
   /**
+   * @param actionHash 
    * @returns
    */
-  get UprightValue(): number {
-    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
+  hasAnimEventFired(actionHash: string | number): boolean {
+    return !!inv<boolean>('0x5851CC48405F4A07', this.handle, _h(actionHash), rai());
   }
 
   /**
-   * @param pos 
-   * @param heading 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
+   * @param p1 
    */
-  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);
+  N_0xEF259AA1E097E0AD(p1: any): void {
+    inv<void>('0xEF259AA1E097E0AD', this.handle, p1);
   }
 
   /**
-   * Returns zero if the entity is not a carriable
+   * Getter for FREEZE_ENTITY_POSITION
    *
    * @returns
    */
-  get CarryConfig(): number {
-    return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
+  get IsFrozen(): any {
+    return inv<number>('0x083D497D57B7400F', this.handle);
   }
 
   /**
-   * tier: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityThreatTier
+   * Returns the entity that is looting a ped but only while the looting is active
    *
-   * @param tier 
-   * @param p2 
+   * @returns
    */
-  setThreatTier(tier: number, p2: boolean): void {
-    inv<void>('0x4B436BAC8CBE9B07', this.handle, tier, p2);
+  get LootingPed(): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
   }
 
   /**
-   * Returns the heading of the entity in degrees. Also know as the "Yaw" of an entity.
-   *
    * @returns
    */
-  get Heading(): number {
-    return inv<number>('0xC230DD956E2F5507', this.handle, raf());
+  get IsWaitingForWorldCollision(): boolean {
+    return !!inv<boolean>('0x5E1CC2E8DC3111DD', this.handle, rai());
   }
 
   /**
-   * Returns the LOD distance of an entity.
+   * Gets the X-component of the entity's forward vector.
    *
    * @returns
    */
-  get LodDist(): number {
-    return inv<number>('0xDF240D0C2A948683', this.handle, rai());
+  get ForwardX(): number {
+    return inv<number>('0xDB0954E9960F6457', this.handle, raf());
   }
 
   /**
    * @returns
    */
-  doesHaveDrawable(): boolean {
-    return !!inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
+  get IsAPed(): boolean {
+    return !!inv<boolean>('0xCF8176912DDA4EA5', this.handle, rai());
   }
 
   /**
-   * @param xyzw 
+   * @returns
    */
-  set Quaternion(xyzw: Vector4) {
-    inv<void>('0x100E7007D13E3687', this.handle, f(xyzw.x), f(xyzw.y), f(xyzw.z), f(xyzw.w));
+  get Pitch(): number {
+    return inv<number>('0xEF355ABEFF7F5005', this.handle, raf());
   }
 
   /**
    * @returns
    */
-  get IsAttachedToAnyObject(): boolean {
-    return !!inv<boolean>('0x306C1F6178F01AB3', this.handle, rai());
+  get IsStatic(): boolean {
+    return !!inv<boolean>('0x86468ADFA0F6B861', this.handle, rai());
   }
 
   /**
-   * Sets a ped or an object totally invincible. It doesn't take any kind of damage. Peds will not ragdoll on explosions.
+   * Returns the model hash from the entity
    *
-   * @param toggle 
+   * @returns
    */
-  set Invincible(toggle: boolean) {
-    inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
-  }
-
-  /**
-   * Attaches entity1 to bone (boneIndex) of entity2. boneIndex - this is different to boneID, use GET_PED_BONE_INDEX to get the index from the ID. use the index for attaching to specific bones. entity1 will be attached to entity2's centre if bone index given doesn't correspond to bone indexes for that entity type.
-   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames useSoftPinning - if set to false attached entity will not detach when fixed
-   * collision - controls collision between the two entities (FALSE disables collision).
-   * isPed - pitch doesn't work when false and roll will only work on negative numbers (only peds)
-   * vertexIndex - position of vertex
-   * fixedRot - if false it ignores entity vector
-   *
-   * @param entity2 
-   * @param boneIndex 
-   * @param pos 
-   * @param rot 
-   * @param p9 
-   * @param useSoftPinning 
-   * @param collision 
-   * @param isPed 
-   * @param vertexIndex 
-   * @param fixedRot 
-   * @param p15 
-   * @param p16 
-   */
-  attachToEntity(entity2: Entity, boneIndex: number, pos: Vector3, rot: Vector3, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean, p15: boolean, p16: boolean): void {
-    inv<void>('0x6B9BBD38AB0796DF', this.handle, entity2.handle, boneIndex, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot, p15, p16);
-  }
-
-  /**
-   * @returns
-   */
-  get IsAnimal(): any {
-    return inv<number>('0x9A100F1CF4546629', this.handle);
+  get Model(): number {
+    return (inv<number>('0xDA76A9F39210D365', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * p6/relative - makes the xyz force not relative to world coords, but to something else
-   * p7/highForce - setting false will make the force really low
-   *
-   * @param forceType 
-   * @param pos 
-   * @param component 
-   * @param isDirectionRel 
-   * @param isForceRel 
-   * @param p8 
+   * Deletes the specified entity, then sets the handle pointed to by the pointer to NULL.
    */
-  applyForceToCenterOfMass(forceType: number, pos: Vector3, component: number, isDirectionRel: boolean, isForceRel: boolean, p8: boolean): void {
-    inv<void>('0x31DA7CEC5334DB37', this.handle, forceType, f(pos.x), f(pos.y), f(pos.z), component, isDirectionRel, isForceRel, p8);
+  deleteEntity(): void {
+    inv<void>('0x4CD38C78BD19A497', this.handle);
   }
 
   /**
-   * Old name: _GET_ENTITY_CAN_BE_DAMAGED
-   *
+   * @param team 
+   * @param playerPedToIgnore 
+   * @param flags 
    * @returns
    */
-  get CanBeDamaged(): any {
-    return inv<number>('0x75DF9E73F2F005FD', this.handle);
+  getNearestPlayerToOnTeam(team: number, playerPedToIgnore: Ped, flags: number): Player | null {
+    return createFromHandle<Player>('Player', inv<number>('0xB2C30C3B4AFF718C', this.handle, team, playerPedToIgnore.handle, flags, rai()));
   }
 
   /**
@@ -443,95 +405,211 @@ export class Entity implements IHandle {
   }
 
   /**
-   * Returns entityType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityType
+   * enum eCarriableState
+   * {
+   * CARRIABLE_STATE_NONE,
+   * CARRIABLE_STATE_TRANSITIONING_TO_HOGTIED,
+   * CARRIABLE_STATE_CARRIABLE_INTRO,
+   * CARRIABLE_STATE_CARRIABLE,
+   * CARRIABLE_STATE_BEING_PICKED_UP_FROM_GROUND,
+   * CARRIABLE_STATE_CARRIED_BY_HUMAN,
+   * CARRIABLE_STATE_BEING_PLACED_ON_GROUND,
+   * CARRIABLE_STATE_CARRIED_BY_MOUNT,
+   * CARRIABLE_STATE_BEING_PLACED_ON_MOUNT,
+   * CARRIABLE_STATE_BEING_PICKED_UP_FROM_MOUNT,
+   * CARRIABLE_STATE_BEING_CUT_FREE,
+   * CARRIABLE_STATE_BEING_PLACED_ON_GROUND_ESCAPE,
+   * CARRIABLE_STATE_BEING_PLACED_IN_VEHICLE
+   * };
    *
    * @returns
    */
-  get Type(): number {
-    return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
+  get CarriableState(): number {
+    return inv<number>('0x61914209C36EFDDB', this.handle, rai());
   }
 
   /**
-   * @returns
+   * @param value 
    */
-  get IsOwnedByPersistenceSystem(): any {
-    return inv<number>('0xA7E51B53309EAC97', this.handle);
+  set MaxHealth(value: number) {
+    inv<void>('0x166E7CF68597D8B5', this.handle, value);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param animType 
+   * Params: p1 (probably animType) = 1, 0
+   *
+   * @param p1 
    * @returns
    */
-  isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
-    return !!inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
+  isPlayingAnyAnim(p1: number): boolean {
+    return !!inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
   }
 
   /**
-   * Marks the specified entity (ped, vehicle or object) as no longer needed, allowing the game engine to delete it whenever it sees fit.
+   * @param enabled 
    */
-  setAsNoLongerNeeded(): void {
-    inv<void>('0x4971D2F8162B9674', this.handle);
+  set LightsEnabled(enabled: boolean) {
+    inv<void>('0xEBDC12861D079ABA', this.handle, enabled);
   }
 
   /**
+   * Offset values are relative to the entity. x = left/right
+   * y = forward/backward
+   * z = up/down
+   *
+   * @param offset 
    * @returns
    */
-  hasBeenDamagedByAnyVehicle(): boolean {
-    return !!inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
+  getOffsetFromInWorldCoords(offset: Vector3): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x1899F328B0E12848', this.handle, f(offset.x), f(offset.y), f(offset.z), rav()));
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param speedMultiplier 
+   * Checks if entity1 is within the box defined by x/y/zSize of entity2. Last three parameters are almost always p5 = 0, p6 = 1, p7 = 0
+   *
+   * @param entity2 
+   * @param xSize 
+   * @param ySize 
+   * @param zSize 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @returns
    */
-  setAnimSpeed(animDict: string | null, animName: string | null, speedMultiplier: number): void {
-    inv<void>('0xEAA885BA3CEA4E4A', this.handle, animDict, animName, f(speedMultiplier));
+  isAtEntity(entity2: Entity, xSize: number, ySize: number, zSize: number, p5: boolean, p6: boolean, p7: number): boolean {
+    return !!inv<boolean>('0xC057F02B837A27F6', this.handle, entity2.handle, f(xSize), f(ySize), f(zSize), p5, p6, p7, rai());
   }
 
-  unpinMapEntity(): void {
-    inv<void>('0xD2B9C78537ED5759', this.handle);
+  /**
+   * @param toggle 
+   */
+  set Visible(toggle: boolean) {
+    inv<void>('0x1794B4FCC84D812F', this.handle, toggle);
   }
 
   /**
-   * Get how much of the entity is submerged. 1.0f is whole entity.
+   * Old name: _SET_ENTITY_CLEANUP_BY_ENGINE
    *
-   * @returns
+   * @param toggle 
    */
-  get SubmergedLevel(): number {
-    return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
+  set ShouldFreezeWaitingOnCollision(toggle: boolean) {
+    inv<void>('0x740CB4F3F602C9F4', this.handle, toggle);
   }
 
   /**
+   * Note: this native was removed in 1232 but added back in 1311
+   * Old name: _GET_ENTITY_PROOFS
+   *
    * @returns
    */
-  get IsAttached(): boolean {
-    return !!inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
+  get Proofs(): number {
+    return inv<number>('0x6CF0DAD7FA1088EA', this.handle, rai());
   }
 
   /**
-   * SET_ENTITY_A*
+   * skin - everything alpha except skin
+   * Set entity alpha level. Ranging from 0 to 255 but changes occur after every 20 percent (after every 51).
    *
+   * @param alphaLevel 
+   * @param skin 
+   */
+  setAlpha(alphaLevel: number, skin: boolean): void {
+    inv<void>('0x0DF7692B1D9E7BA7', this.handle, alphaLevel, skin);
+  }
+
+  /**
+   * @returns
+   */
+  get ThreatTier(): number {
+    return inv<number>('0xE12F56CB25D9CE23', this.handle, rai());
+  }
+
+  /**
    * @param p1 
    */
-  N_0xC0EDEF16D90661EE(p1: number): void {
-    inv<void>('0xC0EDEF16D90661EE', this.handle, f(p1));
+  N_0xA48E4801DEBDF7E4(p1: boolean): void {
+    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
   }
 
   /**
-   * @param looted 
+   * @param toggle 
+   * @param keepPhysics 
    */
-  set FullyLooted(looted: boolean) {
-    inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
+  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
   }
 
   /**
+   * @param p1 
+   */
+  N_0xCDB682BB47C02F0A(p1: string | number): void {
+    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
+  }
+
+  /**
+   * @param volume 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  get IsAttachedToAnyVehicle(): boolean {
-    return !!inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
+  isInVolume(volume: number, p2: boolean, p3: number): boolean {
+    return !!inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
+  }
+
+  /**
+   * @returns rightVector; forwardVector; upVector; position
+   */
+  get Matrix(): [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])];
+  }
+
+  /**
+   * 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.
+   */
+  N_0x371D179701D9C082(): void {
+    inv<void>('0x371D179701D9C082', this.handle);
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  getMaxHealth(p1: boolean): number {
+    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
+  }
+
+  /**
+   * @param animDict 
+   * @param animName 
+   * @param time 
+   */
+  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
+    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
+  }
+
+  /**
+   * 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 alive 
+   * @param realCoords 
+   * @returns
+   */
+  getCoords(alive?: boolean, realCoords?: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
+  }
+
+  get Coords(): Vector3 {
+    return this.getCoords();
+  }
+
+  /**
+   * @returns
+   */
+  get IsAnObject(): boolean {
+    return !!inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
   }
 
   /**
@@ -554,75 +632,174 @@ export class Entity implements IHandle {
   }
 
   /**
-   * @param p1 
+   * @param p1 
+   * @returns
+   */
+  isInAir(p1: any): boolean {
+    return !!inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
+  }
+
+  /**
+   * @returns
+   */
+  get IsAMissionEntity(): boolean {
+    return !!inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  get IsAttachedToAnyPed(): boolean {
+    return !!inv<boolean>('0xC841153DED2CA89A', this.handle, rai());
+  }
+
+  /**
+   * @param to 
+   * @returns
+   */
+  isAttachedToEntity(to: Entity): boolean {
+    return !!inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  hasBeenDamagedByAnyObject(): boolean {
+    return !!inv<boolean>('0x73BB763880CD23A6', this.handle, rai());
+  }
+
+  /**
+   * @param rotationOrder 
+   * @returns
+   */
+  getRotation(rotationOrder: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
+  }
+
+  /**
+   * @param toggle 
+   */
+  set MotionBlur(toggle: boolean) {
+    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
+  }
+
+  resetAlpha(): void {
+    inv<void>('0x744B9EF44779D9AB', this.handle);
+  }
+
+  /**
+   * 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
+   */
+  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());
+  }
+
+  /**
+   * LOD distance can be 0 to 0xFFFF (higher values will result in 0xFFFF) as it is actually stored as a 16-bit value (aka uint16_t).
+   *
+   * @param value 
+   */
+  set LodDist(value: number) {
+    inv<void>('0x5FB407F0A7C877BF', this.handle, value);
+  }
+
+  /**
+   * @param toggle 
+   */
+  set Dynamic(toggle: boolean) {
+    inv<void>('0xFBFC4473F66CE344', this.handle, toggle);
+  }
+
+  /**
+   * @param radius 
+   */
+  set CustomPickupRadius(radius: number) {
+    inv<void>('0x482D17E45665DA44', this.handle, f(radius));
+  }
+
+  /**
+   * @returns
+   */
+  get PopulationType(): number {
+    return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
+  }
+
+  /**
    * @returns
    */
-  isInAir(p1: any): boolean {
-    return !!inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
+  get IsAVehicle(): boolean {
+    return !!inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
   }
 
   /**
+   * @param pos 
+   * @param atTop 
+   * @param inWorldCoords 
    * @returns
    */
-  get IsAMissionEntity(): boolean {
-    return !!inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
+  getHeight(pos: Vector3, atTop: boolean, inWorldCoords: boolean): number {
+    return inv<number>('0x296DEBC84474B375', this.handle, f(pos.x), f(pos.y), f(pos.z), atTop, inWorldCoords, raf());
   }
 
   /**
+   * @param pos 
    * @returns
    */
-  get IsAttachedToAnyPed(): boolean {
-    return !!inv<boolean>('0xC841153DED2CA89A', this.handle, rai());
+  getOffsetFromGivenWorldCoords(pos: Vector3): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x497C6B1A2C9AE69C', this.handle, f(pos.x), f(pos.y), f(pos.z), rav()));
+  }
+
+  addTrackingTrails(): void {
+    inv<void>('0x1AD922AB5038DEF3', this.handle);
   }
 
   /**
-   * @param to 
-   * @returns
+   * @param toggle 
    */
-  isAttachedToEntity(to: Entity): boolean {
-    return !!inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
+  set CanClimbOnEntity(toggle: boolean) {
+    inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
   }
 
   /**
-   * @returns
+   * @returns minimum; maximum
    */
-  hasBeenDamagedByAnyObject(): boolean {
-    return !!inv<boolean>('0x73BB763880CD23A6', this.handle, rai());
+  get WorldPositionOfDimensions(): [Vector3, Vector3] {
+    const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
+    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
   }
 
   /**
-   * @param rotationOrder 
+   * @param p1 
    * @returns
    */
-  getRotation(rotationOrder: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
+  isUnderwater(p1: boolean): any {
+    return inv<number>('0xD4E5C1E93C466127', this.handle, p1);
   }
 
   /**
-   * @param toggle 
+   * @param animation 
+   * @param animGroup 
+   * @param p3 
+   * @returns
    */
-  set MotionBlur(toggle: boolean) {
-    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
-  }
-
-  resetAlpha(): void {
-    inv<void>('0x744B9EF44779D9AB', this.handle);
+  stopAnim(animation: string | null, animGroup: string | null, p3: number): any {
+    return inv<number>('0x786591D986DE9159', this.handle, animation, animGroup, f(p3));
   }
 
   /**
-   * 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
    */
-  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());
+  hasCollidedWithAnything(): boolean {
+    return !!inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
   }
 
   /**
@@ -760,285 +937,371 @@ export class Entity implements IHandle {
   }
 
   /**
-   * @param targetEntity 
+   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
+   *
    * @returns
    */
-  isTouchingEntity(targetEntity: Entity): boolean {
-    return !!inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
+  get VehicleIndexFromIndex(): Vehicle | null {
+    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
   }
 
-  deleteCarriable(): void {
-    inv<void>('0x0D0DB2B6AF19A987', this.handle);
+  /**
+   * @returns
+   */
+  get IsVisible(): boolean {
+    return !!inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
   }
 
   /**
-   * Returns a normalized value between 0.0f and 1.0f. You can get the actual anim time by multiplying this by GET_ANIM_DURATION
+   * SET_ENTITY_LO*
    *
-   * @param animDict 
-   * @param animName 
-   * @returns
+   * @param toggle 
    */
-  getAnimCurrentTime(animDict: string | null, animName: string | null): number {
-    return inv<number>('0x627520389E288A73', this.handle, animDict, animName, raf());
+  N_0xFF9965C47FA404DA(toggle: boolean): void {
+    inv<void>('0xFF9965C47FA404DA', this.handle, toggle);
   }
 
   /**
-   * @param entity2 
-   * @param thisFrameOnly 
+   * Valid indices: 0 - 3
+   * Index 1 always returns a `hogtied` config, doesn't matter the entity.
+   * It's for humans only and the ped must be resurrected first if it's dead.
+   *
+   * @param index 
+   * @returns
    */
-  setNoCollisionEntity(entity2: Entity, thisFrameOnly: boolean): void {
-    inv<void>('0xE037BF068223C38D', this.handle, entity2.handle, thisFrameOnly);
+  getOptimalCarryConfig(index: number): number {
+    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
+  }
+
+  setFadeIn(): void {
+    inv<void>('0xA91E6CF94404E8C9', this.handle);
   }
 
   /**
-   * Result is in meters per second (m/s)
-   *
    * @returns
    */
-  get Speed(): number {
-    return inv<number>('0xFB6BA510A533DF81', this.handle, raf());
+  hasBeenDamagedByAnyPed(): boolean {
+    return !!inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
   }
 
   /**
-   * @param bOnlyDamagedWhenRunningScript 
+   * @param pos 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
+   * @param clearArea 
    */
-  set CanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean) {
-    inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
+  setCoords(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean, clearArea: boolean): void {
+    inv<void>('0x06843DA7060A026B', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis, clearArea);
   }
 
   /**
+   * @param boneName 
    * @returns
    */
-  get IsTrackedVisible(): any {
-    return inv<number>('0xC8CCDB712FBCBA92', this.handle);
+  getBoneIndexByName(boneName: string | null): number {
+    return inv<number>('0xBACA8FE9C76C124E', this.handle, boneName, rai());
   }
 
   /**
-   * @param p1 
-   * @param collision 
+   * @param pause 
    */
-  detachEntity(p1: boolean, collision: boolean): void {
-    inv<void>('0x64CDE9D6BF8ECAD3', this.handle, p1, collision);
+  pauseTracking(pause: boolean): void {
+    inv<void>('0x36EB4D34D4A092C5', this.handle, pause);
+  }
+
+  /**
+   * @param toggle 
+   */
+  set LoadCollisionFlag(toggle: boolean) {
+    inv<void>('0x9B9EE31AED48072E', this.handle, toggle);
+  }
+
+  /**
+   * Changes type and quality of skins
+   * type hashes: https://pastebin.com/C1WvQjCy
+   *
+   * @param type 
+   */
+  set CarcassType(type: string | number) {
+    inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
   }
 
   /**
+   * @param toggle 
+   */
+  set HasGravity(toggle: boolean) {
+    inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
+  }
+
+  /**
+   * @param relative 
    * @returns
    */
-  get IsVisibleToScript(): boolean {
-    return !!inv<boolean>('0xF213C724E77F321A', this.handle, rai());
+  getSpeedVector(relative: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xF2DB09816A419DC5', this.handle, relative, rav()));
   }
 
   /**
    * @param entity2 
-   * @param traceType 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  hasClearLosToEntity(entity2: Entity, traceType: number): boolean {
-    return !!inv<boolean>('0xFCDFF7B72D23A1AC', this.handle, entity2.handle, traceType, rai());
+  hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
+    return !!inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
-   * Used in Script Function GENERIC_ITEM_HAS_ANIM_COMPLETED
-   * *GET_ENTITY**
-   *
-   * @param animDict 
-   * @param animClip 
    * @returns
    */
-  N_0x8E46E18AA828334F(animDict: string | null, animClip: string | null): number {
-    return inv<number>('0x8E46E18AA828334F', this.handle, animDict, animClip, raf());
+  get IsFullyLooted(): any {
+    return inv<number>('0x8DE41E9902E85756', this.handle);
   }
 
   /**
-   * @param playerPedToIgnore 
-   * @param flags 
    * @returns
    */
-  getNearestPlayerToEntity(playerPedToIgnore: Ped, flags: number): Player | null {
-    return createFromHandle<Player>('Player', inv<number>('0x990E294FC387FB88', this.handle, playerPedToIgnore.handle, flags, rai()));
+  get IsOccluded(): boolean {
+    return !!inv<boolean>('0x140188E884645624', this.handle, rai());
   }
 
   /**
-   * Gets the Y-component of the entity's forward vector.
-   *
-   * @returns
+   * @param toggle 
    */
-  get ForwardY(): number {
-    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
+  set CanBeDamaged(toggle: boolean) {
+    inv<void>('0x0D06D522B90E861F', this.handle, toggle);
   }
 
   /**
-   * @param pitch 
-   * @param roll 
-   * @param yaw 
-   * @param rotationOrder 
-   * @param p5 
+   * @param forceFlags 
+   * @param pos 
+   * @param offset 
+   * @param boneIndex 
+   * @param isDirectionRel 
+   * @param ignoreUpVec 
+   * @param isForceRel 
+   * @param p12 
+   * @param p13 
    */
-  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);
+  applyForceToEntity(forceFlags: number, pos: Vector3, offset: Vector3, boneIndex: number, isDirectionRel: boolean, ignoreUpVec: boolean, isForceRel: boolean, p12: boolean, p13: boolean): void {
+    inv<void>('0xF15E8F5D333F09C4', this.handle, forceFlags, f(pos.x), f(pos.y), f(pos.z), f(offset.x), f(offset.y), f(offset.z), boneIndex, isDirectionRel, ignoreUpVec, isForceRel, p12, p13);
   }
 
   /**
-   * @param p1 
-   * @param relationshipGroup 
+   * @returns
    */
-  setOnlyDamagedByRelationshipGroup(p1: boolean, relationshipGroup: string | number): void {
-    inv<void>('0x6C1F6AA2F0ADD104', this.handle, p1, _h(relationshipGroup));
+  get IsDead(): boolean {
+    return !!inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
   }
 
   /**
-   * 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 pos1 
+   * @param pos2 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @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());
+  }
+
+  /**
+   * Returns the coordinates of an entity-bone.
+   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
    *
-   * @param proofsBitset 
-   * @param specialFlag 
+   * @param boneIndex 
+   * @returns
    */
-  setProofs(proofsBitset: number, specialFlag: boolean): void {
-    inv<void>('0xFAEE099C6F890BB8', this.handle, proofsBitset, specialFlag);
+  getWorldPositionOfBone(boneIndex: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x82CFA50E34681CA5', this.handle, boneIndex, rav()));
   }
 
   /**
+   * https://github.com/femga/rdr3_discoveries/tree/master/animations
+   *
+   * @param animName 
+   * @param animDict 
+   * @param p3 
+   * @param loop 
+   * @param stayInAnim 
+   * @param p6 
+   * @param delta 
+   * @param bitset 
    * @returns
    */
-  hasCollisionLoadedAroundEntity(): boolean {
-    return !!inv<boolean>('0xBEB1600952B9CF5C', this.handle, rai());
+  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());
   }
 
   /**
-   * @returns
+   * Returns false if entity is not a ped or object.
+   *
+   * @returns lootTable
    */
-  get IsCarriablePelt(): any {
-    return inv<number>('0x255B6DB4E3AD3C3E', this.handle);
+  get ScriptOverrideLootTablePermanent(): [any, number] {
+    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
+    return [result[0], result[1]];
   }
 
   /**
-   * @param p1 
+   * @param animDict 
+   * @param animName 
+   * @param p3 
    * @returns
    */
-  getVelocity(p1: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x4805D2B1D8CF94A9', this.handle, p1, rav()));
+  hasAnimFinished(animDict: string | null, animName: string | null, p3: number): boolean {
+    return !!inv<boolean>('0xAEB40615337EF1E3', this.handle, animDict, animName, p3, rai());
   }
 
   /**
-   * @param toggle 
+   * @param bCanBeDamaged 
+   * @param relGroup 
    */
-  set CanAutoVaultOnEntity(toggle: boolean) {
-    inv<void>('0x80646744FA88F9D7', this.handle, toggle);
+  setCanBeDamagedByRelationshipGroup(bCanBeDamaged: boolean, relGroup: string | number): void {
+    inv<void>('0x0EF1AFB18649E015', this.handle, bCanBeDamaged, _h(relGroup));
   }
 
   /**
-   * 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));
+  get UprightValue(): number {
+    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
   }
 
   /**
-   * @returns argStruct
+   * @param pos 
+   * @param heading 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
    */
-  get Script(): [number, number] {
-    const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
-    return [result[0] & 0xFFFFFFFF, result[1]];
+  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);
   }
 
   /**
-   * @param actionHash 
+   * Returns zero if the entity is not a carriable
+   *
    * @returns
    */
-  hasAnimEventFired(actionHash: string | number): boolean {
-    return !!inv<boolean>('0x5851CC48405F4A07', this.handle, _h(actionHash), rai());
+  get CarryConfig(): number {
+    return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * @param p1 
+   * tier: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityThreatTier
+   *
+   * @param tier 
+   * @param p2 
    */
-  N_0xEF259AA1E097E0AD(p1: any): void {
-    inv<void>('0xEF259AA1E097E0AD', this.handle, p1);
+  setThreatTier(tier: number, p2: boolean): void {
+    inv<void>('0x4B436BAC8CBE9B07', this.handle, tier, p2);
   }
 
   /**
-   * Getter for FREEZE_ENTITY_POSITION
+   * Returns the heading of the entity in degrees. Also know as the "Yaw" of an entity.
    *
    * @returns
    */
-  get IsFrozen(): any {
-    return inv<number>('0x083D497D57B7400F', this.handle);
+  get Heading(): number {
+    return inv<number>('0xC230DD956E2F5507', this.handle, raf());
   }
 
   /**
-   * Returns the entity that is looting a ped but only while the looting is active
+   * Returns the LOD distance of an entity.
    *
    * @returns
    */
-  get LootingPed(): Ped | null {
-    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
+  get LodDist(): number {
+    return inv<number>('0xDF240D0C2A948683', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  get IsWaitingForWorldCollision(): boolean {
-    return !!inv<boolean>('0x5E1CC2E8DC3111DD', this.handle, rai());
+  doesHaveDrawable(): boolean {
+    return !!inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
   }
 
   /**
-   * Gets the X-component of the entity's forward vector.
-   *
-   * @returns
+   * @param xyzw 
    */
-  get ForwardX(): number {
-    return inv<number>('0xDB0954E9960F6457', this.handle, raf());
+  set Quaternion(xyzw: Vector4) {
+    inv<void>('0x100E7007D13E3687', this.handle, f(xyzw.x), f(xyzw.y), f(xyzw.z), f(xyzw.w));
   }
 
   /**
    * @returns
    */
-  get IsAPed(): boolean {
-    return !!inv<boolean>('0xCF8176912DDA4EA5', this.handle, rai());
+  get IsAttachedToAnyObject(): boolean {
+    return !!inv<boolean>('0x306C1F6178F01AB3', this.handle, rai());
   }
 
   /**
-   * @returns
+   * Sets a ped or an object totally invincible. It doesn't take any kind of damage. Peds will not ragdoll on explosions.
+   *
+   * @param toggle 
    */
-  get Pitch(): number {
-    return inv<number>('0xEF355ABEFF7F5005', this.handle, raf());
+  set Invincible(toggle: boolean) {
+    inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
   }
 
   /**
-   * @returns
+   * Attaches entity1 to bone (boneIndex) of entity2. boneIndex - this is different to boneID, use GET_PED_BONE_INDEX to get the index from the ID. use the index for attaching to specific bones. entity1 will be attached to entity2's centre if bone index given doesn't correspond to bone indexes for that entity type.
+   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames useSoftPinning - if set to false attached entity will not detach when fixed
+   * collision - controls collision between the two entities (FALSE disables collision).
+   * isPed - pitch doesn't work when false and roll will only work on negative numbers (only peds)
+   * vertexIndex - position of vertex
+   * fixedRot - if false it ignores entity vector
+   *
+   * @param entity2 
+   * @param boneIndex 
+   * @param pos 
+   * @param rot 
+   * @param p9 
+   * @param useSoftPinning 
+   * @param collision 
+   * @param isPed 
+   * @param vertexIndex 
+   * @param fixedRot 
+   * @param p15 
+   * @param p16 
    */
-  get IsStatic(): boolean {
-    return !!inv<boolean>('0x86468ADFA0F6B861', this.handle, rai());
+  attachToEntity(entity2: Entity, boneIndex: number, pos: Vector3, rot: Vector3, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean, p15: boolean, p16: boolean): void {
+    inv<void>('0x6B9BBD38AB0796DF', this.handle, entity2.handle, boneIndex, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot, p15, p16);
   }
 
   /**
-   * Returns the model hash from the entity
-   *
    * @returns
    */
-  get Model(): number {
-    return (inv<number>('0xDA76A9F39210D365', this.handle, rai())) & 0xFFFFFFFF;
+  get IsAnimal(): any {
+    return inv<number>('0x9A100F1CF4546629', this.handle);
   }
 
   /**
-   * Deletes the specified entity, then sets the handle pointed to by the pointer to NULL.
+   * p6/relative - makes the xyz force not relative to world coords, but to something else
+   * p7/highForce - setting false will make the force really low
+   *
+   * @param forceType 
+   * @param pos 
+   * @param component 
+   * @param isDirectionRel 
+   * @param isForceRel 
+   * @param p8 
    */
-  deleteEntity(): void {
-    inv<void>('0x4CD38C78BD19A497', this.handle);
+  applyForceToCenterOfMass(forceType: number, pos: Vector3, component: number, isDirectionRel: boolean, isForceRel: boolean, p8: boolean): void {
+    inv<void>('0x31DA7CEC5334DB37', this.handle, forceType, f(pos.x), f(pos.y), f(pos.z), component, isDirectionRel, isForceRel, p8);
   }
 
   /**
-   * @param team 
-   * @param playerPedToIgnore 
-   * @param flags 
+   * Old name: _GET_ENTITY_CAN_BE_DAMAGED
+   *
    * @returns
    */
-  getNearestPlayerToOnTeam(team: number, playerPedToIgnore: Ped, flags: number): Player | null {
-    return createFromHandle<Player>('Player', inv<number>('0xB2C30C3B4AFF718C', this.handle, team, playerPedToIgnore.handle, flags, rai()));
+  get CanBeDamaged(): any {
+    return inv<number>('0x75DF9E73F2F005FD', this.handle);
   }
 
   /**
@@ -1217,226 +1480,110 @@ export class Entity implements IHandle {
   }
 
   /**
-   * @param flagId Refer to [enum: eCarryingFlags]
-   * @param value 
-   */
-  setCarryingFlag(flagId: eCarryingFlags, value: boolean): void {
-    inv<void>('0x18FF3110CF47115D', this.handle, flagId, value);
-  }
-
-  /**
-   * @returns
-   */
-  get IsPredator(): any {
-    return inv<number>('0x5594AFE9DE0C01B7', this.handle);
-  }
-
-  /**
-   * enum eCarriableState
-   * {
-   * CARRIABLE_STATE_NONE,
-   * CARRIABLE_STATE_TRANSITIONING_TO_HOGTIED,
-   * CARRIABLE_STATE_CARRIABLE_INTRO,
-   * CARRIABLE_STATE_CARRIABLE,
-   * CARRIABLE_STATE_BEING_PICKED_UP_FROM_GROUND,
-   * CARRIABLE_STATE_CARRIED_BY_HUMAN,
-   * CARRIABLE_STATE_BEING_PLACED_ON_GROUND,
-   * CARRIABLE_STATE_CARRIED_BY_MOUNT,
-   * CARRIABLE_STATE_BEING_PLACED_ON_MOUNT,
-   * CARRIABLE_STATE_BEING_PICKED_UP_FROM_MOUNT,
-   * CARRIABLE_STATE_BEING_CUT_FREE,
-   * CARRIABLE_STATE_BEING_PLACED_ON_GROUND_ESCAPE,
-   * CARRIABLE_STATE_BEING_PLACED_IN_VEHICLE
-   * };
-   *
-   * @returns
-   */
-  get CarriableState(): number {
-    return inv<number>('0x61914209C36EFDDB', this.handle, rai());
-  }
-
-  /**
-   * @param value 
-   */
-  set MaxHealth(value: number) {
-    inv<void>('0x166E7CF68597D8B5', this.handle, value);
-  }
-
-  /**
-   * Params: p1 (probably animType) = 1, 0
-   *
-   * @param p1 
-   * @returns
-   */
-  isPlayingAnyAnim(p1: number): boolean {
-    return !!inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
-  }
-
-  /**
-   * @param enabled 
-   */
-  set LightsEnabled(enabled: boolean) {
-    inv<void>('0xEBDC12861D079ABA', this.handle, enabled);
-  }
-
-  /**
-   * Offset values are relative to the entity. x = left/right
-   * y = forward/backward
-   * z = up/down
-   *
-   * @param offset 
-   * @returns
-   */
-  getOffsetFromInWorldCoords(offset: Vector3): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x1899F328B0E12848', this.handle, f(offset.x), f(offset.y), f(offset.z), rav()));
-  }
-
-  /**
-   * Checks if entity1 is within the box defined by x/y/zSize of entity2. Last three parameters are almost always p5 = 0, p6 = 1, p7 = 0
-   *
-   * @param entity2 
-   * @param xSize 
-   * @param ySize 
-   * @param zSize 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @returns
-   */
-  isAtEntity(entity2: Entity, xSize: number, ySize: number, zSize: number, p5: boolean, p6: boolean, p7: number): boolean {
-    return !!inv<boolean>('0xC057F02B837A27F6', this.handle, entity2.handle, f(xSize), f(ySize), f(zSize), p5, p6, p7, rai());
-  }
-
-  /**
-   * @param toggle 
-   */
-  set Visible(toggle: boolean) {
-    inv<void>('0x1794B4FCC84D812F', this.handle, toggle);
-  }
-
-  /**
-   * Old name: _SET_ENTITY_CLEANUP_BY_ENGINE
-   *
-   * @param toggle 
-   */
-  set ShouldFreezeWaitingOnCollision(toggle: boolean) {
-    inv<void>('0x740CB4F3F602C9F4', this.handle, toggle);
-  }
-
-  /**
-   * Note: this native was removed in 1232 but added back in 1311
-   * Old name: _GET_ENTITY_PROOFS
-   *
-   * @returns
+   * @param flagId Refer to [enum: eCarryingFlags]
+   * @param value 
    */
-  get Proofs(): number {
-    return inv<number>('0x6CF0DAD7FA1088EA', this.handle, rai());
+  setCarryingFlag(flagId: eCarryingFlags, value: boolean): void {
+    inv<void>('0x18FF3110CF47115D', this.handle, flagId, value);
   }
 
   /**
-   * skin - everything alpha except skin
-   * Set entity alpha level. Ranging from 0 to 255 but changes occur after every 20 percent (after every 51).
-   *
-   * @param alphaLevel 
-   * @param skin 
+   * @returns
    */
-  setAlpha(alphaLevel: number, skin: boolean): void {
-    inv<void>('0x0DF7692B1D9E7BA7', this.handle, alphaLevel, skin);
+  get IsPredator(): any {
+    return inv<number>('0x5594AFE9DE0C01B7', this.handle);
   }
 
   /**
+   * Returns entityType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityType
+   *
    * @returns
    */
-  get ThreatTier(): number {
-    return inv<number>('0xE12F56CB25D9CE23', this.handle, rai());
+  get Type(): number {
+    return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
   }
 
   /**
-   * @param p1 
+   * @returns
    */
-  N_0xA48E4801DEBDF7E4(p1: boolean): void {
-    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
+  get IsOwnedByPersistenceSystem(): any {
+    return inv<number>('0xA7E51B53309EAC97', this.handle);
   }
 
   /**
-   * @param toggle 
-   * @param keepPhysics 
+   * @param animDict 
+   * @param animName 
+   * @param animType 
+   * @returns
    */
-  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
-    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
+  isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
+    return !!inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
   }
 
   /**
-   * @param p1 
+   * Marks the specified entity (ped, vehicle or object) as no longer needed, allowing the game engine to delete it whenever it sees fit.
    */
-  N_0xCDB682BB47C02F0A(p1: string | number): void {
-    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
+  setAsNoLongerNeeded(): void {
+    inv<void>('0x4971D2F8162B9674', this.handle);
   }
 
   /**
-   * @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());
+  hasBeenDamagedByAnyVehicle(): boolean {
+    return !!inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
   }
 
   /**
-   * @returns rightVector; forwardVector; upVector; position
+   * @param animDict 
+   * @param animName 
+   * @param speedMultiplier 
    */
-  get Matrix(): [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])];
+  setAnimSpeed(animDict: string | null, animName: string | null, speedMultiplier: number): void {
+    inv<void>('0xEAA885BA3CEA4E4A', this.handle, animDict, animName, f(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.
-   */
-  N_0x371D179701D9C082(): void {
-    inv<void>('0x371D179701D9C082', this.handle);
+  unpinMapEntity(): void {
+    inv<void>('0xD2B9C78537ED5759', this.handle);
   }
 
   /**
-   * @param p1 
+   * Get how much of the entity is submerged. 1.0f is whole entity.
+   *
    * @returns
    */
-  getMaxHealth(p1: boolean): number {
-    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
+  get SubmergedLevel(): number {
+    return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param time 
+   * @returns
    */
-  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
-    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
+  get IsAttached(): boolean {
+    return !!inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
   }
 
   /**
-   * 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.
+   * SET_ENTITY_A*
    *
-   * @param alive 
-   * @param realCoords 
-   * @returns
+   * @param p1 
    */
-  getCoords(alive?: boolean, realCoords?: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
+  N_0xC0EDEF16D90661EE(p1: number): void {
+    inv<void>('0xC0EDEF16D90661EE', this.handle, f(p1));
   }
 
-  get Coords(): Vector3 {
-    return this.getCoords();
+  /**
+   * @param looted 
+   */
+  set FullyLooted(looted: boolean) {
+    inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
   }
 
   /**
    * @returns
    */
-  get IsAnObject(): boolean {
-    return !!inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
+  get IsAttachedToAnyVehicle(): boolean {
+    return !!inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
   }
 
   /**
@@ -1538,159 +1685,12 @@ export class Entity implements IHandle {
     return inv<number>('0x96C638784DB4C815', this.handle, raf());
   }
 
-  /**
-   * LOD distance can be 0 to 0xFFFF (higher values will result in 0xFFFF) as it is actually stored as a 16-bit value (aka uint16_t).
-   *
-   * @param value 
-   */
-  set LodDist(value: number) {
-    inv<void>('0x5FB407F0A7C877BF', this.handle, value);
-  }
-
-  /**
-   * @param toggle 
-   */
-  set Dynamic(toggle: boolean) {
-    inv<void>('0xFBFC4473F66CE344', this.handle, toggle);
-  }
-
-  /**
-   * @param radius 
-   */
-  set CustomPickupRadius(radius: number) {
-    inv<void>('0x482D17E45665DA44', this.handle, f(radius));
-  }
-
-  /**
-   * @returns
-   */
-  get PopulationType(): number {
-    return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  get IsAVehicle(): boolean {
-    return !!inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
-  }
-
-  /**
-   * @param pos 
-   * @param atTop 
-   * @param inWorldCoords 
-   * @returns
-   */
-  getHeight(pos: Vector3, atTop: boolean, inWorldCoords: boolean): number {
-    return inv<number>('0x296DEBC84474B375', this.handle, f(pos.x), f(pos.y), f(pos.z), atTop, inWorldCoords, raf());
-  }
-
-  /**
-   * @param pos 
-   * @returns
-   */
-  getOffsetFromGivenWorldCoords(pos: Vector3): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x497C6B1A2C9AE69C', this.handle, f(pos.x), f(pos.y), f(pos.z), rav()));
-  }
-
-  addTrackingTrails(): void {
-    inv<void>('0x1AD922AB5038DEF3', this.handle);
-  }
-
-  /**
-   * @param toggle 
-   */
-  set CanClimbOnEntity(toggle: boolean) {
-    inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
-  }
-
-  /**
-   * @returns minimum; maximum
-   */
-  get WorldPositionOfDimensions(): [Vector3, Vector3] {
-    const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
-    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
-  }
-
-  /**
-   * @param p1 
-   * @returns
-   */
-  isUnderwater(p1: boolean): any {
-    return inv<number>('0xD4E5C1E93C466127', this.handle, p1);
-  }
-
-  /**
-   * @param animation 
-   * @param animGroup 
-   * @param p3 
-   * @returns
-   */
-  stopAnim(animation: string | null, animGroup: string | null, p3: number): any {
-    return inv<number>('0x786591D986DE9159', this.handle, animation, animGroup, f(p3));
-  }
-
-  /**
-   * @returns
-   */
-  hasCollidedWithAnything(): boolean {
-    return !!inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
-  }
-
-  /**
-   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
-   *
-   * @returns
-   */
-  get VehicleIndexFromIndex(): Vehicle | null {
-    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
-  }
-
-  /**
-   * @returns
-   */
-  get IsVisible(): boolean {
-    return !!inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
-  }
-
-  /**
-   * SET_ENTITY_LO*
-   *
-   * @param toggle 
-   */
-  N_0xFF9965C47FA404DA(toggle: boolean): void {
-    inv<void>('0xFF9965C47FA404DA', this.handle, toggle);
-  }
-
-  /**
-   * Valid indices: 0 - 3
-   * Index 1 always returns a `hogtied` config, doesn't matter the entity.
-   * It's for humans only and the ped must be resurrected first if it's dead.
-   *
-   * @param index 
-   * @returns
-   */
-  getOptimalCarryConfig(index: number): number {
-    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
-  }
-
-  setFadeIn(): void {
-    inv<void>('0xA91E6CF94404E8C9', this.handle);
-  }
-
-  /**
-   * @returns
-   */
-  hasBeenDamagedByAnyPed(): boolean {
-    return !!inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
-  }
-
 
   /**
    * Gets the network ID of this entity for network synchronization.
    */
   get NetworkId(): number {
-    return inv<number>('0xF260AF6F43953316', this.handle, rai());
+    return inv<number>('0xA11700682F3AD45C', this.handle, rai());
   }
 }