@nativewrappers/redm-codegen 0.0.4 → 0.0.6

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,328 +36,290 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getForwardVectorYx(): Vector3 {
+  get ForwardVectorYx(): Vector3 {
     return Vector3.fromArray(inv<number[]>('0x935A30AA88FB1014', this.handle, rav()));
   }
 
   /**
-   * @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
    */
-  setLoadCollisionFlag(toggle: boolean): void {
-    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 
    */
-  setCarcassType(type: string | number): void {
-    inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
+  set CanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean) {
+    inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setHasGravity(toggle: boolean): void {
-    inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
+  get IsTrackedVisible(): any {
+    return inv<number>('0xC8CCDB712FBCBA92', this.handle);
   }
 
   /**
-   * @param relative 
-   * @returns
+   * @param p1 
+   * @param collision 
    */
-  getSpeedVector(relative: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xF2DB09816A419DC5', this.handle, relative, rav()));
+  detachEntity(p1: boolean, collision: boolean): void {
+    inv<void>('0x64CDE9D6BF8ECAD3', this.handle, p1, collision);
   }
 
   /**
-   * @param entity2 
-   * @param p2 
-   * @param p3 
    * @returns
    */
-  hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
-    return inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
+  get IsVisibleToScript(): boolean {
+    return !!inv<boolean>('0xF213C724E77F321A', this.handle, rai());
   }
 
   /**
+   * @param entity2 
+   * @param traceType 
    * @returns
    */
-  isFullyLooted(): any {
-    return inv<number>('0x8DE41E9902E85756', this.handle);
+  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
    */
-  isOccluded(): boolean {
-    return inv<boolean>('0x140188E884645624', this.handle, rai());
+  N_0x8E46E18AA828334F(animDict: string | null, animClip: string | null): number {
+    return inv<number>('0x8E46E18AA828334F', this.handle, animDict, animClip, raf());
   }
 
   /**
-   * @param toggle 
+   * @param playerPedToIgnore 
+   * @param flags 
+   * @returns
    */
-  setCanBeDamaged(toggle: boolean): void {
-    inv<void>('0x0D06D522B90E861F', this.handle, toggle);
+  getNearestPlayerToEntity(playerPedToIgnore: Ped, flags: number): Player | null {
+    return createFromHandle<Player>('Player', inv<number>('0x990E294FC387FB88', this.handle, playerPedToIgnore.handle, flags, rai()));
   }
 
   /**
-   * @param forceFlags 
-   * @param pos 
-   * @param offset 
-   * @param boneIndex 
-   * @param isDirectionRel 
-   * @param ignoreUpVec 
-   * @param isForceRel 
-   * @param p12 
-   * @param p13 
+   * Gets the Y-component of the entity's forward vector.
+   *
+   * @returns
    */
-  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);
+  get ForwardY(): number {
+    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
   }
 
   /**
-   * @returns
+   * @param pitch 
+   * @param roll 
+   * @param yaw 
+   * @param rotationOrder 
+   * @param p5 
    */
-  isDead(): boolean {
-    return inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
+  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 pos1 
-   * @param pos2 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @returns
+   * @param p1 
+   * @param relationshipGroup 
    */
-  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());
+  setOnlyDamagedByRelationshipGroup(p1: boolean, relationshipGroup: string | number): void {
+    inv<void>('0x6C1F6AA2F0ADD104', this.handle, p1, _h(relationshipGroup));
   }
 
   /**
-   * Returns the coordinates of an entity-bone.
-   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
+   * 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 boneIndex 
-   * @returns
+   * @param proofsBitset 
+   * @param specialFlag 
    */
-  getWorldPositionOfBone(boneIndex: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x82CFA50E34681CA5', this.handle, boneIndex, rav()));
+  setProofs(proofsBitset: number, specialFlag: boolean): void {
+    inv<void>('0xFAEE099C6F890BB8', this.handle, proofsBitset, specialFlag);
   }
 
   /**
-   * 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
    */
-  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 lootTable
+   * @returns
    */
-  getScriptOverrideLootTablePermanent(): [any, number] {
-    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
-    return [result[0], result[1]];
+  get IsCarriablePelt(): any {
+    return inv<number>('0x255B6DB4E3AD3C3E', this.handle);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param p3 
+   * @param p1 
    * @returns
    */
-  hasAnimFinished(animDict: string | null, animName: string | null, p3: number): boolean {
-    return inv<boolean>('0xAEB40615337EF1E3', this.handle, animDict, animName, p3, rai());
+  getVelocity(p1: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x4805D2B1D8CF94A9', this.handle, p1, rav()));
   }
 
   /**
-   * @param bCanBeDamaged 
-   * @param relGroup 
+   * @param toggle 
    */
-  setCanBeDamagedByRelationshipGroup(bCanBeDamaged: boolean, relGroup: string | number): void {
-    inv<void>('0x0EF1AFB18649E015', this.handle, bCanBeDamaged, _h(relGroup));
+  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
+   *
+   * @param lootTable 
    * @returns
    */
-  getUprightValue(): number {
-    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
+  scriptOverrideLootTablePermanent(lootTable: string | number): any {
+    return inv<number>('0x8C03CD6B5E0E85E8', this.handle, _h(lootTable));
   }
 
   /**
-   * @param pos 
-   * @param heading 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
+   * @returns argStruct
    */
-  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 Script(): [number, number] {
+    const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
+    return [result[0] & 0xFFFFFFFF, result[1]];
   }
 
   /**
-   * Returns zero if the entity is not a carriable
-   *
+   * @param actionHash 
    * @returns
    */
-  getCarryConfig(): number {
-    return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
+  hasAnimEventFired(actionHash: string | number): boolean {
+    return !!inv<boolean>('0x5851CC48405F4A07', this.handle, _h(actionHash), rai());
   }
 
   /**
-   * tier: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityThreatTier
-   *
-   * @param tier 
-   * @param p2 
+   * @param p1 
    */
-  setThreatTier(tier: number, p2: boolean): void {
-    inv<void>('0x4B436BAC8CBE9B07', this.handle, tier, p2);
+  N_0xEF259AA1E097E0AD(p1: any): void {
+    inv<void>('0xEF259AA1E097E0AD', this.handle, p1);
   }
 
   /**
-   * Returns the heading of the entity in degrees. Also know as the "Yaw" of an entity.
+   * Getter for FREEZE_ENTITY_POSITION
    *
    * @returns
    */
-  getHeading(): number {
-    return inv<number>('0xC230DD956E2F5507', this.handle, raf());
+  get IsFrozen(): any {
+    return inv<number>('0x083D497D57B7400F', this.handle);
   }
 
   /**
-   * Returns the LOD distance of an entity.
+   * Returns the entity that is looting a ped but only while the looting is active
    *
    * @returns
    */
-  getLodDist(): number {
-    return inv<number>('0xDF240D0C2A948683', this.handle, rai());
+  get LootingPed(): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
   }
 
   /**
    * @returns
    */
-  doesHaveDrawable(): boolean {
-    return inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
+  get IsWaitingForWorldCollision(): boolean {
+    return !!inv<boolean>('0x5E1CC2E8DC3111DD', this.handle, rai());
   }
 
   /**
-   * @param xyzw 
+   * Gets the X-component of the entity's forward vector.
+   *
+   * @returns
    */
-  setQuaternion(xyzw: Vector4): void {
-    inv<void>('0x100E7007D13E3687', this.handle, f(xyzw.x), f(xyzw.y), f(xyzw.z), f(xyzw.w));
+  get ForwardX(): number {
+    return inv<number>('0xDB0954E9960F6457', this.handle, raf());
   }
 
   /**
    * @returns
    */
-  isAttachedToAnyObject(): boolean {
-    return inv<boolean>('0x306C1F6178F01AB3', this.handle, rai());
+  get IsAPed(): boolean {
+    return !!inv<boolean>('0xCF8176912DDA4EA5', 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.
-   *
-   * @param toggle 
+   * @returns
    */
-  setInvincible(toggle: boolean): void {
-    inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
+  get Pitch(): number {
+    return inv<number>('0xEF355ABEFF7F5005', this.handle, raf());
   }
 
   /**
-   * 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 
+   * @returns
    */
-  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);
+  get IsStatic(): boolean {
+    return !!inv<boolean>('0x86468ADFA0F6B861', this.handle, rai());
   }
 
   /**
+   * Returns the model hash from the entity
+   *
    * @returns
    */
-  getIsAnimal(): 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
    */
-  getCanBeDamaged(): 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()));
   }
 
   /**
@@ -382,7 +344,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getForwardVector(): Vector3 {
+  get ForwardVector(): Vector3 {
     return Vector3.fromArray(inv<number[]>('0x2412D9C05BB09B97', this.handle, rav()));
   }
 
@@ -391,7 +353,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());
   }
 
   /**
@@ -407,22 +369,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());
   }
 
   /**
@@ -431,19 +393,139 @@ 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()));
   }
 
   /**
-   * @param p1 
+   * 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
+   */
+  get Proofs(): number {
+    return inv<number>('0x6CF0DAD7FA1088EA', this.handle, rai());
+  }
+
+  /**
+   * 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_0xA48E4801DEBDF7E4(p1: boolean): void {
     inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
@@ -471,13 +553,13 @@ export class Entity implements IHandle {
    * @returns
    */
   isInVolume(volume: number, p2: boolean, p3: number): boolean {
-    return inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
+    return !!inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
   }
 
   /**
    * @returns rightVector; forwardVector; upVector; position
    */
-  getMatrix(): [Vector3, Vector3, Vector3, Vector3] {
+  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])];
   }
@@ -519,110 +601,106 @@ export class Entity implements IHandle {
     return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
   }
 
-  /**
-   * @returns
-   */
-  isAnObject(): boolean {
-    return inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  isUpsidedown(): boolean {
-    return inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
+  get Coords(): Vector3 {
+    return this.getCoords();
   }
 
   /**
-   * @param p1 
    * @returns
    */
-  doesBelongToThisScript(p1: boolean): boolean {
-    return inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
+  get IsAnObject(): boolean {
+    return !!inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
   }
 
   /**
-   * Returns a hash of an entity's name. (Alternative Name: _GET_ENTITY_PROMPT_NAME_HASH)
+   * Used in Script Function DUELING_DID_PLAYER_DISARM_OPPONENT
    *
+   * @param entity2 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  getCarriableFromEntity(): number {
-    return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
+  N_0x3EC28DA1FFAC9DDD(entity2: Entity, p2: any, p3: any): boolean {
+    return !!inv<boolean>('0x3EC28DA1FFAC9DDD', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
-   * @param toggle 
-   * @param keepPhysics 
+   * Must be called from a background script, otherwise it will do nothing.
    */
-  setCollision(toggle: boolean, keepPhysics: boolean): void {
-    inv<void>('0xF66F820909453B8C', this.handle, toggle, keepPhysics);
+  delete2(): void {
+    inv<void>('0x5E94EA09E7207C16', this.handle);
   }
 
   /**
    * @param p1 
    * @returns
    */
-  placeOnGroundProperly(p1: boolean): any {
-    return inv<number>('0x9587913B9E772D29', this.handle, p1);
+  isInAir(p1: any): boolean {
+    return !!inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
   }
 
   /**
    * @returns
    */
-  isInWater(): boolean {
-    return inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
+  get IsAMissionEntity(): boolean {
+    return !!inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
   }
 
   /**
-   * @returns Returns `true` if the entity exists
+   * @returns
    */
-  doesExist(): boolean {
-    return inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
+  get IsAttachedToAnyPed(): boolean {
+    return !!inv<boolean>('0xC841153DED2CA89A', this.handle, rai());
   }
 
   /**
+   * @param to 
    * @returns
    */
-  getAlpha(): number {
-    return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
+  isAttachedToEntity(to: Entity): boolean {
+    return !!inv<boolean>('0x154A3C529497053E', this.handle, to.handle, rai());
   }
 
   /**
-   * This native only works on `Ped` and `Object` entity types
-   *
-   * @param flagId Refer to [enum: eCarryingFlags]
    * @returns
    */
-  getCarryingFlag(flagId: eCarryingFlags): number {
-    return inv<number>('0x808077647856DE62', this.handle, flagId, rai());
+  hasBeenDamagedByAnyObject(): boolean {
+    return !!inv<boolean>('0x73BB763880CD23A6', this.handle, rai());
   }
 
   /**
-   * @param p1 
+   * @param rotationOrder 
+   * @returns
    */
-  forceAiAndAnimationUpdate(p1: boolean): void {
-    inv<void>('0x4C9E96473D4F1A88', this.handle, p1);
+  getRotation(rotationOrder: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
   }
 
   /**
-   * Axis - Invert Axis Flags
-   *
-   * @param pos 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
+   * @param toggle 
    */
-  setCoordsNoOffset(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
-    inv<void>('0x239A3351AC1DA385', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis);
+  set MotionBlur(toggle: boolean) {
+    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
+  }
+
+  resetAlpha(): void {
+    inv<void>('0x744B9EF44779D9AB', this.handle);
   }
 
   /**
-   * Returns (CUR_HEALTH / MAX_HEALTH)
+   * Checks if entity is within x/y/zSize distance of x/y/z. Last three are unknown ints, almost always p7 = 0, p8 = 1, p9 = 0
    *
+   * @param pos 
+   * @param xSize 
+   * @param ySize 
+   * @param zSize 
+   * @param p7 
+   * @param p8 
+   * @param p9 
    * @returns
    */
-  getHealthFloat(): number {
-    return inv<number>('0x96C638784DB4C815', this.handle, raf());
+  isAtCoord(pos: Vector3, xSize: number, ySize: number, zSize: number, p7: boolean, p8: boolean, p9: number): boolean {
+    return !!inv<boolean>('0x5E58342602E94718', this.handle, f(pos.x), f(pos.y), f(pos.z), f(xSize), f(ySize), f(zSize), p7, p8, p9, rai());
   }
 
   /**
@@ -630,36 +708,36 @@ export class Entity implements IHandle {
    *
    * @param value 
    */
-  setLodDist(value: number): void {
+  set LodDist(value: number) {
     inv<void>('0x5FB407F0A7C877BF', this.handle, value);
   }
 
   /**
    * @param toggle 
    */
-  setDynamic(toggle: boolean): void {
+  set Dynamic(toggle: boolean) {
     inv<void>('0xFBFC4473F66CE344', this.handle, toggle);
   }
 
   /**
    * @param radius 
    */
-  setCustomPickupRadius(radius: number): void {
+  set CustomPickupRadius(radius: number) {
     inv<void>('0x482D17E45665DA44', this.handle, f(radius));
   }
 
   /**
    * @returns
    */
-  getPopulationType(): number {
+  get PopulationType(): number {
     return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
   }
 
   /**
    * @returns
    */
-  isAVehicle(): boolean {
-    return inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
+  get IsAVehicle(): boolean {
+    return !!inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
   }
 
   /**
@@ -687,14 +765,14 @@ export class Entity implements IHandle {
   /**
    * @param toggle 
    */
-  setCanClimbOnEntity(toggle: boolean): void {
+  set CanClimbOnEntity(toggle: boolean) {
     inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
   }
 
   /**
    * @returns minimum; maximum
    */
-  getWorldPositionOfDimensions(): [Vector3, Vector3] {
+  get WorldPositionOfDimensions(): [Vector3, Vector3] {
     const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
     return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
   }
@@ -721,647 +799,699 @@ export class Entity implements IHandle {
    * @returns
    */
   hasCollidedWithAnything(): boolean {
-    return inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
+    return !!inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
   }
 
   /**
-   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
-   *
-   * @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 
    */
-  getVehicleIndexFromIndex(): Vehicle | null {
-    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', 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
    */
-  isVisible(): boolean {
-    return inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
+  get HeightAboveGround(): number {
+    return inv<number>('0x0D3B5BAEA08F63E9', this.handle, raf());
   }
 
   /**
-   * SET_ENTITY_LO*
-   *
-   * @param toggle 
+   * @param pos 
+   * @param heading 
+   * @param p5 
+   * @param p6 
    */
-  N_0xFF9965C47FA404DA(toggle: boolean): void {
-    inv<void>('0xFF9965C47FA404DA', this.handle, toggle);
+  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);
   }
 
   /**
-   * 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.
+   * 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 index 
+   * @param originX 
+   * @param originY 
+   * @param originZ 
+   * @param edgeX 
+   * @param edgeY 
+   * @param edgeZ 
+   * @param angle 
+   * @param p8 
+   * @param p9 
+   * @param p10 
    * @returns
    */
-  getOptimalCarryConfig(index: number): number {
-    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
+  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());
   }
 
-  setFadeIn(): void {
-    inv<void>('0xA91E6CF94404E8C9', this.handle);
+  clearLastDamageEntity(): void {
+    inv<void>('0xBB19AC7D4DCEFD0F', this.handle);
   }
 
   /**
-   * @returns
+   * @param toggle 
    */
-  hasBeenDamagedByAnyPed(): boolean {
-    return inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
+  set AlwaysPrerender(toggle: boolean) {
+    inv<void>('0xACAD101E1FB66689', this.handle, toggle);
   }
 
   /**
-   * @param targetEntity 
-   * @returns
+   * Note that the third parameter(denoted as z) is "up and down" with positive numbers encouraging upwards movement.
+   *
+   * @param pos 
    */
-  isTouchingEntity(targetEntity: Entity): boolean {
-    return inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
-  }
-
-  deleteCarriable(): void {
-    inv<void>('0x0D0DB2B6AF19A987', this.handle);
+  set Velocity(pos: Vector3) {
+    inv<void>('0x1C99BB7B6E96D16F', this.handle, f(pos.x), f(pos.y), f(pos.z));
   }
 
   /**
-   * 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 p1 
+   * @param p2 
+   * @param p3 
    */
-  getAnimCurrentTime(animDict: string | null, animName: string | null): number {
-    return inv<number>('0x627520389E288A73', this.handle, animDict, animName, raf());
+  N_0xAF7F3099B9FEB535(p1: number, p2: number, p3: number): void {
+    inv<void>('0xAF7F3099B9FEB535', this.handle, f(p1), f(p2), f(p3));
   }
 
   /**
-   * @param entity2 
-   * @param thisFrameOnly 
+   * @returns
    */
-  setNoCollisionEntity(entity2: Entity, thisFrameOnly: boolean): void {
-    inv<void>('0xE037BF068223C38D', this.handle, entity2.handle, thisFrameOnly);
+  N_0xAF72EC7E1B54539B(): Entity | null {
+    return createFromHandle<Entity>('Entity', inv<number>('0xAF72EC7E1B54539B', this.handle, rai()));
   }
 
   /**
-   * Result is in meters per second (m/s)
+   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
    *
    * @returns
    */
-  getSpeed(): number {
-    return inv<number>('0xFB6BA510A533DF81', this.handle, raf());
+  get ObjectIndexFromIndex(): Prop | null {
+    return createFromHandle<Prop>('Prop', inv<number>('0x280BBE5601EAA983', this.handle, rai()));
   }
 
   /**
-   * @param bOnlyDamagedWhenRunningScript 
+   * Has the entity1 got a clear line of sight to the other entity2 from the direction entity1 is facing.
+   *
+   * @param entity2 
+   * @param traceType 
+   * @returns
    */
-  setCanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean): void {
-    inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
+  hasClearLosToEntityInFront(entity2: Entity, traceType: number): boolean {
+    return !!inv<boolean>('0xE88F19660651D566', this.handle, entity2.handle, traceType, rai());
   }
 
   /**
    * @returns
    */
-  isTrackedVisible(): any {
-    return inv<number>('0xC8CCDB712FBCBA92', this.handle);
+  get IsOnTrainTrack(): any {
+    return inv<number>('0x857ACB0AB4BD0D55', this.handle);
   }
 
   /**
-   * @param p1 
-   * @param collision 
+   * @param angle 
+   * @returns
    */
-  detachEntity(p1: boolean, collision: boolean): void {
-    inv<void>('0x64CDE9D6BF8ECAD3', this.handle, p1, collision);
+  isUpright(angle: number): boolean {
+    return !!inv<boolean>('0xF6F6AFD8D4FB2658', this.handle, f(angle), rai());
   }
 
   /**
+   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
+   *
    * @returns
    */
-  isVisibleToScript(): boolean {
-    return inv<boolean>('0xF213C724E77F321A', this.handle, rai());
+  get VehicleIndexFromIndex(): Vehicle | null {
+    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
   }
 
   /**
-   * @param entity2 
-   * @param traceType 
    * @returns
    */
-  hasClearLosToEntity(entity2: Entity, traceType: number): boolean {
-    return inv<boolean>('0xFCDFF7B72D23A1AC', this.handle, entity2.handle, traceType, rai());
+  get IsVisible(): boolean {
+    return !!inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
   }
 
   /**
-   * Used in Script Function GENERIC_ITEM_HAS_ANIM_COMPLETED
-   * *GET_ENTITY**
+   * SET_ENTITY_LO*
    *
-   * @param animDict 
-   * @param animClip 
+   * @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
    */
-  N_0x8E46E18AA828334F(animDict: string | null, animClip: string | null): number {
-    return inv<number>('0x8E46E18AA828334F', this.handle, animDict, animClip, raf());
+  getOptimalCarryConfig(index: number): number {
+    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
+  }
+
+  setFadeIn(): void {
+    inv<void>('0xA91E6CF94404E8C9', 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()));
+  hasBeenDamagedByAnyPed(): boolean {
+    return !!inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
   }
 
   /**
-   * Gets the Y-component of the entity's forward vector.
-   *
+   * @param pos 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
+   * @param clearArea 
+   */
+  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
    */
-  getForwardY(): number {
-    return inv<number>('0x9A5C073ECBDA7EE7', this.handle, raf());
+  getBoneIndexByName(boneName: string | null): number {
+    return inv<number>('0xBACA8FE9C76C124E', this.handle, boneName, rai());
   }
 
   /**
-   * @param pitch 
-   * @param roll 
-   * @param yaw 
-   * @param rotationOrder 
-   * @param p5 
+   * @param pause 
    */
-  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);
+  pauseTracking(pause: boolean): void {
+    inv<void>('0x36EB4D34D4A092C5', this.handle, pause);
   }
 
   /**
-   * @param p1 
-   * @param relationshipGroup 
+   * @param toggle 
    */
-  setOnlyDamagedByRelationshipGroup(p1: boolean, relationshipGroup: string | number): void {
-    inv<void>('0x6C1F6AA2F0ADD104', this.handle, p1, _h(relationshipGroup));
+  set LoadCollisionFlag(toggle: boolean) {
+    inv<void>('0x9B9EE31AED48072E', this.handle, toggle);
   }
 
   /**
-   * 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
+   * Changes type and quality of skins
+   * type hashes: https://pastebin.com/C1WvQjCy
    *
-   * @param proofsBitset 
-   * @param specialFlag 
+   * @param type 
    */
-  setProofs(proofsBitset: number, specialFlag: boolean): void {
-    inv<void>('0xFAEE099C6F890BB8', this.handle, proofsBitset, specialFlag);
+  set CarcassType(type: string | number) {
+    inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
   }
 
   /**
-   * @returns
+   * @param toggle 
    */
-  hasCollisionLoadedAroundEntity(): boolean {
-    return inv<boolean>('0xBEB1600952B9CF5C', this.handle, rai());
+  set HasGravity(toggle: boolean) {
+    inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
   }
 
   /**
+   * @param relative 
    * @returns
    */
-  getIsCarriablePelt(): any {
-    return inv<number>('0x255B6DB4E3AD3C3E', this.handle);
+  getSpeedVector(relative: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xF2DB09816A419DC5', this.handle, relative, rav()));
   }
 
   /**
-   * @param p1 
+   * @param entity2 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  getVelocity(p1: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x4805D2B1D8CF94A9', this.handle, p1, rav()));
+  hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
+    return !!inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setCanAutoVaultOnEntity(toggle: boolean): void {
-    inv<void>('0x80646744FA88F9D7', this.handle, toggle);
+  get IsFullyLooted(): any {
+    return inv<number>('0x8DE41E9902E85756', this.handle);
   }
 
   /**
-   * 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 IsOccluded(): boolean {
+    return !!inv<boolean>('0x140188E884645624', this.handle, rai());
   }
 
   /**
-   * @returns argStruct
+   * @param toggle 
    */
-  getScript(): [number, number] {
-    const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
-    return [result[0] & 0xFFFFFFFF, result[1]];
+  set CanBeDamaged(toggle: boolean) {
+    inv<void>('0x0D06D522B90E861F', this.handle, toggle);
   }
 
   /**
-   * @param actionHash 
-   * @returns
+   * @param forceFlags 
+   * @param pos 
+   * @param offset 
+   * @param boneIndex 
+   * @param isDirectionRel 
+   * @param ignoreUpVec 
+   * @param isForceRel 
+   * @param p12 
+   * @param p13 
    */
-  hasAnimEventFired(actionHash: string | number): boolean {
-    return inv<boolean>('0x5851CC48405F4A07', this.handle, _h(actionHash), rai());
+  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 
+   * @returns
    */
-  N_0xEF259AA1E097E0AD(p1: any): void {
-    inv<void>('0xEF259AA1E097E0AD', this.handle, p1);
+  get IsDead(): boolean {
+    return !!inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
   }
 
   /**
-   * Getter for FREEZE_ENTITY_POSITION
-   *
+   * @param pos1 
+   * @param pos2 
+   * @param p7 
+   * @param p8 
+   * @param p9 
    * @returns
    */
-  isFrozen(): any {
-    return inv<number>('0x083D497D57B7400F', this.handle);
+  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 entity that is looting a ped but only while the looting is active
+   * Returns the coordinates of an entity-bone.
+   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames
    *
+   * @param boneIndex 
    * @returns
    */
-  getLootingPed(): Ped | null {
-    return createFromHandle<Ped>('Ped', inv<number>('0xEF2D9ED7CE684F08', this.handle, rai()));
+  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
    */
-  isWaitingForWorldCollision(): boolean {
-    return inv<boolean>('0x5E1CC2E8DC3111DD', 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());
   }
 
   /**
-   * Gets the X-component of the entity's forward vector.
+   * Returns false if entity is not a ped or object.
    *
-   * @returns
+   * @returns lootTable
    */
-  getForwardX(): number {
-    return inv<number>('0xDB0954E9960F6457', this.handle, raf());
+  get ScriptOverrideLootTablePermanent(): [any, number] {
+    const result = inv<[number, number]>('0x1E804EA9B12030A4', this.handle, pvi());
+    return [result[0], result[1]];
   }
 
   /**
+   * @param animDict 
+   * @param animName 
+   * @param p3 
    * @returns
    */
-  isAPed(): boolean {
-    return inv<boolean>('0xCF8176912DDA4EA5', this.handle, rai());
+  hasAnimFinished(animDict: string | null, animName: string | null, p3: number): boolean {
+    return !!inv<boolean>('0xAEB40615337EF1E3', this.handle, animDict, animName, p3, rai());
   }
 
   /**
-   * @returns
+   * @param bCanBeDamaged 
+   * @param relGroup 
    */
-  getPitch(): number {
-    return inv<number>('0xEF355ABEFF7F5005', this.handle, raf());
+  setCanBeDamagedByRelationshipGroup(bCanBeDamaged: boolean, relGroup: string | number): void {
+    inv<void>('0x0EF1AFB18649E015', this.handle, bCanBeDamaged, _h(relGroup));
   }
 
   /**
    * @returns
    */
-  isStatic(): boolean {
-    return inv<boolean>('0x86468ADFA0F6B861', this.handle, rai());
+  get UprightValue(): number {
+    return inv<number>('0x56398BE65160C3BE', this.handle, raf());
+  }
+
+  /**
+   * @param pos 
+   * @param heading 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
+   */
+  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);
   }
 
   /**
-   * Returns the model hash from the entity
+   * Returns zero if the entity is not a carriable
    *
    * @returns
    */
-  getModel(): number {
-    return (inv<number>('0xDA76A9F39210D365', this.handle, rai())) & 0xFFFFFFFF;
+  get CarryConfig(): number {
+    return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * Deletes the specified entity, then sets the handle pointed to by the pointer to NULL.
+   * tier: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityThreatTier
+   *
+   * @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());
   }
 
   /**
-   * Seems to return true if entity is burned / scorched
-   * *GET_ENTITY**
+   * Returns the LOD distance of an entity.
    *
    * @returns
    */
-  N_0x37B01666BAE8F7EF(): any {
-    return inv<number>('0x37B01666BAE8F7EF', this.handle);
+  get LodDist(): number {
+    return inv<number>('0xDF240D0C2A948683', this.handle, rai());
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setRequiresMoreExpensiveRiverCheck(toggle: boolean): void {
-    inv<void>('0x850C940EE3E7B8B5', this.handle, toggle);
+  doesHaveDrawable(): boolean {
+    return !!inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
   }
 
   /**
-   * @param boneIndex 
-   * @returns Returns the offset from the entity for the selected bone index.
+   * @param xyzw 
    */
-  getOffsetFromBone(boneIndex: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x5E214112806591EA', this.handle, boneIndex, rav()));
-  }
-
-  N_0x9C6906EF8CB20C5F(): void {
-    inv<void>('0x9C6906EF8CB20C5F', this.handle);
+  set Quaternion(xyzw: Vector4) {
+    inv<void>('0x100E7007D13E3687', this.handle, f(xyzw.x), f(xyzw.y), f(xyzw.z), f(xyzw.w));
   }
 
   /**
-   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
-   *
    * @returns
    */
-  getPedIndexFromIndex(): Ped | null {
-    return createFromHandle<Ped>('Ped', inv<number>('0x0F16D042BD640EA3', this.handle, rai()));
+  get IsAttachedToAnyObject(): boolean {
+    return !!inv<boolean>('0x306C1F6178F01AB3', this.handle, rai());
   }
 
   /**
-   * Sets whether the entity can be targeted without being in line-of-sight.
+   * Sets a ped or an object totally invincible. It doesn't take any kind of damage. Peds will not ragdoll on explosions.
    *
    * @param toggle 
    */
-  setCanBeTargetedWithoutLos(toggle: boolean): void {
-    inv<void>('0x6D09F32E284D0FB7', this.handle, toggle);
-  }
-
-  /**
-   * @returns
-   */
-  isOnScreen(): boolean {
-    return inv<boolean>('0x613C15D5D8DB781F', this.handle, rai());
+  set Invincible(toggle: boolean) {
+    inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
   }
 
   /**
-   * Old name: _SET_ENTITY_DECALS_DISABLED
+   * 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 toggle 
+   * @param entity2 
+   * @param boneIndex 
+   * @param pos 
+   * @param rot 
+   * @param p9 
+   * @param useSoftPinning 
+   * @param collision 
+   * @param isPed 
+   * @param vertexIndex 
+   * @param fixedRot 
+   * @param p15 
+   * @param p16 
    */
-  setNoweapondecals(toggle: boolean): void {
-    inv<void>('0xC64E597783BE9A1D', this.handle, toggle);
+  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
    */
-  getHealth(): number {
-    return inv<number>('0x82368787EA73C0F7', this.handle, rai());
+  get IsAnimal(): any {
+    return inv<number>('0x9A100F1CF4546629', this.handle);
   }
 
   /**
-   * sets the fill in state for some objects like for the stew, coffee mug ,poker chips, jugs ? P1 is either 0 or 2 p2 seems to be a label/name p3 is the fill in state, max seems to be for some 3.0 (most is 1.0) - 0.0
-   * heres some of the labels/names found
-   * tumbler_fill, Canvas, Stew_Fill, from Chip01_Ctrl to Chip10_Ctrl, from empty_jug01_Ctrl to empty_jug20_Ctrl, from full_jug01_Ctrl to full_jug20_Ctrl, CTRL_cupFill, Food_DOF_Fill, from WhiteChip_Ctrl_0 to WhiteChip_Ctrl_10, from BlueChip_Ctrl_0 to BlueChip_Ctrl_10, from BlackChip_Ctrl_0 to BlackChip_Ctrl_10, from RedChip_Ctrl_0 to RedChip_Ctrl_10,
+   * 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 p1 
-   * @param p2 
-   * @param fill 
+   * @param forceType 
+   * @param pos 
+   * @param component 
+   * @param isDirectionRel 
+   * @param isForceRel 
+   * @param p8 
    */
-  setFillInStateForEntity(p1: number, p2: string | null, fill: number): void {
-    inv<void>('0x669655FFB29EF1A9', this.handle, p1, p2, f(fill));
+  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);
   }
 
   /**
+   * Old name: _GET_ENTITY_CAN_BE_DAMAGED
+   *
    * @returns
    */
-  doesHavePhysics(): boolean {
-    return inv<boolean>('0xA512B3F1B2A0B51C', this.handle, rai());
+  get CanBeDamaged(): any {
+    return inv<number>('0x75DF9E73F2F005FD', this.handle);
   }
 
   /**
-   * Returns true if calling script owns specified entity
+   * Seems to return true if entity is burned / scorched
+   * *GET_ENTITY**
    *
    * @returns
    */
-  doesThreadOwnThisEntity(): any {
-    return inv<number>('0x88AD6CC10D8D35B2', this.handle);
+  N_0x37B01666BAE8F7EF(): any {
+    return inv<number>('0x37B01666BAE8F7EF', this.handle);
   }
 
   /**
-   * Attach an entity to coordinates physically better name may be perfered? seems to be used with boats `p_skiff02x` ? The last 6 params are always 0 everywhere in the base code. p7 = 500.0 some kind of time? p8 =1
-   *
-   * @param pos 
-   * @param offset 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   * @param p14 
+   * @param toggle 
    */
-  attachToCoordsPhysically(pos: Vector3, offset: Vector3, p7: number, p8: boolean, p9: number, p10: number, p11: number, p12: number, p13: number, p14: number): void {
-    inv<void>('0x445D7D8EA66E373E', this.handle, f(pos.x), f(pos.y), f(pos.z), f(offset.x), f(offset.y), f(offset.z), f(p7), p8, p9, p10, p11, p12, p13, p14);
+  set RequiresMoreExpensiveRiverCheck(toggle: boolean) {
+    inv<void>('0x850C940EE3E7B8B5', this.handle, toggle);
   }
 
   /**
-   * *REMOVE_DECALS** - _REMOVE_FORCED*
+   * @param boneIndex 
+   * @returns Returns the offset from the entity for the selected bone index.
    */
-  N_0x5826EFD6D73C4DE5(): void {
-    inv<void>('0x5826EFD6D73C4DE5', this.handle);
+  getOffsetFromBone(boneIndex: number): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x5E214112806591EA', this.handle, boneIndex, rav()));
   }
 
-  /**
-   * @param toggle 
-   */
-  freezePosition(toggle: boolean): void {
-    inv<void>('0x7D9EFB7AD6B19754', this.handle, toggle);
+  N_0x9C6906EF8CB20C5F(): void {
+    inv<void>('0x9C6906EF8CB20C5F', this.handle);
   }
 
   /**
-   * Alters entity's health by 'amount'. Can be negative (to drain health).
-   * In the scripts entity2 and weaponHash are unused (zero).
+   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
    *
-   * @param amount 
-   * @param entity2 
-   * @param weaponHash Refer to [enum: eWeaponHash]
    * @returns
    */
-  changeHealth(amount: number, entity2: Entity, weaponHash: eWeaponHash): any {
-    return inv<number>('0x835F131E7DC8F97A', this.handle, f(amount), entity2.handle, weaponHash);
+  get PedIndexFromIndex(): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0x0F16D042BD640EA3', this.handle, rai()));
   }
 
   /**
-   * @returns
+   * Sets whether the entity can be targeted without being in line-of-sight.
+   *
+   * @param toggle 
    */
-  getAttachedTo(): Entity | null {
-    return createFromHandle<Entity>('Entity', inv<number>('0x56D713888A566481', this.handle, rai()));
+  set CanBeTargetedWithoutLos(toggle: boolean) {
+    inv<void>('0x6D09F32E284D0FB7', this.handle, toggle);
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setOnlyDamagedByPlayer(toggle: boolean): void {
-    inv<void>('0x473598683095D430', this.handle, toggle);
+  get IsOnScreen(): boolean {
+    return !!inv<boolean>('0x613C15D5D8DB781F', this.handle, rai());
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * Old name: _SET_ENTITY_DECALS_DISABLED
+   *
+   * @param toggle 
    */
-  setIsTargetPriority(p1: boolean, p2: number): void {
-    inv<void>('0x0A5D170C44CB2189', this.handle, p1, f(p2));
+  set Noweapondecals(toggle: boolean) {
+    inv<void>('0xC64E597783BE9A1D', this.handle, toggle);
   }
 
   /**
-   * @param pos 
-   * @param flags 
    * @returns
    */
-  hasClearLosToCoord(pos: Vector3, flags: number): any {
-    return inv<number>('0x0C9DBF48C6BA6E4C', this.handle, f(pos.x), f(pos.y), f(pos.z), flags);
+  get Health(): number {
+    return inv<number>('0x82368787EA73C0F7', this.handle, rai());
   }
 
   /**
-   * @param flagId Refer to [enum: eCarryingFlags]
-   * @param value 
+   * sets the fill in state for some objects like for the stew, coffee mug ,poker chips, jugs ? P1 is either 0 or 2 p2 seems to be a label/name p3 is the fill in state, max seems to be for some 3.0 (most is 1.0) - 0.0
+   * heres some of the labels/names found
+   * tumbler_fill, Canvas, Stew_Fill, from Chip01_Ctrl to Chip10_Ctrl, from empty_jug01_Ctrl to empty_jug20_Ctrl, from full_jug01_Ctrl to full_jug20_Ctrl, CTRL_cupFill, Food_DOF_Fill, from WhiteChip_Ctrl_0 to WhiteChip_Ctrl_10, from BlueChip_Ctrl_0 to BlueChip_Ctrl_10, from BlackChip_Ctrl_0 to BlackChip_Ctrl_10, from RedChip_Ctrl_0 to RedChip_Ctrl_10,
+   *
+   * @param p1 
+   * @param p2 
+   * @param fill 
    */
-  setCarryingFlag(flagId: eCarryingFlags, value: boolean): void {
-    inv<void>('0x18FF3110CF47115D', this.handle, flagId, value);
+  setFillInStateForEntity(p1: number, p2: string | null, fill: number): void {
+    inv<void>('0x669655FFB29EF1A9', this.handle, p1, p2, f(fill));
   }
 
   /**
    * @returns
    */
-  getIsPredator(): any {
-    return inv<number>('0x5594AFE9DE0C01B7', this.handle);
+  doesHavePhysics(): boolean {
+    return !!inv<boolean>('0xA512B3F1B2A0B51C', this.handle, rai());
   }
 
   /**
-   * 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 true if calling script owns specified entity
    *
    * @returns
    */
-  getCarriableState(): number {
-    return inv<number>('0x61914209C36EFDDB', this.handle, rai());
+  doesThreadOwnThisEntity(): any {
+    return inv<number>('0x88AD6CC10D8D35B2', this.handle);
   }
 
   /**
-   * @param value 
+   * Attach an entity to coordinates physically better name may be perfered? seems to be used with boats `p_skiff02x` ? The last 6 params are always 0 everywhere in the base code. p7 = 500.0 some kind of time? p8 =1
+   *
+   * @param pos 
+   * @param offset 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
    */
-  setMaxHealth(value: number): void {
-    inv<void>('0x166E7CF68597D8B5', this.handle, value);
+  attachToCoordsPhysically(pos: Vector3, offset: Vector3, p7: number, p8: boolean, p9: number, p10: number, p11: number, p12: number, p13: number, p14: number): void {
+    inv<void>('0x445D7D8EA66E373E', this.handle, f(pos.x), f(pos.y), f(pos.z), f(offset.x), f(offset.y), f(offset.z), f(p7), p8, p9, p10, p11, p12, p13, p14);
   }
 
   /**
-   * Params: p1 (probably animType) = 1, 0
-   *
-   * @param p1 
-   * @returns
+   * *REMOVE_DECALS** - _REMOVE_FORCED*
    */
-  isPlayingAnyAnim(p1: number): boolean {
-    return inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
+  N_0x5826EFD6D73C4DE5(): void {
+    inv<void>('0x5826EFD6D73C4DE5', this.handle);
   }
 
   /**
-   * @param enabled 
+   * @param toggle 
    */
-  setLightsEnabled(enabled: boolean): void {
-    inv<void>('0xEBDC12861D079ABA', this.handle, enabled);
+  freezePosition(toggle: boolean): void {
+    inv<void>('0x7D9EFB7AD6B19754', this.handle, toggle);
   }
 
   /**
-   * Offset values are relative to the entity. x = left/right
-   * y = forward/backward
-   * z = up/down
+   * Alters entity's health by 'amount'. Can be negative (to drain health).
+   * In the scripts entity2 and weaponHash are unused (zero).
    *
-   * @param offset 
+   * @param amount 
+   * @param entity2 
+   * @param weaponHash Refer to [enum: eWeaponHash]
    * @returns
    */
-  getOffsetFromInWorldCoords(offset: Vector3): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x1899F328B0E12848', this.handle, f(offset.x), f(offset.y), f(offset.z), rav()));
+  changeHealth(amount: number, entity2: Entity, weaponHash: eWeaponHash): any {
+    return inv<number>('0x835F131E7DC8F97A', this.handle, f(amount), entity2.handle, weaponHash);
   }
 
   /**
-   * 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());
+  get AttachedTo(): Entity | null {
+    return createFromHandle<Entity>('Entity', inv<number>('0x56D713888A566481', this.handle, rai()));
   }
 
   /**
    * @param toggle 
    */
-  setVisible(toggle: boolean): void {
-    inv<void>('0x1794B4FCC84D812F', this.handle, toggle);
+  set OnlyDamagedByPlayer(toggle: boolean) {
+    inv<void>('0x473598683095D430', this.handle, toggle);
   }
 
   /**
-   * Old name: _SET_ENTITY_CLEANUP_BY_ENGINE
-   *
-   * @param toggle 
+   * @param p1 
+   * @param p2 
    */
-  setShouldFreezeWaitingOnCollision(toggle: boolean): void {
-    inv<void>('0x740CB4F3F602C9F4', this.handle, toggle);
+  setIsTargetPriority(p1: boolean, p2: number): void {
+    inv<void>('0x0A5D170C44CB2189', this.handle, p1, f(p2));
   }
 
   /**
-   * Note: this native was removed in 1232 but added back in 1311
-   * Old name: _GET_ENTITY_PROOFS
-   *
+   * @param pos 
+   * @param flags 
    * @returns
    */
-  getProofs(): number {
-    return inv<number>('0x6CF0DAD7FA1088EA', this.handle, rai());
+  hasClearLosToCoord(pos: Vector3, flags: number): any {
+    return inv<number>('0x0C9DBF48C6BA6E4C', this.handle, f(pos.x), f(pos.y), f(pos.z), flags);
   }
 
   /**
-   * 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 
+   * @param flagId Refer to [enum: eCarryingFlags]
+   * @param value 
    */
-  setAlpha(alphaLevel: number, skin: boolean): void {
-    inv<void>('0x0DF7692B1D9E7BA7', this.handle, alphaLevel, skin);
+  setCarryingFlag(flagId: eCarryingFlags, value: boolean): void {
+    inv<void>('0x18FF3110CF47115D', this.handle, flagId, value);
   }
 
   /**
    * @returns
    */
-  getThreatTier(): number {
-    return inv<number>('0xE12F56CB25D9CE23', this.handle, rai());
+  get IsPredator(): any {
+    return inv<number>('0x5594AFE9DE0C01B7', this.handle);
   }
 
   /**
@@ -1369,14 +1499,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);
   }
 
@@ -1387,7 +1517,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());
   }
 
   /**
@@ -1401,7 +1531,7 @@ export class Entity implements IHandle {
    * @returns
    */
   hasBeenDamagedByAnyVehicle(): boolean {
-    return inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
+    return !!inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
   }
 
   /**
@@ -1422,15 +1552,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());
   }
 
   /**
@@ -1445,242 +1575,123 @@ 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());
   }
 
   /**
-   * Used in Script Function DUELING_DID_PLAYER_DISARM_OPPONENT
-   *
-   * @param entity2 
-   * @param p2 
-   * @param p3 
    * @returns
    */
-  N_0x3EC28DA1FFAC9DDD(entity2: Entity, p2: any, p3: any): boolean {
-    return inv<boolean>('0x3EC28DA1FFAC9DDD', this.handle, entity2.handle, p2, p3, rai());
-  }
-
-  /**
-   * Must be called from a background script, otherwise it will do nothing.
-   */
-  delete2(): void {
-    inv<void>('0x5E94EA09E7207C16', this.handle);
+  get IsUpsidedown(): boolean {
+    return !!inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
   }
 
   /**
    * @param p1 
    * @returns
    */
-  isInAir(p1: any): boolean {
-    return inv<boolean>('0x886E37EC497200B6', this.handle, p1, rai());
-  }
-
-  /**
-   * @returns
-   */
-  isAMissionEntity(): boolean {
-    return inv<boolean>('0x138190F64DB4BBD1', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  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());
+  doesBelongToThisScript(p1: boolean): boolean {
+    return !!inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
   }
 
   /**
-   * @param rotationOrder 
+   * Returns a hash of an entity's name. (Alternative Name: _GET_ENTITY_PROMPT_NAME_HASH)
+   *
    * @returns
    */
-  getRotation(rotationOrder: number): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xE09CAF86C32CB48F', this.handle, rotationOrder, rav()));
+  get CarriableFromEntity(): number {
+    return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
    * @param toggle 
+   * @param keepPhysics 
    */
-  setMotionBlur(toggle: boolean): void {
-    inv<void>('0x516C6ABD18322B63', this.handle, toggle);
-  }
-
-  resetAlpha(): void {
-    inv<void>('0x744B9EF44779D9AB', this.handle);
+  setCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xF66F820909453B8C', this.handle, toggle, keepPhysics);
   }
 
   /**
-   * 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 
+   * @param p1 
    * @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());
-  }
-
-  /**
-   * @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 
-   */
-  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));
+  placeOnGroundProperly(p1: boolean): any {
+    return inv<number>('0x9587913B9E772D29', this.handle, p1);
   }
 
   /**
    * @returns
    */
-  getHeightAboveGround(): number {
-    return inv<number>('0x0D3B5BAEA08F63E9', this.handle, raf());
+  get IsInWater(): boolean {
+    return !!inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
   }
 
   /**
-   * @param pos 
-   * @param heading 
-   * @param p5 
-   * @param p6 
+   * @returns Returns `true` if the entity exists
    */
-  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);
+  doesExist(): boolean {
+    return !!inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
   }
 
   /**
-   * 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
    */
-  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());
-  }
-
-  clearLastDamageEntity(): void {
-    inv<void>('0xBB19AC7D4DCEFD0F', this.handle);
-  }
-
-  /**
-   * @param toggle 
-   */
-  setAlwaysPrerender(toggle: boolean): void {
-    inv<void>('0xACAD101E1FB66689', this.handle, toggle);
+  get Alpha(): number {
+    return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
   }
 
   /**
-   * Note that the third parameter(denoted as z) is "up and down" with positive numbers encouraging upwards movement.
+   * This native only works on `Ped` and `Object` entity types
    *
-   * @param pos 
+   * @param flagId Refer to [enum: eCarryingFlags]
+   * @returns
    */
-  setVelocity(pos: Vector3): void {
-    inv<void>('0x1C99BB7B6E96D16F', this.handle, f(pos.x), f(pos.y), f(pos.z));
+  getCarryingFlag(flagId: eCarryingFlags): number {
+    return inv<number>('0x808077647856DE62', this.handle, flagId, rai());
   }
 
   /**
-   * SET_ENTITY_LO*
-   *
    * @param p1 
-   * @param p2 
-   * @param p3 
-   */
-  N_0xAF7F3099B9FEB535(p1: number, p2: number, p3: number): void {
-    inv<void>('0xAF7F3099B9FEB535', this.handle, f(p1), f(p2), f(p3));
-  }
-
-  /**
-   * @returns
    */
-  N_0xAF72EC7E1B54539B(): Entity | null {
-    return createFromHandle<Entity>('Entity', inv<number>('0xAF72EC7E1B54539B', this.handle, rai()));
+  forceAiAndAnimationUpdate(p1: boolean): void {
+    inv<void>('0x4C9E96473D4F1A88', this.handle, p1);
   }
 
   /**
-   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
+   * Axis - Invert Axis Flags
    *
-   * @returns
+   * @param pos 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
    */
-  getObjectIndexFromIndex(): Prop | null {
-    return createFromHandle<Prop>('Prop', inv<number>('0x280BBE5601EAA983', this.handle, rai()));
+  setCoordsNoOffset(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
+    inv<void>('0x239A3351AC1DA385', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis);
   }
 
   /**
-   * Has the entity1 got a clear line of sight to the other entity2 from the direction entity1 is facing.
+   * Returns (CUR_HEALTH / MAX_HEALTH)
    *
-   * @param entity2 
-   * @param traceType 
    * @returns
    */
-  hasClearLosToEntityInFront(entity2: Entity, traceType: number): boolean {
-    return inv<boolean>('0xE88F19660651D566', this.handle, entity2.handle, traceType, rai());
+  get HealthFloat(): number {
+    return inv<number>('0x96C638784DB4C815', this.handle, raf());
   }
 
-  /**
-   * @returns
-   */
-  isOnTrainTrack(): any {
-    return inv<number>('0x857ACB0AB4BD0D55', this.handle);
-  }
 
   /**
-   * @param angle 
-   * @returns
+   * Gets the network ID of this entity for network synchronization.
    */
-  isUpright(angle: number): boolean {
-    return inv<boolean>('0xF6F6AFD8D4FB2658', this.handle, f(angle), rai());
+  get NetworkId(): number {
+    return inv<number>('0xA11700682F3AD45C', this.handle, rai());
   }
-
 }
 
 registerHandle('Entity', Entity);