@nativewrappers/redm-codegen 0.0.2

package/src/classes/PedTask.ts

@@ -0,0 +1,3644 @@
+import type { eVehicleSeat } from '../enums/eVehicleSeat';
+import type { eWeaponHash } from '../enums/eWeaponHash';
+import type { AnimScene } from '../classes/AnimScene';
+import type { Entity } from '../classes/Entity';
+import type { Prop } from '../classes/Prop';
+import type { Vehicle } from '../classes/Vehicle';
+import type { Volume } from '../classes/Volume';
+import { Vector2 } from '../types/Vector2';
+import { Vector3 } from '../types/Vector3';
+import { Vector4 } from '../types/Vector4';
+import { Color } from '../types/Color';
+import { BaseTask } from './BaseTask';
+import type { Ped } from './Ped';
+import { createFromHandle } from '../types/HandleRegistry';
+import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f } from '../types/NativeAliases';
+
+export class PedTask extends BaseTask {
+  constructor(entity: Ped) {
+    super(entity);
+  }
+
+  /**
+   * @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 
+   */
+  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);
+  }
+
+  /**
+   * @param neverUseInteriors 
+   */
+  setPedPathNeverUseInteriors(neverUseInteriors: boolean): void {
+    inv<void>('0x42CFD8FD8CC8DC69', this.entity.handle, neverUseInteriors);
+  }
+
+  /**
+   * @param radius 
+   */
+  combatHatedTargets(radius: number): void {
+    inv<void>('0x8182B561A29BD597', this.entity.handle, f(radius));
+  }
+
+  /**
+   * Only used in R* Scripts fishing_core and av_fishing_river
+   *
+   * @returns p1
+   */
+  setTaskFishing(): [any, number] {
+    const result = inv<[number, number]>('0xF3735ACD11ACD501', this.entity.handle, pvi());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   */
+  goToEntityWhileAimingAtEntityUsingCombatStyle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any): void {
+    inv<void>('0xCEF0117C233026AD', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+  }
+
+  /**
+   * @param preferStayInWater 
+   * @param p2 
+   */
+  setPedPathPreferStayInWater(preferStayInWater: boolean, p2: number): void {
+    inv<void>('0xC6170856E54557B2', this.entity.handle, preferStayInWater, f(p2));
+  }
+
+  /**
+   * @param name 
+   */
+  requestTaskMoveNetworkStateTransition(name: string | null): void {
+    inv<void>('0xD01015C7316AE176', this.entity.handle, name);
+  }
+
+  /**
+   * @param entity 
+   */
+  pedFishingrodHookEntity(entity: Entity): void {
+    inv<void>('0x1A52076D26E09004', this.entity.handle, entity.handle);
+  }
+
+  /**
+   * 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());
+  }
+
+  /**
+   * @param entity 
+   */
+  walkAway(entity: Entity): void {
+    inv<void>('0x04ACFAC71E6858F9', this.entity.handle, entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  getHogtieEscapeTimer(): number {
+    return inv<number>('0x4687E69D258BBE41', this.entity.handle, raf());
+  }
+
+  weapon(): void {
+    inv<void>('0x7157B82D60E4BC46', this.entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  isPedWalking(): boolean {
+    return inv<boolean>('0xDE4C184B2B9B071A', this.entity.handle, rai());
+  }
+
+  clearLookAt(): void {
+    inv<void>('0x0F804F1DB19B9689', this.entity.handle);
+  }
+
+  /**
+   * @param inputContext 
+   * @returns
+   */
+  getItemInteractionPromptProgress(inputContext: string | number): number {
+    return inv<number>('0xBC864A70AD55E0C1', this.entity.handle, _h(inputContext), raf());
+  }
+
+  /**
+   * @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());
+  }
+
+  /**
+   * 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
+   *
+   * @param bait 
+   * @param withoutBuoy 
+   * @param instantly 
+   */
+  setFishingBait(bait: string | null, withoutBuoy: boolean, instantly: boolean): void {
+    inv<void>('0x9B0C7FA063E67629', this.entity.handle, bait, withoutBuoy, instantly);
+  }
+
+  /**
+   * Params: p3, p4, p5, p6: 0, 0, 0, -1.0f in R* Scripts
+   *
+   * @param item 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @returns guid
+   */
+  itemInteraction3(item: string | number, p3: any, p4: any, p5: any, p6: number): number {
+    const result = inv<number>('0xD61D5E1AD9876DEB', this.entity.handle, _h(item), pvi(), p3, p4, p5, f(p6));
+    return result;
+  }
+
+  /**
+   * @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());
+  }
+
+  /**
+   * @param vehicle 
+   * @param seat 
+   */
+  warpPedIntoVehicle(vehicle: Vehicle, seat: number): void {
+    inv<void>('0x9A7D091411C5F684', this.entity.handle, vehicle.handle, seat);
+  }
+
+  /**
+   * ped = Ped you want to perform this task.
+   * target = the Entity they should aim at.
+   * distanceToStopAt = distance from the target, where the ped should stop to aim.
+   * StartAimingDist = distance where the ped should start to aim.
+   *
+   * @param target 
+   * @param distanceToStopAt 
+   * @param StartAimingDist 
+   */
+  gotoEntityAiming(target: Entity, distanceToStopAt: number, StartAimingDist: number): void {
+    inv<void>('0xA9DA48FAB8A76C12', this.entity.handle, target.handle, f(distanceToStopAt), f(StartAimingDist));
+  }
+
+  /**
+   * @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 
+   */
+  goToCoordWhileAimingAtEntityUsingCombatStyle(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>('0x78426D0982D083C9', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+  }
+
+  /**
+   * Used with 'P_BODYPARTARMFLOAT02X' model in fishing_core.c
+   *
+   * @param object 
+   */
+  pedFishingrodHookObject(object: Prop): void {
+    inv<void>('0xCE71C2F9BAA3F975', this.entity.handle, object.handle);
+  }
+
+  /**
+   * @param exitAnimation 
+   * @param p2 
+   */
+  reactLookAtEnd(exitAnimation: number, p2: boolean): void {
+    inv<void>('0x541E5B41DCA45828', this.entity.handle, exitAnimation, p2);
+  }
+
+  clearDrivebyTaskUnderneathDrivingTask(): void {
+    inv<void>('0xC35B5CDB2824CF69', this.entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  getPedWaypointOverrideSpeed(): number {
+    return inv<number>('0xD39A2F3E7FCAFF08', this.entity.handle, raf());
+  }
+
+  /**
+   * Climbs or vaults the nearest thing.
+   *
+   * @param unused 
+   */
+  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 
+   */
+  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);
+  }
+
+  /**
+   * flags: 0 = HANDS_UP_NOTHING; 1 = HANDS_UP_STRAIGHT_TO_LOOP
+   *
+   * @param duration 
+   * @param facingPed 
+   * @param timeToFacePed 
+   * @param flags 
+   */
+  handsUp(duration: number, facingPed: Ped, timeToFacePed: number, flags: number): void {
+    inv<void>('0xF2EAB31979A7F910', this.entity.handle, duration, facingPed.handle, timeToFacePed, flags);
+  }
+
+  /**
+   * 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 
+   */
+  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);
+  }
+
+  /**
+   * @returns
+   */
+  getPedIsIgnoringDeadBodies(): any {
+    return inv<number>('0x1948BBE561A2375A', this.entity.handle);
+  }
+
+  /**
+   * @param toggle 
+   */
+  setPedPathCanUseLadders(toggle: boolean): void {
+    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 
+   */
+  setHogtieEscapeTimer(time: number): void {
+    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 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 p1 
+   */
+  N_0xFFB520A3E16F7B7B(p1: number): void {
+    inv<void>('0xFFB520A3E16F7B7B', this.entity.handle, f(p1));
+  }
+
+  persistentCharacter(): void {
+    inv<void>('0x4391700CBD89C3D8', this.entity.handle);
+  }
+
+  /**
+   * @param speed 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  waypointPlaybackOverrideSpeed(speed: number, p2: any, p3: any, p4: any): void {
+    inv<void>('0x7D7D2B47FA788E85', this.entity.handle, f(speed), p2, p3, p4);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  climbLadder(p1: number, p2: boolean, p3: boolean): void {
+    inv<void>('0xB6C987F9285A3814', this.entity.handle, f(p1), p2, p3);
+  }
+
+  /**
+   * 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 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 
+   */
+  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 targetPed 
+   */
+  cutFreeHogtiedTargetPed(targetPed: Ped): void {
+    inv<void>('0x81D16C4FF3A77ADF', this.entity.handle, targetPed.handle);
+  }
+
+  /**
+   * @param signalName 
+   * @param value 
+   */
+  setTaskMoveNetworkSignalFloat2(signalName: string | null, value: number): void {
+    inv<void>('0x099D4A855D53B03B', this.entity.handle, signalName, f(value));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  ambientAnimalHunt(p1: any, p2: any): void {
+    inv<void>('0x4B39D8F9D0FE7749', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param p1 
+   * @param taskFlag Refer to [enum: eEnterExitVehicleFlags]
+   */
+  leaveAnyVehicle(p1: number, taskFlag: number): void {
+    inv<void>('0x504D54DF3F6F2247', this.entity.handle, p1, taskFlag);
+  }
+
+  /**
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
+   */
+  combatPed(targetPed: Ped, p2: number, p3: number): void {
+    inv<void>('0xF166E48407BAC484', this.entity.handle, targetPed.handle, p2, p3);
+  }
+
+  /**
+   * 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 
+   */
+  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);
+  }
+
+  /**
+   * @returns
+   */
+  isPedLeadingHorse(): any {
+    return inv<number>('0xEFC4303DDC6E60D3', this.entity.handle);
+  }
+
+  /**
+   * @param entity 
+   * @param offset 
+   * @param movementSpeed 
+   * @param timeout 
+   * @param stoppingRange 
+   * @param persistFollowing 
+   * @param p9 
+   * @param walkOnly 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   */
+  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);
+  }
+
+  /**
+   * 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 
+   */
+  aimGunAtEntity(targetEntity: Entity, duration: number, p3: boolean, p4: number): void {
+    inv<void>('0x9B53BB6E8943AF53', this.entity.handle, targetEntity.handle, duration, p3, p4);
+  }
+
+  /**
+   * `_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.
+   */
+  N_0x2C497BDEF897C6DF(): AnimScene | null {
+    return createFromHandle<AnimScene>('AnimScene', inv<number>('0x2C497BDEF897C6DF', this.entity.handle, rai()));
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  police(p1: boolean): any {
+    return inv<number>('0x87BE56724650408E', this.entity.handle, p1);
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @param waypointRecording 
+   * @param p2 
+   * @param flag 
+   * @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);
+  }
+
+  /**
+   * @param targetPed 
+   */
+  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 
+   */
+  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);
+  }
+
+  /**
+   * @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 
+   */
+  wanderSwim(p1: any): void {
+    inv<void>('0x527EA3DB8BC7F03B', this.entity.handle, p1);
+  }
+
+  /**
+   * duration in milliseconds
+   *
+   * @param pos 
+   * @param duration 
+   */
+  turnPedToFaceCoord(pos: Vector3, duration: number): void {
+    inv<void>('0x1DDA930A0AC38571', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration);
+  }
+
+  /**
+   * @param preferAvoidMud 
+   * @param p2 
+   */
+  setPedPathPreferToAvoidMud(preferAvoidMud: boolean, p2: number): void {
+    inv<void>('0x8BB283A7888AD1AD', this.entity.handle, preferAvoidMud, f(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 
+   */
+  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));
+  }
+
+  /**
+   * @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 
+   */
+  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));
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @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));
+  }
+
+  /**
+   * @param pos 
+   * @param distance 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  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 eventName 
+   * @returns
+   */
+  getTaskMoveNetworkEvent(eventName: string | null): boolean {
+    return inv<boolean>('0xB4F47213DF45A64C', this.entity.handle, eventName, rai());
+  }
+
+  /**
+   * Baits: see 0x9B0C7FA063E67629
+   *
+   * @param bait 
+   * @param withoutBuoy 
+   */
+  swapFishingBait(bait: string | null, withoutBuoy: boolean): void {
+    inv<void>('0x2C28AC30A72722DA', this.entity.handle, bait, withoutBuoy);
+  }
+
+  /**
+   * @returns
+   */
+  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 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);
+  }
+
+  /**
+   * @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 moveNetworkDefName 
+   * @param p3 
+   * @param p4 
+   * @param animDict 
+   * @param flags 
+   * @returns taskData
+   */
+  moveNetworkByNameWithInitParams(moveNetworkDefName: string | null, p3: number, p4: boolean, animDict: string | null, flags: number): number {
+    const result = inv<number>('0x139805C2A67C4795', this.entity.handle, moveNetworkDefName, pvi(), f(p3), p4, animDict, flags);
+    return result;
+  }
+
+  /**
+   * @param pos 
+   * @param entity 
+   */
+  jump2(pos: Vector3, entity: Entity): void {
+    inv<void>('0x91083103137D7254', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), entity.handle);
+  }
+
+  /**
+   * @param scenario 
+   * @param conditionalAnim 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @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);
+  }
+
+  /**
+   * @returns
+   */
+  isPedRunningTaskItemInteraction(): any {
+    return inv<number>('0xEC7E480FF8BD0BED', this.entity.handle);
+  }
+
+  /**
+   * @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 
+   */
+  setPedPathAvoidTraffic(avoidTraffic: boolean): void {
+    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 
+   */
+  setPedPathAvoidFire(avoidFire: boolean): void {
+    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
+   */
+  isTaskMoveNetworkReadyForTransition(): boolean {
+    return inv<boolean>('0x30ED88D5E0C56A37', this.entity.handle, rai());
+  }
+
+  clearDefensiveArea(): void {
+    inv<void>('0x95A6C46A31D1917D', this.entity.handle);
+  }
+
+  /**
+   * @param modifier 
+   */
+  setPedPathDeepSnowCostModifier(modifier: number): void {
+    inv<void>('0xE8C296B75EACC357', this.entity.handle, f(modifier));
+  }
+
+  /**
+   * @returns
+   */
+  getItemInteractionItemId(): string | 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
+   */
+  getItemInteractionState(): string | number {
+    return (inv<number>('0x6AA3DCA2C6F5EB6D', this.entity.handle, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @returns
+   */
+  getIsPedAimingInTheAir(): any {
+    return inv<number>('0x8785E6E40C7A8819', 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 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);
+  }
+
+  /**
+   * @param taskIndex 
+   * @returns
+   */
+  getIsTaskActive(taskIndex: number): boolean {
+    return inv<boolean>('0xB0760331C7AA4155', this.entity.handle, taskIndex, rai());
+  }
+
+  /**
+   * Returns hash of the underlying move network def, see move_networks.xml
+   * https://alloc8or.re/rdr3/doc/misc/move_networks.txt
+   *
+   * @returns
+   */
+  getTaskMoveNetworkId(): string | number {
+    return (inv<number>('0xCACC2F9D994504B7', this.entity.handle, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  guardAssignedDefensiveArea(p1: number, p2: number, p3: number, p4: number, p5: number, p6: any): void {
+    inv<void>('0xD2A207EEBDF9889B', this.entity.handle, f(p1), f(p2), f(p3), f(p4), f(p5), p6);
+  }
+
+  /**
+   * @param pos 
+   * @param duration 
+   * @param firingPattern 
+   * @param p6 
+   */
+  shootAtCoord(pos: Vector3, duration: number, firingPattern: string | number, p6: any): void {
+    inv<void>('0x46A6CC01E0826106', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration, _h(firingPattern), p6);
+  }
+
+  /**
+   * Makes a ped react to an entity.
+   * Params: reactingTo Entity can be 0, p8 is always 4
+   *
+   * @param reactingTo 
+   * @param pos 
+   * @param reactionName 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  react(reactingTo: Entity, pos: Vector3, reactionName: string | null, p6: number, p7: number, p8: number): void {
+    inv<void>('0xC4C32C31920E1B70', this.entity.handle, reactingTo.handle, f(pos.x), f(pos.y), f(pos.z), reactionName, f(p6), f(p7), p8);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  guardAssignedDefensiveArea2(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
+    inv<void>('0x1FC9B33976BACD6C', this.entity.handle, p1, p2, p3, p4, p5, p6, p7);
+  }
+
+  /**
+   * @param pos 
+   * @param heading 
+   */
+  plantBomb(pos: Vector3, heading: number): void {
+    inv<void>('0x965FEC691D55E9BF', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(heading));
+  }
+
+  /**
+   * @param scenarioHash 
+   * @param pos 
+   * @param heading 
+   * @param duration 
+   * @param sittingScenario 
+   * @param teleport 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   */
+  startScenarioAtPosition(scenarioHash: string | number, pos: Vector3, heading: number, duration: number, sittingScenario: boolean, teleport: boolean, p9: string | null, p10: number, p11: boolean): void {
+    inv<void>('0x4D1F61FC34AF3CD1', this.entity.handle, _h(scenarioHash), f(pos.x), f(pos.y), f(pos.z), f(heading), duration, sittingScenario, teleport, p9, f(p10), p11);
+  }
+
+  /**
+   * @param vehicle 
+   * @param pos 
+   * @param speed 
+   * @param behaviorFlag 
+   * @param stoppingRange 
+   */
+  vehicleGotoNavmesh(vehicle: Vehicle, pos: Vector3, speed: number, behaviorFlag: number, stoppingRange: number): void {
+    inv<void>('0x195AEEB13CEFE2EE', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(speed), behaviorFlag, f(stoppingRange));
+  }
+
+  /**
+   * grappleStyle: AR_GRAPPLE_MOUNT_STANDING_FROM_FRONT, AR_GRAPPLE_MOUNT_STANDING_FROM_RIGHT, AR_GRAPPLE_MOUNT_STANDING_FROM_BACK, AR_GRAPPLE_MOUNT_STANDING_FROM_LEFT, AR_GRAPPLE_MOUNT_FROM_FRONT, AR_WOLF_EXECUTION_ENTER_FROM_BACK, AR_GRAPPLE_DRAG_FRONT_ON_ASS, AR_GRAPPLE_FRONT_FROM_LEFT_FAR, AR_BEAR_CHALLENGE_FRONT, AR_GRAPPLE_FRONT_FROM_FRONT, AR_GRAPPLE_MOUNT_FACEUP_FROM_FRONT
+   *
+   * @param targetPed 
+   * @param grappleStyle 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @returns
+   */
+  grapple(targetPed: Ped, grappleStyle: string | number, p3: number, p4: number, p5: number, p6: number): any {
+    return inv<number>('0x779A2FFACEFAEA7B', this.entity.handle, targetPed.handle, _h(grappleStyle), p3, f(p4), p5, p6);
+  }
+
+  /**
+   * @param ped1 
+   * @param waypointRecording 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  followEntityAlongWaypointRecordingAtOffset(ped1: Ped, waypointRecording: string | null, p3: number, p4: number, p5: number, p6: number, p7: number, p8: boolean): void {
+    inv<void>('0x4D2B787BAE9AB760', this.entity.handle, ped1.handle, waypointRecording, f(p3), f(p4), p5, p6, p7, p8);
+  }
+
+  /**
+   * @param pos 
+   * @param speed 
+   * @param p5 
+   * @param p6 
+   * @param walkingStyle 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   */
+  goToCoordAnyMeansExtraParams(pos: Vector3, speed: number, p5: any, p6: boolean, walkingStyle: number, p8: number, p9: any, p10: any, p11: any, p12: any): void {
+    inv<void>('0x1DD45F9ECFDB1BC9', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speed), p5, p6, walkingStyle, f(p8), p9, p10, p11, p12);
+  }
+
+  /**
+   * @param pos 
+   * @param timeout 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param coverpoint 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   */
+  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);
+  }
+
+  /**
+   * @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 
+   */
+  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 target 
+   */
+  arrestPed(target: Ped): void {
+    inv<void>('0xF3B9A78A178572B1', this.entity.handle, target.handle);
+  }
+
+  /**
+   * @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));
+  }
+
+  /**
+   * @param waypointRecording 
+   * @returns
+   */
+  isWaypointPlaybackGoingOnForPed(waypointRecording: string | null): boolean {
+    return inv<boolean>('0xE03B3F2D3DC59B64', this.entity.handle, waypointRecording, rai());
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  animalWrithe(p1: any, p2: any): void {
+    inv<void>('0x8C038A39C4A4B6D6', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  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 
+   */
+  combatPedTimed(targetPed: Ped, p2: number, p3: any): void {
+    inv<void>('0x944F30DCB7096BDE', this.entity.handle, targetPed.handle, p2, p3);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  throwProjectile(p1: any, p2: any, p3: any): void {
+    inv<void>('0x7285951DBF6B5A51', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param pos 
+   * @param heading 
+   * @param p5 
+   */
+  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));
+  }
+
+  /**
+   * 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 grappleTarget 
+   * @param grappleStyle 
+   * @param p3 
+   * @param p4 
+   * @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);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  combatAnimalWarn(p1: any, p2: any): void {
+    inv<void>('0xF960F3D57B660E96', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param toggle 
+   */
+  setPedIgnoreDeadBodies(toggle: boolean): void {
+    inv<void>('0x013A7BA5015C1372', this.entity.handle, toggle);
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @param attacker 
+   * @param p2 
+   * @returns Returns `true` on success, or `false` if `attacker` doesn't exist, or is dead.
+   */
+  intimidated(attacker: Ped, p2: boolean): boolean {
+    return inv<boolean>('0x648B75D44930D6BD', this.entity.handle, attacker.handle, p2, rai());
+  }
+
+  /**
+   * @returns
+   */
+  waypointPlaybackGetIsShooting(): any {
+    return inv<number>('0xA5B94DF8AF058F46', this.entity.handle);
+  }
+
+  /**
+   * @param pos 
+   * @param distance 
+   * @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);
+  }
+
+  /**
+   * 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());
+  }
+
+  /**
+   * @returns
+   */
+  waypointPlaybackGetIsAiming(): any {
+    return inv<number>('0xD73A5D1F0325C71C', this.entity.handle);
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @returns
+   */
+  isPedCuffed(): boolean {
+    return inv<boolean>('0x74E559B3BC910685', this.entity.handle, rai());
+  }
+
+  /**
+   * @param avoidWater 
+   * @param p2 
+   */
+  setPedPathPreferToAvoidWater(avoidWater: boolean, p2: number): void {
+    inv<void>('0x38FE1EC73743793C', this.entity.handle, avoidWater, f(p2));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   */
+  investigate(p1: any, p2: any, p3: any, p4: any, p5: any): void {
+    inv<void>('0x5C8514540D27FBFB', this.entity.handle, p1, p2, p3, p4, p5);
+  }
+
+  waypointPlaybackUseDefaultSpeed(): void {
+    inv<void>('0x6599D834B12D0800', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  knockedOutAndHogtied(p1: number, p2: number): void {
+    inv<void>('0x42AC6401ABB8C7E5', this.entity.handle, f(p1), p2);
+  }
+
+  /**
+   * @returns
+   */
+  getPedDesiredMoveBlendRatio(): number {
+    return inv<number>('0x8517D4A6CA8513ED', this.entity.handle, raf());
+  }
+
+  N_0xDF94844D474F31E5(): void {
+    inv<void>('0xDF94844D474F31E5', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  seekCoverToCoverPoint(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0xD43D95C7A869447F', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * @param fleeFromTarget 
+   */
+  flyAway(fleeFromTarget: Ped): void {
+    inv<void>('0xE86A537B5A3C297C', this.entity.handle, fleeFromTarget.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  guardCurrentPosition(p1: number, p2: number, p3: boolean): void {
+    inv<void>('0x4A58A47A72E3FCB4', this.entity.handle, f(p1), f(p2), p3);
+  }
+
+  /**
+   * @param modifier 
+   */
+  setPedPathFoliageCostModifier(modifier: number): void {
+    inv<void>('0x3AD8EFF9703BE657', this.entity.handle, f(modifier));
+  }
+
+  /**
+   * @param preferHorseWalkable 
+   * @param p2 
+   */
+  setPedPathPreferHorseWalkable(preferHorseWalkable: boolean, p2: number): void {
+    inv<void>('0x216343750545A486', this.entity.handle, preferHorseWalkable, f(p2));
+  }
+
+  clearPedSecondaryTask(): void {
+    inv<void>('0x176CECF6F920D707', this.entity.handle);
+  }
+
+  /**
+   * Not implemented.
+   *
+   * @param maxCruiseSpeed 
+   */
+  setDriveTaskMaxCruiseSpeed(maxCruiseSpeed: number): void {
+    inv<void>('0x404A5AA9B9F0B746', this.entity.handle, f(maxCruiseSpeed));
+  }
+
+  /**
+   * Params: p4 either 0.2f, 0.25f, 0.31f, 0.4f
+   *
+   * @param p1 
+   * @param p2 
+   * @param entity 
+   * @param p4 
+   * @param p5 
+   * @param vPosOpponentX 
+   * @param vPosOpponentY 
+   * @param vPosOpponentZ 
+   * @param fOpponentHead 
+   * @param p10 
+   */
+  duel(p1: any, p2: number, entity: Entity, p4: number, p5: number, vPosOpponentX: number, vPosOpponentY: number, vPosOpponentZ: number, fOpponentHead: number, p10: number): void {
+    inv<void>('0x5D5B0D5BC3626E5A', this.entity.handle, p1, f(p2), entity.handle, f(p4), p5, f(vPosOpponentX), f(vPosOpponentY), f(vPosOpponentZ), f(fOpponentHead), p10);
+  }
+
+  /**
+   * @param vehicle 
+   * @param waypointRecording 
+   * @param drivingMode 
+   * @param p4 
+   * @param eWaypoint 
+   * @param flag 
+   * @param p7 
+   * @param p8 
+   * @param stoppingDist 
+   * @param p10 
+   */
+  vehicleFollowWaypointRecording(vehicle: Vehicle, waypointRecording: string | null, drivingMode: number, p4: any, eWaypoint: number, flag: number, p7: number, p8: boolean, stoppingDist: number, p10: any): void {
+    inv<void>('0x3123FAA6DB1CF7ED', this.entity.handle, vehicle.handle, waypointRecording, drivingMode, p4, eWaypoint, flag, f(p7), p8, f(stoppingDist), p10);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  followEntityWhileAimingAtEntity(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
+    inv<void>('0x2D532EAA142CF83F', this.entity.handle, p1, p2, p3, p4, p5, p6, p7);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  gotoEntityOffsetXyAiming(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0x901BD69984400F62', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * @param train 
+   * @param scenarioPoint 
+   * @param scenarioHash 
+   */
+  rideTrain(train: Vehicle, scenarioPoint: number, scenarioHash: string | number): void {
+    inv<void>('0x37FB1C870E2EC2C6', this.entity.handle, train.handle, scenarioPoint, _h(scenarioHash));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  setStealthMovement(p1: boolean, p2: any, p3: boolean): void {
+    inv<void>('0x4C3FA937B44A90FA', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param moveNetworkDefName 
+   * @param pos 
+   * @param rot 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param flag 
+   * @param p14 
+   * @returns taskData
+   */
+  moveNetworkAdvancedByNameWithInitParams(moveNetworkDefName: string | null, pos: Vector3, rot: Vector3, p9: number, p10: number, p11: number, p12: number, flag: number, p14: number): number {
+    const result = inv<number>('0x7B6A04F98BBAFB2C', this.entity.handle, moveNetworkDefName, pvi(), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), p9, f(p10), p11, p12, flag, p14);
+    return result;
+  }
+
+  /**
+   * @param target 
+   * @param duration 
+   * @param distance 
+   * @param speed 
+   * @param p5 
+   * @param p6 
+   */
+  goToEntity(target: Entity, duration: number, distance: number, speed: number, p5: number, p6: number): void {
+    inv<void>('0x6A071245EB0D1882', this.entity.handle, target.handle, duration, f(distance), f(speed), f(p5), p6);
+  }
+
+  /**
+   * @param heading 
+   */
+  climb2(heading: number): void {
+    inv<void>('0xDF1D85BCAF60D537', this.entity.handle, f(heading));
+  }
+
+  /**
+   * @param p1 
+   */
+  pickUpWeapon(p1: any): void {
+    inv<void>('0x55B0ECFD98596624', this.entity.handle, p1);
+  }
+
+  /**
+   * @param toggle 
+   */
+  setPedPathCanDropFromHeight(toggle: boolean): void {
+    inv<void>('0xE361C5C71C431A4F', this.entity.handle, toggle);
+  }
+
+  /**
+   * @param targetPed 
+   * @param targetVehicle 
+   * @param targetPos 
+   * @param distanceToShoot 
+   * @param pedAccuracy 
+   * @param p8 
+   * @param firingPattern 
+   */
+  driveBy(targetPed: Ped, targetVehicle: Vehicle, targetPos: Vector3, distanceToShoot: number, pedAccuracy: number, p8: boolean, firingPattern: string | number): void {
+    inv<void>('0x2F8AF0E82773A171', this.entity.handle, targetPed.handle, targetVehicle.handle, f(targetPos.x), f(targetPos.y), f(targetPos.z), f(distanceToShoot), pedAccuracy, p8, _h(firingPattern));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  endDuel(p1: boolean, p2: number): void {
+    inv<void>('0xEED08A3A98B847E2', this.entity.handle, p1, f(p2));
+  }
+
+  /**
+   * @param pos 
+   * @param distance 
+   * @param duration 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   */
+  useNearestScenarioToCoord(pos: Vector3, distance: number, duration: number, p6: boolean, p7: boolean, p8: boolean, p9: boolean): void {
+    inv<void>('0x322BFDEA666E2B0E', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), duration, p6, p7, p8, p9);
+  }
+
+  /**
+   * stopRange: how close vehicle will get to destination before stopping, default 4.0
+   * straightLineDist: distance at which AI switches to heading for target directly instead of following nodes, default -1
+   *
+   * @param vehicle 
+   * @param pos 
+   * @param speed 
+   * @param style 
+   * @param vehicleModel 
+   * @param drivingMode 
+   * @param stopRange 
+   * @param straightLineDist 
+   */
+  vehicleDriveToCoord(vehicle: Vehicle, pos: Vector3, speed: number, style: any, vehicleModel: string | number, drivingMode: number, stopRange: number, straightLineDist: number): void {
+    inv<void>('0xE2A2AA2F659D77A7', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(speed), style, _h(vehicleModel), drivingMode, f(stopRange), f(straightLineDist));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  flyingCircle(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): void {
+    inv<void>('0x72997893BFB8ECCC', this.entity.handle, p1, p2, p3, p4, p5, p6);
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/tree/master/animations
+   * flags: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eScriptedAnimFlags
+   * ikFlags: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eIkControlFlags
+   *
+   * @param animDict 
+   * @param animName 
+   * @param speed 
+   * @param speedMultiplier 
+   * @param duration 
+   * @param flags Refer to [enum: eScriptedAnimFlags]
+   * @param playbackRate 
+   * @param p8 
+   * @param ikFlags Refer to [enum: eIkControlFlags]
+   * @param p10 
+   * @param taskFilter 
+   * @param p12 
+   */
+  playAnim(animDict: string | null, animName: string | null, speed: number, speedMultiplier: number, duration: number, flags: number, playbackRate: number, p8: boolean, ikFlags: number, p10: boolean, taskFilter: string | null, p12: boolean): void {
+    inv<void>('0xEA47FE3719165B94', this.entity.handle, animDict, animName, f(speed), f(speedMultiplier), duration, flags, f(playbackRate), p8, ikFlags, p10, taskFilter, p12);
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/blob/master/animations/scenarios
+   * Params: duration in milliseconds conditionalHash (optionally):
+   * 0 = play random conditional anim.
+   * Every conditional anim has requirements to play it.
+   * If requirements are not met, ped plays random allowed conditional anim or can be stuck.
+   * For example, this scenario type has possible conditional anim WORLD_HUMAN_LEAN_BACK_WALL_SMOKING_MALE_D, but it can not be played by player, because condition is set to NOT be CAIConditionIsPlayer (check file amb_rest.meta and amb_rest_CA.meta with OPENIV to clarify requirements).
+   *
+   * @param scenarioHash 
+   * @param duration 
+   * @param playEnterAnim 
+   * @param conditionalHash 
+   * @param heading 
+   * @param p6 
+   */
+  startScenarioInPlaceHash(scenarioHash: string | number, duration: number, playEnterAnim: boolean, conditionalHash: string | number, heading: number, p6: boolean): void {
+    inv<void>('0x524B54361229154F', this.entity.handle, _h(scenarioHash), duration, playEnterAnim, _h(conditionalHash), f(heading), p6);
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/tree/master/tasks/TASK_ANIMAL_INTERACTION
+   *
+   * @param targetPed 
+   * @param interactionType 
+   * @param interactionModel 
+   * @param skipIdleAnimationClip 
+   */
+  animalInteraction(targetPed: Ped, interactionType: string | number, interactionModel: string | number, skipIdleAnimationClip: boolean): void {
+    inv<void>('0xCD181A959CFDD7F4', this.entity.handle, targetPed.handle, _h(interactionType), _h(interactionModel), skipIdleAnimationClip);
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0x28EF780BDEA8A639(p1: number): void {
+    inv<void>('0x28EF780BDEA8A639', this.entity.handle, p1);
+  }
+
+  hogtieable(): void {
+    inv<void>('0x6AFD8FE0D723328F', this.entity.handle);
+  }
+
+  /**
+   * @param preferAvoidFoliage 
+   * @param p2 
+   */
+  setPedPathPreferToAvoidFoliage(preferAvoidFoliage: boolean, p2: number): void {
+    inv<void>('0x12990818C1D35886', this.entity.handle, preferAvoidFoliage, f(p2));
+  }
+
+  /**
+   * @param target 
+   */
+  vehicleAimAtPed(target: Ped): void {
+    inv<void>('0xE41885592B08B097', this.entity.handle, target.handle);
+  }
+
+  /**
+   * @param pos 
+   * @param p4 
+   * @param p5 
+   */
+  lootNearestEntity(pos: Vector3, p4: number, p5: number): void {
+    inv<void>('0xCF1501CBC4059412', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), p4, f(p5));
+  }
+
+  /**
+   * @param toggle 
+   */
+  setPedPathCanUseClimbovers(toggle: boolean): void {
+    inv<void>('0x8E06A6FE76C9EFF4', this.entity.handle, toggle);
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  getScenarioPointPedIsUsing(p1: boolean): number {
+    return inv<number>('0xDF7993356F52359A', this.entity.handle, p1, rai());
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/blob/master/AI/EVENTS/aud_ped_whistle_types.lua
+   * p2: UNSPECIFIED
+   *
+   * @param audPedWhistleType 
+   * @param p2 
+   */
+  whistleAnim(audPedWhistleType: string | number, p2: string | number): void {
+    inv<void>('0xD6401A1B2F63BED6', this.entity.handle, _h(audPedWhistleType), _h(p2));
+  }
+
+  /**
+   * @param cruiseSpeed 
+   */
+  setDriveTaskCruiseSpeed(cruiseSpeed: number): void {
+    inv<void>('0x5C9B84BD7D31D908', this.entity.handle, f(cruiseSpeed));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  moveBeInFormation(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): void {
+    inv<void>('0x4AA5AA97C65E4A2F', this.entity.handle, p1, p2, p3, p4, p5, p6);
+  }
+
+  /**
+   * @returns
+   */
+  isPedDuelling(): any {
+    return inv<number>('0xC8B29D18022EA2B7', this.entity.handle);
+  }
+
+  /**
+   * @param signalName 
+   * @param pos 
+   */
+  setTaskMoveNetworkSignalVector(signalName: string | null, pos: Vector3): void {
+    inv<void>('0x4662BFE01938D98D', this.entity.handle, signalName, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * Makes the specified ped flee the specified distance from the specified position.
+   *
+   * @param pos 
+   * @param distance 
+   * @param time 
+   * @param fleeType Refer to [enum: eFleeStyle]
+   * @param fleeSpeed 
+   */
+  smartFleeCoord(pos: Vector3, distance: number, time: number, fleeType: number, fleeSpeed: number): void {
+    inv<void>('0x94587F17E9C365D5', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(distance), time, fleeType, f(fleeSpeed));
+  }
+
+  /**
+   * @returns
+   */
+  N_0xFDECCA06E8B81346(): any {
+    return inv<number>('0xFDECCA06E8B81346', this.entity.handle);
+  }
+
+  /**
+   * @param pos 
+   * @param heading 
+   * @param scenarioName 
+   */
+  standGuard(pos: Vector3, heading: number, scenarioName: string | null): void {
+    inv<void>('0xAE032F8BBA959E90', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(heading), scenarioName);
+  }
+
+  /**
+   * @param vehicle 
+   * @param targetVehicle 
+   * @param mode 
+   * @param speed 
+   * @param drivingStyle 
+   * @param minDistance 
+   * @param p7 
+   * @param noRoadsDistance 
+   */
+  vehicleEscort(vehicle: Vehicle, targetVehicle: Vehicle, mode: number, speed: number, drivingStyle: number, minDistance: number, p7: number, noRoadsDistance: number): void {
+    inv<void>('0x0FA6E4B75F302400', this.entity.handle, vehicle.handle, targetVehicle.handle, mode, f(speed), drivingStyle, f(minDistance), p7, f(noRoadsDistance));
+  }
+
+  /**
+   * @param ped2 
+   * @param entity 
+   */
+  dumpCarriableFromParent(ped2: Ped, entity: Entity): void {
+    inv<void>('0x17CA98707B15926A', this.entity.handle, ped2.handle, entity.handle);
+  }
+
+  /**
+   * The break free progress increases as the player spams the prompt key until it reaches 1.0, at which point the ped breaks free.
+   *
+   * @returns
+   */
+  getPedWritheBreakFreeProgress(): number {
+    return inv<number>('0x03D741CB4052E26C', this.entity.handle, raf());
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  eat(p1: any, p2: any): void {
+    inv<void>('0xBD7949BD07299672', this.entity.handle, p1, p2);
+  }
+
+  N_0x88FD60D846D9CD63(): void {
+    inv<void>('0x88FD60D846D9CD63', 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 
+   */
+  followToOffsetOfCoord(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>('0x2E3676282C18A692', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+  }
+
+  /**
+   * @param toggle 
+   */
+  setBlockingOfNonTemporaryEvents(toggle: boolean): void {
+    inv<void>('0x90D2156198831D69', this.entity.handle, toggle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  vehicleDriveToCoord2(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0xF0108F01FB105DA2', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  stopLeadingHorse(): void {
+    inv<void>('0xED27560703F37258', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   */
+  setPedClearAimingInTheAir(p1: any): void {
+    inv<void>('0x34C0010188D7C54A', this.entity.handle, p1);
+  }
+
+  /**
+   * @returns
+   */
+  pedIsInScenarioBase(): any {
+    return inv<number>('0x02EBBB3989B7E695', this.entity.handle);
+  }
+
+  /**
+   * @param animDict 
+   * @param animName 
+   * @param pos 
+   * @param rot 
+   * @param speed 
+   * @param speedMultiplier 
+   * @param duration 
+   * @param flags Refer to [enum: eScriptedAnimFlags]
+   * @param p13 
+   * @param p14 Refer to [enum: eIkControlFlags]
+   * @param p15 
+   * @param p16 
+   */
+  playAnimAdvanced(animDict: string | null, animName: string | null, pos: Vector3, rot: Vector3, speed: number, speedMultiplier: number, duration: number, flags: number, p13: number, p14: number, p15: number, p16: number): void {
+    inv<void>('0x83CDB10EA29B370B', this.entity.handle, animDict, animName, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(speed), f(speedMultiplier), duration, flags, f(p13), p14, p15, p16);
+  }
+
+  /**
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  combatAnimalChargePed(targetPed: Ped, p2: boolean, p3: any, p4: any, p5: any, p6: any): void {
+    inv<void>('0xEE3AA414CF99F368', this.entity.handle, targetPed.handle, p2, p3, p4, p5, p6);
+  }
+
+  /**
+   * @returns
+   */
+  getLedHorseFromPed(): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0xED1F514AF4732258', this.entity.handle, rai()));
+  }
+
+  /**
+   * @returns
+   */
+  N_0xBEDBE39B5FD98FD6(): boolean {
+    return inv<boolean>('0xBEDBE39B5FD98FD6', this.entity.handle, rai());
+  }
+
+  /**
+   * @returns
+   */
+  isPedRunningInspectionTask(): any {
+    return inv<number>('0x038B1F1674F0E242', this.entity.handle);
+  }
+
+  /**
+   * @param entity 
+   * @param pos 
+   * @param p5 
+   * @param flags 
+   */
+  placeCarriedEntityAtCoord(entity: Entity, pos: Vector3, p5: number, flags: number): void {
+    inv<void>('0xC7F0B43DCDC57E3D', this.entity.handle, entity.handle, f(pos.x), f(pos.y), f(pos.z), f(p5), flags);
+  }
+
+  /**
+   * Params: moveBlendRatio commonly 1.25f, p5 is always 0 in R* Scripts
+   *
+   * @param moveBlendRatio 
+   * @param pos 
+   * @param p5 
+   */
+  moveFollowRoadUsingNavmesh(moveBlendRatio: number, pos: Vector3, p5: any): void {
+    inv<void>('0x79482C12482A860D', this.entity.handle, f(moveBlendRatio), f(pos.x), f(pos.y), f(pos.z), p5);
+  }
+
+  /**
+   * @returns
+   */
+  getPedWaypointProgress(): number {
+    return inv<number>('0x2720AAA75001E094', this.entity.handle, rai());
+  }
+
+  /**
+   * @param targetPed 
+   * @param targetVehicle 
+   * @param pos 
+   */
+  setDrivebyTaskTarget(targetPed: Ped, targetVehicle: Vehicle, pos: Vector3): void {
+    inv<void>('0xE5B302114D8162EE', this.entity.handle, targetPed.handle, targetVehicle.handle, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * All Interaction states
+   * https://github.com/femga/rdr3_discoveries/tree/master/tasks/TASK_ITEM_INTERACTION#-4-item_interaction_state_name--item_interaction_propid--1
+   *
+   * @param itemInteractionState 
+   * @param p2 
+   */
+  setItemInteractionState(itemInteractionState: string | number, p2: number): void {
+    inv<void>('0xB35370D5353995CB', this.entity.handle, _h(itemInteractionState), f(p2));
+  }
+
+  /**
+   * @param pos 
+   * @param speed 
+   * @param entity 
+   * @param p6 
+   * @param walkingStyle 
+   * @param p8 
+   */
+  goToCoordAnyMeans(pos: Vector3, speed: number, entity: Entity, p6: boolean, walkingStyle: number, p8: number): void {
+    inv<void>('0x5BC448CB78FA3E88', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speed), entity.handle, p6, walkingStyle, f(p8));
+  }
+
+  /**
+   * @param propNameGxt 
+   * @param prop 
+   * @param propId 
+   * @param itemInteractionState 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  itemInteraction2(propNameGxt: string | number, prop: Prop, propId: string | number, itemInteractionState: string | number, p5: number, p6: any, p7: number): void {
+    inv<void>('0x72F52AA2D2B172CC', this.entity.handle, _h(propNameGxt), prop.handle, _h(propId), _h(itemInteractionState), p5, p6, f(p7));
+  }
+
+  emotePlayAction(): void {
+    inv<void>('0x6A1AF481407BF6E9', this.entity.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  wanderAndConverseWithPed(p1: any, p2: any, p3: any): void {
+    inv<void>('0x8AC76D1408731732', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  animalUnalerted(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0x21FDF9A25CFE1CE5', this.entity.handle, p1, p2, p3, p4);
+  }
+
+  /**
+   * See TASK_VEHICLE_MISSION
+   *
+   * @param vehicle 
+   * @param pedTarget 
+   * @param mode 
+   * @param maxSpeed 
+   * @param drivingStyle 
+   * @param minDistance 
+   * @param p7 
+   * @param DriveAgainstTraffic 
+   */
+  vehicleMissionPedTarget(vehicle: Vehicle, pedTarget: Ped, mode: number, maxSpeed: number, drivingStyle: number, minDistance: number, p7: number, DriveAgainstTraffic: boolean): void {
+    inv<void>('0x9454528DF15D657A', this.entity.handle, vehicle.handle, pedTarget.handle, mode, f(maxSpeed), drivingStyle, f(minDistance), f(p7), DriveAgainstTraffic);
+  }
+
+  /**
+   * @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 
+   * @param p16 
+   * @param p17 
+   */
+  moveNetworkAdvancedByNameWithInitParamsAttached(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, p16: any, p17: any): void {
+    inv<void>('0xF92171093BCABED4', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
+  }
+
+  /**
+   * @param vehicle 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   */
+  boardVehicle(vehicle: Vehicle, p2: any, p3: any, p4: any, p5: any): void {
+    inv<void>('0xE53D17AD837CBF7C', this.entity.handle, vehicle.handle, p2, p3, p4, p5);
+  }
+
+  /**
+   * @param pos 
+   * @param fromPos 
+   * @param timeout 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param p12 
+   * @param p13 
+   * @param p14 
+   * @param p15 
+   * @param p16 
+   * @param p17 
+   */
+  putPedDirectlyIntoCoverFromCoords(pos: Vector3, fromPos: Vector3, timeout: number, p8: any, p9: any, p10: any, p11: any, p12: any, p13: any, p14: any, p15: any, p16: any, p17: any): void {
+    inv<void>('0xDF8A5855B9F9A97B', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(fromPos.x), f(fromPos.y), f(fromPos.z), timeout, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
+  }
+
+  /**
+   * @param horse 
+   */
+  leadHorse(horse: Ped): void {
+    inv<void>('0x9A7A4A54596FE09D', this.entity.handle, horse.handle);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   */
+  seekCoverToCoords(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any): void {
+    inv<void>('0x39246A6958EF072C', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+  }
+
+  /**
+   * flags:
+   * MOVE_WHILST_WAITING_FOR_PATH = (1 << 0),
+   * DO_NOT_STAND_STILL_AT_END_OF_PATH = (1 << 1),
+   * SKIP_NAVIGATION = (1 << 2),
+   * TEASF_AUTO_START_ANIM_SCENE = (1 << 3),
+   * FORCE_STAND_STILL_AT_END_OF_PATH = (1 << 6),
+   * ENTER_ANIM_SCENE_DONT_FOLLOW_NAVMESH = (1 << 7)
+   *
+   * @param animScene 
+   * @param entityName 
+   * @param playbackListName 
+   * @param enterSpeed 
+   * @param bAutoStart 
+   * @param flag 
+   * @param p7 
+   * @param p8 
+   */
+  enterAnimScene(animScene: AnimScene, entityName: string | null, playbackListName: string | null, enterSpeed: number, bAutoStart: boolean, flag: number, p7: number, p8: number): void {
+    inv<void>('0xC2329B0206426644', this.entity.handle, animScene.handle, entityName, playbackListName, f(enterSpeed), bAutoStart, flag, p7, f(p8));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   */
+  followPointRoute(p1: any, p2: any, p3: any, p4: any, p5: any): void {
+    inv<void>('0x0E14C5550DC3CD1D', this.entity.handle, p1, p2, p3, p4, p5);
+  }
+
+  /**
+   * @param mayEnterDeepWater 
+   */
+  setPedPathMayEnterDeepWater(mayEnterDeepWater: boolean): void {
+    inv<void>('0x9DE63896B176EA94', this.entity.handle, mayEnterDeepWater);
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0x9050DF2C53801208(p1: number): void {
+    inv<void>('0x9050DF2C53801208', this.entity.handle, f(p1));
+  }
+
+  /**
+   * This native checks if a ped is on the ground, in pain from a (gunshot) wound.
+   *
+   * @returns
+   */
+  isPedInWrithe(): boolean {
+    return inv<boolean>('0xDEB6D52126E7D640', this.entity.handle, rai());
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param flags 
+   */
+  boardVehicle2(p1: any, p2: any, p3: number, flags: number): void {
+    inv<void>('0xE41A09C8DDFF7AA4', this.entity.handle, p1, p2, f(p3), flags);
+  }
+
+  /**
+   * *SET_PED**
+   *
+   * @param p1 
+   * @param p2 
+   */
+  N_0x41D1331AFAD5A091(p1: number, p2: any): void {
+    inv<void>('0x41D1331AFAD5A091', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @returns
+   */
+  isPedArrestingAnyPed(): any {
+    return inv<number>('0xA9CC7856D52DBD25', this.entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  waypointPlaybackGetIsPaused(): boolean {
+    return inv<boolean>('0x701375A7D43F01CB', this.entity.handle, rai());
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  isPedScenarioReactLooking(p1: boolean): any {
+    return inv<number>('0x916B8E075ABC8B4E', this.entity.handle, p1);
+  }
+
+  /**
+   * @returns args
+   */
+  shootWithWeapon(): number {
+    const result = inv<number>('0x08AA95E8298AE772', this.entity.handle, pvi());
+    return result;
+  }
+
+  N_0x22CDBF317C40A122(): void {
+    inv<void>('0x22CDBF317C40A122', this.entity.handle);
+  }
+
+  /**
+   * @returns
+   */
+  getPedWaypointDistance(): number {
+    return inv<number>('0xE6A877C64CAF1BC5', this.entity.handle, raf());
+  }
+
+  /**
+   * @param mayEnterWater 
+   */
+  setPedPathMayEnterWater(mayEnterWater: boolean): void {
+    inv<void>('0xF35425A4204367EC', this.entity.handle, mayEnterWater);
+  }
+
+  /**
+   * Makes the ped ragdoll like when falling from a great height
+   *
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  setHighFallTask(p1: number, p2: number, p3: number): void {
+    inv<void>('0x8C825BDC7741D37C', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param p1 
+   */
+  setPedDesiredMoveBlendRatio(p1: number): void {
+    inv<void>('0x1E982AC8716912C5', this.entity.handle, f(p1));
+  }
+
+  /**
+   * @param patrolRoute 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  patrol(patrolRoute: string | null, p2: any, p3: boolean, p4: boolean): void {
+    inv<void>('0xBDA5DF49D080FE4E', this.entity.handle, patrolRoute, p2, p3, p4);
+  }
+
+  /**
+   * @returns
+   */
+  isEntityRevivable(): any {
+    return inv<number>('0x6C50B9DCCCA70023', this.entity.handle);
+  }
+
+  /**
+   * @param travelMbr 
+   * @param pos 
+   * @param p5 
+   * @param p6 
+   */
+  flyToCoord(travelMbr: number, pos: Vector3, p5: boolean, p6: boolean): void {
+    inv<void>('0xD6CFC2D59DA72042', this.entity.handle, f(travelMbr), f(pos.x), f(pos.y), f(pos.z), p5, p6);
+  }
+
+  /**
+   * @param vehicle 
+   * @param flags Refer to [enum: eEnterExitVehicleFlags]
+   * @param unkPed 
+   */
+  leaveVehicle(vehicle: Vehicle, flags: number, unkPed: Ped): void {
+    inv<void>('0xD3DBCE61A490BE02', this.entity.handle, vehicle.handle, flags, unkPed.handle);
+  }
+
+  /**
+   * Immediately stops the pedestrian from whatever it's doing. They stop fighting, animations, etc. they forget what they were doing. resetCrouch TRUE = ped will stand up if crouching, FALSE = ped will remain crouching if crouched
+   *
+   * @param p1 
+   * @param resetCrouch 
+   */
+  clearPedTasksImmediately(p1: boolean, resetCrouch: boolean): void {
+    inv<void>('0xAAA34F8A7CB32098', this.entity.handle, p1, resetCrouch);
+  }
+
+  /**
+   * @param entity 
+   */
+  pickupCarriableEntity(entity: Entity): void {
+    inv<void>('0x502EC17B1BED4BFA', this.entity.handle, entity.handle);
+  }
+
+  /**
+   * @param killer 
+   * @param p2 
+   * @param weaponHash Refer to [enum: eWeaponHash]
+   * @param p4 
+   * @param p5 
+   */
+  animalBleedOut(killer: Ped, p2: boolean, weaponHash: eWeaponHash, p4: number, p5: number): void {
+    inv<void>('0x30A768C30D385EC5', this.entity.handle, killer.handle, p2, weaponHash, p4, p5);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   */
+  gotoEntityOffsetXyzAiming(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any): void {
+    inv<void>('0x41B0832CA96B5351', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+  }
+
+  /**
+   * @param entity 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  N_0x517D01BF27B682D1(entity: Entity, p2: number, p3: number, p4: number, p5: number, p6: number): void {
+    inv<void>('0x517D01BF27B682D1', this.entity.handle, entity.handle, f(p2), f(p3), f(p4), f(p5), p6);
+  }
+
+  /**
+   * @param animDict 
+   * @param animName 
+   */
+  playAnimOnRunningScenario(animDict: string | null, animName: string | null): void {
+    inv<void>('0x748040460F8DF5DC', this.entity.handle, animDict, animName);
+  }
+
+  /**
+   * @param ped2 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  useScenarioPoint2(ped2: Ped, p2: any, p3: string | null, p4: number, p5: string | number, p6: number, p7: boolean): void {
+    inv<void>('0x0F6641449DD86FBE', this.entity.handle, ped2.handle, p2, p3, p4, _h(p5), f(p6), p7);
+  }
+
+  /**
+   * @param barkAtTarget 
+   * @param mood 
+   */
+  bark(barkAtTarget: Ped, mood: string | number): void {
+    inv<void>('0x83BFC1F836B2F3F2', this.entity.handle, barkAtTarget.handle, _h(mood));
+  }
+
+  /**
+   * @returns
+   */
+  getTaskMoveNetworkState(): string | null {
+    return inv<string>('0x717E4D1F2048376D', this.entity.handle, ras());
+  }
+
+  /**
+   * @param vehicle 
+   * @param timeout 
+   * @param seat 
+   * @param speed 
+   * @param flag Refer to [enum: eEnterExitVehicleFlags]
+   * @param p6 
+   */
+  enterVehicle(vehicle: Vehicle, timeout: number, seat: number, speed: number, flag: number, p6: any): void {
+    inv<void>('0xC20E50AA46D09CA8', this.entity.handle, vehicle.handle, timeout, seat, f(speed), flag, p6);
+  }
+
+  /**
+   * Documentation from GTA V, might be the same in RDR: '1 - brake
+   * '3 - brake + reverse
+   * '4 - turn left 90 + braking
+   * '5 - turn right 90 + braking
+   * '6 - brake strong (handbrake?) until time ends
+   * '7 - turn left + accelerate
+   * '7 - turn right + accelerate
+   * '9 - weak acceleration
+   * '10 - turn left + restore wheel pos to center in the end
+   * '11 - turn right + restore wheel pos to center in the end
+   * '13 - turn left + go reverse
+   * '14 - turn left + go reverse
+   * '16 - crash the game after like 2 seconds :)
+   * '17 - keep actual state, game crashed after few tries
+   * '18 - game crash
+   * '19 - strong brake + turn left/right
+   * '20 - weak brake + turn left then turn right
+   * '21 - weak brake + turn right then turn left
+   * '22 - brake + reverse
+   * '23 - accelerate fast
+   * '24 - brake
+   * '25 - brake turning left then when almost stopping it turns left more
+   * '26 - brake turning right then when almost stopping it turns right more
+   * '27 - brake until car stop or until time ends
+   * '28 - brake + strong reverse acceleration
+   * '30 - performs a burnout (brake until stop + brake and accelerate)
+   * '31 - accelerate + handbrake
+   * '32 - accelerate very strong Seems to be this:
+   * Works on NPCs, but overrides their current task. If inside a task sequence (and not being the last task), "time" will work, otherwise the task will be performed forever until tasked with something else
+   *
+   * @param vehicle 
+   * @param action 
+   * @param time 
+   */
+  vehicleTempAction(vehicle: Vehicle, action: number, time: number): void {
+    inv<void>('0xC429DCEEB339E129', this.entity.handle, vehicle.handle, action, time);
+  }
+
+  /**
+   * @param pos 
+   * @param ped2 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @param firingPattern 
+   * @param p13 
+   * @param p14 
+   */
+  goToCoordWhileAimingAtEntity(pos: Vector3, ped2: Ped, p5: number, p6: any, p7: number, p8: number, p9: any, p10: any, p11: any, firingPattern: string | number, p13: number, p14: any): void {
+    inv<void>('0xB2A16444EAD9AE47', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), ped2.handle, f(p5), p6, f(p7), f(p8), p9, p10, p11, _h(firingPattern), p13, p14);
+  }
+
+  /**
+   * Gets the status of a script-assigned task, and returns an int between 0-8
+   * taskHash: https://alloc8or.re/rdr3/doc/enums/eScriptTaskHash.txt WAITING_TO_START_TASK = 0,
+   * PERFORMING_TASK
+   * DORMANT_TASK
+   * VACANT_STAGE
+   * GROUP_TASK_STAGE
+   * ATTRACTOR_SCRIPT_TASK_STAGE
+   * SECONDARY_TASK_STAGE
+   * TASK_NOT_FOUND
+   * FINISHED_TASK
+   *
+   * @param taskHash 
+   * @param p2 
+   * @returns
+   */
+  getScriptTaskStatus(taskHash: string | number, p2: boolean): number {
+    return inv<number>('0x77F1BEB8863288D5', this.entity.handle, _h(taskHash), p2, rai());
+  }
+
+  /**
+   * @returns
+   */
+  getScenarioPointTypePedIsUsing(): number {
+    return inv<number>('0x2D0571BB55879DA2', this.entity.handle, rai());
+  }
+
+  /**
+   * Takes scenario point handle instead of hash
+   *
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  startScenarioInPlace2(p1: any, p2: string | null, p3: number, p4: boolean, p5: number, p6: boolean): void {
+    inv<void>('0xA917E39F2CEFD215', this.entity.handle, p1, p2, p3, p4, f(p5), p6);
+  }
+
+  /**
+   * @param duration 
+   * @param pedToCowerFrom 
+   * @param p3 
+   */
+  cower(duration: number, pedToCowerFrom: Ped, p3: string | null): void {
+    inv<void>('0x3EB1FE9E8E908E15', this.entity.handle, duration, pedToCowerFrom.handle, p3);
+  }
+
+  /**
+   * @param unused 
+   */
+  reloadWeapon(unused: boolean): void {
+    inv<void>('0x62D2916F56B9CD2D', this.entity.handle, unused);
+  }
+
+  /**
+   * @param targetPed 
+   */
+  lassoPed(targetPed: Ped): void {
+    inv<void>('0xC716EB2BD16370A3', this.entity.handle, targetPed.handle);
+  }
+
+  /**
+   * @param volume 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  wanderInVolume(volume: Volume, p2: number, p3: number, p4: number): void {
+    inv<void>('0x9FDA168777B28424', this.entity.handle, volume.handle, f(p2), f(p3), p4);
+  }
+
+  /**
+   * This function is hard-coded to always return false.
+   *
+   * @returns
+   */
+  isPedBeingArrested(): boolean {
+    return inv<boolean>('0x90A09F3A45FED688', this.entity.handle, rai());
+  }
+
+  /**
+   * @param p1 
+   */
+  companionAmbient(p1: any): void {
+    inv<void>('0xE017CF6E2527FE4F', this.entity.handle, p1);
+  }
+
+  /**
+   * Params: p5 = some flag?, p6 = -1.0f, p8 = 0 in R* Scripts
+   * fleeStyle: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/eFleeStyle
+   *
+   * @param pos 
+   * @param fleeStyle 
+   * @param p5 
+   * @param p6 
+   * @param duration 
+   * @param p8 
+   */
+  fleeCoord(pos: Vector3, fleeStyle: number, p5: number, p6: number, duration: number, p8: number): void {
+    inv<void>('0x58428248BF4B64E4', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), fleeStyle, p5, f(p6), duration, p8);
+  }
+
+  /**
+   * @param unused 
+   */
+  jump(unused: boolean): void {
+    inv<void>('0x0AE4086104E067B1', this.entity.handle, unused);
+  }
+
+  /**
+   * @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());
+  }
+
+  /**
+   * @param entity 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  seekClearLosToEntity(entity: Entity, p2: number, p3: number, p4: number): void {
+    inv<void>('0x8D7F2A63688C20A4', this.entity.handle, entity.handle, f(p2), f(p3), f(p4));
+  }
+
+  /**
+   * @param pos 
+   * @param p4 
+   */
+  vehicleShootAtCoord(pos: Vector3, p4: number): void {
+    inv<void>('0x5190796ED39C9B6D', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(p4));
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  isPedExitingScenario(p1: boolean): any {
+    return inv<number>('0x0C3CB2E600C8977D', this.entity.handle, p1);
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/tree/master/tasks/TASK_HORSE_ACTION
+   * Params: p2, p3 are set to 0 in R* Scripts
+   *
+   * @param action 
+   * @param targetPed 
+   * @param p3 
+   */
+  horseAction(action: number, targetPed: Ped, p3: any): void {
+    inv<void>('0xA09CFD29100F06C3', this.entity.handle, action, targetPed.handle, p3);
+  }
+
+  /**
+   * @param targetPed 
+   * @param lookIntensity Refer to [enum: eLookIntensity]
+   * @param exitAnimation Refer to [enum: eLookReturnAnimation]
+   * @param duration 
+   * @param p5 
+   * @param targetPed2 
+   * @param p7 
+   * @param p8 
+   */
+  reactLookAt(targetPed: Ped, lookIntensity: number, exitAnimation: number, duration: number, p5: number, targetPed2: Ped, p7: any, p8: any): void {
+    inv<void>('0xE7FA07624574B79A', this.entity.handle, targetPed.handle, lookIntensity, exitAnimation, f(duration), p5, targetPed2.handle, p7, p8);
+  }
+
+  /**
+   * @param vehicle 
+   * @param speed 
+   * @param drivingStyle 
+   */
+  vehicleDriveWander(vehicle: Vehicle, speed: number, drivingStyle: number): void {
+    inv<void>('0x480142959D337D00', this.entity.handle, vehicle.handle, f(speed), drivingStyle);
+  }
+
+  /**
+   * Params: p3 = 0, 1; p5 = 0.0f, -1.0f
+   * https://github.com/femga/rdr3_discoveries/tree/master/tasks/TASK_ITEM_INTERACTION
+   *
+   * @param itemHash 
+   * @param interactionAnimHash 
+   * @param p3 
+   * @param flag 
+   * @param p5 
+   */
+  startTaskItemInteraction(itemHash: string | number, interactionAnimHash: string | number, p3: number, flag: number, p5: number): void {
+    inv<void>('0xAE72E7DF013AAA61', this.entity.handle, _h(itemHash), _h(interactionAnimHash), p3, flag, f(p5));
+  }
+
+  /**
+   * Despite its name, it only attacks ONE hated target. The one closest hated target.
+   *
+   * @param radius 
+   * @param flags 
+   * @param p3 
+   */
+  combatHatedTargetsAroundPed(radius: number, flags: number, p3: any): void {
+    inv<void>('0x7BF835BB9E2698C8', this.entity.handle, f(radius), flags, p3);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  animalAlerted(p1: any, p2: any): void {
+    inv<void>('0x979D93372FC8C565', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param pos 
+   * @param radius 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  wanderInArea(pos: Vector3, radius: number, p5: number, p6: number, p7: number): void {
+    inv<void>('0xE054346CA3A0F315', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(radius), f(p5), f(p6), p7);
+  }
+
+  /**
+   * _SET_PED_PATH_P*
+   *
+   * @param modifier 
+   */
+  setPedPathLadderCostModifier(modifier: number): void {
+    inv<void>('0x70F7A1EAB1AE3AA8', this.entity.handle, f(modifier));
+  }
+
+  /**
+   * @param targetPed 
+   * @param p2 
+   */
+  cutFreeHogtiedTargetPed2(targetPed: Ped, p2: number): void {
+    inv<void>('0x525421A507216084', this.entity.handle, targetPed.handle, f(p2));
+  }
+
+  /**
+   * @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 
+   */
+  goToCoordWhileAimingAtCoord(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>('0x11315AB3385B8AC0', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
+  }
+
+  /**
+   * Dismounts the ped from the animal it's mounted on. taskFlag affects what side the rider gets off. p2-p5 are almost always 0.
+   *
+   * @param taskFlag Refer to [enum: eEnterExitVehicleFlags]
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param targetPed 
+   */
+  dismountAnimal(taskFlag: number, p2: any, p3: any, p4: any, targetPed: Ped): void {
+    inv<void>('0x48E92D3DDE23C23A', this.entity.handle, taskFlag, p2, p3, p4, targetPed.handle);
+  }
+
+  /**
+   * @returns
+   */
+  pedHasUseScenarioTask(): boolean {
+    return inv<boolean>('0x295E3CCEC879CCD7', this.entity.handle, rai());
+  }
+
+  /**
+   * Makes the specified ped achieve the specified heading. pedHandle: The handle of the ped to assign the task to.
+   * heading: The desired heading.
+   * timeout: The time, in milliseconds, to allow the task to complete. If the task times out, it is canceled, and the ped will stay at the heading it managed to reach in the time.
+   *
+   * @param heading 
+   * @param timeout 
+   */
+  achieveHeading(heading: number, timeout: number): void {
+    inv<void>('0x93B93A37987F1F3D', this.entity.handle, f(heading), timeout);
+  }
+
+  /**
+   * @returns
+   */
+  isPedStill(): boolean {
+    return inv<boolean>('0xAC29253EEF8F0180', this.entity.handle, rai());
+  }
+
+  /**
+   * @param scenario 
+   * @returns
+   */
+  isPedActiveInScenario(scenario: number): boolean {
+    return inv<boolean>('0xAA135F9482C82CC3', this.entity.handle, scenario, rai());
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  waypointPlaybackResume(p1: boolean, p2: number, p3: number): void {
+    inv<void>('0x244F70C84C547D2D', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  aimAtCoord(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): void {
+    inv<void>('0x4AF1D73861212F52', this.entity.handle, p1, p2, p3, p4, p5, p6);
+  }
+
+  /**
+   * @param task 
+   * @param multiplier 
+   * @param p3 
+   * @param animDict 
+   * @param flags 
+   */
+  moveNetworkByName(task: string | null, multiplier: number, p3: boolean, animDict: string | null, flags: number): void {
+    inv<void>('0x2D537BA194896636', this.entity.handle, task, f(multiplier), p3, animDict, flags);
+  }
+
+  /**
+   * Only used in R* SP Script beat_washed_ashore
+   * Returns Object prop for TASK::_TASK_ITEM_INTERACTION_2
+   *
+   * @param p1 
+   * @returns
+   */
+  N_0x678D3226CF70B9C8(p1: boolean): Prop | null {
+    return createFromHandle<Prop>('Prop', inv<number>('0x678D3226CF70B9C8', this.entity.handle, p1, rai()));
+  }
+
+  /**
+   * @param waypointRecording 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   */
+  followWaypointRecordingAtOffset(waypointRecording: string | null, p2: number, p3: number, p4: number, p5: number, p6: boolean): void {
+    inv<void>('0xBE9B0520BD7C445B', this.entity.handle, waypointRecording, f(p2), p3, p4, p5, p6);
+  }
+
+  /**
+   * @param fromPed 
+   * @param duration 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   */
+  seekCoverFromPed(fromPed: Ped, duration: number, p3: any, p4: any, p5: any): void {
+    inv<void>('0x84D32B3BEC531324', this.entity.handle, fromPed.handle, duration, p3, p4, p5);
+  }
+
+  /**
+   * @returns
+   */
+  getRansackScenarioPointPedIsUsing(): any {
+    return inv<number>('0xD04241BBF6D03A5E', this.entity.handle);
+  }
+
+  emoteOutro(): void {
+    inv<void>('0xBDFEEB7600BCD938', this.entity.handle);
+  }
+
+  /**
+   * @param task 
+   * @returns
+   */
+  getScriptTaskActionTime(task: string | number): number {
+    return inv<number>('0xA710DC5D25F8B942', this.entity.handle, _h(task), raf());
+  }
+
+  /**
+   * @param p1 
+   * @returns
+   */
+  isEmoteTaskRunning(p1: any): boolean {
+    return inv<boolean>('0xCF9B71C0AF824036', this.entity.handle, p1, rai());
+  }
+
+  /**
+   * @returns args
+   */
+  followPavementToCoord(): number {
+    const result = inv<number>('0x1B1475414E70DD8E', this.entity.handle, pvi());
+    return result;
+  }
+
+  /**
+   * @returns
+   */
+  isTaskMoveNetworkActive(): boolean {
+    return inv<boolean>('0x921CE12C489C4C41', this.entity.handle, rai());
+  }
+
+  /**
+   * @param pos 
+   * @param p4 
+   */
+  addFleeTargetCoords(pos: Vector3, p4: number): void {
+    inv<void>('0xE8F1A5B4CED3725A', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(p4));
+  }
+
+  /**
+   * item hashes: PRIMARYITEM, P_MUGCOFFEE01X_PH_R_HAND, P_BOTTLEBEER01X_PH_R_HAND
+   * http://prntscr.com/1qtp3bz
+   * https://github.com/femga/rdr3_discoveries/tree/master/tasks/TASK_ITEM_INTERACTION
+   *
+   * @param item 
+   * @returns
+   */
+  getItemInteractionEntityFromPed(item: string | number): Entity | null {
+    return createFromHandle<Entity>('Entity', inv<number>('0x05A0100EA714DB68', this.entity.handle, _h(item), rai()));
+  }
+
+  /**
+   * @param entity 
+   */
+  lootEntity(entity: Entity): void {
+    inv<void>('0x48FAE038401A2888', this.entity.handle, entity.handle);
+  }
+
+  /**
+   * Params: p2: AR_TAKEDOWN_FRONT, AR_EXECUTION_FRONT, 0 in R* Scripts
+   *
+   * @param targetPed 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @returns
+   */
+  melee(targetPed: Ped, p2: string | number, p3: any, p4: any, p5: number, p6: any, p7: number): any {
+    return inv<number>('0x482C99D0B38D1B0A', this.entity.handle, targetPed.handle, _h(p2), p3, p4, f(p5), p6, f(p7));
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   */
+  leadAndConverse(p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any): void {
+    inv<void>('0xAA19711D33C6708C', this.entity.handle, p1, p2, p3, p4, p5, p6, p7, p8);
+  }
+
+  /**
+   * clipset: CLIPSET@MECH_HOGTIE@HUMAN@BREAKOUT_MG@GROUND, CLIPSET@MECH_HOGTIE@HUMAN@BREAKOUT_MG@SHOULDER, CLIPSET@MECH_HOGTIE@HUMAN@BREAKOUT_MG@MOUNT
+   * clipset can also be 0
+   *
+   * @param p1 
+   * @param clipset 
+   * @returns
+   */
+  setEnhancedBreakFree(p1: boolean, clipset: string | null): any {
+    return inv<number>('0x1BF9D36A5EAFFBAE', this.entity.handle, p1, clipset);
+  }
+
+  /**
+   * @returns args
+   */
+  scriptedAnimation(): number {
+    const result = inv<number>('0x126EF75F1E17ABE5', this.entity.handle, pvi());
+    return result;
+  }
+
+  /**
+   * @param p1 
+   */
+  N_0x8B1FDF63C3193EDA(p1: number): void {
+    inv<void>('0x8B1FDF63C3193EDA', this.entity.handle, f(p1));
+  }
+
+  /**
+   * @param target 
+   * @param p2 
+   */
+  vehicleShootAtPed(target: Ped, p2: number): void {
+    inv<void>('0x10AB107B887214D8', this.entity.handle, target.handle, f(p2));
+  }
+
+  /**
+   * motionStateHash: see FORCE_PED_MOTION_STATE
+   *
+   * @param motionStateHash 
+   * @param p2 
+   */
+  forceMotionState(motionStateHash: string | number, p2: boolean): void {
+    inv<void>('0x4F056E1AFFEF17AB', this.entity.handle, _h(motionStateHash), p2);
+  }
+
+  /**
+   * 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 p5 
+   */
+  turnPedToFaceEntity(targetEntity: Entity, duration: number, p3: number, p4: number, p5: number): void {
+    inv<void>('0x5AD23D40115353AC', this.entity.handle, targetEntity.handle, duration, f(p3), f(p4), f(p5));
+  }
+
+  /**
+   * @param entity 
+   * @param p2 
+   * @param pos 
+   * @param duration 
+   */
+  gotoEntityOffset(entity: Entity, p2: any, pos: Vector3, duration: number): void {
+    inv<void>('0xE39B4FF4FDEBDE27', this.entity.handle, entity.handle, p2, f(pos.x), f(pos.y), f(pos.z), duration);
+  }
+
+  /**
+   * @param pos 
+   * @param duration 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  seekCoverFromPos(pos: Vector3, duration: number, p5: any, p6: any, p7: any): void {
+    inv<void>('0x75AC2B60386D89F2', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), duration, p5, p6, p7);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  moveInTrafficAwayFromEntity(p1: any, p2: any, p3: any, p4: any): void {
+    inv<void>('0x13DED0BC45600FE1', this.entity.handle, p1, p2, p3, p4);
+  }
+
+  /**
+   * @param pos 
+   */
+  vehicleAimAtCoord(pos: Vector3): void {
+    inv<void>('0x447C1E9EF844BC0F', this.entity.handle, f(pos.x), f(pos.y), f(pos.z));
+  }
+
+  /**
+   * If no timeout, set timeout to -1.
+   *
+   * @param pos 
+   * @param speedMultiplier 
+   * @param timeout 
+   * @param stoppingRange 
+   * @param flags 
+   * @param heading 
+   */
+  followNavMeshToCoord(pos: Vector3, speedMultiplier: number, timeout: number, stoppingRange: number, flags: number, heading: number): void {
+    inv<void>('0x15D3A79D4E44B913', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(speedMultiplier), timeout, f(stoppingRange), flags, f(heading));
+  }
+
+  /**
+   * Despite its name, it only attacks ONE hated target. The one closest to the specified position.
+   *
+   * @param pos 
+   * @param radius 
+   * @param flags 
+   * @param p6 
+   */
+  combatHatedTargetsInArea(pos: Vector3, radius: number, flags: number, p6: any): void {
+    inv<void>('0x4CF5F55DAC3280A0', this.entity.handle, f(pos.x), f(pos.y), f(pos.z), f(radius), flags, p6);
+  }
+
+  /**
+   * Params: p2 is always -1.f in R* Scripts
+   *
+   * @param targetPed 
+   * @param p2 
+   */
+  addFleeTargetPed(targetPed: Ped, p2: number): void {
+    inv<void>('0x3923EC958249657D', this.entity.handle, targetPed.handle, f(p2));
+  }
+
+  /**
+   * Params: p2 is returned by BUILTIN::SHIFT_LEFT
+   *
+   * @param ped2 
+   * @param p2 
+   */
+  evasiveAnim(ped2: Ped, p2: number): void {
+    inv<void>('0x5F22926E1BCE9B08', this.entity.handle, ped2.handle, p2);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   */
+  performSequenceFromProgress(p1: any, p2: any, p3: any): void {
+    inv<void>('0x89221B16730234F0', this.entity.handle, p1, p2, p3);
+  }
+
+  /**
+   * @param signalName 
+   * @param value 
+   */
+  setTaskMoveNetworkSignalBool(signalName: string | null, value: boolean): void {
+    inv<void>('0xB0A6CFD2C69C1088', this.entity.handle, signalName, value);
+  }
+
+  /**
+   * flags: 67108864, 2097152, 524564, 524675 (eDrivingFlags)
+   * p7 = 6 or 3
+   * p8 = x coordinate
+   * p9 - 8.f
+   * p10 = false
+   *
+   * @param vehicle 
+   * @param pos 
+   * @param speed 
+   * @param drivingFlags 
+   * @param p7 
+   * @param stoppingRange1 
+   * @param stoppingRange2 
+   * @param p10 
+   */
+  vehicleDriveToDestination(vehicle: Vehicle, pos: Vector3, speed: number, drivingFlags: number, p7: number, stoppingRange1: number, stoppingRange2: number, p10: boolean): void {
+    inv<void>('0x7F241A0D14354583', this.entity.handle, vehicle.handle, f(pos.x), f(pos.y), f(pos.z), f(speed), drivingFlags, p7, f(stoppingRange1), f(stoppingRange2), p10);
+  }
+
+  /**
+   * @param p1 
+   * @param p2 
+   */
+  ambientAnimalStalk(p1: any, p2: any): void {
+    inv<void>('0x37C13863ABA1B4A3', this.entity.handle, p1, p2);
+  }
+
+  /**
+   * @param phaseName 
+   * @returns
+   */
+  getTaskMoveNetworkPhaseFloat(phaseName: string | null): number {
+    return inv<number>('0x844CEEE428EA35B0', this.entity.handle, phaseName, raf());
+  }
+
+  /**
+   * This tasks the ped to do nothing for the specified amount of milliseconds.
+   * This is useful if you want to add a delay between tasks when using a sequence task.
+   *
+   * @param ms 
+   */
+  pause(ms: number): void {
+    inv<void>('0xE73A266DB0CA9042', this.entity.handle, ms);
+  }
+
+  /**
+   * Makes the specified ped shuffle to the next vehicle seat.
+   * The ped MUST be in a vehicle and the vehicle parameter MUST be the ped's current vehicle.
+   *
+   * @param vehicle 
+   */
+  shuffleToNextVehicleSeat(vehicle: Vehicle): void {
+    inv<void>('0x7AA80209BDA643EB', this.entity.handle, vehicle.handle);
+  }
+
+}