@nativewrappers/redm-codegen 0.0.4 → 0.0.6

package/src/classes/PedTask.ts

@@ -19,6 +19,189 @@ export class PedTask extends BaseTask {
     super(entity);
   }
 
+  /**
+   * @param toggle 
+   */
+  set PedPathCanUseLadders(toggle: boolean) {
+    inv<void>('0x77A5B103C87F476E', this.entity.handle, toggle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  stopAnimPlayback(p1: number, p2: boolean): void {
+    inv<void>('0xEE08C992D238C5D1', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param targetPed 
+   * @param p2 
+   * @returns
+   */
+  confront(targetPed: Ped, p2: number): any {
+    return inv<number>('0x3A2A2071DF5CC569', this.entity.handle, targetPed.handle, p2);
+  }
+
+  N_0x1F298C7BD30D1240(): void {
+    inv<void>('0x1F298C7BD30D1240', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  setCrouchMovement(p1: boolean, p2: any, p3: boolean): void {
+    inv<void>('0x17293C633C8AC019', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * Tells the ped to go to an offset coord from an entity, without using the navmesh. if timeBeforeTeleport is -1 the ped will never warp, p7 is 1 or 0 still unknown param
+   *
+   * @param entity 
+   * @param offset 
+   * @param moveBlendRatio 
+   * @param timeBeforeTeleport 
+   * @param p7 
+   */
+  goStraightToCoordRelativeToEntity(entity: Entity, offset: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, p7: number): void {
+    inv<void>('0x61E360B7E040D12E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), moveBlendRatio, timeBeforeTeleport, p7);
+  }
+
+  /**
+   * Sets the time it takes for a hogtied ped to escape
+   * -1.0f for ped to never escape
+   *
+   * @param time 
+   */
+  set HogtieEscapeTimer(time: number) {
+    inv<void>('0xAB591AE6B48B913E', this.entity.handle, f(time));
+  }
+
+  /**
+   * Makes the ped run to take cover
+   */
+  stayInCover(): void {
+    inv<void>('0xE5DA8615A6180789', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   */
+  followWaypointRecordingAdvanced(p1: any): void {
+    inv<void>('0x0CFC13EBC19BCA52', this.entity.handle, p1);
+  }
+
+  /**
+   * Tells the ped to go to a coord, without using the navemesh. if timeBeforeTeleport is -1 the ped will never warp, p8 is always 0 or 1 still unknown
+   *
+   * @param pos 
+   * @param moveBlendRatio 
+   * @param timeBeforeTeleport 
+   * @param finalHeading 
+   * @param targetRadius 
+   * @param p8 
+   */
+  goStraightToCoord(pos: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, finalHeading: number, targetRadius: number, p8: number): void {
+    inv<void>('0xD76B57B44F1E6F8B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(moveBlendRatio), timeBeforeTeleport, f(finalHeading), f(targetRadius), p8);
+  }
+
+  /**
+   * @param pos 
+   * @param speedMultiplier 
+   * @param timeout 
+   * @param stoppingRange 
+   * @param flags 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param entity 
+   * @param unk 
+   */
+  followNavMeshToCoordAdvanced(pos: Vector3, speedMultiplier: number, timeout: number, stoppingRange: number, flags: number, p8: number, p9: number, p10: number, entity: Entity, unk: number): void {
+    inv<void>('0x17F58B88D085DBAC', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speedMultiplier), timeout, f(stoppingRange), flags, f(p8), f(p9), f(p10), entity.handle, f(unk));
+  }
+
+  /**
+   * @param radius 
+   * @param time 
+   * @param flags 
+   */
+  combatHatedTargetsAroundPedTimed(radius: number, time: number, flags: number): void {
+    inv<void>('0x2BBA30B854534A0C', this.entity.handle, f(radius), time, flags);
+  }
+
+  /**
+   * @returns
+   */
+  get IsPedRunning(): boolean {
+    return !!inv<boolean>('0xC5286FFC176F28A2', this.entity.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  get IsPedSprinting(): boolean {
+    return !!inv<boolean>('0x57E457CD2C0FC168', this.entity.handle, rai());
+  }
+
+  /**
+   * @param useSlidingSurfaces 
+   */
+  set PedPathMayUseSlidingSurfaces(useSlidingSurfaces: boolean) {
+    inv<void>('0x06ECF3925BC2ABAE', this.entity.handle, useSlidingSurfaces);
+  }
+
+  /**
+   * Force a ped that is already attacking to aim directly at the specified world coordinates.
+   *
+   * @param pos 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  forcePointAimAtCoord(pos: Vector3, p4?: number, p5?: boolean, p6?: boolean): void {
+    inv<void>('0x41323F4E0C4AE94B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5, p6);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  swapWeapon(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0xA21C51255B205245', this.entity.handle, p1, p2, p3, p4);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  gotoEntityOffsetXyz(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0xFA6DA9D151769392', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * @param pos 
+   * @param distance 
+   * @param duration 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   */
+  useNearestScenarioToCoordWarp(pos: Vector3, distance: number, duration: number, p6: boolean, p7: boolean, p8: boolean, p9: boolean): void {
+    inv<void>('0x58E2E0F23F6B76C3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), duration, p6, p7, p8, p9);
+  }
+
   /**
    * Baits: p_fishHook02x, p_baitBread01x, p_baitCorn01x, p_baitCheese01x, p_baitWorm01x, p_baitCricket01x, p_crawdad01x, p_finisheDragonfly01x, p_finisdFishlure01x, p_finishdCrawd01x, p_finisheDragonflyLegendary01x, p_finisdFishlureLegendary01x, p_finishdCrawdLegendary01x, p_lgoc_spinner_v4
    *
@@ -48,8 +231,8 @@ export class PedTask extends BaseTask {
   /**
    * @returns Returns `true` if the specified `ped` is currently in combat using a ranged weapon, and is ready to shoot (actively attempting to attack)
    */
-  getTaskCombatReadyToShoot(): boolean {
-    return inv<boolean>('0x5EA655F01D93667A', this.entity.handle, rai());
+  get TaskCombatReadyToShoot(): boolean {
+    return !!inv<boolean>('0x5EA655F01D93667A', this.entity.handle, rai());
   }
 
   /**
@@ -115,10 +298,83 @@ export class PedTask extends BaseTask {
     inv<void>('0xC35B5CDB2824CF69', this.entity.handle);
   }
 
+  /**
+   * @param p1 
+   * @returns
+   */
+  N_0x2D657B10F211C572(p1: number): any {
+    return inv<number>('0x2D657B10F211C572', this.entity.handle, f(p1));
+  }
+
+  /**
+   * Coords: volume coords used in R* Script smuggler2
+   * p4/p5 = 0 in R* Scripts previous name TASK_COMBAT_PED_3
+   *
+   * @param pos 
+   * @param p4 
+   * @param p5 
+   */
+  combatPedAtCoords(pos: Vector3, p4: number, p5: number): void {
+    inv<void>('0xC624414FA748B9BA', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5);
+  }
+
+  /**
+   * Makes the specified ped stand still for (time) milliseconds.
+   *
+   * @param time 
+   */
+  standStill(time: number): void {
+    inv<void>('0x919BE13EED931959', this.entity.handle, time);
+  }
+
+  /**
+   * @param animDictionary 
+   * @param animationName 
+   * @param p3 
+   */
+  stopAnimTask(animDictionary: string | null, animationName: string | null, p3: number): void {
+    inv<void>('0x97FF36A1D40EA00A', this.entity.handle, animDictionary, animationName, f(p3));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  turnToFaceClosestPed(p1: number, p2: number, p3: number): void {
+    inv<void>('0x84179419DBDD36F2', this.entity.handle, f(p1), f(p2), p3);
+  }
+
+  /**
+   * Fishing Research: https://pastebin.com/NmK5ZLVs
+   * Only used in R* Scripts fishing_core and av_fishing_river
+   *
+   * @returns p1
+   */
+  get TaskFishing(): [any, number] {
+    const result = inv<[number, number]>('0xF3735ACD11ACD500', this.entity.handle, pvi());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  shockingEventReact(p1: any, p2: any): void {
+    inv<void>('0x452419CBD838065B', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @returns
+   */
+  N_0xB520DBDA7FCF573F(): boolean {
+    return !!inv<boolean>('0xB520DBDA7FCF573F', this.entity.handle, rai());
+  }
+
   /**
    * @param neverUseInteriors 
    */
-  setPedPathNeverUseInteriors(neverUseInteriors: boolean): void {
+  set PedPathNeverUseInteriors(neverUseInteriors: boolean) {
     inv<void>('0x42CFD8FD8CC8DC69', this.entity.handle, neverUseInteriors);
   }
 
@@ -178,117 +434,148 @@ export class PedTask extends BaseTask {
   }
 
   /**
-   * @param p1 
+   * @returns
    */
-  N_0xFFB520A3E16F7B7B(p1: number): void {
-    inv<void>('0xFFB520A3E16F7B7B', this.entity.handle, f(p1));
-  }
-
-  persistentCharacter(): void {
-    inv<void>('0x4391700CBD89C3D8', this.entity.handle);
+  get PedWaypointOverrideSpeed(): number {
+    return inv<number>('0xD39A2F3E7FCAFF08', this.entity.handle, raf());
   }
 
   /**
-   * @param speed 
-   * @param p2 
-   * @param p3 
-   * @param p4 
+   * Climbs or vaults the nearest thing.
+   *
+   * @param unused 
    */
-  waypointPlaybackOverrideSpeed(speed: number, p2: any, p3: any, p4: any): void {
-    inv<void>('0x7D7D2B47FA788E85', this.entity.handle, f(speed), p2, p3, p4);
+  climb(unused: boolean): void {
+    inv<void>('0x89D9FCC2435112F1', this.entity.handle, unused);
+  }
+
+  /**
+   * Old name: _TASK_VEHICLE_DRIVE_TO_POINT
+   * flag: 524419 and 0 in shop_horse_shop R* Script
+   *
+   * @param vehicle 
+   * @param pos 
+   * @param p5 
+   * @param p6 
+   * @param flag 
+   */
+  vehicleDriveStraightToPoint(vehicle: Vehicle, pos: Vector3, p5: number, p6: number, flag: number): void {
+    inv<void>('0x089FF2FB965F0A29', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(p5), f(p6), flag);
   }
 
   /**
    * @param p1 
    * @param p2 
    * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
+   * @param p15 
    */
-  climbLadder(p1: number, p2: boolean, p3: boolean): void {
-    inv<void>('0xB6C987F9285A3814', this.entity.handle, f(p1), p2, p3);
+  goToCoordWhileAimingAtCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any, p15: any): void {
+    inv<void>('0x639C0425A0B4E77E', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
   }
 
   /**
-   * Makes a ped run away from another ped (fleeFromTarget) fleeDistance = ped will flee this distance
-   * fleeTime = ped will flee for this amount of time, set to "-1" to flee forever
-   * fleeType = can be 0, R* Scripts: fm_mission/race_controller: 66048; fme_escaped_convicts: 2260992, 2523136, 2359296; la_alligator/fox: 2097152; net_fetch: 17301536; net_stable_mount: 540928
-   * fleeSpeed = mostly 3f, rarely 1f in R* Scripts
+   * flags: 0 = HANDS_UP_NOTHING; 1 = HANDS_UP_STRAIGHT_TO_LOOP
    *
-   * @param fleeFromTarget 
-   * @param fleeDistance 
-   * @param fleeTime 
-   * @param fleeType Refer to [enum: eFleeStyle]
-   * @param fleeSpeed 
-   * @param targetPed 
+   * @param duration 
+   * @param facingPed 
+   * @param timeToFacePed 
+   * @param flags 
    */
-  smartFleePed(fleeFromTarget: Ped, fleeDistance: number, fleeTime: number, fleeType: number, fleeSpeed: number, targetPed: Ped): void {
-    inv<void>('0x22B0D0E37CCB840D', this.entity.handle, fleeFromTarget.handle, f(fleeDistance), fleeTime, fleeType, f(fleeSpeed), targetPed.handle);
+  handsUp(duration: number, facingPed: Ped, timeToFacePed: number, flags: number): void {
+    inv<void>('0xF2EAB31979A7F910', this.entity.handle, duration, facingPed.handle, timeToFacePed, flags);
   }
 
   /**
-   * @param pos 
-   * @param time 
-   * @param p5 
+   * timer: in ms, if it reaches 0 it will auto warp the ped on the horse
+   * Flags will still apply to mountStyle
+   *
+   * @param mount 
+   * @param timer 
+   * @param seatIndex Refer to [enum: eVehicleSeat]
+   * @param pedSpeed 
+   * @param mountStyle 
    * @param p6 
+   * @param p7 
    */
-  aimGunAtCoord(pos: Vector3, time: number, p5: boolean, p6: boolean): void {
-    inv<void>('0x6671F3EEC681BDA1', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), time, p5, p6);
+  mountAnimal(mount: Ped, timer: number, seatIndex: eVehicleSeat, pedSpeed: number, mountStyle: number, p6: any, p7: any): void {
+    inv<void>('0x92DB0739813C5186', this.entity.handle, mount.handle, timer, seatIndex, f(pedSpeed), mountStyle, p6, p7);
   }
 
   /**
-   * @param targetPed 
+   * @returns
    */
-  cutFreeHogtiedTargetPed(targetPed: Ped): void {
-    inv<void>('0x81D16C4FF3A77ADF', this.entity.handle, targetPed.handle);
+  get PedIsIgnoringDeadBodies(): any {
+    return inv<number>('0x1948BBE561A2375A', this.entity.handle);
   }
 
   /**
-   * @param signalName 
-   * @param value 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
    */
-  setTaskMoveNetworkSignalFloat2(signalName: string | null, value: number): void {
-    inv<void>('0x099D4A855D53B03B', this.entity.handle, signalName, f(value));
+  setSphereDefensiveArea(p1: number, p2: number, p3: number, p4: number): void {
+    inv<void>('0x933C06518B52A9A4', this.entity.handle, f(p1), f(p2), f(p3), f(p4));
   }
 
   /**
    * @param p1 
    * @param p2 
+   * @param p3 
+   * @param p4 
    */
-  ambientAnimalHunt(p1: any, p2: any): void {
-    inv<void>('0x4B39D8F9D0FE7749', this.entity.handle, p1, p2);
+  useRandomScenarioInGroup(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0x14747F4A5971DE4E', this.entity.handle, p1, p2, p3, p4);
   }
 
   /**
-   * @param goToLocationX 
-   * @param goToLocationY 
-   * @param goToLocationZ 
-   * @param focusLocationX 
-   * @param focusLocationY 
-   * @param focusLocationZ 
-   * @param speed 
-   * @param shootAtEnemies 
-   * @param distanceToStopAt 
-   * @param noRoadsDistance 
-   * @param unkTrue 
-   * @param unkFlag 
-   * @param aimingFlag 
-   * @param firingPattern 
+   * enum eWhistleType
+   * {
+   * WHISTLE_MAIN,
+   * WHISTLE_SECONDARY,
+   * WHISTLE_DOUBLE,
+   * WHISTLE_URGENT,
+   * WHISTLE_LONG
+   * };
+   *
+   * @param p1 
+   * @param whistleType 
    */
-  goToCoordAndAimAtHatedEntitiesNearCoord(goToLocationX: number, goToLocationY: number, goToLocationZ: number, focusLocationX: number, focusLocationY: number, focusLocationZ: number, speed: number, shootAtEnemies: boolean, distanceToStopAt: number, noRoadsDistance: number, unkTrue: boolean, unkFlag: number, aimingFlag: number, firingPattern: string | number): void {
-    inv<void>('0xA55547801EB331FC', this.entity.handle, f(goToLocationX), f(goToLocationY), f(goToLocationZ), f(focusLocationX), f(focusLocationY), f(focusLocationZ), f(speed), shootAtEnemies, f(distanceToStopAt), f(noRoadsDistance), unkTrue, unkFlag, aimingFlag, _h(firingPattern));
+  goToWhistle(p1: Ped, whistleType: number): void {
+    inv<void>('0xBAD6545608CECA6E', this.entity.handle, p1.handle, whistleType);
+  }
+
+  /**
+   * @param pos 
+   * @param duration 
+   * @param flags 
+   * @param p6 
+   * @param p7 
+   */
+  lookAtCoord(pos: Vector3, duration: number, flags: number, p6: number, p7: boolean): void {
+    inv<void>('0x6FA46612594F7973', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration, flags, p6, p7);
   }
 
   /**
-   * @param itemHash 
-   * @param interactionAnimHash 
-   * @param p3 
    * @returns
    */
-  canStartItemInteraction(itemHash: string | number, interactionAnimHash: string | number, p3: number): any {
-    return inv<number>('0x2D19BC4DF626CBE7', this.entity.handle, _h(itemHash), _h(interactionAnimHash), p3);
+  get IsPedInHitReact(): boolean {
+    return !!inv<boolean>('0xF330A5C062B29BED', this.entity.handle, rai());
   }
 
   /**
-   * @param targetPed 
+   * @param p1 
    * @param p2 
    * @param p3 
    * @param p4 
@@ -296,268 +583,291 @@ export class PedTask extends BaseTask {
    * @param p6 
    * @param p7 
    * @param p8 
-   * @param p9 
-   * @param p10 
    */
-  followAndConverseWithPed(targetPed: Ped, p2: any, p3: any, p4: number, p5: number, p6: number, p7: any, p8: any, p9: number, p10: number): void {
-    inv<void>('0x489FFCCCE7392B55', this.entity.handle, targetPed.handle, p2, p3, f(p4), f(p5), p6, p7, p8, f(p9), f(p10));
+  N_0x3FFCD7BBA074CC80(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0x3FFCD7BBA074CC80', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * @returns
+   */
+  get IsMountedWeaponTaskUnderneathDrivingTask(): boolean {
+    return !!inv<boolean>('0xA320EF046186FA3B', this.entity.handle, rai());
+  }
+
+  /**
+   * flags: See TASK_ENTER_VEHICLE
+   *
+   * @param p1 
+   * @param flags Refer to [enum: eEnterExitVehicleFlags]
+   */
+  disembarkNearestTrainCarriage(p1: number, flags: number): void {
+    inv<void>('0x0A11F3BDEC03ED5F', this.entity.handle, f(p1), flags);
   }
 
   /**
+   * fleeType: see TASK_FLEE_COORD
+   *
+   * @param fleeFromTarget 
    * @param pos 
    * @param distance 
-   * @param p5 
    * @param p6 
    * @param p7 
    * @param p8 
+   * @param targetPed 
    */
-  useNearestScenarioChainToCoord(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
-    inv<void>('0x9FDA1B3D7E7028B3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
+  fleeFromPed(fleeFromTarget: Ped, pos: Vector3, distance: number, p6: number, p7: number, p8: number, targetPed: Ped): void {
+    inv<void>('0x7B74D8EEDE9B5727', this.entity.handle, fleeFromTarget.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p6, p7, f(p8), targetPed.handle);
   }
 
   /**
-   * @param eventName 
    * @returns
    */
-  getTaskMoveNetworkEvent(eventName: string | null): boolean {
-    return inv<boolean>('0xB4F47213DF45A64C', this.entity.handle, eventName, rai());
+  get IsPedGettingUp(): boolean {
+    return !!inv<boolean>('0x2A74E1D5F2F00EEC', this.entity.handle, rai());
   }
 
   /**
-   * Baits: see 0x9B0C7FA063E67629
-   *
-   * @param bait 
-   * @param withoutBuoy 
+   * @param time 
    */
-  swapFishingBait(bait: string | null, withoutBuoy: boolean): void {
-    inv<void>('0x2C28AC30A72722DA', this.entity.handle, bait, withoutBuoy);
+  duck(time: number): void {
+    inv<void>('0xA14B5FBF986BAC23', this.entity.handle, time);
   }
 
   /**
-   * @returns
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
    */
-  isDrivebyTaskUnderneathDrivingTask(): boolean {
-    return inv<boolean>('0x8785E6E40C7A8818', this.entity.handle, rai());
-  }
-
-  cuffPed(): void {
-    inv<void>('0x7981037A96E7D174', this.entity.handle);
+  robPed(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0x7BB967F85D8CCBDB', this.entity.handle, p1, p2, p3, p4);
   }
 
   /**
-   * This native allows to control the cruise speed of where you want the ped to go
-   * 3rd param might be the entity ped is in? like boat or wagon, 12th param might be the cruiseSpeed of the entity ped is in?
-   * EXAMPLE: TaskGoToCoordAnyMeansExtraParamsWithCruiseSpeed(PlayerPedId(), vector3(x, y, z), 3.0, entity, 1, 0, -1082130432, 0, 101004800, 520, 3.0, 1082130432, 0)
+   * getupSetHash: see nm_blend_out_sets.meta
    *
-   * @param cruiseSpeed 
-   * @param entity 
+   * @param flags 
+   * @param getupSetHash 
+   * @param p3 
    * @param p4 
    * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param cruiseSpeed2 
-   * @param p13 
-   * @param p14 
-   * @returns gotoCoords
    */
-  goToCoordAnyMeansExtraParamsWithCruiseSpeed(cruiseSpeed: number, entity: Entity, p4: number, p5: number, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, cruiseSpeed2: number, p13: any, p14: any): Vector3 {
-    const result = inv<number[]>('0xB8ECD61F531A7B02', this.entity.handle, pvv(), f(cruiseSpeed), entity.handle, p4, p5, p6, p7, p8, p9, p10, p11, f(cruiseSpeed2), p13, p14);
-    return Vector3.fromArray(result);
+  unhogtiePed(flags: number, getupSetHash: string | number, p3: string | null, p4: string | null, p5: number): void {
+    inv<void>('0x79559BAD83CCD038', this.entity.handle, flags, _h(getupSetHash), p3, p4, f(p5));
   }
 
   /**
-   * @returns
+   * hecks if the ped camera is directed at the given coord within the specified radius. https://www.youtube.com/watch?v=iLHXrWVvq_c
+   *
+   * @param coord The coord to check if they're looking at
+   * @param radius The radius of the frustum
+   * @returns Returns `true` if the ped camera is within the range of the frustum, `false` otherwise
    */
-  isTaskMoveNetworkReadyForTransition(): boolean {
-    return inv<boolean>('0x30ED88D5E0C56A37', this.entity.handle, rai());
-  }
-
-  clearDefensiveArea(): void {
-    inv<void>('0x95A6C46A31D1917D', this.entity.handle);
+  isPedLookingAtCoord(coord: Vector3, radius: number): boolean {
+    return !!inv<boolean>('0x508F5053E3F6F0C4', this.entity.handle, f(coord.x), f(coord.y), f(coord.z), f(radius), rai());
   }
 
   /**
-   * @param modifier 
+   * @param entity 
    */
-  setPedPathDeepSnowCostModifier(modifier: number): void {
-    inv<void>('0xE8C296B75EACC357', this.entity.handle, f(modifier));
+  walkAway(entity: Entity): void {
+    inv<void>('0x04ACFAC71E6858F9', this.entity.handle, entity.handle);
   }
 
   /**
    * @returns
    */
-  getItemInteractionItemId(): number {
-    return (inv<number>('0x804425C4BBD00883', this.entity.handle, rai())) & 0xFFFFFFFF;
-  }
-
-  /**
-   * @param entity 
-   * @param mount 
-   * @param p3 
-   */
-  placeCarriedEntityOnMount(entity: Entity, mount: Ped, p3: number): void {
-    inv<void>('0x6D3D87C57B3D52C7', this.entity.handle, entity.handle, mount.handle, f(p3));
+  get HogtieEscapeTimer(): number {
+    return inv<number>('0x4687E69D258BBE41', this.entity.handle, raf());
   }
 
-  detachCarriablePed(): void {
-    inv<void>('0x36D188AECB26094B', this.entity.handle);
+  weapon(): void {
+    inv<void>('0x7157B82D60E4BC46', this.entity.handle);
   }
 
   /**
    * @returns
    */
-  getItemInteractionState(): number {
-    return (inv<number>('0x6AA3DCA2C6F5EB6D', this.entity.handle, rai())) & 0xFFFFFFFF;
+  get IsPedWalking(): boolean {
+    return !!inv<boolean>('0xDE4C184B2B9B071A', this.entity.handle, rai());
   }
 
   /**
-   * @returns
+   * @param p1 
    */
-  getIsPedAimingInTheAir(): any {
-    return inv<number>('0x8785E6E40C7A8819', this.entity.handle);
-  }
+  N_0xFFB520A3E16F7B7B(p1: number): void {
+    inv<void>('0xFFB520A3E16F7B7B', this.entity.handle, f(p1));
+  }
+
+  persistentCharacter(): void {
+    inv<void>('0x4391700CBD89C3D8', this.entity.handle);
+  }
 
   /**
-   * param3: duration in ms, use -1 to look forever
-   * param4: using 2048 is fine
-   * param5: using 3 is fine
-   *
-   * @param lookAtTarget 
-   * @param duration 
+   * @param speed 
+   * @param p2 
    * @param p3 
    * @param p4 
-   * @param p5 
    */
-  lookAtEntity(lookAtTarget: Entity, duration: number, p3: number, p4: number, p5: number): void {
-    inv<void>('0x69F4BE8C8CC4796C', this.entity.handle, lookAtTarget.handle, duration, p3, p4, p5);
+  waypointPlaybackOverrideSpeed(speed: number, p2: any, p3: any, p4: any): void {
+    inv<void>('0x7D7D2B47FA788E85', this.entity.handle, f(speed), p2, p3, p4);
   }
 
   /**
-   * @param taskIndex 
-   * @returns
+   * @param p1 
+   * @param p2 
+   * @param p3 
    */
-  getIsTaskActive(taskIndex: number): boolean {
-    return inv<boolean>('0xB0760331C7AA4155', this.entity.handle, taskIndex, rai());
+  climbLadder(p1: number, p2: boolean, p3: boolean): void {
+    inv<void>('0xB6C987F9285A3814', this.entity.handle, f(p1), p2, p3);
   }
 
   /**
-   * grappleStyle: AR_GRAPPLE_STRUGGLE, AR_ALLIGATOR_LEG_GRAB_CHALLENGE_FAIL, AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_BACK_DEFEND, AR_GRAPPLE_FRONT_FROM_FRONT
+   * Makes a ped run away from another ped (fleeFromTarget) fleeDistance = ped will flee this distance
+   * fleeTime = ped will flee for this amount of time, set to "-1" to flee forever
+   * fleeType = can be 0, R* Scripts: fm_mission/race_controller: 66048; fme_escaped_convicts: 2260992, 2523136, 2359296; la_alligator/fox: 2097152; net_fetch: 17301536; net_stable_mount: 540928
+   * fleeSpeed = mostly 3f, rarely 1f in R* Scripts
    *
-   * @param grappleTarget 
-   * @param grappleStyle 
-   * @param p3 
-   * @param p4 
+   * @param fleeFromTarget 
+   * @param fleeDistance 
+   * @param fleeTime 
+   * @param fleeType Refer to [enum: eFleeStyle]
+   * @param fleeSpeed 
+   * @param targetPed 
+   */
+  smartFleePed(fleeFromTarget: Ped, fleeDistance: number, fleeTime: number, fleeType: number, fleeSpeed: number, targetPed: Ped): void {
+    inv<void>('0x22B0D0E37CCB840D', this.entity.handle, fleeFromTarget.handle, f(fleeDistance), fleeTime, fleeType, f(fleeSpeed), targetPed.handle);
+  }
+
+  /**
+   * @param pos 
+   * @param time 
    * @param p5 
    * @param p6 
    */
-  putPedDirectlyIntoGrapple(grappleTarget: Ped, grappleStyle: string | number, p3: number, p4: number, p5: boolean, p6: number): void {
-    inv<void>('0xA05F3F20889D7A5B', this.entity.handle, grappleTarget.handle, _h(grappleStyle), f(p3), f(p4), p5, p6);
+  aimGunAtCoord(pos: Vector3, time: number, p5: boolean, p6: boolean): void {
+    inv<void>('0x6671F3EEC681BDA1', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), time, p5, p6);
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * @param targetPed 
    */
-  combatAnimalWarn(p1: any, p2: any): void {
-    inv<void>('0xF960F3D57B660E96', this.entity.handle, p1, p2);
+  cutFreeHogtiedTargetPed(targetPed: Ped): void {
+    inv<void>('0x81D16C4FF3A77ADF', this.entity.handle, targetPed.handle);
   }
 
   /**
-   * @param toggle 
+   * @param signalName 
+   * @param value 
    */
-  setPedIgnoreDeadBodies(toggle: boolean): void {
-    inv<void>('0x013A7BA5015C1372', this.entity.handle, toggle);
+  setTaskMoveNetworkSignalFloat2(signalName: string | null, value: number): void {
+    inv<void>('0x099D4A855D53B03B', this.entity.handle, signalName, f(value));
   }
 
   /**
    * @param p1 
    * @param p2 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
    */
-  moveInTrafficToDestination(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
-    inv<void>('0xDCA3A13F7A45338B', this.entity.handle, p1, p2, p3, p4, p5, p6, p7);
+  ambientAnimalHunt(p1: any, p2: any): void {
+    inv<void>('0x4B39D8F9D0FE7749', this.entity.handle, p1, p2);
   }
 
   /**
-   * @param attacker 
-   * @param p2 
-   * @returns Returns `true` on success, or `false` if `attacker` doesn't exist, or is dead.
+   * @param p1 
+   * @param taskFlag Refer to [enum: eEnterExitVehicleFlags]
    */
-  intimidated(attacker: Ped, p2: boolean): boolean {
-    return inv<boolean>('0x648B75D44930D6BD', this.entity.handle, attacker.handle, p2, rai());
+  leaveAnyVehicle(p1: number, taskFlag: number): void {
+    inv<void>('0x504D54DF3F6F2247', this.entity.handle, p1, taskFlag);
   }
 
   /**
-   * @returns
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
    */
-  waypointPlaybackGetIsShooting(): any {
-    return inv<number>('0xA5B94DF8AF058F46', this.entity.handle);
+  combatPed(targetPed: Ped, p2: number, p3: number): void {
+    inv<void>('0xF166E48407BAC484', this.entity.handle, targetPed.handle, p2, p3);
   }
 
   /**
-   * @param pos 
-   * @param distance 
+   * Params: p4 = -1.0f, p5 = -1, p6 = 0 in R* Scripts
+   *
+   * @param fleeFromTarget 
+   * @param fleeStyle Refer to [enum: eFleeStyle]
+   * @param flag 
+   * @param p4 
    * @param p5 
    * @param p6 
-   * @param p7 
-   * @param p8 
    */
-  useNearestScenarioChainToCoordWarp(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
-    inv<void>('0x97A28E63F0BA5631', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
+  fleePed(fleeFromTarget: Ped, fleeStyle: number, flag: number, p4: number, p5: number, p6: number): void {
+    inv<void>('0xFD45175A6DFD7CE9', this.entity.handle, fleeFromTarget.handle, fleeStyle, flag, f(p4), p5, p6);
   }
 
   /**
-   * returned values:
-   * 0 to 7 = task that's currently in progress, 0 meaning the first one.
-   * -1 no task sequence in progress.
-   *
    * @returns
    */
-  getSequenceProgress(): number {
-    return inv<number>('0x00A9010CFE1E3533', this.entity.handle, rai());
+  get IsPedLeadingHorse(): any {
+    return inv<number>('0xEFC4303DDC6E60D3', this.entity.handle);
   }
 
   /**
-   * @returns
+   * @param entity 
+   * @param offset 
+   * @param movementSpeed 
+   * @param timeout 
+   * @param stoppingRange 
+   * @param persistFollowing 
+   * @param p9 
+   * @param walkOnly 
+   * @param p11 
+   * @param p12 
+   * @param p13 
    */
-  waypointPlaybackGetIsAiming(): any {
-    return inv<number>('0xD73A5D1F0325C71C', this.entity.handle);
+  followToOffsetOfEntity(entity: Entity, offset: Vector3, movementSpeed: number, timeout: number, stoppingRange: number, persistFollowing: boolean, p9: boolean, walkOnly: boolean, p11: boolean, p12: boolean, p13: boolean): void {
+    inv<void>('0x304AE42E357B8C7E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), f(movementSpeed), timeout, f(stoppingRange), persistFollowing, p9, walkOnly, p11, p12, p13);
   }
 
   /**
-   * @param toggle 
+   * duration: the amount of time in milliseconds to do the task. -1 will keep the task going until either another task is applied, or CLEAR_ALL_TASKS() is called with the ped
+   *
+   * @param targetEntity 
+   * @param duration 
+   * @param p3 
+   * @param p4 
    */
-  setPedPathCanUseLadders(toggle: boolean): void {
-    inv<void>('0x77A5B103C87F476E', this.entity.handle, toggle);
+  aimGunAtEntity(targetEntity: Entity, duration: number, p3: boolean, p4: number): void {
+    inv<void>('0x9B53BB6E8943AF53', this.entity.handle, targetEntity.handle, duration, p3, p4);
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * `_GET_ANIM_SCENE_FROM_PED_*` But in a strange way, it also seems to work with the butcher's meat-cutting animscene. This does not return AnimScenes in general — it seems restricted to
+   * SEARCH-related scenes (needs more research).
+   *
+   * @returns Returns the AnimScene handle currently associated with the given Ped, but only when the anim event "SEARCHSTART" has fired on that Ped.
    */
-  stopAnimPlayback(p1: number, p2: boolean): void {
-    inv<void>('0xEE08C992D238C5D1', this.entity.handle, p1, p2);
+  N_0x2C497BDEF897C6DF(): AnimScene | null {
+    return createFromHandle<AnimScene>('AnimScene', inv<number>('0x2C497BDEF897C6DF', this.entity.handle, rai()));
   }
 
   /**
-   * @param targetPed 
-   * @param p2 
+   * @param p1 
    * @returns
    */
-  confront(targetPed: Ped, p2: number): any {
-    return inv<number>('0x3A2A2071DF5CC569', this.entity.handle, targetPed.handle, p2);
+  police(p1: boolean): any {
+    return inv<number>('0x87BE56724650408E', this.entity.handle, p1);
   }
 
-  N_0x1F298C7BD30D1240(): void {
-    inv<void>('0x1F298C7BD30D1240', this.entity.handle);
+  /**
+   * @param scenarioPoint 
+   * @param flag 
+   */
+  hitchAnimal(scenarioPoint: number, flag: number): void {
+    inv<void>('0x9030AD4B6207BFE8', this.entity.handle, scenarioPoint, flag);
+  }
+
+  uncuffPed(): void {
+    inv<void>('0x67406F2C8F87FC4F', this.entity.handle);
   }
 
   /**
@@ -565,95 +875,101 @@ export class PedTask extends BaseTask {
    * @param p2 
    * @param p3 
    */
-  setCrouchMovement(p1: boolean, p2: any, p3: boolean): void {
-    inv<void>('0x17293C633C8AC019', this.entity.handle, p1, p2, p3);
+  waypointPlaybackPause(p1: any, p2: any, p3: any): void {
+    inv<void>('0x0F342546AA06FED5', this.entity.handle, p1, p2, p3);
   }
 
   /**
-   * Tells the ped to go to an offset coord from an entity, without using the navmesh. if timeBeforeTeleport is -1 the ped will never warp, p7 is 1 or 0 still unknown param
+   * meleeStyles: AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_MOUNT_FACEDOWN_FROM_FRONT, AR_ALLIGATOR_LEAPKILL, AR_ALLIGATOR_WAIST_AUTOKILL_FRONT
    *
-   * @param entity 
-   * @param offset 
-   * @param moveBlendRatio 
-   * @param timeBeforeTeleport 
-   * @param p7 
+   * @param meleeTarget 
+   * @param meleeStyle 
+   * @param p3 
+   * @param animBlendRatio 
+   * @param p5 
+   * @param p6 
    */
-  goStraightToCoordRelativeToEntity(entity: Entity, offset: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, p7: number): void {
-    inv<void>('0x61E360B7E040D12E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), moveBlendRatio, timeBeforeTeleport, p7);
+  putPedDirectlyIntoMelee(meleeTarget: Ped, meleeStyle: string | number, p3: number, animBlendRatio: number, p5: boolean, p6: number): void {
+    inv<void>('0x1C6CD14A876FFE39', this.entity.handle, meleeTarget.handle, _h(meleeStyle), f(p3), f(animBlendRatio), p5, p6);
   }
 
   /**
-   * Sets the time it takes for a hogtied ped to escape
-   * -1.0f for ped to never escape
-   *
-   * @param time 
+   * @param waypointRecording 
+   * @param p2 
+   * @param flag 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
    */
-  setHogtieEscapeTimer(time: number): void {
-    inv<void>('0xAB591AE6B48B913E', this.entity.handle, f(time));
+  followWaypointRecording(waypointRecording: string | null, p2: number, flag: number, p4: number, p5: boolean, p6: any, p7: number): void {
+    inv<void>('0x0759591819534F7B', this.entity.handle, waypointRecording, p2, flag, p4, p5, p6, p7);
   }
 
   /**
-   * Makes the ped run to take cover
+   * @param targetPed 
    */
-  stayInCover(): void {
-    inv<void>('0xE5DA8615A6180789', this.entity.handle);
+  hogtieTargetPed(targetPed: Ped): void {
+    inv<void>('0x27829AFD3E03AC1A', this.entity.handle, targetPed.handle);
   }
 
   /**
+   * shootatEntity:
+   * If true, peds will shoot at Entity till it is dead.
+   * If false, peds will just walk till they reach the entity and will cease shooting.
+   *
    * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
    */
-  followWaypointRecordingAdvanced(p1: any): void {
-    inv<void>('0x0CFC13EBC19BCA52', this.entity.handle, p1);
+  goToEntityWhileAimingAtEntity(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any): void {
+    inv<void>('0x97465886D35210E9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
   }
 
   /**
-   * Tells the ped to go to a coord, without using the navemesh. if timeBeforeTeleport is -1 the ped will never warp, p8 is always 0 or 1 still unknown
-   *
    * @param pos 
-   * @param moveBlendRatio 
-   * @param timeBeforeTeleport 
-   * @param finalHeading 
-   * @param targetRadius 
-   * @param p8 
+   * @param distance 
    */
-  goStraightToCoord(pos: Vector3, moveBlendRatio: number, timeBeforeTeleport: number, finalHeading: number, targetRadius: number, p8: number): void {
-    inv<void>('0xD76B57B44F1E6F8B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(moveBlendRatio), timeBeforeTeleport, f(finalHeading), f(targetRadius), p8);
+  useNearestTrainScenarioToCoordWarp(pos: Vector3, distance: number): void {
+    inv<void>('0x3774B03456DD6106', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance));
   }
 
   /**
-   * @returns
+   * @param p1 
    */
-  getPedWaypointOverrideSpeed(): number {
-    return inv<number>('0xD39A2F3E7FCAFF08', this.entity.handle, raf());
+  wanderSwim(p1: any): void {
+    inv<void>('0x527EA3DB8BC7F03B', this.entity.handle, p1);
   }
 
   /**
-   * Climbs or vaults the nearest thing.
+   * duration in milliseconds
    *
-   * @param unused 
+   * @param pos 
+   * @param duration 
    */
-  climb(unused: boolean): void {
-    inv<void>('0x89D9FCC2435112F1', this.entity.handle, unused);
+  turnPedToFaceCoord(pos: Vector3, duration: number): void {
+    inv<void>('0x1DDA930A0AC38571', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration);
   }
 
   /**
-   * Old name: _TASK_VEHICLE_DRIVE_TO_POINT
-   * flag: 524419 and 0 in shop_horse_shop R* Script
-   *
-   * @param vehicle 
-   * @param pos 
-   * @param p5 
-   * @param p6 
-   * @param flag 
+   * @param preferAvoidMud 
+   * @param p2 
    */
-  vehicleDriveStraightToPoint(vehicle: Vehicle, pos: Vector3, p5: number, p6: number, flag: number): void {
-    inv<void>('0x089FF2FB965F0A29', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(p5), f(p6), flag);
+  setPedPathPreferToAvoidMud(preferAvoidMud: boolean, p2: number): void {
+    inv<void>('0x8BB283A7888AD1AD', this.entity.handle, preferAvoidMud, f(p2));
   }
 
   /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
+   * @param animDict 
+   * @param animName 
+   * @param entity 
    * @param p4 
    * @param p5 
    * @param p6 
@@ -665,142 +981,172 @@ export class PedTask extends BaseTask {
    * @param p12 
    * @param p13 
    * @param p14 
-   * @param p15 
    */
-  goToCoordWhileAimingAtCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any, p15: any): void {
-    inv<void>('0x639C0425A0B4E77E', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
+  playUpperAnimFacingEntity(animDict: string | null, animName: string | null, entity: Entity, p4: number, p5: number, p6: number, p7: number, p8: number, p9: boolean, p10: boolean, p11: number, p12: string | null, p13: number, p14: number): void {
+    inv<void>('0xAD67214236AB1CFE', this.entity.handle, animDict, animName, entity.handle, p4, f(p5), f(p6), p7, f(p8), p9, p10, f(p11), p12, p13, f(p14));
   }
 
   /**
-   * flags: 0 = HANDS_UP_NOTHING; 1 = HANDS_UP_STRAIGHT_TO_LOOP
-   *
-   * @param duration 
-   * @param facingPed 
-   * @param timeToFacePed 
-   * @param flags 
+   * @param goToLocationX 
+   * @param goToLocationY 
+   * @param goToLocationZ 
+   * @param focusLocationX 
+   * @param focusLocationY 
+   * @param focusLocationZ 
+   * @param speed 
+   * @param shootAtEnemies 
+   * @param distanceToStopAt 
+   * @param noRoadsDistance 
+   * @param unkTrue 
+   * @param unkFlag 
+   * @param aimingFlag 
+   * @param firingPattern 
    */
-  handsUp(duration: number, facingPed: Ped, timeToFacePed: number, flags: number): void {
-    inv<void>('0xF2EAB31979A7F910', this.entity.handle, duration, facingPed.handle, timeToFacePed, flags);
+  goToCoordAndAimAtHatedEntitiesNearCoord(goToLocationX: number, goToLocationY: number, goToLocationZ: number, focusLocationX: number, focusLocationY: number, focusLocationZ: number, speed: number, shootAtEnemies: boolean, distanceToStopAt: number, noRoadsDistance: number, unkTrue: boolean, unkFlag: number, aimingFlag: number, firingPattern: string | number): void {
+    inv<void>('0xA55547801EB331FC', this.entity.handle, f(goToLocationX), f(goToLocationY), f(goToLocationZ), f(focusLocationX), f(focusLocationY), f(focusLocationZ), f(speed), shootAtEnemies, f(distanceToStopAt), f(noRoadsDistance), unkTrue, unkFlag, aimingFlag, _h(firingPattern));
   }
 
   /**
-   * timer: in ms, if it reaches 0 it will auto warp the ped on the horse
-   * Flags will still apply to mountStyle
-   *
-   * @param mount 
-   * @param timer 
-   * @param seatIndex Refer to [enum: eVehicleSeat]
-   * @param pedSpeed 
-   * @param mountStyle 
-   * @param p6 
-   * @param p7 
+   * @param itemHash 
+   * @param interactionAnimHash 
+   * @param p3 
+   * @returns
    */
-  mountAnimal(mount: Ped, timer: number, seatIndex: eVehicleSeat, pedSpeed: number, mountStyle: number, p6: any, p7: any): void {
-    inv<void>('0x92DB0739813C5186', this.entity.handle, mount.handle, timer, seatIndex, f(pedSpeed), mountStyle, p6, p7);
+  canStartItemInteraction(itemHash: string | number, interactionAnimHash: string | number, p3: number): any {
+    return inv<number>('0x2D19BC4DF626CBE7', this.entity.handle, _h(itemHash), _h(interactionAnimHash), p3);
   }
 
   /**
-   * @returns
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
    */
-  getPedIsIgnoringDeadBodies(): any {
-    return inv<number>('0x1948BBE561A2375A', this.entity.handle);
+  followAndConverseWithPed(targetPed: Ped, p2: any, p3: any, p4: number, p5: number, p6: number, p7: any, p8: any, p9: number, p10: number): void {
+    inv<void>('0x489FFCCCE7392B55', this.entity.handle, targetPed.handle, p2, p3, f(p4), f(p5), p6, p7, p8, f(p9), f(p10));
   }
 
   /**
-   * @param p1 
-   * @param taskFlag Refer to [enum: eEnterExitVehicleFlags]
+   * @param pos 
+   * @param distance 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
    */
-  leaveAnyVehicle(p1: number, taskFlag: number): void {
-    inv<void>('0x504D54DF3F6F2247', this.entity.handle, p1, taskFlag);
+  useNearestScenarioChainToCoord(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
+    inv<void>('0x9FDA1B3D7E7028B3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
   }
 
   /**
-   * @param targetPed 
-   * @param p2 
-   * @param p3 
+   * @param eventName 
+   * @returns
    */
-  combatPed(targetPed: Ped, p2: number, p3: number): void {
-    inv<void>('0xF166E48407BAC484', this.entity.handle, targetPed.handle, p2, p3);
+  getTaskMoveNetworkEvent(eventName: string | null): boolean {
+    return !!inv<boolean>('0xB4F47213DF45A64C', this.entity.handle, eventName, rai());
   }
 
   /**
-   * Params: p4 = -1.0f, p5 = -1, p6 = 0 in R* Scripts
+   * Baits: see 0x9B0C7FA063E67629
    *
-   * @param fleeFromTarget 
-   * @param fleeStyle Refer to [enum: eFleeStyle]
-   * @param flag 
-   * @param p4 
-   * @param p5 
-   * @param p6 
+   * @param bait 
+   * @param withoutBuoy 
    */
-  fleePed(fleeFromTarget: Ped, fleeStyle: number, flag: number, p4: number, p5: number, p6: number): void {
-    inv<void>('0xFD45175A6DFD7CE9', this.entity.handle, fleeFromTarget.handle, fleeStyle, flag, f(p4), p5, p6);
+  swapFishingBait(bait: string | null, withoutBuoy: boolean): void {
+    inv<void>('0x2C28AC30A72722DA', this.entity.handle, bait, withoutBuoy);
   }
 
   /**
    * @returns
    */
-  isPedLeadingHorse(): any {
-    return inv<number>('0xEFC4303DDC6E60D3', this.entity.handle);
+  get IsDrivebyTaskUnderneathDrivingTask(): boolean {
+    return !!inv<boolean>('0x8785E6E40C7A8818', this.entity.handle, rai());
+  }
+
+  cuffPed(): void {
+    inv<void>('0x7981037A96E7D174', this.entity.handle);
   }
 
   /**
+   * This native allows to control the cruise speed of where you want the ped to go
+   * 3rd param might be the entity ped is in? like boat or wagon, 12th param might be the cruiseSpeed of the entity ped is in?
+   * EXAMPLE: TaskGoToCoordAnyMeansExtraParamsWithCruiseSpeed(PlayerPedId(), vector3(x, y, z), 3.0, entity, 1, 0, -1082130432, 0, 101004800, 520, 3.0, 1082130432, 0)
+   *
+   * @param cruiseSpeed 
    * @param entity 
-   * @param offset 
-   * @param movementSpeed 
-   * @param timeout 
-   * @param stoppingRange 
-   * @param persistFollowing 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
    * @param p9 
-   * @param walkOnly 
+   * @param p10 
    * @param p11 
-   * @param p12 
+   * @param cruiseSpeed2 
    * @param p13 
+   * @param p14 
+   * @returns gotoCoords
    */
-  followToOffsetOfEntity(entity: Entity, offset: Vector3, movementSpeed: number, timeout: number, stoppingRange: number, persistFollowing: boolean, p9: boolean, walkOnly: boolean, p11: boolean, p12: boolean, p13: boolean): void {
-    inv<void>('0x304AE42E357B8C7E', this.entity.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), f(movementSpeed), timeout, f(stoppingRange), persistFollowing, p9, walkOnly, p11, p12, p13);
+  goToCoordAnyMeansExtraParamsWithCruiseSpeed(cruiseSpeed: number, entity: Entity, p4: number, p5: number, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, cruiseSpeed2: number, p13: any, p14: any): Vector3 {
+    const result = inv<number[]>('0xB8ECD61F531A7B02', this.entity.handle, pvv(), f(cruiseSpeed), entity.handle, p4, p5, p6, p7, p8, p9, p10, p11, f(cruiseSpeed2), p13, p14);
+    return Vector3.fromArray(result);
   }
 
   /**
-   * duration: the amount of time in milliseconds to do the task. -1 will keep the task going until either another task is applied, or CLEAR_ALL_TASKS() is called with the ped
-   *
-   * @param targetEntity 
-   * @param duration 
-   * @param p3 
-   * @param p4 
+   * @param radius 
    */
-  aimGunAtEntity(targetEntity: Entity, duration: number, p3: boolean, p4: number): void {
-    inv<void>('0x9B53BB6E8943AF53', this.entity.handle, targetEntity.handle, duration, p3, p4);
+  combatHatedTargetsNoLosTest(radius: number): void {
+    inv<void>('0xB5BC69D9C4060BC3', this.entity.handle, f(radius));
   }
 
   /**
-   * `_GET_ANIM_SCENE_FROM_PED_*` But in a strange way, it also seems to work with the butcher's meat-cutting animscene. This does not return AnimScenes in general — it seems restricted to
-   * SEARCH-related scenes (needs more research).
-   *
-   * @returns Returns the AnimScene handle currently associated with the given Ped, but only when the anim event "SEARCHSTART" has fired on that Ped.
+   * @param p1 
    */
-  N_0x2C497BDEF897C6DF(): AnimScene | null {
-    return createFromHandle<AnimScene>('AnimScene', inv<number>('0x2C497BDEF897C6DF', this.entity.handle, rai()));
+  N_0x31BB338F64D5C861(p1: boolean): void {
+    inv<void>('0x31BB338F64D5C861', this.entity.handle, p1);
   }
 
   /**
-   * @param p1 
-   * @returns
+   * @param modifier 
    */
-  police(p1: boolean): any {
-    return inv<number>('0x87BE56724650408E', this.entity.handle, p1);
+  set PedPathClimbCostModifier(modifier: number) {
+    inv<void>('0x88E32DB8C1A4AA4B', this.entity.handle, f(modifier));
   }
 
   /**
-   * @param scenarioPoint 
-   * @param flag 
+   * @param entity 
+   * @param duration 
+   * @param targetRadius 
+   * @param offset 
+   * @param moveBlendRatio 
+   * @param offsetFlags 
    */
-  hitchAnimal(scenarioPoint: number, flag: number): void {
-    inv<void>('0x9030AD4B6207BFE8', this.entity.handle, scenarioPoint, flag);
+  gotoEntityOffsetXy(entity: Entity, duration: number, targetRadius: number, offset: Vector2, moveBlendRatio: number, offsetFlags: number): void {
+    inv<void>('0x338E7EF52B6095A9', this.entity.handle, entity.handle, duration, f(targetRadius), f(offset.x), f(offset.y), f(moveBlendRatio), offsetFlags);
   }
 
-  uncuffPed(): void {
-    inv<void>('0x67406F2C8F87FC4F', this.entity.handle);
+  /**
+   * Makes ped walk around the area the params p1 p2 seems to not affect anything but p2 is either 0 or 1 and p1 is mostly 1.0 or ped heading
+   *
+   * @param p2 
+   * @param p3 
+   */
+  wanderStandard(p2: number, p3: number): void {
+    inv<void>('0xBB9CE077274F6A1B', this.entity.handle, f(p2), p3);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  clearPedTasks(p1: boolean, p2: boolean): void {
+    inv<void>('0xE1EF3C1216AFF2CD', this.entity.handle, p1, p2);
   }
 
   /**
@@ -835,43 +1181,188 @@ export class PedTask extends BaseTask {
    * @param p8 
    * @param p9 
    */
-  useScenarioPoint(scenario: number, conditionalAnim: string | null, p3: number, p4: boolean, p5: boolean, p6: string | number, p7: boolean, p8: number, p9: boolean): void {
-    inv<void>('0xCCDAE6324B6A821C', this.entity.handle, scenario, conditionalAnim, p3, p4, p5, _h(p6), p7, f(p8), p9);
+  useScenarioPoint(scenario: number, conditionalAnim: string | null, p3: number, p4: boolean, p5: boolean, p6: string | number, p7: boolean, p8: number, p9: boolean): void {
+    inv<void>('0xCCDAE6324B6A821C', this.entity.handle, scenario, conditionalAnim, p3, p4, p5, _h(p6), p7, f(p8), p9);
+  }
+
+  /**
+   * @returns
+   */
+  get IsPedRunningTaskItemInteraction(): boolean {
+    return !!inv<boolean>('0xEC7E480FF8BD0BED', this.entity.handle, rai());
+  }
+
+  /**
+   * @param vehicle 
+   */
+  breakVehicleDoorLock(vehicle: Vehicle): void {
+    inv<void>('0xBB28D1BC9EA8A6A5', this.entity.handle, vehicle.handle);
+  }
+
+  /**
+   * @param vehicle 
+   * @param vehicleTarget 
+   * @param missionType 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param DriveAgainstTraffic 
+   */
+  vehicleMission(vehicle: Vehicle, vehicleTarget: Vehicle, missionType: number, p4: number, p5: any, p6: number, p7: number, DriveAgainstTraffic: boolean): void {
+    inv<void>('0x659427E0EF36BCDE', this.entity.handle, vehicle.handle, vehicleTarget.handle, missionType, f(p4), p5, f(p6), f(p7), DriveAgainstTraffic);
+  }
+
+  /**
+   * @param avoidTraffic 
+   */
+  set PedPathAvoidTraffic(avoidTraffic: boolean) {
+    inv<void>('0x7C015D8BCEC72CF4', this.entity.handle, avoidTraffic);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  guard(p1: any, p2: any): void {
+    inv<void>('0xB9FB242EACCAF30F', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param attacker 
+   * @param p2 
+   * @param unusedParam3 Unused by the native.
+   * @param unusedParam4 Unused by the native.
+   * @param everyFrame Removes the `0x1000` bitmask from `flag`
+   * @param p6 
+   * @param p7 Removes the `0x80000` bitmask from `flag`
+   * @param flag 
+   * @returns Returns `true` on success, `false` if it failed (whether due to `attacker` being invalid, or the `attacker` ped being dead)
+   */
+  intimidated2(attacker: Ped, p2: number, unusedParam3: boolean, unusedParam4: boolean, everyFrame: boolean, p6: boolean, p7: boolean, flag: number): boolean {
+    return !!inv<boolean>('0x933ACC1A1771A288', this.entity.handle, attacker.handle, p2, unusedParam3, unusedParam4, everyFrame, p6, p7, flag, rai());
+  }
+
+  /**
+   * @param avoidFire 
+   */
+  set PedPathAvoidFire(avoidFire: boolean) {
+    inv<void>('0x4455517B28441E60', this.entity.handle, avoidFire);
+  }
+
+  /**
+   * @param reviver 
+   * @param tool 
+   */
+  reviveTarget(reviver: Ped, tool: string | number): void {
+    inv<void>('0x356088527D9EBAAD', this.entity.handle, reviver.handle, _h(tool));
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/blob/master/animations/kit_emotes_list.lua
+   * emote: https://alloc8or.re/rdr3/doc/enums/eEmote.txt enum eEmoteType
+   * {
+   * EMOTE_TYPE_INVALID = -1,
+   * EMOTE_TYPE_REACT,
+   * EMOTE_TYPE_ACTION,
+   * EMOTE_TYPE_TAUNT,
+   * EMOTE_TYPE_GREET,
+   * EMOTE_TYPE_TWIRL_GUN,
+   * EMOTE_TYPE_DANCE_FLOOR
+   * }; enum eEmotePlaybackMode
+   * {
+   * EMOTE_PM_INVALID = -1,
+   * EMOTE_PM_UPPERBODY,
+   * EMOTE_PM_UPPERBODY_LOOP,
+   * EMOTE_PM_FULLBODY,
+   * };
+   *
+   * @param emoteType 
+   * @param playbackMode 
+   * @param emote 
+   * @param isSecondaryTask 
+   * @param canBreakOut 
+   * @param disableEarlyOutAnimTag 
+   * @param ignoreInvalidMainTask 
+   * @param destroyProps 
+   */
+  playEmoteWithHash(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
+    inv<void>('0xB31A277C1AC7B7FF', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
+  }
+
+  /**
+   * @returns
+   */
+  get IsTaskMoveNetworkReadyForTransition(): boolean {
+    return !!inv<boolean>('0x30ED88D5E0C56A37', this.entity.handle, rai());
+  }
+
+  clearDefensiveArea(): void {
+    inv<void>('0x95A6C46A31D1917D', this.entity.handle);
+  }
+
+  /**
+   * @param modifier 
+   */
+  set PedPathDeepSnowCostModifier(modifier: number) {
+    inv<void>('0xE8C296B75EACC357', this.entity.handle, f(modifier));
+  }
+
+  /**
+   * @returns
+   */
+  get ItemInteractionItemId(): number {
+    return (inv<number>('0x804425C4BBD00883', this.entity.handle, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param entity 
+   * @param mount 
+   * @param p3 
+   */
+  placeCarriedEntityOnMount(entity: Entity, mount: Ped, p3: number): void {
+    inv<void>('0x6D3D87C57B3D52C7', this.entity.handle, entity.handle, mount.handle, f(p3));
+  }
+
+  detachCarriablePed(): void {
+    inv<void>('0x36D188AECB26094B', this.entity.handle);
   }
 
   /**
    * @returns
    */
-  isPedRunningTaskItemInteraction(): any {
-    return inv<number>('0xEC7E480FF8BD0BED', this.entity.handle);
+  get ItemInteractionState(): number {
+    return (inv<number>('0x6AA3DCA2C6F5EB6D', this.entity.handle, rai())) & 0xFFFFFFFF;
   }
 
   /**
-   * @param vehicle 
+   * @returns
    */
-  breakVehicleDoorLock(vehicle: Vehicle): void {
-    inv<void>('0xBB28D1BC9EA8A6A5', this.entity.handle, vehicle.handle);
+  get IsPedAimingInTheAir(): any {
+    return inv<number>('0x8785E6E40C7A8819', this.entity.handle);
   }
 
   /**
-   * @param vehicle 
-   * @param vehicleTarget 
-   * @param missionType 
+   * param3: duration in ms, use -1 to look forever
+   * param4: using 2048 is fine
+   * param5: using 3 is fine
+   *
+   * @param lookAtTarget 
+   * @param duration 
+   * @param p3 
    * @param p4 
    * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param DriveAgainstTraffic 
    */
-  vehicleMission(vehicle: Vehicle, vehicleTarget: Vehicle, missionType: number, p4: number, p5: any, p6: number, p7: number, DriveAgainstTraffic: boolean): void {
-    inv<void>('0x659427E0EF36BCDE', this.entity.handle, vehicle.handle, vehicleTarget.handle, missionType, f(p4), p5, f(p6), f(p7), DriveAgainstTraffic);
+  lookAtEntity(lookAtTarget: Entity, duration: number, p3: number, p4: number, p5: number): void {
+    inv<void>('0x69F4BE8C8CC4796C', this.entity.handle, lookAtTarget.handle, duration, p3, p4, p5);
   }
 
   /**
-   * @param avoidTraffic 
+   * @param taskIndex 
+   * @returns
    */
-  setPedPathAvoidTraffic(avoidTraffic: boolean): void {
-    inv<void>('0x7C015D8BCEC72CF4', this.entity.handle, avoidTraffic);
+  getIsTaskActive(taskIndex: number): boolean {
+    return !!inv<boolean>('0xB0760331C7AA4155', this.entity.handle, taskIndex, rai());
   }
 
   /**
@@ -880,7 +1371,7 @@ export class PedTask extends BaseTask {
    *
    * @returns
    */
-  getTaskMoveNetworkId(): number {
+  get TaskMoveNetworkId(): number {
     return (inv<number>('0xCACC2F9D994504B7', this.entity.handle, rai())) & 0xFFFFFFFF;
   }
 
@@ -1015,70 +1506,18 @@ export class PedTask extends BaseTask {
 
   /**
    * @param pos 
-   * @param speedMultiplier 
    * @param timeout 
-   * @param stoppingRange 
-   * @param flags 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param entity 
-   * @param unk 
-   */
-  followNavMeshToCoordAdvanced(pos: Vector3, speedMultiplier: number, timeout: number, stoppingRange: number, flags: number, p8: number, p9: number, p10: number, entity: Entity, unk: number): void {
-    inv<void>('0x17F58B88D085DBAC', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speedMultiplier), timeout, f(stoppingRange), flags, f(p8), f(p9), f(p10), entity.handle, f(unk));
-  }
-
-  /**
-   * @param radius 
-   * @param time 
-   * @param flags 
-   */
-  combatHatedTargetsAroundPedTimed(radius: number, time: number, flags: number): void {
-    inv<void>('0x2BBA30B854534A0C', this.entity.handle, f(radius), time, flags);
-  }
-
-  /**
-   * @returns
-   */
-  isPedRunning(): boolean {
-    return inv<boolean>('0xC5286FFC176F28A2', this.entity.handle, rai());
-  }
-
-  /**
-   * @returns
-   */
-  isPedSprinting(): boolean {
-    return inv<boolean>('0x57E457CD2C0FC168', this.entity.handle, rai());
-  }
-
-  /**
-   * @param useSlidingSurfaces 
-   */
-  setPedPathMayUseSlidingSurfaces(useSlidingSurfaces: boolean): void {
-    inv<void>('0x06ECF3925BC2ABAE', this.entity.handle, useSlidingSurfaces);
-  }
-
-  /**
-   * Force a ped that is already attacking to aim directly at the specified world coordinates.
-   *
-   * @param pos 
-   * @param p4 
    * @param p5 
    * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param coverpoint 
+   * @param p10 
+   * @param p11 
+   * @param p12 
    */
-  forcePointAimAtCoord(pos: Vector3, p4?: number, p5?: boolean, p6?: boolean): void {
-    inv<void>('0x41323F4E0C4AE94B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5, p6);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   */
-  swapWeapon(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0xA21C51255B205245', this.entity.handle, p1, p2, p3, p4);
+  putPedDirectlyIntoCover(pos: Vector3, timeout: number, p5: boolean, p6: number, p7: any, p8: any, coverpoint: number, p10: boolean, p11: boolean, p12: any): void {
+    inv<void>('0x4172393E6BE1FECE', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), timeout, p5, f(p6), p7, p8, coverpoint, p10, p11, p12);
   }
 
   /**
@@ -1090,482 +1529,267 @@ export class PedTask extends BaseTask {
    * @param p6 
    * @param p7 
    * @param p8 
-   */
-  gotoEntityOffsetXyz(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
-    inv<void>('0xFA6DA9D151769392', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
-  }
-
-  /**
-   * @param pos 
-   * @param distance 
-   * @param duration 
-   * @param p6 
-   * @param p7 
-   * @param p8 
    * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
    */
-  useNearestScenarioToCoordWarp(pos: Vector3, distance: number, duration: number, p6: boolean, p7: boolean, p8: boolean, p9: boolean): void {
-    inv<void>('0x58E2E0F23F6B76C3', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), duration, p6, p7, p8, p9);
-  }
-
-  /**
-   * @param p1 
-   * @returns
-   */
-  N_0x2D657B10F211C572(p1: number): any {
-    return inv<number>('0x2D657B10F211C572', this.entity.handle, f(p1));
-  }
-
-  /**
-   * Coords: volume coords used in R* Script smuggler2
-   * p4/p5 = 0 in R* Scripts previous name TASK_COMBAT_PED_3
-   *
-   * @param pos 
-   * @param p4 
-   * @param p5 
-   */
-  combatPedAtCoords(pos: Vector3, p4: number, p5: number): void {
-    inv<void>('0xC624414FA748B9BA', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, p5);
-  }
-
-  /**
-   * Makes the specified ped stand still for (time) milliseconds.
-   *
-   * @param time 
-   */
-  standStill(time: number): void {
-    inv<void>('0x919BE13EED931959', this.entity.handle, time);
-  }
-
-  /**
-   * @param animDictionary 
-   * @param animationName 
-   * @param p3 
-   */
-  stopAnimTask(animDictionary: string | null, animationName: string | null, p3: number): void {
-    inv<void>('0x97FF36A1D40EA00A', this.entity.handle, animDictionary, animationName, f(p3));
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   */
-  turnToFaceClosestPed(p1: number, p2: number, p3: number): void {
-    inv<void>('0x84179419DBDD36F2', this.entity.handle, f(p1), f(p2), p3);
-  }
-
-  /**
-   * Fishing Research: https://pastebin.com/NmK5ZLVs
-   * Only used in R* Scripts fishing_core and av_fishing_river
-   *
-   * @returns p1
-   */
-  getTaskFishing(): [any, number] {
-    const result = inv<[number, number]>('0xF3735ACD11ACD500', this.entity.handle, pvi());
-    return [result[0], result[1]];
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   */
-  shockingEventReact(p1: any, p2: any): void {
-    inv<void>('0x452419CBD838065B', this.entity.handle, p1, p2);
-  }
-
-  /**
-   * @returns
-   */
-  N_0xB520DBDA7FCF573F(): boolean {
-    return inv<boolean>('0xB520DBDA7FCF573F', this.entity.handle, rai());
-  }
-
-  /**
-   * fleeType: see TASK_FLEE_COORD
-   *
-   * @param fleeFromTarget 
-   * @param pos 
-   * @param distance 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param targetPed 
-   */
-  fleeFromPed(fleeFromTarget: Ped, pos: Vector3, distance: number, p6: number, p7: number, p8: number, targetPed: Ped): void {
-    inv<void>('0x7B74D8EEDE9B5727', this.entity.handle, fleeFromTarget.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p6, p7, f(p8), targetPed.handle);
-  }
-
-  /**
-   * @returns
-   */
-  isPedGettingUp(): boolean {
-    return inv<boolean>('0x2A74E1D5F2F00EEC', this.entity.handle, rai());
-  }
-
-  /**
-   * @param time 
-   */
-  duck(time: number): void {
-    inv<void>('0xA14B5FBF986BAC23', this.entity.handle, time);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   */
-  robPed(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0x7BB967F85D8CCBDB', this.entity.handle, p1, p2, p3, p4);
-  }
-
-  /**
-   * getupSetHash: see nm_blend_out_sets.meta
-   *
-   * @param flags 
-   * @param getupSetHash 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   */
-  unhogtiePed(flags: number, getupSetHash: string | number, p3: string | null, p4: string | null, p5: number): void {
-    inv<void>('0x79559BAD83CCD038', this.entity.handle, flags, _h(getupSetHash), p3, p4, f(p5));
-  }
-
-  /**
-   * hecks if the ped camera is directed at the given coord within the specified radius. https://www.youtube.com/watch?v=iLHXrWVvq_c
-   *
-   * @param coord The coord to check if they're looking at
-   * @param radius The radius of the frustum
-   * @returns Returns `true` if the ped camera is within the range of the frustum, `false` otherwise
-   */
-  isPedLookingAtCoord(coord: Vector3, radius: number): boolean {
-    return inv<boolean>('0x508F5053E3F6F0C4', this.entity.handle, f(coord.x), f(coord.y), f(coord.z), f(radius), rai());
+  goToCoordAndAimAtHatedEntitiesNearCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any): void {
+    inv<void>('0x87BD711FC31EA273', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
   }
 
   /**
-   * @param entity 
+   * @param target 
    */
-  walkAway(entity: Entity): void {
-    inv<void>('0x04ACFAC71E6858F9', this.entity.handle, entity.handle);
+  arrestPed(target: Ped): void {
+    inv<void>('0xF3B9A78A178572B1', this.entity.handle, target.handle);
   }
 
   /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
    * @returns
    */
-  getHogtieEscapeTimer(): number {
-    return inv<number>('0x4687E69D258BBE41', this.entity.handle, raf());
-  }
-
-  weapon(): void {
-    inv<void>('0x7157B82D60E4BC46', this.entity.handle);
+  setPedWaypointRouteOffset(p1: number, p2: number, p3: number): any {
+    return inv<number>('0xED98E10B0AFCE4B4', this.entity.handle, f(p1), f(p2), f(p3));
   }
 
   /**
+   * @param waypointRecording 
    * @returns
    */
-  isPedWalking(): boolean {
-    return inv<boolean>('0xDE4C184B2B9B071A', this.entity.handle, rai());
+  isWaypointPlaybackGoingOnForPed(waypointRecording: string | null): boolean {
+    return !!inv<boolean>('0xE03B3F2D3DC59B64', this.entity.handle, waypointRecording, rai());
   }
 
   /**
    * @param p1 
    * @param p2 
-   * @param p3 
-   */
-  waypointPlaybackPause(p1: any, p2: any, p3: any): void {
-    inv<void>('0x0F342546AA06FED5', this.entity.handle, p1, p2, p3);
-  }
-
-  /**
-   * meleeStyles: AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_MOUNT_FACEDOWN_FROM_FRONT, AR_ALLIGATOR_LEAPKILL, AR_ALLIGATOR_WAIST_AUTOKILL_FRONT
-   *
-   * @param meleeTarget 
-   * @param meleeStyle 
-   * @param p3 
-   * @param animBlendRatio 
-   * @param p5 
-   * @param p6 
    */
-  putPedDirectlyIntoMelee(meleeTarget: Ped, meleeStyle: string | number, p3: number, animBlendRatio: number, p5: boolean, p6: number): void {
-    inv<void>('0x1C6CD14A876FFE39', this.entity.handle, meleeTarget.handle, _h(meleeStyle), f(p3), f(animBlendRatio), p5, p6);
+  animalWrithe(p1: any, p2: any): void {
+    inv<void>('0x8C038A39C4A4B6D6', this.entity.handle, p1, p2);
   }
 
   /**
-   * @param waypointRecording 
+   * @param p1 
    * @param p2 
-   * @param flag 
+   * @param p3 
    * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
    */
-  followWaypointRecording(waypointRecording: string | null, p2: number, flag: number, p4: number, p5: boolean, p6: any, p7: number): void {
-    inv<void>('0x0759591819534F7B', this.entity.handle, waypointRecording, p2, flag, p4, p5, p6, p7);
+  aimAtEntity(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0xCF7569BD0FB480A0', this.entity.handle, p1, p2, p3, p4);
   }
 
   /**
    * @param targetPed 
+   * @param p2 
+   * @param p3 
    */
-  hogtieTargetPed(targetPed: Ped): void {
-    inv<void>('0x27829AFD3E03AC1A', this.entity.handle, targetPed.handle);
+  combatPedTimed(targetPed: Ped, p2: number, p3: any): void {
+    inv<void>('0x944F30DCB7096BDE', this.entity.handle, targetPed.handle, p2, p3);
   }
 
   /**
-   * shootatEntity:
-   * If true, peds will shoot at Entity till it is dead.
-   * If false, peds will just walk till they reach the entity and will cease shooting.
-   *
    * @param p1 
    * @param p2 
    * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
    */
-  goToEntityWhileAimingAtEntity(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any): void {
-    inv<void>('0x97465886D35210E9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+  throwProjectile(p1: any, p2: any, p3: any): void {
+    inv<void>('0x7285951DBF6B5A51', this.entity.handle, p1, p2, p3);
   }
 
   /**
    * @param pos 
-   * @param distance 
-   */
-  useNearestTrainScenarioToCoordWarp(pos: Vector3, distance: number): void {
-    inv<void>('0x3774B03456DD6106', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance));
-  }
-
-  /**
-   * @param p1 
+   * @param heading 
+   * @param p5 
    */
-  wanderSwim(p1: any): void {
-    inv<void>('0x527EA3DB8BC7F03B', this.entity.handle, p1);
+  pedSlideToCoord(pos: Vector3, heading: number, p5: number): void {
+    inv<void>('0xD04FE6765D990A06', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), f(p5));
   }
 
   /**
-   * duration in milliseconds
+   * grappleStyle: AR_GRAPPLE_STRUGGLE, AR_ALLIGATOR_LEG_GRAB_CHALLENGE_FAIL, AR_GRAPPLE_BACK_FROM_BACK, AR_GRAPPLE_BACK_DEFEND, AR_GRAPPLE_FRONT_FROM_FRONT
    *
-   * @param pos 
-   * @param duration 
+   * @param grappleTarget 
+   * @param grappleStyle 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
    */
-  turnPedToFaceCoord(pos: Vector3, duration: number): void {
-    inv<void>('0x1DDA930A0AC38571', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration);
+  putPedDirectlyIntoGrapple(grappleTarget: Ped, grappleStyle: string | number, p3: number, p4: number, p5: boolean, p6: number): void {
+    inv<void>('0xA05F3F20889D7A5B', this.entity.handle, grappleTarget.handle, _h(grappleStyle), f(p3), f(p4), p5, p6);
   }
 
   /**
-   * @param preferAvoidMud 
+   * @param p1 
    * @param p2 
    */
-  setPedPathPreferToAvoidMud(preferAvoidMud: boolean, p2: number): void {
-    inv<void>('0x8BB283A7888AD1AD', this.entity.handle, preferAvoidMud, f(p2));
+  combatAnimalWarn(p1: any, p2: any): void {
+    inv<void>('0xF960F3D57B660E96', this.entity.handle, p1, p2);
   }
 
   /**
-   * @param animDict 
-   * @param animName 
-   * @param entity 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   * @param p14 
+   * @param toggle 
    */
-  playUpperAnimFacingEntity(animDict: string | null, animName: string | null, entity: Entity, p4: number, p5: number, p6: number, p7: number, p8: number, p9: boolean, p10: boolean, p11: number, p12: string | null, p13: number, p14: number): void {
-    inv<void>('0xAD67214236AB1CFE', this.entity.handle, animDict, animName, entity.handle, p4, f(p5), f(p6), p7, f(p8), p9, p10, f(p11), p12, p13, f(p14));
+  set PedIgnoreDeadBodies(toggle: boolean) {
+    inv<void>('0x013A7BA5015C1372', this.entity.handle, toggle);
   }
 
   /**
    * @param p1 
    * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
    */
-  guard(p1: any, p2: any): void {
-    inv<void>('0xB9FB242EACCAF30F', this.entity.handle, p1, p2);
+  moveInTrafficToDestination(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
+    inv<void>('0xDCA3A13F7A45338B', this.entity.handle, p1, p2, p3, p4, p5, p6, p7);
   }
 
   /**
    * @param attacker 
    * @param p2 
-   * @param unusedParam3 Unused by the native.
-   * @param unusedParam4 Unused by the native.
-   * @param everyFrame Removes the `0x1000` bitmask from `flag`
-   * @param p6 
-   * @param p7 Removes the `0x80000` bitmask from `flag`
-   * @param flag 
-   * @returns Returns `true` on success, `false` if it failed (whether due to `attacker` being invalid, or the `attacker` ped being dead)
+   * @returns Returns `true` on success, or `false` if `attacker` doesn't exist, or is dead.
    */
-  intimidated2(attacker: Ped, p2: number, unusedParam3: boolean, unusedParam4: boolean, everyFrame: boolean, p6: boolean, p7: boolean, flag: number): boolean {
-    return inv<boolean>('0x933ACC1A1771A288', this.entity.handle, attacker.handle, p2, unusedParam3, unusedParam4, everyFrame, p6, p7, flag, rai());
+  intimidated(attacker: Ped, p2: boolean): boolean {
+    return !!inv<boolean>('0x648B75D44930D6BD', this.entity.handle, attacker.handle, p2, rai());
   }
 
   /**
-   * @param avoidFire 
+   * @returns
    */
-  setPedPathAvoidFire(avoidFire: boolean): void {
-    inv<void>('0x4455517B28441E60', this.entity.handle, avoidFire);
+  waypointPlaybackGetIsShooting(): any {
+    return inv<number>('0xA5B94DF8AF058F46', this.entity.handle);
   }
 
   /**
-   * @param reviver 
-   * @param tool 
+   * @param pos 
+   * @param distance 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
    */
-  reviveTarget(reviver: Ped, tool: string | number): void {
-    inv<void>('0x356088527D9EBAAD', this.entity.handle, reviver.handle, _h(tool));
+  useNearestScenarioChainToCoordWarp(pos: Vector3, distance: number, p5: boolean, p6: boolean, p7: boolean, p8: boolean): void {
+    inv<void>('0x97A28E63F0BA5631', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), p5, p6, p7, p8);
   }
 
   /**
-   * https://github.com/femga/rdr3_discoveries/blob/master/animations/kit_emotes_list.lua
-   * emote: https://alloc8or.re/rdr3/doc/enums/eEmote.txt enum eEmoteType
-   * {
-   * EMOTE_TYPE_INVALID = -1,
-   * EMOTE_TYPE_REACT,
-   * EMOTE_TYPE_ACTION,
-   * EMOTE_TYPE_TAUNT,
-   * EMOTE_TYPE_GREET,
-   * EMOTE_TYPE_TWIRL_GUN,
-   * EMOTE_TYPE_DANCE_FLOOR
-   * }; enum eEmotePlaybackMode
-   * {
-   * EMOTE_PM_INVALID = -1,
-   * EMOTE_PM_UPPERBODY,
-   * EMOTE_PM_UPPERBODY_LOOP,
-   * EMOTE_PM_FULLBODY,
-   * };
+   * returned values:
+   * 0 to 7 = task that's currently in progress, 0 meaning the first one.
+   * -1 no task sequence in progress.
    *
-   * @param emoteType 
-   * @param playbackMode 
-   * @param emote 
-   * @param isSecondaryTask 
-   * @param canBreakOut 
-   * @param disableEarlyOutAnimTag 
-   * @param ignoreInvalidMainTask 
-   * @param destroyProps 
+   * @returns
    */
-  playEmoteWithHash(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
-    inv<void>('0xB31A277C1AC7B7FF', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
+  get SequenceProgress(): number {
+    return inv<number>('0x00A9010CFE1E3533', this.entity.handle, rai());
   }
 
   /**
-   * @param pos 
-   * @param timeout 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param coverpoint 
-   * @param p10 
-   * @param p11 
-   * @param p12 
+   * @returns
    */
-  putPedDirectlyIntoCover(pos: Vector3, timeout: number, p5: boolean, p6: number, p7: any, p8: any, coverpoint: number, p10: boolean, p11: boolean, p12: any): void {
-    inv<void>('0x4172393E6BE1FECE', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), timeout, p5, f(p6), p7, p8, coverpoint, p10, p11, p12);
+  waypointPlaybackGetIsAiming(): any {
+    return inv<number>('0xD73A5D1F0325C71C', this.entity.handle);
   }
 
   /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   * @param p9 
-   * @param p10 
-   * @param p11 
-   * @param p12 
-   * @param p13 
-   * @param p14 
+   * @param signalName 
+   * @param value 
    */
-  goToCoordAndAimAtHatedEntitiesNearCoordUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any): void {
-    inv<void>('0x87BD711FC31EA273', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+  setTaskMoveNetworkSignalFloat(signalName: string | null, value: number): void {
+    inv<void>('0xD5BB4025AE449A4E', this.entity.handle, signalName, f(value));
   }
 
   /**
-   * @param target 
+   * @param taskSequenceId 
    */
-  arrestPed(target: Ped): void {
-    inv<void>('0xF3B9A78A178572B1', this.entity.handle, target.handle);
+  performSequence(taskSequenceId: number): void {
+    inv<void>('0x5ABA3986D90D8A3B', this.entity.handle, taskSequenceId);
   }
 
   /**
    * @param p1 
    * @param p2 
    * @param p3 
-   * @returns
    */
-  setPedWaypointRouteOffset(p1: number, p2: number, p3: number): any {
-    return inv<number>('0xED98E10B0AFCE4B4', this.entity.handle, f(p1), f(p2), f(p3));
+  moveInTraffic(p1: any, p2: any, p3: any): void {
+    inv<void>('0x8AA1593AEC087A29', this.entity.handle, p1, p2, p3);
   }
 
   /**
-   * @param waypointRecording 
-   * @returns
+   * @param p1 
+   * @param permanently 
    */
-  isWaypointPlaybackGoingOnForPed(waypointRecording: string | null): boolean {
-    return inv<boolean>('0xE03B3F2D3DC59B64', this.entity.handle, waypointRecording, rai());
+  knockedOut(p1: number, permanently: boolean): void {
+    inv<void>('0xF90427F00A495A28', this.entity.handle, f(p1), permanently);
   }
 
   /**
-   * @param p1 
-   * @param p2 
+   * @param duration 
    */
-  animalWrithe(p1: any, p2: any): void {
-    inv<void>('0x8C038A39C4A4B6D6', this.entity.handle, p1, p2);
+  updateTaskHandsUpDuration(duration: number): void {
+    inv<void>('0xA98FCAFD7893C834', this.entity.handle, duration);
   }
 
   /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
+   * Similar to 0xB31A277C1AC7B7FF but checks if the ped's inventory contains the specified emote kit.
+   *
+   * @param emoteType 
+   * @param playbackMode 
+   * @param emote 
+   * @param isSecondaryTask 
+   * @param canBreakOut 
+   * @param disableEarlyOutAnimTag 
+   * @param ignoreInvalidMainTask 
+   * @param destroyProps 
    */
-  aimAtEntity(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0xCF7569BD0FB480A0', this.entity.handle, p1, p2, p3, p4);
+  playEmote(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
+    inv<void>('0x884E3436CC1F41DD', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
   }
 
   /**
-   * @param targetPed 
+   * @param boat 
    * @param p2 
    * @param p3 
+   * @param pos 
+   * @param p7 
+   * @param maxSpeed 
+   * @param drivingStyle 
+   * @param p10 
+   * @param p11 
    */
-  combatPedTimed(targetPed: Ped, p2: number, p3: any): void {
-    inv<void>('0x944F30DCB7096BDE', this.entity.handle, targetPed.handle, p2, p3);
+  boatMission(boat: Vehicle, p2: any, p3: any, pos: Vector3, p7: any, maxSpeed: number, drivingStyle: number, p10: number, p11: any): void {
+    inv<void>('0x15C86013127CE63F', this.entity.handle, boat.handle, p2, p3, f(pos.x), f(pos.y), f(pos.z), p7, f(maxSpeed), drivingStyle, f(p10), p11);
   }
 
   /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
+   * @param useLimits If `true` the ped's viewing angle will be limited to the angle range given for `minAngle` and `maxAngle`, when set to `false` the player always fully faces the player
+   * @param minAngle The minimum viewing angle, requires `useLimits` to be `true`.
+   * @param maxAngle The maximum viewing angle, reuqeres `useLimits` to be `true`.
    */
-  throwProjectile(p1: any, p2: any, p3: any): void {
-    inv<void>('0x7285951DBF6B5A51', this.entity.handle, p1, p2, p3);
+  setIntimidatedFacingAngle(useLimits: boolean, minAngle: number, maxAngle: number): void {
+    inv<void>('0x0FE797DD9F70DFA6', this.entity.handle, useLimits, f(minAngle), f(maxAngle));
   }
 
   /**
-   * @param pos 
-   * @param heading 
-   * @param p5 
+   * @param targetPed 
+   * @param p2 
    */
-  pedSlideToCoord(pos: Vector3, heading: number, p5: number): void {
-    inv<void>('0xD04FE6765D990A06', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), f(p5));
+  animalFlee(targetPed: Ped, p2: any): void {
+    inv<void>('0xA899B61C66F09134', this.entity.handle, targetPed.handle, p2);
   }
 
   /**
    * @returns
    */
-  isPedCuffed(): boolean {
-    return inv<boolean>('0x74E559B3BC910685', this.entity.handle, rai());
+  get IsPedCuffed(): boolean {
+    return !!inv<boolean>('0x74E559B3BC910685', this.entity.handle, rai());
   }
 
   /**
@@ -1602,7 +1826,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getPedDesiredMoveBlendRatio(): number {
+  get PedDesiredMoveBlendRatio(): number {
     return inv<number>('0x8517D4A6CA8513ED', this.entity.handle, raf());
   }
 
@@ -1643,7 +1867,7 @@ export class PedTask extends BaseTask {
   /**
    * @param modifier 
    */
-  setPedPathFoliageCostModifier(modifier: number): void {
+  set PedPathFoliageCostModifier(modifier: number) {
     inv<void>('0x3AD8EFF9703BE657', this.entity.handle, f(modifier));
   }
 
@@ -1664,7 +1888,7 @@ export class PedTask extends BaseTask {
    *
    * @param maxCruiseSpeed 
    */
-  setDriveTaskMaxCruiseSpeed(maxCruiseSpeed: number): void {
+  set DriveTaskMaxCruiseSpeed(maxCruiseSpeed: number) {
     inv<void>('0x404A5AA9B9F0B746', this.entity.handle, f(maxCruiseSpeed));
   }
 
@@ -1793,7 +2017,7 @@ export class PedTask extends BaseTask {
   /**
    * @param toggle 
    */
-  setPedPathCanDropFromHeight(toggle: boolean): void {
+  set PedPathCanDropFromHeight(toggle: boolean) {
     inv<void>('0xE361C5C71C431A4F', this.entity.handle, toggle);
   }
 
@@ -1951,7 +2175,7 @@ export class PedTask extends BaseTask {
   /**
    * @param toggle 
    */
-  setPedPathCanUseClimbovers(toggle: boolean): void {
+  set PedPathCanUseClimbovers(toggle: boolean) {
     inv<void>('0x8E06A6FE76C9EFF4', this.entity.handle, toggle);
   }
 
@@ -1977,7 +2201,7 @@ export class PedTask extends BaseTask {
   /**
    * @param cruiseSpeed 
    */
-  setDriveTaskCruiseSpeed(cruiseSpeed: number): void {
+  set DriveTaskCruiseSpeed(cruiseSpeed: number) {
     inv<void>('0x5C9B84BD7D31D908', this.entity.handle, f(cruiseSpeed));
   }
 
@@ -1996,7 +2220,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  isPedDuelling(): any {
+  get IsPedDuelling(): any {
     return inv<number>('0xC8B29D18022EA2B7', this.entity.handle);
   }
 
@@ -2064,7 +2288,7 @@ export class PedTask extends BaseTask {
    *
    * @returns
    */
-  getPedWritheBreakFreeProgress(): number {
+  get PedWritheBreakFreeProgress(): number {
     return inv<number>('0x03D741CB4052E26C', this.entity.handle, raf());
   }
 
@@ -2103,7 +2327,7 @@ export class PedTask extends BaseTask {
   /**
    * @param toggle 
    */
-  setBlockingOfNonTemporaryEvents(toggle: boolean): void {
+  set BlockingOfNonTemporaryEvents(toggle: boolean) {
     inv<void>('0x90D2156198831D69', this.entity.handle, toggle);
   }
 
@@ -2128,7 +2352,7 @@ export class PedTask extends BaseTask {
   /**
    * @param p1 
    */
-  setPedClearAimingInTheAir(p1: any): void {
+  set PedClearAimingInTheAir(p1: any) {
     inv<void>('0x34C0010188D7C54A', this.entity.handle, p1);
   }
 
@@ -2172,7 +2396,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getLedHorseFromPed(): Ped | null {
+  get LedHorseFromPed(): Ped | null {
     return createFromHandle<Ped>('Ped', inv<number>('0xED1F514AF4732258', this.entity.handle, rai()));
   }
 
@@ -2180,14 +2404,14 @@ export class PedTask extends BaseTask {
    * @returns
    */
   N_0xBEDBE39B5FD98FD6(): boolean {
-    return inv<boolean>('0xBEDBE39B5FD98FD6', this.entity.handle, rai());
+    return !!inv<boolean>('0xBEDBE39B5FD98FD6', this.entity.handle, rai());
   }
 
   /**
    * @returns
    */
-  isPedRunningInspectionTask(): any {
-    return inv<number>('0x038B1F1674F0E242', this.entity.handle);
+  get IsPedRunningInspectionTask(): boolean {
+    return !!inv<boolean>('0x038B1F1674F0E242', this.entity.handle, rai());
   }
 
   /**
@@ -2214,7 +2438,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getPedWaypointProgress(): number {
+  get PedWaypointProgress(): number {
     return inv<number>('0x2720AAA75001E094', this.entity.handle, rai());
   }
 
@@ -2414,7 +2638,7 @@ export class PedTask extends BaseTask {
   /**
    * @param mayEnterDeepWater 
    */
-  setPedPathMayEnterDeepWater(mayEnterDeepWater: boolean): void {
+  set PedPathMayEnterDeepWater(mayEnterDeepWater: boolean) {
     inv<void>('0x9DE63896B176EA94', this.entity.handle, mayEnterDeepWater);
   }
 
@@ -2430,8 +2654,8 @@ export class PedTask extends BaseTask {
    *
    * @returns
    */
-  isPedInWrithe(): boolean {
-    return inv<boolean>('0xDEB6D52126E7D640', this.entity.handle, rai());
+  get IsPedInWrithe(): boolean {
+    return !!inv<boolean>('0xDEB6D52126E7D640', this.entity.handle, rai());
   }
 
   /**
@@ -2457,7 +2681,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  isPedArrestingAnyPed(): any {
+  get IsPedArrestingAnyPed(): any {
     return inv<number>('0xA9CC7856D52DBD25', this.entity.handle);
   }
 
@@ -2465,15 +2689,15 @@ export class PedTask extends BaseTask {
    * @returns
    */
   waypointPlaybackGetIsPaused(): boolean {
-    return inv<boolean>('0x701375A7D43F01CB', this.entity.handle, rai());
+    return !!inv<boolean>('0x701375A7D43F01CB', this.entity.handle, rai());
   }
 
   /**
    * @param p1 
    * @returns
    */
-  isPedScenarioReactLooking(p1: boolean): any {
-    return inv<number>('0x916B8E075ABC8B4E', this.entity.handle, p1);
+  isPedScenarioReactLooking(p1: boolean): boolean {
+    return !!inv<boolean>('0x916B8E075ABC8B4E', this.entity.handle, p1, rai());
   }
 
   /**
@@ -2491,14 +2715,14 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getPedWaypointDistance(): number {
+  get PedWaypointDistance(): number {
     return inv<number>('0xE6A877C64CAF1BC5', this.entity.handle, raf());
   }
 
   /**
    * @param mayEnterWater 
    */
-  setPedPathMayEnterWater(mayEnterWater: boolean): void {
+  set PedPathMayEnterWater(mayEnterWater: boolean) {
     inv<void>('0xF35425A4204367EC', this.entity.handle, mayEnterWater);
   }
 
@@ -2516,7 +2740,7 @@ export class PedTask extends BaseTask {
   /**
    * @param p1 
    */
-  setPedDesiredMoveBlendRatio(p1: number): void {
+  set PedDesiredMoveBlendRatio(p1: number) {
     inv<void>('0x1E982AC8716912C5', this.entity.handle, f(p1));
   }
 
@@ -2533,7 +2757,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  isEntityRevivable(): any {
+  get IsEntityRevivable(): any {
     return inv<number>('0x6C50B9DCCCA70023', this.entity.handle);
   }
 
@@ -2643,7 +2867,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getTaskMoveNetworkState(): string | null {
+  get TaskMoveNetworkState(): string | null {
     return inv<string>('0x717E4D1F2048376D', this.entity.handle, ras());
   }
 
@@ -2739,7 +2963,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getScenarioPointTypePedIsUsing(): number {
+  get ScenarioPointTypePedIsUsing(): number {
     return inv<number>('0x2D0571BB55879DA2', this.entity.handle, rai());
   }
 
@@ -2795,8 +3019,8 @@ export class PedTask extends BaseTask {
    *
    * @returns
    */
-  isPedBeingArrested(): boolean {
-    return inv<boolean>('0x90A09F3A45FED688', this.entity.handle, rai());
+  get IsPedBeingArrested(): boolean {
+    return !!inv<boolean>('0x90A09F3A45FED688', this.entity.handle, rai());
   }
 
   /**
@@ -2831,8 +3055,8 @@ export class PedTask extends BaseTask {
   /**
    * @returns Returns `true` if the specified mount is currently being lead by a player, `false` otherwise.
    */
-  isPedBeingLead(): boolean {
-    return inv<boolean>('0xAC5045AB7F1A34FD', this.entity.handle, rai());
+  get IsPedBeingLead(): boolean {
+    return !!inv<boolean>('0xAC5045AB7F1A34FD', this.entity.handle, rai());
   }
 
   /**
@@ -2857,8 +3081,8 @@ export class PedTask extends BaseTask {
    * @param p1 
    * @returns
    */
-  isPedExitingScenario(p1: boolean): any {
-    return inv<number>('0x0C3CB2E600C8977D', this.entity.handle, p1);
+  isPedExitingScenario(p1: boolean): boolean {
+    return !!inv<boolean>('0x0C3CB2E600C8977D', this.entity.handle, p1, rai());
   }
 
   /**
@@ -2945,7 +3169,7 @@ export class PedTask extends BaseTask {
    *
    * @param modifier 
    */
-  setPedPathLadderCostModifier(modifier: number): void {
+  set PedPathLadderCostModifier(modifier: number) {
     inv<void>('0x70F7A1EAB1AE3AA8', this.entity.handle, f(modifier));
   }
 
@@ -2995,7 +3219,7 @@ export class PedTask extends BaseTask {
    * @returns
    */
   pedHasUseScenarioTask(): boolean {
-    return inv<boolean>('0x295E3CCEC879CCD7', this.entity.handle, rai());
+    return !!inv<boolean>('0x295E3CCEC879CCD7', this.entity.handle, rai());
   }
 
   /**
@@ -3013,8 +3237,8 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  isPedStill(): boolean {
-    return inv<boolean>('0xAC29253EEF8F0180', this.entity.handle, rai());
+  get IsPedStill(): boolean {
+    return !!inv<boolean>('0xAC29253EEF8F0180', this.entity.handle, rai());
   }
 
   /**
@@ -3022,7 +3246,7 @@ export class PedTask extends BaseTask {
    * @returns
    */
   isPedActiveInScenario(scenario: number): boolean {
-    return inv<boolean>('0xAA135F9482C82CC3', this.entity.handle, scenario, rai());
+    return !!inv<boolean>('0xAA135F9482C82CC3', this.entity.handle, scenario, rai());
   }
 
   /**
@@ -3094,7 +3318,7 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  getRansackScenarioPointPedIsUsing(): any {
+  get RansackScenarioPointPedIsUsing(): any {
     return inv<number>('0xD04241BBF6D03A5E', this.entity.handle);
   }
 
@@ -3115,7 +3339,7 @@ export class PedTask extends BaseTask {
    * @returns
    */
   isEmoteTaskRunning(p1: any): boolean {
-    return inv<boolean>('0xCF9B71C0AF824036', this.entity.handle, p1, rai());
+    return !!inv<boolean>('0xCF9B71C0AF824036', this.entity.handle, p1, rai());
   }
 
   /**
@@ -3129,8 +3353,8 @@ export class PedTask extends BaseTask {
   /**
    * @returns
    */
-  isTaskMoveNetworkActive(): boolean {
-    return inv<boolean>('0x921CE12C489C4C41', this.entity.handle, rai());
+  get IsTaskMoveNetworkActive(): boolean {
+    return !!inv<boolean>('0x921CE12C489C4C41', this.entity.handle, rai());
   }
 
   /**
@@ -3417,228 +3641,4 @@ export class PedTask extends BaseTask {
     return inv<number>('0xBC864A70AD55E0C1', this.entity.handle, _h(inputContext), raf());
   }
 
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   */
-  setSphereDefensiveArea(p1: number, p2: number, p3: number, p4: number): void {
-    inv<void>('0x933C06518B52A9A4', this.entity.handle, f(p1), f(p2), f(p3), f(p4));
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   */
-  useRandomScenarioInGroup(p1: any, p2: any, p3: any, p4: any): void {
-    inv<void>('0x14747F4A5971DE4E', this.entity.handle, p1, p2, p3, p4);
-  }
-
-  /**
-   * enum eWhistleType
-   * {
-   * WHISTLE_MAIN,
-   * WHISTLE_SECONDARY,
-   * WHISTLE_DOUBLE,
-   * WHISTLE_URGENT,
-   * WHISTLE_LONG
-   * };
-   *
-   * @param p1 
-   * @param whistleType 
-   */
-  goToWhistle(p1: Ped, whistleType: number): void {
-    inv<void>('0xBAD6545608CECA6E', this.entity.handle, p1.handle, whistleType);
-  }
-
-  /**
-   * @param pos 
-   * @param duration 
-   * @param flags 
-   * @param p6 
-   * @param p7 
-   */
-  lookAtCoord(pos: Vector3, duration: number, flags: number, p6: number, p7: boolean): void {
-    inv<void>('0x6FA46612594F7973', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration, flags, p6, p7);
-  }
-
-  /**
-   * @returns
-   */
-  isPedInHitReact(): any {
-    return inv<number>('0xF330A5C062B29BED', this.entity.handle);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   * @param p4 
-   * @param p5 
-   * @param p6 
-   * @param p7 
-   * @param p8 
-   */
-  N_0x3FFCD7BBA074CC80(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
-    inv<void>('0x3FFCD7BBA074CC80', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
-  }
-
-  /**
-   * @returns
-   */
-  isMountedWeaponTaskUnderneathDrivingTask(): boolean {
-    return inv<boolean>('0xA320EF046186FA3B', this.entity.handle, rai());
-  }
-
-  /**
-   * flags: See TASK_ENTER_VEHICLE
-   *
-   * @param p1 
-   * @param flags Refer to [enum: eEnterExitVehicleFlags]
-   */
-  disembarkNearestTrainCarriage(p1: number, flags: number): void {
-    inv<void>('0x0A11F3BDEC03ED5F', this.entity.handle, f(p1), flags);
-  }
-
-  /**
-   * @param radius 
-   */
-  combatHatedTargetsNoLosTest(radius: number): void {
-    inv<void>('0xB5BC69D9C4060BC3', this.entity.handle, f(radius));
-  }
-
-  /**
-   * @param p1 
-   */
-  N_0x31BB338F64D5C861(p1: boolean): void {
-    inv<void>('0x31BB338F64D5C861', this.entity.handle, p1);
-  }
-
-  /**
-   * @param modifier 
-   */
-  setPedPathClimbCostModifier(modifier: number): void {
-    inv<void>('0x88E32DB8C1A4AA4B', this.entity.handle, f(modifier));
-  }
-
-  /**
-   * @param entity 
-   * @param duration 
-   * @param targetRadius 
-   * @param offset 
-   * @param moveBlendRatio 
-   * @param offsetFlags 
-   */
-  gotoEntityOffsetXy(entity: Entity, duration: number, targetRadius: number, offset: Vector2, moveBlendRatio: number, offsetFlags: number): void {
-    inv<void>('0x338E7EF52B6095A9', this.entity.handle, entity.handle, duration, f(targetRadius), f(offset.x), f(offset.y), f(moveBlendRatio), offsetFlags);
-  }
-
-  /**
-   * Makes ped walk around the area the params p1 p2 seems to not affect anything but p2 is either 0 or 1 and p1 is mostly 1.0 or ped heading
-   *
-   * @param p2 
-   * @param p3 
-   */
-  wanderStandard(p2: number, p3: number): void {
-    inv<void>('0xBB9CE077274F6A1B', this.entity.handle, f(p2), p3);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   */
-  clearPedTasks(p1: boolean, p2: boolean): void {
-    inv<void>('0xE1EF3C1216AFF2CD', this.entity.handle, p1, p2);
-  }
-
-  /**
-   * @param signalName 
-   * @param value 
-   */
-  setTaskMoveNetworkSignalFloat(signalName: string | null, value: number): void {
-    inv<void>('0xD5BB4025AE449A4E', this.entity.handle, signalName, f(value));
-  }
-
-  /**
-   * @param taskSequenceId 
-   */
-  performSequence(taskSequenceId: number): void {
-    inv<void>('0x5ABA3986D90D8A3B', this.entity.handle, taskSequenceId);
-  }
-
-  /**
-   * @param p1 
-   * @param p2 
-   * @param p3 
-   */
-  moveInTraffic(p1: any, p2: any, p3: any): void {
-    inv<void>('0x8AA1593AEC087A29', this.entity.handle, p1, p2, p3);
-  }
-
-  /**
-   * @param p1 
-   * @param permanently 
-   */
-  knockedOut(p1: number, permanently: boolean): void {
-    inv<void>('0xF90427F00A495A28', this.entity.handle, f(p1), permanently);
-  }
-
-  /**
-   * @param duration 
-   */
-  updateTaskHandsUpDuration(duration: number): void {
-    inv<void>('0xA98FCAFD7893C834', this.entity.handle, duration);
-  }
-
-  /**
-   * Similar to 0xB31A277C1AC7B7FF but checks if the ped's inventory contains the specified emote kit.
-   *
-   * @param emoteType 
-   * @param playbackMode 
-   * @param emote 
-   * @param isSecondaryTask 
-   * @param canBreakOut 
-   * @param disableEarlyOutAnimTag 
-   * @param ignoreInvalidMainTask 
-   * @param destroyProps 
-   */
-  playEmote(emoteType: number, playbackMode: number, emote: string | number, isSecondaryTask: boolean, canBreakOut: boolean, disableEarlyOutAnimTag: boolean, ignoreInvalidMainTask: boolean, destroyProps: boolean): void {
-    inv<void>('0x884E3436CC1F41DD', this.entity.handle, emoteType, playbackMode, _h(emote), isSecondaryTask, canBreakOut, disableEarlyOutAnimTag, ignoreInvalidMainTask, destroyProps);
-  }
-
-  /**
-   * @param boat 
-   * @param p2 
-   * @param p3 
-   * @param pos 
-   * @param p7 
-   * @param maxSpeed 
-   * @param drivingStyle 
-   * @param p10 
-   * @param p11 
-   */
-  boatMission(boat: Vehicle, p2: any, p3: any, pos: Vector3, p7: any, maxSpeed: number, drivingStyle: number, p10: number, p11: any): void {
-    inv<void>('0x15C86013127CE63F', this.entity.handle, boat.handle, p2, p3, f(pos.x), f(pos.y), f(pos.z), p7, f(maxSpeed), drivingStyle, f(p10), p11);
-  }
-
-  /**
-   * @param useLimits If `true` the ped's viewing angle will be limited to the angle range given for `minAngle` and `maxAngle`, when set to `false` the player always fully faces the player
-   * @param minAngle The minimum viewing angle, requires `useLimits` to be `true`.
-   * @param maxAngle The maximum viewing angle, reuqeres `useLimits` to be `true`.
-   */
-  setIntimidatedFacingAngle(useLimits: boolean, minAngle: number, maxAngle: number): void {
-    inv<void>('0x0FE797DD9F70DFA6', this.entity.handle, useLimits, f(minAngle), f(maxAngle));
-  }
-
-  /**
-   * @param targetPed 
-   * @param p2 
-   */
-  animalFlee(targetPed: Ped, p2: any): void {
-    inv<void>('0xA899B61C66F09134', this.entity.handle, targetPed.handle, p2);
-  }
-
 }