@nativewrappers/redm-codegen 0.0.3 → 0.0.5

package/src/classes/Entity.ts

@@ -27,7 +27,7 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  getIsBird(): any {
+  get IsBird(): any {
     return inv<number>('0xC346A546612C49A9', this.handle);
   }
 
@@ -36,7 +36,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getForwardVectorYx(): Vector3 {
+  get ForwardVectorYx(): Vector3 {
     return Vector3.fromArray(inv<number[]>('0x935A30AA88FB1014', this.handle, rav()));
   }
 
@@ -69,7 +69,7 @@ export class Entity implements IHandle {
   /**
    * @param toggle 
    */
-  setLoadCollisionFlag(toggle: boolean): void {
+  set LoadCollisionFlag(toggle: boolean) {
     inv<void>('0x9B9EE31AED48072E', this.handle, toggle);
   }
 
@@ -79,14 +79,14 @@ export class Entity implements IHandle {
    *
    * @param type 
    */
-  setCarcassType(type: string | number): void {
+  set CarcassType(type: string | number) {
     inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
   }
 
   /**
    * @param toggle 
    */
-  setHasGravity(toggle: boolean): void {
+  set HasGravity(toggle: boolean) {
     inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
   }
 
@@ -105,27 +105,27 @@ export class Entity implements IHandle {
    * @returns
    */
   hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
-    return inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
+    return !!inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
    * @returns
    */
-  isFullyLooted(): any {
+  get IsFullyLooted(): any {
     return inv<number>('0x8DE41E9902E85756', this.handle);
   }
 
   /**
    * @returns
    */
-  isOccluded(): boolean {
-    return inv<boolean>('0x140188E884645624', this.handle, rai());
+  get IsOccluded(): boolean {
+    return !!inv<boolean>('0x140188E884645624', this.handle, rai());
   }
 
   /**
    * @param toggle 
    */
-  setCanBeDamaged(toggle: boolean): void {
+  set CanBeDamaged(toggle: boolean) {
     inv<void>('0x0D06D522B90E861F', this.handle, toggle);
   }
 
@@ -147,200 +147,122 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  isDead(): boolean {
-    return inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
+  get IsDead(): boolean {
+    return !!inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
   }
 
   /**
-   * @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]];
+  get ScriptOverrideLootTablePermanent(): [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()));
+  get UprightValue(): 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());
+  get CarryConfig(): 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()));
+  get Heading(): number {
+    return inv<number>('0xC230DD956E2F5507', this.handle, raf());
   }
 
   /**
@@ -348,7 +270,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getLodDist(): number {
+  get LodDist(): number {
     return inv<number>('0xDF240D0C2A948683', this.handle, rai());
   }
 
@@ -356,21 +278,21 @@ export class Entity implements IHandle {
    * @returns
    */
   doesHaveDrawable(): boolean {
-    return inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
+    return !!inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
   }
 
   /**
    * @param xyzw 
    */
-  setQuaternion(xyzw: Vector4): void {
+  set Quaternion(xyzw: Vector4) {
     inv<void>('0x100E7007D13E3687', this.handle, f(xyzw.x), f(xyzw.y), f(xyzw.z), f(xyzw.w));
   }
 
   /**
    * @returns
    */
-  isAttachedToAnyObject(): boolean {
-    return inv<boolean>('0x306C1F6178F01AB3', this.handle, rai());
+  get IsAttachedToAnyObject(): boolean {
+    return !!inv<boolean>('0x306C1F6178F01AB3', this.handle, rai());
   }
 
   /**
@@ -378,7 +300,7 @@ export class Entity implements IHandle {
    *
    * @param toggle 
    */
-  setInvincible(toggle: boolean): void {
+  set Invincible(toggle: boolean) {
     inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
   }
 
@@ -410,7 +332,7 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  getIsAnimal(): any {
+  get IsAnimal(): any {
     return inv<number>('0x9A100F1CF4546629', this.handle);
   }
 
@@ -434,7 +356,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getCanBeDamaged(): any {
+  get CanBeDamaged(): any {
     return inv<number>('0x75DF9E73F2F005FD', this.handle);
   }
 
@@ -460,7 +382,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getForwardVector(): Vector3 {
+  get ForwardVector(): Vector3 {
     return Vector3.fromArray(inv<number[]>('0x2412D9C05BB09B97', this.handle, rav()));
   }
 
@@ -469,7 +391,7 @@ export class Entity implements IHandle {
    * @returns
    */
   isTouchingModel(modelHash: string | number): boolean {
-    return inv<boolean>('0x2AE3EBC8DEB9768B', this.handle, _h(modelHash), rai());
+    return !!inv<boolean>('0x2AE3EBC8DEB9768B', this.handle, _h(modelHash), rai());
   }
 
   /**
@@ -485,22 +407,22 @@ export class Entity implements IHandle {
   /**
    * @param toggle 
    */
-  setRenderScorched(toggle: boolean): void {
+  set RenderScorched(toggle: boolean) {
     inv<void>('0x85B8A7534E44BC23', this.handle, toggle);
   }
 
   /**
    * @param heading 
    */
-  setHeading(heading: number): void {
+  set Heading(heading: number) {
     inv<void>('0xCF2B9C0645C4651B', this.handle, f(heading));
   }
 
   /**
    * @returns
    */
-  getCollisionDisabled(): boolean {
-    return inv<boolean>('0xAA2FADD30F45A9DA', this.handle, rai());
+  get CollisionDisabled(): boolean {
+    return !!inv<boolean>('0xAA2FADD30F45A9DA', this.handle, rai());
   }
 
   /**
@@ -509,14 +431,14 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getRoll(): number {
+  get Roll(): number {
     return inv<number>('0xBF966536FA8B6879', this.handle, raf());
   }
 
   /**
    * @returns
    */
-  getNearestParticipantToEntity(): Player | null {
+  get NearestParticipantToEntity(): Player | null {
     return createFromHandle<Player>('Player', inv<number>('0x6888A43C35A5F630', this.handle, rai()));
   }
 
@@ -525,14 +447,14 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getType(): number {
+  get Type(): number {
     return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  isOwnedByPersistenceSystem(): any {
+  get IsOwnedByPersistenceSystem(): any {
     return inv<number>('0xA7E51B53309EAC97', this.handle);
   }
 
@@ -543,7 +465,7 @@ export class Entity implements IHandle {
    * @returns
    */
   isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
-    return inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
+    return !!inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
   }
 
   /**
@@ -557,7 +479,7 @@ export class Entity implements IHandle {
    * @returns
    */
   hasBeenDamagedByAnyVehicle(): boolean {
-    return inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
+    return !!inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
   }
 
   /**
@@ -578,15 +500,15 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getSubmergedLevel(): number {
+  get SubmergedLevel(): number {
     return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
   }
 
   /**
    * @returns
    */
-  isAttached(): boolean {
-    return inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
+  get IsAttached(): boolean {
+    return !!inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
   }
 
   /**
@@ -601,198 +523,205 @@ export class Entity implements IHandle {
   /**
    * @param looted 
    */
-  setFullyLooted(looted: boolean): void {
+  set FullyLooted(looted: boolean) {
     inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
   }
 
   /**
    * @returns
    */
-  isAttachedToAnyVehicle(): boolean {
-    return inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
+  get IsAttachedToAnyVehicle(): boolean {
+    return !!inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
   }
 
   /**
-   * @param p1 
-   */
-  N_0xA48E4801DEBDF7E4(p1: boolean): void {
-    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
-  }
-
-  /**
-   * @param toggle 
-   * @param keepPhysics 
-   */
-  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 
+   * Used in Script Function DUELING_DID_PLAYER_DISARM_OPPONENT
+   *
+   * @param entity2 
    * @param p2 
    * @param p3 
    * @returns
    */
-  isInVolume(volume: number, p2: boolean, p3: number): boolean {
-    return inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
+  N_0x3EC28DA1FFAC9DDD(entity2: Entity, p2: any, p3: any): boolean {
+    return !!inv<boolean>('0x3EC28DA1FFAC9DDD', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
-   * @returns rightVector; forwardVector; upVector; position
+   * Must be called from a background script, otherwise it will do nothing.
    */
-  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])];
+  delete2(): void {
+    inv<void>('0x5E94EA09E7207C16', this.handle);
   }
 
   /**
-   * 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.
+   * @param p1 
+   * @returns
    */
-  N_0x371D179701D9C082(): void {
-    inv<void>('0x371D179701D9C082', this.handle);
+  isInAir(p1: any): boolean {
+    return !!inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
   }
 
   /**
-   * @param p1 
    * @returns
    */
-  getMaxHealth(p1: boolean): number {
-    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
+  get IsAMissionEntity(): boolean {
+    return !!inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
   }
 
   /**
-   * @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 IsAttachedToAnyPed(): boolean {
+    return !!inv<boolean>('0xC841153DED2CA89A', 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.
-   *
-   * @param alive 
-   * @param realCoords 
+   * @param to 
    * @returns
    */
-  getCoords(alive: boolean, realCoords: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
+  isAttachedToEntity(to: Entity): boolean {
+    return !!inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
   }
 
   /**
    * @returns
    */
-  isAnObject(): boolean {
-    return inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
+  hasBeenDamagedByAnyObject(): boolean {
+    return !!inv<boolean>('0x73BB763880CD23A6', this.handle, 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 
+   * @param rotationOrder 
+   * @returns
    */
-  setLodDist(value: number): void {
-    inv<void>('0x5FB407F0A7C877BF', this.handle, value);
+  getRotation(rotationOrder: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
   }
 
   /**
    * @param toggle 
    */
-  setDynamic(toggle: boolean): void {
-    inv<void>('0xFBFC4473F66CE344', this.handle, toggle);
+  set MotionBlur(toggle: boolean) {
+    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
+  }
+
+  resetAlpha(): void {
+    inv<void>('0x744B9EF44779D9AB', this.handle);
   }
 
   /**
-   * @param radius 
+   * 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
    */
-  setCustomPickupRadius(radius: number): void {
-    inv<void>('0x482D17E45665DA44', this.handle, f(radius));
+  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());
   }
 
   /**
-   * @returns
+   * @param entity2 
+   * @param p2 
+   * @param boneIndex 
+   * @param offset 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
+   * @param p15 
+   * @param p16 
+   * @param p17 
+   * @param p18 
+   * @param p19 
+   * @param p20 
+   * @param p21 
    */
-  getPopulationType(): number {
-    return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
+  attachToEntityPhysically(entity2: Entity, p2: number, boneIndex: number, offset: Vector3, p7: number, p8: number, p9: number, p10: number, p11: number, p12: number, p13: number, p14: boolean, p15: boolean, p16: boolean, p17: boolean, p18: number, p19: boolean, p20: number, p21: number): void {
+    inv<void>('0xB629A43CA1643481', this.handle, entity2.handle, p2, boneIndex, f(offset.x), f(offset.y), f(offset.z), f(p7), f(p8), f(p9), f(p10), f(p11), f(p12), f(p13), p14, p15, p16, p17, p18, p19, f(p20), f(p21));
   }
 
   /**
    * @returns
    */
-  isAVehicle(): boolean {
-    return inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
+  get HeightAboveGround(): number {
+    return inv<number>('0x0D3B5BAEA08F63E9', this.handle, raf());
   }
 
   /**
    * @param pos 
-   * @param atTop 
-   * @param inWorldCoords 
-   * @returns
+   * @param heading 
+   * @param p5 
+   * @param p6 
    */
-  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());
+  setCoordsAndHeadingNoOffset(pos: Vector3, heading: number, p5: boolean, p6: boolean): void {
+    inv<void>('0x0918E3565C20F03C', this.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), p5, p6);
   }
 
   /**
-   * @param pos 
+   * Creates a spherical cone at origin that extends to surface with the angle specified. Then returns true if the entity is inside the spherical cone Angle is measured in degrees.
+   *
+   * @param originX 
+   * @param originY 
+   * @param originZ 
+   * @param edgeX 
+   * @param edgeY 
+   * @param edgeZ 
+   * @param angle 
+   * @param p8 
+   * @param p9 
+   * @param p10 
    * @returns
    */
-  getOffsetFromGivenWorldCoords(pos: Vector3): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x497C6B1A2C9AE69C', this.handle, f(pos.x), f(pos.y), f(pos.z), rav()));
+  isInAngledArea(originX: number, originY: number, originZ: number, edgeX: number, edgeY: number, edgeZ: number, angle: number, p8: boolean, p9: boolean, p10: any): boolean {
+    return !!inv<boolean>('0xD3151E53134595E5', this.handle, f(originX), f(originY), f(originZ), f(edgeX), f(edgeY), f(edgeZ), f(angle), p8, p9, p10, rai());
   }
 
-  addTrackingTrails(): void {
-    inv<void>('0x1AD922AB5038DEF3', this.handle);
+  clearLastDamageEntity(): void {
+    inv<void>('0xBB19AC7D4DCEFD0F', this.handle);
   }
 
   /**
    * @param toggle 
    */
-  setCanClimbOnEntity(toggle: boolean): void {
-    inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
+  set AlwaysPrerender(toggle: boolean) {
+    inv<void>('0xACAD101E1FB66689', this.handle, toggle);
   }
 
   /**
-   * @returns minimum; maximum
+   * Note that the third parameter(denoted as z) is "up and down" with positive numbers encouraging upwards movement.
+   *
+   * @param pos 
    */
-  getWorldPositionOfDimensions(): [Vector3, Vector3] {
-    const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
-    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
+  set Velocity(pos: Vector3) {
+    inv<void>('0x1C99BB7B6E96D16F', this.handle, f(pos.x), f(pos.y), f(pos.z));
   }
 
   /**
+   * SET_ENTITY_LO*
+   *
    * @param p1 
-   * @returns
-   */
-  isUnderwater(p1: boolean): any {
-    return inv<number>('0xD4E5C1E93C466127', this.handle, p1);
-  }
-
-  /**
-   * @param animation 
-   * @param animGroup 
+   * @param p2 
    * @param p3 
-   * @returns
    */
-  stopAnim(animation: string | null, animGroup: string | null, p3: number): any {
-    return inv<number>('0x786591D986DE9159', this.handle, animation, animGroup, f(p3));
+  N_0xAF7F3099B9FEB535(p1: number, p2: number, p3: number): void {
+    inv<void>('0xAF7F3099B9FEB535', this.handle, f(p1), f(p2), f(p3));
   }
 
   /**
    * @returns
    */
-  hasCollidedWithAnything(): boolean {
-    return inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
+  N_0xAF72EC7E1B54539B(): Entity | null {
+    return createFromHandle<Entity>('Entity', inv<number>('0xAF72EC7E1B54539B', this.handle, rai()));
   }
 
   /**
@@ -800,47 +729,34 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getVehicleIndexFromIndex(): Vehicle | null {
-    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
-  }
-
-  /**
-   * @returns
-   */
-  isVisible(): boolean {
-    return inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
+  get ObjectIndexFromIndex(): Prop | null {
+    return createFromHandle<Prop>('Prop', inv<number>('0x280BBE5601EAA983', this.handle, rai()));
   }
 
   /**
-   * SET_ENTITY_LO*
+   * Has the entity1 got a clear line of sight to the other entity2 from the direction entity1 is facing.
    *
-   * @param toggle 
+   * @param entity2 
+   * @param traceType 
+   * @returns
    */
-  N_0xFF9965C47FA404DA(toggle: boolean): void {
-    inv<void>('0xFF9965C47FA404DA', this.handle, toggle);
+  hasClearLosToEntityInFront(entity2: Entity, traceType: number): boolean {
+    return !!inv<boolean>('0xE88F19660651D566', this.handle, entity2.handle, traceType, rai());
   }
 
   /**
-   * 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);
+  get IsOnTrainTrack(): any {
+    return inv<number>('0x857ACB0AB4BD0D55', this.handle);
   }
 
   /**
+   * @param angle 
    * @returns
    */
-  hasBeenDamagedByAnyPed(): boolean {
-    return inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
+  isUpright(angle: number): boolean {
+    return !!inv<boolean>('0xF6F6AFD8D4FB2658', this.handle, f(angle), rai());
   }
 
   /**
@@ -848,7 +764,7 @@ export class Entity implements IHandle {
    * @returns
    */
   isTouchingEntity(targetEntity: Entity): boolean {
-    return inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
+    return !!inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
   }
 
   deleteCarriable(): void {
@@ -879,21 +795,21 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getSpeed(): number {
+  get Speed(): number {
     return inv<number>('0xFB6BA510A533DF81', this.handle, raf());
   }
 
   /**
    * @param bOnlyDamagedWhenRunningScript 
    */
-  setCanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean): void {
+  set CanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean) {
     inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
   }
 
   /**
    * @returns
    */
-  isTrackedVisible(): any {
+  get IsTrackedVisible(): any {
     return inv<number>('0xC8CCDB712FBCBA92', this.handle);
   }
 
@@ -908,8 +824,8 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  isVisibleToScript(): boolean {
-    return inv<boolean>('0xF213C724E77F321A', this.handle, rai());
+  get IsVisibleToScript(): boolean {
+    return !!inv<boolean>('0xF213C724E77F321A', this.handle, rai());
   }
 
   /**
@@ -918,7 +834,7 @@ export class Entity implements IHandle {
    * @returns
    */
   hasClearLosToEntity(entity2: Entity, traceType: number): boolean {
-    return inv<boolean>('0xFCDFF7B72D23A1AC', this.handle, entity2.handle, traceType, rai());
+    return !!inv<boolean>('0xFCDFF7B72D23A1AC', this.handle, entity2.handle, traceType, rai());
   }
 
   /**
@@ -934,117 +850,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()));
   }
 
   /**
-   * Returns the coordinates of an entity-bone.
-   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
+   * Gets the Y-component of the entity's forward vector.
    *
-   * @param boneIndex 
    * @returns
    */
-  getWorldPositionOfBone(boneIndex: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x82CFA50E34681CA5', this.handle, boneIndex, rav()));
+  get ForwardY(): number {
+    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
   }
 
   /**
-   * https://github.com/femga/rdr3_discoveries/tree/master/animations
+   * @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 animName 
-   * @param animDict 
-   * @param p3 
-   * @param loop 
-   * @param stayInAnim 
-   * @param p6 
-   * @param delta 
-   * @param bitset 
+   * @param proofsBitset 
+   * @param specialFlag 
+   */
+  setProofs(proofsBitset: number, specialFlag: boolean): void {
+    inv<void>('0xFAEE099C6F890BB8', this.handle, proofsBitset, specialFlag);
+  }
+
+  /**
    * @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());
+  hasCollisionLoadedAroundEntity(): boolean {
+    return !!inv<boolean>('0xBEB1600952B9CF5C', this.handle, rai());
   }
 
   /**
-   * Returns false if entity is not a ped or object.
+   * @returns
+   */
+  get IsCarriablePelt(): 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 
+   */
+  set CanAutoVaultOnEntity(toggle: boolean) {
+    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
    *
-   * @returns lootTable
+   * @param lootTable 
+   * @returns
+   */
+  scriptOverrideLootTablePermanent(lootTable: string | number): any {
+    return inv<number>('0x8C03CD6B5E0E85E8', this.handle, _h(lootTable));
+  }
+
+  /**
+   * @returns argStruct
+   */
+  get Script(): [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);
+  }
+
+  /**
+   * Getter for FREEZE_ENTITY_POSITION
+   *
+   * @returns
+   */
+  get IsFrozen(): any {
+    return inv<number>('0x083D497D57B7400F', this.handle);
+  }
+
+  /**
+   * Returns the entity that is looting a ped but only while the looting is active
+   *
+   * @returns
+   */
+  get LootingPed(): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
+  }
+
+  /**
+   * @returns
    */
-  getScriptOverrideLootTablePermanent(): [any, number] {
-    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
-    return [result[0], result[1]];
+  get 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());
+  get ForwardX(): 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));
+  get IsAPed(): boolean {
+    return !!inv<boolean>('0xCF8176912DDA4EA5', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  getUprightValue(): number {
-    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
+  get Pitch(): 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);
+  get 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;
+  get Model(): 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()));
   }
 
   /**
@@ -1060,7 +1054,7 @@ export class Entity implements IHandle {
   /**
    * @param toggle 
    */
-  setRequiresMoreExpensiveRiverCheck(toggle: boolean): void {
+  set RequiresMoreExpensiveRiverCheck(toggle: boolean) {
     inv<void>('0x850C940EE3E7B8B5', this.handle, toggle);
   }
 
@@ -1081,7 +1075,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getPedIndexFromIndex(): Ped | null {
+  get PedIndexFromIndex(): Ped | null {
     return createFromHandle<Ped>('Ped', inv<number>('0x0F16D042BD640EA3', this.handle, rai()));
   }
 
@@ -1090,15 +1084,15 @@ export class Entity implements IHandle {
    *
    * @param toggle 
    */
-  setCanBeTargetedWithoutLos(toggle: boolean): void {
+  set CanBeTargetedWithoutLos(toggle: boolean) {
     inv<void>('0x6D09F32E284D0FB7', this.handle, toggle);
   }
 
   /**
    * @returns
    */
-  isOnScreen(): boolean {
-    return inv<boolean>('0x613C15D5D8DB781F', this.handle, rai());
+  get IsOnScreen(): boolean {
+    return !!inv<boolean>('0x613C15D5D8DB781F', this.handle, rai());
   }
 
   /**
@@ -1106,14 +1100,14 @@ export class Entity implements IHandle {
    *
    * @param toggle 
    */
-  setNoweapondecals(toggle: boolean): void {
+  set Noweapondecals(toggle: boolean) {
     inv<void>('0xC64E597783BE9A1D', this.handle, toggle);
   }
 
   /**
    * @returns
    */
-  getHealth(): number {
+  get Health(): number {
     return inv<number>('0x82368787EA73C0F7', this.handle, rai());
   }
 
@@ -1134,7 +1128,7 @@ export class Entity implements IHandle {
    * @returns
    */
   doesHavePhysics(): boolean {
-    return inv<boolean>('0xA512B3F1B2A0B51C', this.handle, rai());
+    return !!inv<boolean>('0xA512B3F1B2A0B51C', this.handle, rai());
   }
 
   /**
@@ -1194,14 +1188,14 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  getAttachedTo(): Entity | null {
+  get AttachedTo(): Entity | null {
     return createFromHandle<Entity>('Entity', inv<number>('0x56D713888A566481', this.handle, rai()));
   }
 
   /**
    * @param toggle 
    */
-  setOnlyDamagedByPlayer(toggle: boolean): void {
+  set OnlyDamagedByPlayer(toggle: boolean) {
     inv<void>('0x473598683095D430', this.handle, toggle);
   }
 
@@ -1233,7 +1227,7 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  getIsPredator(): any {
+  get IsPredator(): any {
     return inv<number>('0x5594AFE9DE0C01B7', this.handle);
   }
 
@@ -1257,14 +1251,14 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getCarriableState(): number {
+  get CarriableState(): number {
     return inv<number>('0x61914209C36EFDDB', this.handle, rai());
   }
 
   /**
    * @param value 
    */
-  setMaxHealth(value: number): void {
+  set MaxHealth(value: number) {
     inv<void>('0x166E7CF68597D8B5', this.handle, value);
   }
 
@@ -1275,13 +1269,13 @@ export class Entity implements IHandle {
    * @returns
    */
   isPlayingAnyAnim(p1: number): boolean {
-    return inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
+    return !!inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
   }
 
   /**
    * @param enabled 
    */
-  setLightsEnabled(enabled: boolean): void {
+  set LightsEnabled(enabled: boolean) {
     inv<void>('0xEBDC12861D079ABA', this.handle, enabled);
   }
 
@@ -1310,13 +1304,13 @@ export class Entity implements IHandle {
    * @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());
+    return !!inv<boolean>('0xC057F02B837A27F6', this.handle, entity2.handle, f(xSize), f(ySize), f(zSize), p5, p6, p7, rai());
   }
 
   /**
    * @param toggle 
    */
-  setVisible(toggle: boolean): void {
+  set Visible(toggle: boolean) {
     inv<void>('0x1794B4FCC84D812F', this.handle, toggle);
   }
 
@@ -1325,7 +1319,7 @@ export class Entity implements IHandle {
    *
    * @param toggle 
    */
-  setShouldFreezeWaitingOnCollision(toggle: boolean): void {
+  set ShouldFreezeWaitingOnCollision(toggle: boolean) {
     inv<void>('0x740CB4F3F602C9F4', this.handle, toggle);
   }
 
@@ -1335,7 +1329,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getProofs(): number {
+  get Proofs(): number {
     return inv<number>('0x6CF0DAD7FA1088EA', this.handle, rai());
   }
 
@@ -1353,106 +1347,103 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  getThreatTier(): number {
+  get ThreatTier(): number {
     return inv<number>('0xE12F56CB25D9CE23', this.handle, rai());
   }
 
   /**
-   * Used in Script Function DUELING_DID_PLAYER_DISARM_OPPONENT
-   *
-   * @param entity2 
-   * @param p2 
-   * @param p3 
-   * @returns
+   * @param p1 
    */
-  N_0x3EC28DA1FFAC9DDD(entity2: Entity, p2: any, p3: any): boolean {
-    return inv<boolean>('0x3EC28DA1FFAC9DDD', this.handle, entity2.handle, p2, p3, rai());
+  N_0xA48E4801DEBDF7E4(p1: boolean): void {
+    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
   }
 
   /**
-   * Must be called from a background script, otherwise it will do nothing.
+   * @param toggle 
+   * @param keepPhysics 
    */
-  delete2(): void {
-    inv<void>('0x5E94EA09E7207C16', this.handle);
+  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
   }
 
   /**
    * @param p1 
-   * @returns
    */
-  isInAir(p1: any): boolean {
-    return inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
+  N_0xCDB682BB47C02F0A(p1: string | number): void {
+    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
   }
 
   /**
+   * @param volume 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  isAMissionEntity(): boolean {
-    return inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
+  isInVolume(volume: number, p2: boolean, p3: number): boolean {
+    return !!inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
   }
 
   /**
-   * @returns
+   * @returns rightVector; forwardVector; upVector; position
    */
-  isAttachedToAnyPed(): boolean {
-    return inv<boolean>('0xC841153DED2CA89A', this.handle, rai());
+  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])];
   }
 
   /**
-   * @param to 
-   * @returns
+   * 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.
    */
-  isAttachedToEntity(to: Entity): boolean {
-    return inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
+  N_0x371D179701D9C082(): void {
+    inv<void>('0x371D179701D9C082', this.handle);
   }
 
   /**
+   * @param p1 
    * @returns
    */
-  hasBeenDamagedByAnyObject(): boolean {
-    return inv<boolean>('0x73BB763880CD23A6', this.handle, rai());
+  getMaxHealth(p1: boolean): number {
+    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
   }
 
   /**
-   * @param rotationOrder 
-   * @returns
+   * @param animDict 
+   * @param animName 
+   * @param time 
    */
-  getRotation(rotationOrder: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
+  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
+    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
   }
 
   /**
-   * @param toggle 
+   * 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
    */
-  setMotionBlur(toggle: boolean): void {
-    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
+  getCoords(alive?: boolean, realCoords?: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
   }
 
-  resetAlpha(): void {
-    inv<void>('0x744B9EF44779D9AB', this.handle);
+  get Coords(): Vector3 {
+    return this.getCoords();
   }
 
   /**
-   * 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());
+  get IsAnObject(): boolean {
+    return !!inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  isUpsidedown(): boolean {
-    return inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
+  get IsUpsidedown(): boolean {
+    return !!inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
   }
 
   /**
@@ -1460,7 +1451,7 @@ export class Entity implements IHandle {
    * @returns
    */
   doesBelongToThisScript(p1: boolean): boolean {
-    return inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
+    return !!inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
   }
 
   /**
@@ -1468,7 +1459,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getCarriableFromEntity(): number {
+  get CarriableFromEntity(): number {
     return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
   }
 
@@ -1491,21 +1482,21 @@ export class Entity implements IHandle {
   /**
    * @returns
    */
-  isInWater(): boolean {
-    return inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
+  get IsInWater(): boolean {
+    return !!inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
   }
 
   /**
    * @returns Returns `true` if the entity exists
    */
   doesExist(): boolean {
-    return inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
+    return !!inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  getAlpha(): number {
+  get Alpha(): number {
     return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
   }
 
@@ -1543,107 +1534,107 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getHealthFloat(): number {
+  get HealthFloat(): number {
     return inv<number>('0x96C638784DB4C815', this.handle, raf());
   }
 
   /**
-   * @param entity2 
-   * @param p2 
-   * @param boneIndex 
-   * @param offset 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   * @param p14 
-   * @param p15 
-   * @param p16 
-   * @param p17 
-   * @param p18 
-   * @param p19 
-   * @param p20 
-   * @param p21 
+   * 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 
    */
-  attachToEntityPhysically(entity2: Entity, p2: number, boneIndex: number, offset: Vector3, p7: number, p8: number, p9: number, p10: number, p11: number, p12: number, p13: number, p14: boolean, p15: boolean, p16: boolean, p17: boolean, p18: number, p19: boolean, p20: number, p21: number): void {
-    inv<void>('0xB629A43CA1643481', this.handle, entity2.handle, p2, boneIndex, f(offset.x), f(offset.y), f(offset.z), f(p7), f(p8), f(p9), f(p10), f(p11), f(p12), f(p13), p14, p15, p16, p17, p18, p19, f(p20), f(p21));
+  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
    */
-  getHeightAboveGround(): number {
-    return inv<number>('0x0D3B5BAEA08F63E9', this.handle, raf());
+  get PopulationType(): number {
+    return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  get IsAVehicle(): boolean {
+    return !!inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
   }
 
   /**
    * @param pos 
-   * @param heading 
-   * @param p5 
-   * @param p6 
+   * @param atTop 
+   * @param inWorldCoords 
+   * @returns
    */
-  setCoordsAndHeadingNoOffset(pos: Vector3, heading: number, p5: boolean, p6: boolean): void {
-    inv<void>('0x0918E3565C20F03C', this.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), p5, p6);
+  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());
   }
 
   /**
-   * Creates a spherical cone at origin that extends to surface with the angle specified. Then returns true if the entity is inside the spherical cone Angle is measured in degrees.
-   *
-   * @param originX 
-   * @param originY 
-   * @param originZ 
-   * @param edgeX 
-   * @param edgeY 
-   * @param edgeZ 
-   * @param angle 
-   * @param p8 
-   * @param p9 
-   * @param p10 
+   * @param pos 
    * @returns
    */
-  isInAngledArea(originX: number, originY: number, originZ: number, edgeX: number, edgeY: number, edgeZ: number, angle: number, p8: boolean, p9: boolean, p10: any): boolean {
-    return inv<boolean>('0xD3151E53134595E5', this.handle, f(originX), f(originY), f(originZ), f(edgeX), f(edgeY), f(edgeZ), f(angle), p8, p9, p10, rai());
+  getOffsetFromGivenWorldCoords(pos: Vector3): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x497C6B1A2C9AE69C', this.handle, f(pos.x), f(pos.y), f(pos.z), rav()));
   }
 
-  clearLastDamageEntity(): void {
-    inv<void>('0xBB19AC7D4DCEFD0F', this.handle);
+  addTrackingTrails(): void {
+    inv<void>('0x1AD922AB5038DEF3', this.handle);
   }
 
   /**
    * @param toggle 
    */
-  setAlwaysPrerender(toggle: boolean): void {
-    inv<void>('0xACAD101E1FB66689', this.handle, toggle);
+  set CanClimbOnEntity(toggle: boolean) {
+    inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
   }
 
   /**
-   * Note that the third parameter(denoted as z) is "up and down" with positive numbers encouraging upwards movement.
-   *
-   * @param pos 
+   * @returns minimum; maximum
    */
-  setVelocity(pos: Vector3): void {
-    inv<void>('0x1C99BB7B6E96D16F', this.handle, f(pos.x), f(pos.y), f(pos.z));
+  get WorldPositionOfDimensions(): [Vector3, Vector3] {
+    const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
+    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
   }
 
   /**
-   * SET_ENTITY_LO*
-   *
    * @param p1 
-   * @param p2 
+   * @returns
+   */
+  isUnderwater(p1: boolean): any {
+    return inv<number>('0xD4E5C1E93C466127', this.handle, p1);
+  }
+
+  /**
+   * @param animation 
+   * @param animGroup 
    * @param p3 
+   * @returns
    */
-  N_0xAF7F3099B9FEB535(p1: number, p2: number, p3: number): void {
-    inv<void>('0xAF7F3099B9FEB535', this.handle, f(p1), f(p2), f(p3));
+  stopAnim(animation: string | null, animGroup: string | null, p3: number): any {
+    return inv<number>('0x786591D986DE9159', this.handle, animation, animGroup, f(p3));
   }
 
   /**
    * @returns
    */
-  N_0xAF72EC7E1B54539B(): Entity | null {
-    return createFromHandle<Entity>('Entity', inv<number>('0xAF72EC7E1B54539B', this.handle, rai()));
+  hasCollidedWithAnything(): boolean {
+    return !!inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
   }
 
   /**
@@ -1651,36 +1642,56 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getObjectIndexFromIndex(): Prop | null {
-    return createFromHandle<Prop>('Prop', inv<number>('0x280BBE5601EAA983', this.handle, rai()));
+  get VehicleIndexFromIndex(): Vehicle | null {
+    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
   }
 
   /**
-   * Has the entity1 got a clear line of sight to the other entity2 from the direction entity1 is facing.
-   *
-   * @param entity2 
-   * @param traceType 
    * @returns
    */
-  hasClearLosToEntityInFront(entity2: Entity, traceType: number): boolean {
-    return inv<boolean>('0xE88F19660651D566', this.handle, entity2.handle, traceType, rai());
+  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
    */
-  isOnTrainTrack(): any {
-    return inv<number>('0x857ACB0AB4BD0D55', this.handle);
+  getOptimalCarryConfig(index: number): number {
+    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
+  }
+
+  setFadeIn(): void {
+    inv<void>('0xA91E6CF94404E8C9', this.handle);
   }
 
   /**
-   * @param angle 
    * @returns
    */
-  isUpright(angle: number): boolean {
-    return inv<boolean>('0xF6F6AFD8D4FB2658', this.handle, f(angle), rai());
+  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());
+  }
 }
 
 registerHandle('Entity', Entity);