@nativewrappers/redm-codegen 0.0.2 → 0.0.3

package/src/classes/Entity.ts

@@ -19,94 +19,136 @@ export class Entity implements IHandle {
     return handle === 0 ? null : new Entity(handle);
   }
 
+  static fromNetworkId(netId: number): Entity | null {
+    if (!inv<number>('0x38CE16C96BD11F2C', netId, rai())) return null;
+    return Entity.fromHandle(inv<number>('0x5B912C3F653822E6', netId, rai()));
+  }
+
   /**
-   * @param targetEntity 
    * @returns
    */
-  isTouchingEntity(targetEntity: Entity): boolean {
-    return inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
+  getIsBird(): any {
+    return inv<number>('0xC346A546612C49A9', this.handle);
   }
 
-  deleteCarriable(): void {
-    inv<void>('0x0D0DB2B6AF19A987', this.handle);
+  /**
+   * Gets the entity's forward vector in YX(Z) eulers. Similar to GET_ENTITY_FORWARD_VECTOR
+   *
+   * @returns
+   */
+  getForwardVectorYx(): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x935A30AA88FB1014', this.handle, rav()));
   }
 
   /**
-   * 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 
+   * @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
    */
-  getAnimCurrentTime(animDict: string | null, animName: string | null): number {
-    return inv<number>('0x627520389E288A73', this.handle, animDict, animName, raf());
+  getBoneIndexByName(boneName: string | null): number {
+    return inv<number>('0xBACA8FE9C76C124E', this.handle, boneName, rai());
   }
 
   /**
-   * @param entity2 
-   * @param thisFrameOnly 
+   * @param pause 
    */
-  setNoCollisionEntity(entity2: Entity, thisFrameOnly: boolean): void {
-    inv<void>('0xE037BF068223C38D', this.handle, entity2.handle, thisFrameOnly);
+  pauseTracking(pause: boolean): void {
+    inv<void>('0x36EB4D34D4A092C5', this.handle, pause);
   }
 
   /**
-   * Result is in meters per second (m/s)
+   * @param toggle 
+   */
+  setLoadCollisionFlag(toggle: boolean): void {
+    inv<void>('0x9B9EE31AED48072E', this.handle, toggle);
+  }
+
+  /**
+   * Changes type and quality of skins
+   * type hashes: https://pastebin.com/C1WvQjCy
    *
-   * @returns
+   * @param type 
    */
-  getSpeed(): number {
-    return inv<number>('0xFB6BA510A533DF81', this.handle, raf());
+  setCarcassType(type: string | number): void {
+    inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
   }
 
   /**
-   * @param bOnlyDamagedWhenRunningScript 
+   * @param toggle 
    */
-  setCanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean): void {
-    inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
+  setHasGravity(toggle: boolean): void {
+    inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
   }
 
   /**
+   * @param relative 
    * @returns
    */
-  isTrackedVisible(): any {
-    return inv<number>('0xC8CCDB712FBCBA92', this.handle);
+  getSpeedVector(relative: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xF2DB09816A419DC5', this.handle, relative, rav()));
   }
 
   /**
-   * @param p1 
-   * @param collision 
+   * @param entity2 
+   * @param p2 
+   * @param p3 
+   * @returns
    */
-  detachEntity(p1: boolean, collision: boolean): void {
-    inv<void>('0x64CDE9D6BF8ECAD3', this.handle, p1, collision);
+  hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
+    return inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
   }
 
   /**
    * @returns
    */
-  isVisibleToScript(): boolean {
-    return inv<boolean>('0xF213C724E77F321A', this.handle, rai());
+  isFullyLooted(): any {
+    return inv<number>('0x8DE41E9902E85756', this.handle);
   }
 
   /**
-   * @param entity2 
-   * @param traceType 
    * @returns
    */
-  hasClearLosToEntity(entity2: Entity, traceType: number): boolean {
-    return inv<boolean>('0xFCDFF7B72D23A1AC', this.handle, entity2.handle, traceType, rai());
+  isOccluded(): boolean {
+    return inv<boolean>('0x140188E884645624', this.handle, rai());
+  }
+
+  /**
+   * @param toggle 
+   */
+  setCanBeDamaged(toggle: boolean): void {
+    inv<void>('0x0D06D522B90E861F', this.handle, toggle);
+  }
+
+  /**
+   * @param forceFlags 
+   * @param pos 
+   * @param offset 
+   * @param boneIndex 
+   * @param isDirectionRel 
+   * @param ignoreUpVec 
+   * @param isForceRel 
+   * @param p12 
+   * @param p13 
+   */
+  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);
   }
 
   /**
-   * Used in Script Function GENERIC_ITEM_HAS_ANIM_COMPLETED
-   * *GET_ENTITY**
-   *
-   * @param animDict 
-   * @param animClip 
    * @returns
    */
-  N_0x8E46E18AA828334F(animDict: string | null, animClip: string | null): number {
-    return inv<number>('0x8E46E18AA828334F', this.handle, animDict, animClip, raf());
+  isDead(): boolean {
+    return inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
   }
 
   /**
@@ -200,7 +242,7 @@ export class Entity implements IHandle {
   /**
    * @returns argStruct
    */
-  getScript(): [string | number, number] {
+  getScript(): [number, number] {
     const result = inv<[number, number]>('0x2A08A32B6D49906F', this.handle, pvi(), rai());
     return [result[0] & 0xFFFFFFFF, result[1]];
   }
@@ -280,7 +322,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getModel(): string | number {
+  getModel(): number {
     return (inv<number>('0xDA76A9F39210D365', this.handle, rai())) & 0xFFFFFFFF;
   }
 
@@ -301,6 +343,101 @@ export class Entity implements IHandle {
     return createFromHandle<Player>('Player', inv<number>('0xB2C30C3B4AFF718C', this.handle, team, playerPedToIgnore.handle, flags, rai()));
   }
 
+  /**
+   * Returns the LOD distance of an entity.
+   *
+   * @returns
+   */
+  getLodDist(): number {
+    return inv<number>('0xDF240D0C2A948683', this.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  doesHaveDrawable(): boolean {
+    return inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
+  }
+
+  /**
+   * @param xyzw 
+   */
+  setQuaternion(xyzw: Vector4): void {
+    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());
+  }
+
+  /**
+   * Sets a ped or an object totally invincible. It doesn't take any kind of damage. Peds will not ragdoll on explosions.
+   *
+   * @param toggle 
+   */
+  setInvincible(toggle: boolean): void {
+    inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
+  }
+
+  /**
+   * Attaches entity1 to bone (boneIndex) of entity2. boneIndex - this is different to boneID, use GET_PED_BONE_INDEX to get the index from the ID. use the index for attaching to specific bones. entity1 will be attached to entity2's centre if bone index given doesn't correspond to bone indexes for that entity type.
+   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames useSoftPinning - if set to false attached entity will not detach when fixed
+   * collision - controls collision between the two entities (FALSE disables collision).
+   * isPed - pitch doesn't work when false and roll will only work on negative numbers (only peds)
+   * vertexIndex - position of vertex
+   * fixedRot - if false it ignores entity vector
+   *
+   * @param entity2 
+   * @param boneIndex 
+   * @param pos 
+   * @param rot 
+   * @param p9 
+   * @param useSoftPinning 
+   * @param collision 
+   * @param isPed 
+   * @param vertexIndex 
+   * @param fixedRot 
+   * @param p15 
+   * @param p16 
+   */
+  attachToEntity(entity2: Entity, boneIndex: number, pos: Vector3, rot: Vector3, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean, p15: boolean, p16: boolean): void {
+    inv<void>('0x6B9BBD38AB0796DF', this.handle, entity2.handle, boneIndex, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot, p15, p16);
+  }
+
+  /**
+   * @returns
+   */
+  getIsAnimal(): any {
+    return inv<number>('0x9A100F1CF4546629', this.handle);
+  }
+
+  /**
+   * 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 
+   */
+  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
+   */
+  getCanBeDamaged(): any {
+    return inv<number>('0x75DF9E73F2F005FD', this.handle);
+  }
+
   /**
    * @param p1 
    */
@@ -384,349 +521,416 @@ export class Entity implements IHandle {
   }
 
   /**
-   * 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 entityType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityType
    *
    * @returns
    */
-  getCarriableState(): number {
-    return inv<number>('0x61914209C36EFDDB', this.handle, rai());
+  getType(): number {
+    return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
   }
 
   /**
-   * @param value 
+   * @returns
    */
-  setMaxHealth(value: number): void {
-    inv<void>('0x166E7CF68597D8B5', this.handle, value);
+  isOwnedByPersistenceSystem(): any {
+    return inv<number>('0xA7E51B53309EAC97', this.handle);
   }
 
   /**
-   * Params: p1 (probably animType) = 1, 0
-   *
-   * @param p1 
+   * @param animDict 
+   * @param animName 
+   * @param animType 
    * @returns
    */
-  isPlayingAnyAnim(p1: number): boolean {
-    return inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
+  isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
+    return inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
   }
 
   /**
-   * @param enabled 
+   * Marks the specified entity (ped, vehicle or object) as no longer needed, allowing the game engine to delete it whenever it sees fit.
    */
-  setLightsEnabled(enabled: boolean): void {
-    inv<void>('0xEBDC12861D079ABA', this.handle, enabled);
+  setAsNoLongerNeeded(): void {
+    inv<void>('0x4971D2F8162B9674', this.handle);
   }
 
   /**
-   * 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()));
+  hasBeenDamagedByAnyVehicle(): boolean {
+    return inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
   }
 
   /**
-   * 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 animDict 
+   * @param animName 
+   * @param speedMultiplier 
+   */
+  setAnimSpeed(animDict: string | null, animName: string | null, speedMultiplier: number): void {
+    inv<void>('0xEAA885BA3CEA4E4A', this.handle, animDict, animName, f(speedMultiplier));
+  }
+
+  unpinMapEntity(): void {
+    inv<void>('0xD2B9C78537ED5759', this.handle);
+  }
+
+  /**
+   * Get how much of the entity is submerged. 1.0f is whole entity.
    *
-   * @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());
+  getSubmergedLevel(): number {
+    return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setVisible(toggle: boolean): void {
-    inv<void>('0x1794B4FCC84D812F', this.handle, toggle);
+  isAttached(): boolean {
+    return inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
   }
 
   /**
-   * Old name: _SET_ENTITY_CLEANUP_BY_ENGINE
+   * SET_ENTITY_A*
    *
-   * @param toggle 
+   * @param p1 
    */
-  setShouldFreezeWaitingOnCollision(toggle: boolean): void {
-    inv<void>('0x740CB4F3F602C9F4', this.handle, toggle);
+  N_0xC0EDEF16D90661EE(p1: number): void {
+    inv<void>('0xC0EDEF16D90661EE', this.handle, f(p1));
+  }
+
+  /**
+   * @param looted 
+   */
+  setFullyLooted(looted: boolean): void {
+    inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
   }
 
   /**
-   * Note: this native was removed in 1232 but added back in 1311
-   * Old name: _GET_ENTITY_PROOFS
-   *
    * @returns
    */
-  getProofs(): number {
-    return inv<number>('0x6CF0DAD7FA1088EA', this.handle, rai());
+  isAttachedToAnyVehicle(): boolean {
+    return inv<boolean>('0x12DF6E0D2E736749', 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 
+   * @param p1 
    */
-  setAlpha(alphaLevel: number, skin: boolean): void {
-    inv<void>('0x0DF7692B1D9E7BA7', this.handle, alphaLevel, skin);
+  N_0xA48E4801DEBDF7E4(p1: boolean): void {
+    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
   }
 
   /**
-   * @returns
+   * @param toggle 
+   * @param keepPhysics 
    */
-  getThreatTier(): number {
-    return inv<number>('0xE12F56CB25D9CE23', this.handle, rai());
+  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0xCDB682BB47C02F0A(p1: string | number): void {
+    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
   }
 
   /**
+   * @param volume 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  isUpsidedown(): boolean {
-    return inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
+  isInVolume(volume: number, p2: boolean, p3: number): boolean {
+    return inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
+  }
+
+  /**
+   * @returns rightVector; forwardVector; upVector; position
+   */
+  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])];
+  }
+
+  /**
+   * Called if entity is in water and submerged level is larger than 1f. If CARRYING_FLAG_FORCE_ALLOW_WARP_TO_SAFE_GROUND_LOCATION is true, it gets disabled as well.
+   */
+  N_0x371D179701D9C082(): void {
+    inv<void>('0x371D179701D9C082', this.handle);
   }
 
   /**
    * @param p1 
    * @returns
    */
-  doesBelongToThisScript(p1: boolean): boolean {
-    return inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
+  getMaxHealth(p1: boolean): number {
+    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
   }
 
   /**
-   * Returns a hash of an entity's name. (Alternative Name: _GET_ENTITY_PROMPT_NAME_HASH)
+   * @param animDict 
+   * @param animName 
+   * @param time 
+   */
+  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
+    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
+  }
+
+  /**
+   * Gets the current coordinates for a specified entity.
+   * `entity` = The entity to get the coordinates from.
+   * `alive` = Unused by the game, potentially used by debug builds in order to assert whether or not an entity was alive. If entity is a ped and it's in a vehicle or on a mount the coords of that entity are returned. Set 'realCoords' to true when you need the true ped coords.
    *
+   * @param alive 
+   * @param realCoords 
    * @returns
    */
-  getCarriableFromEntity(): string | number {
-    return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
+  getCoords(alive: boolean, realCoords: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
+  }
+
+  /**
+   * @returns
+   */
+  isAnObject(): boolean {
+    return inv<boolean>('0x0A27A546A375FDEF', 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 
+   */
+  setLodDist(value: number): void {
+    inv<void>('0x5FB407F0A7C877BF', this.handle, value);
   }
 
   /**
    * @param toggle 
-   * @param keepPhysics 
    */
-  setCollision(toggle: boolean, keepPhysics: boolean): void {
-    inv<void>('0xF66F820909453B8C', this.handle, toggle, keepPhysics);
+  setDynamic(toggle: boolean): void {
+    inv<void>('0xFBFC4473F66CE344', this.handle, toggle);
   }
 
   /**
-   * @param p1 
-   * @returns
+   * @param radius 
    */
-  placeOnGroundProperly(p1: boolean): any {
-    return inv<number>('0x9587913B9E772D29', this.handle, p1);
+  setCustomPickupRadius(radius: number): void {
+    inv<void>('0x482D17E45665DA44', this.handle, f(radius));
   }
 
   /**
    * @returns
    */
-  isInWater(): boolean {
-    return inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
+  getPopulationType(): number {
+    return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
   }
 
   /**
-   * @returns Returns `true` if the entity exists
+   * @returns
    */
-  doesExist(): boolean {
-    return inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
+  isAVehicle(): boolean {
+    return inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
   }
 
   /**
+   * @param pos 
+   * @param atTop 
+   * @param inWorldCoords 
    * @returns
    */
-  getAlpha(): number {
-    return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
+  getHeight(pos: Vector3, atTop: boolean, inWorldCoords: boolean): number {
+    return inv<number>('0x296DEBC84474B375', this.handle, f(pos.x), f(pos.y), f(pos.z), atTop, inWorldCoords, raf());
   }
 
   /**
-   * This native only works on `Ped` and `Object` entity types
-   *
-   * @param flagId Refer to [enum: eCarryingFlags]
+   * @param pos 
    * @returns
    */
-  getCarryingFlag(flagId: eCarryingFlags): number {
-    return inv<number>('0x808077647856DE62', this.handle, flagId, rai());
+  getOffsetFromGivenWorldCoords(pos: Vector3): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x497C6B1A2C9AE69C', this.handle, f(pos.x), f(pos.y), f(pos.z), rav()));
+  }
+
+  addTrackingTrails(): void {
+    inv<void>('0x1AD922AB5038DEF3', this.handle);
   }
 
   /**
-   * @param p1 
+   * @param toggle 
    */
-  forceAiAndAnimationUpdate(p1: boolean): void {
-    inv<void>('0x4C9E96473D4F1A88', this.handle, p1);
+  setCanClimbOnEntity(toggle: boolean): void {
+    inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
   }
 
   /**
-   * Axis - Invert Axis Flags
-   *
-   * @param pos 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
+   * @returns minimum; maximum
    */
-  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);
+  getWorldPositionOfDimensions(): [Vector3, Vector3] {
+    const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
+    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
   }
 
   /**
-   * Returns (CUR_HEALTH / MAX_HEALTH)
-   *
+   * @param p1 
    * @returns
    */
-  getHealthFloat(): number {
-    return inv<number>('0x96C638784DB4C815', this.handle, raf());
+  isUnderwater(p1: boolean): any {
+    return inv<number>('0xD4E5C1E93C466127', this.handle, p1);
   }
 
   /**
+   * @param animation 
+   * @param animGroup 
+   * @param p3 
    * @returns
    */
-  getIsBird(): any {
-    return inv<number>('0xC346A546612C49A9', this.handle);
+  stopAnim(animation: string | null, animGroup: string | null, p3: number): any {
+    return inv<number>('0x786591D986DE9159', this.handle, animation, animGroup, f(p3));
   }
 
   /**
-   * Gets the entity's forward vector in YX(Z) eulers. Similar to GET_ENTITY_FORWARD_VECTOR
-   *
    * @returns
    */
-  getForwardVectorYx(): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x935A30AA88FB1014', this.handle, rav()));
+  hasCollidedWithAnything(): boolean {
+    return inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
   }
 
   /**
-   * @param pos 
-   * @param xAxis 
-   * @param yAxis 
-   * @param zAxis 
-   * @param clearArea 
+   * Simply returns whatever is passed to it (Regardless of whether the handle is valid or not).
+   *
+   * @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);
+  getVehicleIndexFromIndex(): Vehicle | null {
+    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
   }
 
   /**
-   * @param boneName 
    * @returns
    */
-  getBoneIndexByName(boneName: string | null): number {
-    return inv<number>('0xBACA8FE9C76C124E', this.handle, boneName, rai());
+  isVisible(): boolean {
+    return inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
   }
 
   /**
-   * @param pause 
+   * SET_ENTITY_LO*
+   *
+   * @param toggle 
    */
-  pauseTracking(pause: boolean): void {
-    inv<void>('0x36EB4D34D4A092C5', this.handle, pause);
+  N_0xFF9965C47FA404DA(toggle: boolean): void {
+    inv<void>('0xFF9965C47FA404DA', this.handle, toggle);
   }
 
   /**
-   * @param 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
    */
-  setLoadCollisionFlag(toggle: boolean): void {
-    inv<void>('0x9B9EE31AED48072E', this.handle, toggle);
+  getOptimalCarryConfig(index: number): number {
+    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
+  }
+
+  setFadeIn(): void {
+    inv<void>('0xA91E6CF94404E8C9', this.handle);
   }
 
   /**
-   * Changes type and quality of skins
-   * type hashes: https://pastebin.com/C1WvQjCy
+   * @returns
+   */
+  hasBeenDamagedByAnyPed(): boolean {
+    return inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
+  }
+
+  /**
+   * @param targetEntity 
+   * @returns
+   */
+  isTouchingEntity(targetEntity: Entity): boolean {
+    return inv<boolean>('0x9A2304A64C3C8423', this.handle, targetEntity.handle, rai());
+  }
+
+  deleteCarriable(): void {
+    inv<void>('0x0D0DB2B6AF19A987', this.handle);
+  }
+
+  /**
+   * 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 type 
+   * @param animDict 
+   * @param animName 
+   * @returns
    */
-  setCarcassType(type: string | number): void {
-    inv<void>('0x399657ED871B3A6C', this.handle, _h(type));
+  getAnimCurrentTime(animDict: string | null, animName: string | null): number {
+    return inv<number>('0x627520389E288A73', this.handle, animDict, animName, raf());
   }
 
   /**
-   * @param toggle 
+   * @param entity2 
+   * @param thisFrameOnly 
    */
-  setHasGravity(toggle: boolean): void {
-    inv<void>('0x0CEDB728A1083FA7', this.handle, toggle);
+  setNoCollisionEntity(entity2: Entity, thisFrameOnly: boolean): void {
+    inv<void>('0xE037BF068223C38D', this.handle, entity2.handle, thisFrameOnly);
   }
 
   /**
-   * @param relative 
+   * Result is in meters per second (m/s)
+   *
    * @returns
    */
-  getSpeedVector(relative: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xF2DB09816A419DC5', this.handle, relative, rav()));
+  getSpeed(): number {
+    return inv<number>('0xFB6BA510A533DF81', this.handle, raf());
   }
 
   /**
-   * @param entity2 
-   * @param p2 
-   * @param p3 
-   * @returns
+   * @param bOnlyDamagedWhenRunningScript 
    */
-  hasBeenDamagedByEntity(entity2: Entity, p2: boolean, p3: boolean): boolean {
-    return inv<boolean>('0x7B6E7BEC1143AC86', this.handle, entity2.handle, p2, p3, rai());
+  setCanOnlyBeDamagedByScriptParticipants(bOnlyDamagedWhenRunningScript: boolean): void {
+    inv<void>('0xFF83AF534156B399', this.handle, bOnlyDamagedWhenRunningScript);
   }
 
   /**
    * @returns
    */
-  isFullyLooted(): any {
-    return inv<number>('0x8DE41E9902E85756', this.handle);
+  isTrackedVisible(): any {
+    return inv<number>('0xC8CCDB712FBCBA92', this.handle);
   }
 
   /**
-   * @returns
+   * @param p1 
+   * @param collision 
    */
-  isOccluded(): boolean {
-    return inv<boolean>('0x140188E884645624', this.handle, rai());
+  detachEntity(p1: boolean, collision: boolean): void {
+    inv<void>('0x64CDE9D6BF8ECAD3', this.handle, p1, collision);
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setCanBeDamaged(toggle: boolean): void {
-    inv<void>('0x0D06D522B90E861F', this.handle, toggle);
+  isVisibleToScript(): boolean {
+    return inv<boolean>('0xF213C724E77F321A', this.handle, rai());
   }
 
   /**
-   * @param forceFlags 
-   * @param pos 
-   * @param offset 
-   * @param boneIndex 
-   * @param isDirectionRel 
-   * @param ignoreUpVec 
-   * @param isForceRel 
-   * @param p12 
-   * @param p13 
+   * @param entity2 
+   * @param traceType 
+   * @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);
+  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
    */
-  isDead(): boolean {
-    return inv<boolean>('0x7D5B1F88E7504BBA', this.handle, rai());
+  N_0x8E46E18AA828334F(animDict: string | null, animClip: string | null): number {
+    return inv<number>('0x8E46E18AA828334F', this.handle, animDict, animClip, raf());
   }
 
   /**
@@ -820,7 +1024,7 @@ export class Entity implements IHandle {
    *
    * @returns
    */
-  getCarryConfig(): string | number {
+  getCarryConfig(): number {
     return (inv<number>('0x0FD25587BB306C86', this.handle, rai())) & 0xFFFFFFFF;
   }
 
@@ -843,101 +1047,6 @@ export class Entity implements IHandle {
     return inv<number>('0xC230DD956E2F5507', this.handle, raf());
   }
 
-  /**
-   * Returns the LOD distance of an entity.
-   *
-   * @returns
-   */
-  getLodDist(): number {
-    return inv<number>('0xDF240D0C2A948683', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  doesHaveDrawable(): boolean {
-    return inv<boolean>('0x20487F0DA9AF164A', this.handle, rai());
-  }
-
-  /**
-   * @param xyzw 
-   */
-  setQuaternion(xyzw: Vector4): void {
-    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());
-  }
-
-  /**
-   * Sets a ped or an object totally invincible. It doesn't take any kind of damage. Peds will not ragdoll on explosions.
-   *
-   * @param toggle 
-   */
-  setInvincible(toggle: boolean): void {
-    inv<void>('0xA5C38736C426FCB8', this.handle, toggle);
-  }
-
-  /**
-   * Attaches entity1 to bone (boneIndex) of entity2. boneIndex - this is different to boneID, use GET_PED_BONE_INDEX to get the index from the ID. use the index for attaching to specific bones. entity1 will be attached to entity2's centre if bone index given doesn't correspond to bone indexes for that entity type.
-   * https://github.com/femga/rdr3_discoveries/tree/master/boneNames useSoftPinning - if set to false attached entity will not detach when fixed
-   * collision - controls collision between the two entities (FALSE disables collision).
-   * isPed - pitch doesn't work when false and roll will only work on negative numbers (only peds)
-   * vertexIndex - position of vertex
-   * fixedRot - if false it ignores entity vector
-   *
-   * @param entity2 
-   * @param boneIndex 
-   * @param pos 
-   * @param rot 
-   * @param p9 
-   * @param useSoftPinning 
-   * @param collision 
-   * @param isPed 
-   * @param vertexIndex 
-   * @param fixedRot 
-   * @param p15 
-   * @param p16 
-   */
-  attachToEntity(entity2: Entity, boneIndex: number, pos: Vector3, rot: Vector3, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean, p15: boolean, p16: boolean): void {
-    inv<void>('0x6B9BBD38AB0796DF', this.handle, entity2.handle, boneIndex, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot, p15, p16);
-  }
-
-  /**
-   * @returns
-   */
-  getIsAnimal(): any {
-    return inv<number>('0x9A100F1CF4546629', this.handle);
-  }
-
-  /**
-   * 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 
-   */
-  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
-   */
-  getCanBeDamaged(): any {
-    return inv<number>('0x75DF9E73F2F005FD', this.handle);
-  }
-
   /**
    * Seems to return true if entity is burned / scorched
    * *GET_ENTITY**
@@ -1125,183 +1234,127 @@ export class Entity implements IHandle {
    * @returns
    */
   getIsPredator(): any {
-    return inv<number>('0x5594AFE9DE0C01B7', this.handle);
-  }
-
-  /**
-   * Returns entityType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eEntityType
-   *
-   * @returns
-   */
-  getType(): number {
-    return inv<number>('0x97F696ACA466B4E0', this.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  isOwnedByPersistenceSystem(): any {
-    return inv<number>('0xA7E51B53309EAC97', this.handle);
-  }
-
-  /**
-   * @param animDict 
-   * @param animName 
-   * @param animType 
-   * @returns
-   */
-  isPlayingAnim(animDict: string | null, animName: string | null, animType: number): boolean {
-    return inv<boolean>('0xDEE49D5CA6C49148', this.handle, animDict, animName, animType, rai());
-  }
-
-  /**
-   * Marks the specified entity (ped, vehicle or object) as no longer needed, allowing the game engine to delete it whenever it sees fit.
-   */
-  setAsNoLongerNeeded(): void {
-    inv<void>('0x4971D2F8162B9674', this.handle);
-  }
-
-  /**
-   * @returns
-   */
-  hasBeenDamagedByAnyVehicle(): boolean {
-    return inv<boolean>('0x695D7C26DE65C423', this.handle, rai());
-  }
-
-  /**
-   * @param animDict 
-   * @param animName 
-   * @param speedMultiplier 
-   */
-  setAnimSpeed(animDict: string | null, animName: string | null, speedMultiplier: number): void {
-    inv<void>('0xEAA885BA3CEA4E4A', this.handle, animDict, animName, f(speedMultiplier));
-  }
-
-  unpinMapEntity(): void {
-    inv<void>('0xD2B9C78537ED5759', this.handle);
-  }
-
-  /**
-   * Get how much of the entity is submerged. 1.0f is whole entity.
-   *
-   * @returns
-   */
-  getSubmergedLevel(): number {
-    return inv<number>('0x4A77C3F73FD9E831', this.handle, raf());
-  }
-
-  /**
-   * @returns
-   */
-  isAttached(): boolean {
-    return inv<boolean>('0xEE6AD63ABF59C0B7', this.handle, rai());
-  }
-
-  /**
-   * SET_ENTITY_A*
-   *
-   * @param p1 
-   */
-  N_0xC0EDEF16D90661EE(p1: number): void {
-    inv<void>('0xC0EDEF16D90661EE', this.handle, f(p1));
-  }
-
-  /**
-   * @param looted 
-   */
-  setFullyLooted(looted: boolean): void {
-    inv<void>('0x6BCF5F3D8FFE988D', this.handle, looted);
+    return inv<number>('0x5594AFE9DE0C01B7', this.handle);
   }
 
   /**
+   * enum eCarriableState
+   * {
+   * CARRIABLE_STATE_NONE,
+   * CARRIABLE_STATE_TRANSITIONING_TO_HOGTIED,
+   * CARRIABLE_STATE_CARRIABLE_INTRO,
+   * CARRIABLE_STATE_CARRIABLE,
+   * CARRIABLE_STATE_BEING_PICKED_UP_FROM_GROUND,
+   * CARRIABLE_STATE_CARRIED_BY_HUMAN,
+   * CARRIABLE_STATE_BEING_PLACED_ON_GROUND,
+   * CARRIABLE_STATE_CARRIED_BY_MOUNT,
+   * CARRIABLE_STATE_BEING_PLACED_ON_MOUNT,
+   * CARRIABLE_STATE_BEING_PICKED_UP_FROM_MOUNT,
+   * CARRIABLE_STATE_BEING_CUT_FREE,
+   * CARRIABLE_STATE_BEING_PLACED_ON_GROUND_ESCAPE,
+   * CARRIABLE_STATE_BEING_PLACED_IN_VEHICLE
+   * };
+   *
    * @returns
    */
-  isAttachedToAnyVehicle(): boolean {
-    return inv<boolean>('0x12DF6E0D2E736749', this.handle, rai());
+  getCarriableState(): number {
+    return inv<number>('0x61914209C36EFDDB', this.handle, rai());
   }
 
   /**
-   * @param p1 
+   * @param value 
    */
-  N_0xA48E4801DEBDF7E4(p1: boolean): void {
-    inv<void>('0xA48E4801DEBDF7E4', this.handle, p1);
+  setMaxHealth(value: number): void {
+    inv<void>('0x166E7CF68597D8B5', this.handle, value);
   }
 
   /**
-   * @param toggle 
-   * @param keepPhysics 
+   * Params: p1 (probably animType) = 1, 0
+   *
+   * @param p1 
+   * @returns
    */
-  setCompletelyDisableCollision(toggle: boolean, keepPhysics: boolean): void {
-    inv<void>('0xE0580EC84813875A', this.handle, toggle, keepPhysics);
+  isPlayingAnyAnim(p1: number): boolean {
+    return inv<boolean>('0x0B7CB1300CBFE19C', this.handle, p1, rai());
   }
 
   /**
-   * @param p1 
+   * @param enabled 
    */
-  N_0xCDB682BB47C02F0A(p1: string | number): void {
-    inv<void>('0xCDB682BB47C02F0A', this.handle, _h(p1));
+  setLightsEnabled(enabled: boolean): void {
+    inv<void>('0xEBDC12861D079ABA', this.handle, enabled);
   }
 
   /**
-   * @param volume 
-   * @param p2 
-   * @param p3 
+   * Offset values are relative to the entity. x = left/right
+   * y = forward/backward
+   * z = up/down
+   *
+   * @param offset 
    * @returns
    */
-  isInVolume(volume: number, p2: boolean, p3: number): boolean {
-    return inv<boolean>('0x5A5526BC09C06623', this.handle, volume, p2, p3, rai());
+  getOffsetFromInWorldCoords(offset: Vector3): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x1899F328B0E12848', this.handle, f(offset.x), f(offset.y), f(offset.z), rav()));
   }
 
   /**
-   * @returns rightVector; forwardVector; upVector; position
+   * 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
    */
-  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])];
+  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());
   }
 
   /**
-   * 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 toggle 
    */
-  N_0x371D179701D9C082(): void {
-    inv<void>('0x371D179701D9C082', this.handle);
+  setVisible(toggle: boolean): void {
+    inv<void>('0x1794B4FCC84D812F', this.handle, toggle);
   }
 
   /**
-   * @param p1 
-   * @returns
+   * Old name: _SET_ENTITY_CLEANUP_BY_ENGINE
+   *
+   * @param toggle 
    */
-  getMaxHealth(p1: boolean): number {
-    return inv<number>('0x15D757606D170C3C', this.handle, p1, rai());
+  setShouldFreezeWaitingOnCollision(toggle: boolean): void {
+    inv<void>('0x740CB4F3F602C9F4', this.handle, toggle);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param time 
+   * Note: this native was removed in 1232 but added back in 1311
+   * Old name: _GET_ENTITY_PROOFS
+   *
+   * @returns
    */
-  setAnimCurrentTime(animDict: string | null, animName: string | null, time: number): void {
-    inv<void>('0x11CDABDC7783B2BC', this.handle, animDict, animName, f(time));
+  getProofs(): number {
+    return inv<number>('0x6CF0DAD7FA1088EA', 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.
+   * 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 alive 
-   * @param realCoords 
-   * @returns
+   * @param alphaLevel 
+   * @param skin 
    */
-  getCoords(alive: boolean, realCoords: boolean): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0xA86D5F069399F44D', this.handle, alive, realCoords, rav()));
+  setAlpha(alphaLevel: number, skin: boolean): void {
+    inv<void>('0x0DF7692B1D9E7BA7', this.handle, alphaLevel, skin);
   }
 
   /**
    * @returns
    */
-  isAnObject(): boolean {
-    return inv<boolean>('0x0A27A546A375FDEF', this.handle, rai());
+  getThreatTier(): number {
+    return inv<number>('0xE12F56CB25D9CE23', this.handle, rai());
   }
 
   /**
@@ -1396,102 +1449,102 @@ export class Entity implements IHandle {
   }
 
   /**
-   * 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 
+   * @returns
    */
-  setLodDist(value: number): void {
-    inv<void>('0x5FB407F0A7C877BF', this.handle, value);
+  isUpsidedown(): boolean {
+    return inv<boolean>('0x109DE3DA41AAD94A', this.handle, rai());
   }
 
   /**
-   * @param toggle 
+   * @param p1 
+   * @returns
    */
-  setDynamic(toggle: boolean): void {
-    inv<void>('0xFBFC4473F66CE344', this.handle, toggle);
+  doesBelongToThisScript(p1: boolean): boolean {
+    return inv<boolean>('0x622B1980CBE13332', this.handle, p1, rai());
   }
 
   /**
-   * @param radius 
+   * Returns a hash of an entity's name. (Alternative Name: _GET_ENTITY_PROMPT_NAME_HASH)
+   *
+   * @returns
    */
-  setCustomPickupRadius(radius: number): void {
-    inv<void>('0x482D17E45665DA44', this.handle, f(radius));
+  getCarriableFromEntity(): number {
+    return (inv<number>('0x31FEF6A20F00B963', this.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * @returns
+   * @param toggle 
+   * @param keepPhysics 
    */
-  getPopulationType(): number {
-    return inv<number>('0xADE28862B6D7B85B', this.handle, rai());
+  setCollision(toggle: boolean, keepPhysics: boolean): void {
+    inv<void>('0xF66F820909453B8C', this.handle, toggle, keepPhysics);
   }
 
   /**
+   * @param p1 
    * @returns
    */
-  isAVehicle(): boolean {
-    return inv<boolean>('0xC3D96AF45FCCEC4C', this.handle, rai());
+  placeOnGroundProperly(p1: boolean): any {
+    return inv<number>('0x9587913B9E772D29', this.handle, p1);
   }
 
   /**
-   * @param pos 
-   * @param atTop 
-   * @param inWorldCoords 
    * @returns
    */
-  getHeight(pos: Vector3, atTop: boolean, inWorldCoords: boolean): number {
-    return inv<number>('0x296DEBC84474B375', this.handle, f(pos.x), f(pos.y), f(pos.z), atTop, inWorldCoords, raf());
+  isInWater(): boolean {
+    return inv<boolean>('0xDDE5C125AC446723', this.handle, rai());
   }
 
   /**
-   * @param pos 
-   * @returns
+   * @returns Returns `true` if the entity exists
    */
-  getOffsetFromGivenWorldCoords(pos: Vector3): Vector3 {
-    return Vector3.fromArray(inv<number[]>('0x497C6B1A2C9AE69C', this.handle, f(pos.x), f(pos.y), f(pos.z), rav()));
-  }
-
-  addTrackingTrails(): void {
-    inv<void>('0x1AD922AB5038DEF3', this.handle);
+  doesExist(): boolean {
+    return inv<boolean>('0xD42BD6EB2E0F1677', this.handle, rai());
   }
 
   /**
-   * @param toggle 
+   * @returns
    */
-  setCanClimbOnEntity(toggle: boolean): void {
-    inv<void>('0x24AED2A608F93C4C', this.handle, toggle);
+  getAlpha(): number {
+    return inv<number>('0x1BB501624FAF2BEA', this.handle, rai());
   }
 
   /**
-   * @returns minimum; maximum
+   * This native only works on `Ped` and `Object` entity types
+   *
+   * @param flagId Refer to [enum: eCarryingFlags]
+   * @returns
    */
-  getWorldPositionOfDimensions(): [Vector3, Vector3] {
-    const result = inv<[number[], number[]]>('0xF3FDA9A617A15145', this.handle, pvv(), pvv());
-    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
+  getCarryingFlag(flagId: eCarryingFlags): number {
+    return inv<number>('0x808077647856DE62', this.handle, flagId, rai());
   }
 
   /**
    * @param p1 
-   * @returns
    */
-  isUnderwater(p1: boolean): any {
-    return inv<number>('0xD4E5C1E93C466127', this.handle, p1);
+  forceAiAndAnimationUpdate(p1: boolean): void {
+    inv<void>('0x4C9E96473D4F1A88', this.handle, p1);
   }
 
   /**
-   * @param animation 
-   * @param animGroup 
-   * @param p3 
-   * @returns
+   * Axis - Invert Axis Flags
+   *
+   * @param pos 
+   * @param xAxis 
+   * @param yAxis 
+   * @param zAxis 
    */
-  stopAnim(animation: string | null, animGroup: string | null, p3: number): any {
-    return inv<number>('0x786591D986DE9159', this.handle, animation, animGroup, f(p3));
+  setCoordsNoOffset(pos: Vector3, xAxis: boolean, yAxis: boolean, zAxis: boolean): void {
+    inv<void>('0x239A3351AC1DA385', this.handle, f(pos.x), f(pos.y), f(pos.z), xAxis, yAxis, zAxis);
   }
 
   /**
+   * Returns (CUR_HEALTH / MAX_HEALTH)
+   *
    * @returns
    */
-  hasCollidedWithAnything(): boolean {
-    return inv<boolean>('0xDF18751EC74F90FF', this.handle, rai());
+  getHealthFloat(): number {
+    return inv<number>('0x96C638784DB4C815', this.handle, raf());
   }
 
   /**
@@ -1628,54 +1681,6 @@ export class Entity implements IHandle {
     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
-   */
-  getVehicleIndexFromIndex(): Vehicle | null {
-    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xDF1E5AAC561AFC59', this.handle, rai()));
-  }
-
-  /**
-   * @returns
-   */
-  isVisible(): boolean {
-    return inv<boolean>('0xFFC96ECB7FA404CA', this.handle, rai());
-  }
-
-  /**
-   * SET_ENTITY_LO*
-   *
-   * @param toggle 
-   */
-  N_0xFF9965C47FA404DA(toggle: boolean): void {
-    inv<void>('0xFF9965C47FA404DA', this.handle, toggle);
-  }
-
-  /**
-   * Valid indices: 0 - 3
-   * Index 1 always returns a `hogtied` config, doesn't matter the entity.
-   * It's for humans only and the ped must be resurrected first if it's dead.
-   *
-   * @param index 
-   * @returns
-   */
-  getOptimalCarryConfig(index: number): string | number {
-    return (inv<number>('0x34F008A7E48C496B', this.handle, index, rai())) & 0xFFFFFFFF;
-  }
-
-  setFadeIn(): void {
-    inv<void>('0xA91E6CF94404E8C9', this.handle);
-  }
-
-  /**
-   * @returns
-   */
-  hasBeenDamagedByAnyPed(): boolean {
-    return inv<boolean>('0x9934E9C42D52D87E', this.handle, rai());
-  }
-
 }
 
 registerHandle('Entity', Entity);