import type { eVehicleSeat } from '../enums/eVehicleSeat';
import type { Entity } from '../classes/Entity';
import type { Ped } from '../classes/Ped';
import type { Player } from '../classes/Player';
import type { Vehicle } from '../classes/Vehicle';
import type { Volume } from '../classes/Volume';
import type { ScrHandle } from '../types/NativeAliases';
import { Vector2 } from '../types/Vector2';
import { Vector3 } from '../types/Vector3';
import { Vector4 } from '../types/Vector4';
import { Color } from '../types/Color';
import { createFromHandle } from '../types/HandleRegistry';
import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f, int, uint, float, Hash, u8, u16, u32, u64, i8, i16, i32, i64 } from '../types/NativeAliases';

export class PedStatics {
  /**
   * @param p0 
   * @param p1 
   */
  static N_0x0A4618FFD517E24D(p0: any, p1: any): void {
    inv<void>('0x0A4618FFD517E24D', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0x2FA568BFA725F8D6(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0x2FA568BFA725F8D6', p0, p1, p2, p3);
  }

  static spawnpointsCancelSearch(): void {
    inv<void>('0xFEE4A5459472A9F8');
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x7B5C293238EE4F20(p0: any): any {
    return inv<number>('0x7B5C293238EE4F20', p0);
  }

  /**
   * The hash of the created relationship group is output in the second parameter.
   *
   * @param name 
   * @returns groupHash
   */
  static addRelationshipGroup(name: string): [any, number] {
    const result = inv<[number, number]>('0xF372BC22FCB88606', name, pvi());
    return [result[0], result[1]];
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0x5FCF25D584065BFD(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0x5FCF25D584065BFD', p0, p1, p2, p3);
  }

  /**
   * @param requestId 
   * @returns
   */
  static isMetaPedOutfitRequestValid(requestId: int): boolean {
    return !!inv<boolean>('0xB25E57FC8E37114D', requestId, rai());
  }

  /**
   * @param randomInt 
   * @returns x; y; z
   */
  static spawnpointsGetSearchResult(randomInt: int): [number, number, number] {
    const result = inv<[number, number, number]>('0x280C7E3AC7F56E90', randomInt, pvf(), pvf(), pvf());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param numPeds 
   */
  static reserveAmbientPeds(numPeds: int): void {
    inv<void>('0xED9582B3DA8F02B4', numPeds);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x52250B92EA70BE3D(p0: any): any {
    return inv<number>('0x52250B92EA70BE3D', p0);
  }

  /**
   * @param groupId 
   * @returns
   */
  static getGroupFormation(groupId: int): int {
    return inv<number>('0x13A1B061007C906B', groupId, rai());
  }

  /**
   * @param multiplier 
   */
  static setScenarioPedRangeMultiplierThisFrame(multiplier: float): void {
    inv<void>('0xA77FA7BE9312F8C0', f(multiplier));
  }

  /**
   * Removes a texture created by 0xC5E7204F322E49EB.
   *
   * @param textureId 
   */
  static releaseTexture(textureId: int): void {
    inv<void>('0x6BEFAA907B076859', textureId);
  }

  /**
   * PS_SMALL = 0,
   * PS_MEDIUM,
   * PS_MEDIUM_LARGE,
   * PS_LARGE,
   * PS_EXTRA_LARGE
   *
   * @param modelHash 
   * @returns
   */
  static getPedModelSizeFromHash(modelHash: string | number): int {
    return inv<number>('0xA65AA1ACE81E5A77', _h(modelHash), rai());
  }

  /**
   * Used for AUDIO / ANIMSCENE (REFERENCE_REGIONAL_CHARACTER)
   * Params: p1 = 0
   * _GET_PED_IN*
   *
   * @param perscharModel 
   * @param p1 
   * @returns
   */
  static N_0xE76687023D8C8505(perscharModel: string | number, p1: int): Entity | null {
    return createFromHandle<Entity>('Entity', inv<number>('0xE76687023D8C8505', _h(perscharModel), p1, rai()));
  }

  /**
   * @param modifier 
   */
  static setAiMeleeWeaponDamageModifier(modifier: float): void {
    inv<void>('0x66460DEDDD417254', f(modifier));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @returns
   */
  static N_0x31B2E7F2E3C58B89(p0: any, p1: any, p2: any, p3: any): any {
    return inv<number>('0x31B2E7F2E3C58B89', p0, p1, p2, p3);
  }

  /**
   * @param entity 
   * @param p1 
   * @param p2 
   */
  static detachCarriableEntity(entity: Entity, p1: boolean, p2: boolean): void {
    inv<void>('0xED00D72F81CF7278', entity.handle, p1, p2);
  }

  /**
   * _SET_ENABLE_B* - _SET_ENABLE_H*
   *
   * @param groupId 
   * @param p1 
   */
  static N_0xA8A95CECB1906EA2(groupId: int, p1: boolean): void {
    inv<void>('0xA8A95CECB1906EA2', groupId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xAD3330E3C3E98007(p0: any, p1: any): void {
    inv<void>('0xAD3330E3C3E98007', p0, p1);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0xC2EF407645BEECDC(p0: any): any {
    return inv<number>('0xC2EF407645BEECDC', p0);
  }

  /**
   * @param requestId 
   * @returns
   */
  static isMetaPedAssetValid(requestId: int): boolean {
    return !!inv<boolean>('0x93FFD92F05EC32FD', requestId, rai());
  }

  /**
   * Sets the range at which members will automatically leave the group.
   *
   * @param groupId 
   * @param separationRange 
   */
  static setGroupSeparationRange(groupId: int, separationRange: float): void {
    inv<void>('0x4102C7858CFEE4E4', groupId, f(separationRange));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xCB1A3864C524F784(p0: any, p1: any): void {
    inv<void>('0xCB1A3864C524F784', p0, p1);
  }

  /**
   * Used in Script Function SATCHEL_COUNT_BREAKDOWN_COMPONENTS The first index of the buffer is required, it's the max size of loot (always 15 in R* scripts)
   * outLoot is an array of loot hash, its size is returned by the native (it starts at the index 1).
   *
   * @param model 
   * @param damageCleanliness 
   * @param skinningQuality 
   * @returns Return the number of loot items for a ped carcass of given model, damage cleanliness and skinning quality.; outLoot
   * @example
   * ```lua
   * -- Request the loots for a cow with 0 as damage cleanliness and 2 as skinning quality
   * local size = 15
   * local struct = DataView.ArrayBuffer(size * 8)
   * struct:SetInt32(0, size)
   * 
   * local numLoot = Citizen.InvokeNative(0xB29C553BA582D09E, struct:Buffer(), `a_c_cow`, 0, 2, Citizen.ResultAsInteger())
   * if (numLoot > 0) then
   *     for i = 1, numLoot do
   *         local hash = struct:GetInt32(i * 8)
   *         print(("i: %d: loot: %d"):format(i, hash))
   *     end
   * end
   * ```
   */
  static computeLootForPedCarcass(model: string | number, damageCleanliness: int, skinningQuality: int): [int, number] {
    const result = inv<[number, number]>('0xB29C553BA582D09E', pvi(), _h(model), damageCleanliness, skinningQuality, rai());
    return [result[0], result[1]];
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static setPopControlSphereThisFrame(p0: any, p1: any, p2: any, p3: any, p4: any): void {
    inv<void>('0xD8C3BE3EE94CAF2D', p0, p1, p2, p3, p4);
  }

  /**
   * @param pos1 
   * @param pos2 
   * @param p6 
   * @param p7 
   * @returns
   */
  static isAnyPedShootingInArea(pos1: Vector3, pos2: Vector3, p6: boolean, p7: boolean): boolean {
    return !!inv<boolean>('0xA0D3D71EA1086C55', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), p6, p7, rai());
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x242EDF85D4E87B65(p0: any): any {
    return inv<number>('0x242EDF85D4E87B65', p0);
  }

  /**
   * @returns
   */
  static areAllAmbientPedReservationsReady(): any {
    return inv<number>('0x5E420FF293EE5472');
  }

  /**
   * @param p0 
   */
  static setBlockingOfNonTemporaryEventsForAmbientPedsThisFrame(p0: boolean): void {
    inv<void>('0x9911F4A24485F653', p0);
  }

  /**
   * @param shopItem 
   * @param p1 
   * @param ped 
   * @param metapedType 
   * @param p4 
   * @returns drawable; albedo; normal; material; p9; p10; p11; p12
   */
  static getShopItemBaseLayers(shopItem: string | number, p1: any, ped: Ped, metapedType: int, p4: boolean): [boolean, number, number, number, number, number, number, number, number] {
    const result = inv<[boolean, number, number, number, number, number, number, number, number]>('0x63342C50EC115CE8', _h(shopItem), p1, ped.handle, metapedType, p4, pvi(), pvi(), pvi(), pvi(), pvi(), pvi(), pvi(), pvi(), rai());
    return [!!result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], result[8]];
  }

  /**
   * Returns animal skin quality modifier
   *
   * @param player 
   * @returns
   */
  static getPlayerCurrentAnimalDamageModifier(player: Player): float {
    return inv<number>('0xEE2D5C819A65BF26', player.handle, raf());
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0x0105FEE8F9091255(p0: any, p1: any): any {
    return inv<number>('0x0105FEE8F9091255', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xEBD49472BCCF7642(p0: any, p1: any): void {
    inv<void>('0xEBD49472BCCF7642', p0, p1);
  }

  /**
   * Should be called at least once for any new texture override.
   * Otherwise component textures will be just black.
   * Also needs to be called for updating any ped overlays to apply the changes.
   *
   * @param textureId 
   */
  static updatePedTexture(textureId: int): void {
    inv<void>('0x92DAABA2C1C10B0E', textureId);
  }

  /**
   * @param groupId 
   * @returns
   */
  static doesGroupExist(groupId: int): boolean {
    return !!inv<boolean>('0x7C6B0C22F9F40BBE', groupId, rai());
  }

  /**
   * Gets the closest ped in a radius.
   *
   * @param pos 
   * @param radius 
   * @param p4 
   * @param p5 
   * @param p7 
   * @param p8 
   * @param p9 
   * @param pedType 
   * @returns outPed
   */
  static getClosestPed(pos: Vector3, radius: float, p4: boolean, p5: boolean, p7: boolean, p8: boolean, p9: boolean, pedType: int): [boolean, Ped | null] {
    const result = inv<[boolean, number]>('0xC33AB876A77F8164', f(pos.x), f(pos.y), f(pos.z), f(radius), p4, p5, pvi(), p7, p8, p9, pedType, rai());
    return [!!result[0], createFromHandle<Ped>('Ped', result[1])];
  }

  /**
   * Used to set up bad guy groups in nb_kidnapped R* Script (MP_RE_KIDNAPPED): p1 = 4.f
   * *SET_FORMATION**
   *
   * @param groupId 
   * @param p1 
   * @returns
   */
  static N_0xB05CC690CDE8A4A9(groupId: int, p1: float): boolean {
    return !!inv<boolean>('0xB05CC690CDE8A4A9', groupId, f(p1), rai());
  }

  /**
   * *SET_SCENARIO_PED** - *SET_SPAWNER**
   *
   * @param groupId 
   * @param p1 
   */
  static N_0x97C475212B327666(groupId: int, p1: boolean): void {
    inv<void>('0x97C475212B327666', groupId, p1);
  }

  static N_0x0ADA3EC589E1736E(): void {
    inv<void>('0x0ADA3EC589E1736E');
  }

  /**
   * Creates a new ped group.
   * Groups can contain up to 8 peds. The parameter is unused. Returns a handle to the created group, or 0 if a group couldn't be created.
   *
   * @param taskAllocator 
   * @returns
   */
  static createGroup(taskAllocator: int): int {
    return inv<number>('0x90370EBE0FEE1A3D', taskAllocator, rai());
  }

  /**
   * Returns offset (0 < 32) to be used with MISC::SET_BIT
   * _GET_PED_CR*
   *
   * @param groupId 
   * @param ped 
   * @returns
   */
  static N_0x8AF8E647D6B2A649(groupId: int, ped: Ped): int {
    return inv<number>('0x8AF8E647D6B2A649', groupId, ped.handle, rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xA2B8E47442C76CEC(p0: any, p1: any): void {
    inv<void>('0xA2B8E47442C76CEC', p0, p1);
  }

  /**
   * @param entity 
   * @returns
   */
  static getCarrierAsPed(entity: Entity): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0x09B83E68DE004CD4', entity.handle, rai()));
  }

  /**
   * @param multiplier 
   */
  static setScenarioHumanDensityMultiplierThisFrame(multiplier: float): void {
    inv<void>('0x28CB6391ACEDD9DB', f(multiplier));
  }

  /**
   * @param p0 
   */
  static N_0x8D9DB115FBA8E23D(p0: any): void {
    inv<void>('0x8D9DB115FBA8E23D', p0);
  }

  /**
   * @returns
   */
  static getNumReservedAmbientPedsReady(): int {
    return inv<number>('0x5C16855277819BBF', rai());
  }

  /**
   * @param groupId 
   * @param p1 
   */
  static N_0x86FAFC18E3D4380C(groupId: int, p1: boolean): void {
    inv<void>('0x86FAFC18E3D4380C', groupId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x49DADFC4CD808B0A(p0: any, p1: any, p2: any): void {
    inv<void>('0x49DADFC4CD808B0A', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x9E66708B2B41F14A(p0: any, p1: any): void {
    inv<void>('0x9E66708B2B41F14A', p0, p1);
  }

  /**
   * @param groupId 
   * @param toggle 
   */
  static setFormationAutoAssignPosition(groupId: int, toggle: boolean): void {
    inv<void>('0x478F6B9920446CE2', groupId, toggle);
  }

  /**
   * @param p0 
   */
  static N_0xDEDBED3020DA49DC(p0: any): void {
    inv<void>('0xDEDBED3020DA49DC', p0);
  }

  /**
   * Removes every texture layer
   * Old Name: _RESET_PED_TEXTURE_2
   *
   * @param textureId 
   */
  static clearPedTexture(textureId: int): void {
    inv<void>('0xB63B9178D0F58D82', textureId);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x82CB0F3F0C7785E5(p0: any): any {
    return inv<number>('0x82CB0F3F0C7785E5', p0);
  }

  /**
   * 
   * @remarks The `p3`, `p4` and `p5` probably match the GTA counter part, testing is required.
   * See
   *
   * @param vehicle The vehicle to create the ped inside of
   * @param modelHash The hash of the ped to create, this must be
   * @param seatIndex Refer to {@link eVehicleSeat}
   * @param p3 
   * @param p4 
   * @param p5 
   * @returns Returns the ped that was created in the vehicle, or `0` if the ped didn't get created
   */
  static createPedInsideVehicle(vehicle: Vehicle, modelHash: string | number, seatIndex: eVehicleSeat, p3: boolean, p4: boolean, p5: boolean): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0x7DD959874C1FD534', vehicle.handle, _h(modelHash), seatIndex, p3, p4, p5, rai()));
  }

  /**
   * eFormationType 0: Default
   * 1: Circle Around Leader
   * 2: Alternative Circle Around Leader
   * 3: Line, with Leader at center
   *
   * @param groupId 
   * @param formationType 
   */
  static setGroupFormation(groupId: int, formationType: int): void {
    inv<void>('0xCE2F5FC3AF7E8C1E', groupId, formationType);
  }

  /**
   * @param groupId 
   */
  static removeGroup(groupId: int): void {
    inv<void>('0x8EB2F69076AF7053', groupId);
  }

  /**
   * @param model 
   * @returns
   */
  static isThisModelAHorse(model: string | number): boolean {
    return !!inv<boolean>('0x772A1969F649E902', _h(model), rai());
  }

  /**
   * *SET_FORMATION**
   *
   * @param groupId 
   * @param p1 
   */
  static N_0xD5BD1B5318A81994(groupId: int, p1: boolean): void {
    inv<void>('0xD5BD1B5318A81994', groupId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xFD8E853F0BC2E942(p0: any, p1: any): void {
    inv<void>('0xFD8E853F0BC2E942', p0, p1);
  }

  /**
   * @param volume 
   * @param spawnpointsFlag 
   * @param p2 
   * @param duration 
   * @param p4 
   */
  static spawnpointsStartSearchWithVolume(volume: Volume, spawnpointsFlag: int, p2: float, duration: int, p4: float): void {
    inv<void>('0x83ED1FC9DF3411F5', volume.handle, spawnpointsFlag, f(p2), duration, f(p4));
  }

  /**
   * Creates metaped from ped outfit requestId. See _REQUEST_METAPED_OUTFIT
   *
   * @param requestId 
   * @param pos 
   * @param heading 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @returns
   */
  static createMetaPedOutfitPed(requestId: int, pos: Vector3, heading: float, p5: boolean, p6: boolean, p7: boolean, p8: boolean): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0xEAF682A14F8E5F53', requestId, f(pos.x), f(pos.y), f(pos.z), f(heading), p5, p6, p7, p8, rai()));
  }

  static clearPedNonCreationArea(): void {
    inv<void>('0x2E05208086BA0651');
  }

  /**
   * @param groupId 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static setGroupFormationSpacing(groupId: int, p1: float, p2: float, p3: float): void {
    inv<void>('0x1D9D45004C28C916', groupId, f(p1), f(p2), f(p3));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @returns
   */
  static N_0xA4AC05B1A364EBC5(p0: any, p1: any, p2: any): any {
    return inv<number>('0xA4AC05B1A364EBC5', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x604E1010E3162E86(p0: any, p1: any, p2: any): void {
    inv<void>('0x604E1010E3162E86', p0, p1, p2);
  }

  /**
   * @param p0 
   */
  static N_0x7406C71F4AC2FFCC(p0: any): void {
    inv<void>('0x7406C71F4AC2FFCC', p0);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x92A1B55A59720395(p0: any, p1: any): void {
    inv<void>('0x92A1B55A59720395', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x9184788BFF1EDAD7(p0: any, p1: any): void {
    inv<void>('0x9184788BFF1EDAD7', p0, p1);
  }

  /**
   * @param p0 
   */
  static N_0xA405BF9F01960C16(p0: any): void {
    inv<void>('0xA405BF9F01960C16', p0);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x992187D975635DF5(p0: any, p1: any): void {
    inv<void>('0x992187D975635DF5', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0xA274F51EF7E34B95(p0: any, p1: any): any {
    return inv<number>('0xA274F51EF7E34B95', p0, p1);
  }

  /**
   * @param entity 
   * @returns
   */
  static getCarrierAsMount(entity: Entity): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0xA033D7E4BBF9844D', entity.handle, rai()));
  }

  /**
   * @param group1 
   * @param group2 
   * @returns
   */
  static getRelationshipBetweenGroups(group1: string | number, group2: string | number): int {
    return inv<number>('0x9E6B70061662AE5C', _h(group1), _h(group2), rai());
  }

  static resetAiWeaponDamageModifier(): void {
    inv<void>('0xEA16670E7BA4743C');
  }

  /**
   * @returns
   */
  static spawnpointsIsSearchComplete(): any {
    return inv<number>('0xA586FBEB32A53DBB');
  }

  /**
   * @param group 
   * @param p1 
   */
  static N_0x9629FAF6460D35CB(group: string | number, p1: boolean): void {
    inv<void>('0x9629FAF6460D35CB', _h(group), p1);
  }

  /**
   * Sets the scenario ped density to the given config. Valid configs: See common/data/ai/densityscoringconfigs.meta for more information.
   *
   * @param configHash 
   */
  static setScenarioPedDensityThisFrame(configHash: string | number): void {
    inv<void>('0x95423627A9CA598E', _h(configHash));
  }

  /**
   * @param outfit 
   * @param suboutfit 
   * @param model 
   * @returns
   */
  static doesMetaPedSuboutfitExistForPedModel(outfit: string | number, suboutfit: string | number, model: string | number): boolean {
    return !!inv<boolean>('0x4FF3C2B4E6A196C1', _h(outfit), _h(suboutfit), _h(model), rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xBF567DF2BEF211A6(p0: any, p1: any): void {
    inv<void>('0xBF567DF2BEF211A6', p0, p1);
  }

  /**
   * @param requestId 
   * @returns
   */
  static hasMetaPedRequestLoaded(requestId: int): any {
    return inv<number>('0xC0940AC858C1E126', requestId);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xCA95C156C14B2054(p0: any, p1: any): void {
    inv<void>('0xCA95C156C14B2054', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @returns
   */
  static N_0xD97BC27AC039F681(p0: any, p1: any, p2: any, p3: any): any {
    return inv<number>('0xD97BC27AC039F681', p0, p1, p2, p3);
  }

  /**
   * @param textureId 
   * @param layerId 
   * @param sheetGridIndex 
   */
  static setTextureLayerSheetGridIndex(textureId: int, layerId: int, sheetGridIndex: int): void {
    inv<void>('0x3329AAE2882FC8E4', textureId, layerId, sheetGridIndex);
  }

  /**
   * Creates ped overlay in texture override data and returns it's index.
   * This index are used for further overlay editing. albedoHash: a hash of overlay's albedo texture
   * colorType: a color type(from 0 to 2). 0 is used for overlays with RGB colors usually.
   *
   * @param textureId 
   * @param albedoHash 
   * @param normalHash 
   * @param materialHash 
   * @param blendType 
   * @param texAlpha 
   * @param sheetGridIndex 
   * @returns
   */
  static addTextureLayer(textureId: int, albedoHash: string | number, normalHash: string | number, materialHash: string | number, blendType: int, texAlpha: float, sheetGridIndex: int): int {
    return inv<number>('0x86BB5FF45F193A02', textureId, _h(albedoHash), _h(normalHash), _h(materialHash), blendType, f(texAlpha), sheetGridIndex, rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0xCDFB8C04D4C95D9B(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0xCDFB8C04D4C95D9B', p0, p1, p2, p3);
  }

  /**
   * @param toggle 
   */
  static setCreateRandomCops(toggle: boolean): void {
    inv<void>('0x102E68B2024D536D', toggle);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xCBDE59C48F2B06F5(p0: any, p1: any, p2: any): void {
    inv<void>('0xCBDE59C48F2B06F5', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xA2F8B3B5FEDFC100(p0: any, p1: any): void {
    inv<void>('0xA2F8B3B5FEDFC100', p0, p1);
  }

  /**
   * @param model 
   * @returns
   */
  static isPedModelSuppressed(model: string | number): boolean {
    return !!inv<boolean>('0xAA9F048DCF69B6DC', _h(model), rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x3FDBB99EFD8CE4AF(p0: any, p1: any, p2: any): void {
    inv<void>('0x3FDBB99EFD8CE4AF', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0x8BA0C65AC15A7D33(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0x8BA0C65AC15A7D33', p0, p1, p2, p3);
  }

  /**
   * @param p0 
   * @returns
   */
  static isScenarioBlockingAreaValid(p0: any): boolean {
    return !!inv<boolean>('0x91A5F9CBEBB9D936', p0, rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x15F4732C357B1D6D(p0: any, p1: any, p2: any): void {
    inv<void>('0x15F4732C357B1D6D', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x5BB04BC74A474B47(p0: any, p1: any): void {
    inv<void>('0x5BB04BC74A474B47', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x56076667E7C2DCD6(p0: any, p1: any): void {
    inv<void>('0x56076667E7C2DCD6', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x29F3539189D3E277(p0: any, p1: any): void {
    inv<void>('0x29F3539189D3E277', p0, p1);
  }

  /**
   * @param groupId 
   * @param pos 
   * @param position 
   */
  static addCustomFormationLocation(groupId: int, pos: Vector3, position: int): void {
    inv<void>('0x4E23CD07BD161E06', groupId, f(pos.x), f(pos.y), f(pos.z), position);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x75D3333409CD33CE(p0: any, p1: any, p2: any): void {
    inv<void>('0x75D3333409CD33CE', p0, p1, p2);
  }

  /**
   * Animal Skin Quality Modifier
   * Params: p2 = 2, p3 = 3 in R* Scripts
   *
   * @param player 
   * @param modifier 
   * @param p2 
   * @param p3 
   * @returns
   */
  static setPlayerCurrentAnimalDamageModifier(player: Player, modifier: float, p2: int, p3: int): any {
    return inv<number>('0x9EFF3C91DF38304F', player.handle, f(modifier), p2, p3);
  }

  /**
   * @param relationship 
   * @param group1 
   * @param group2 
   */
  static setRelationshipBetweenGroups(relationship: int, group1: string | number, group2: string | number): void {
    inv<void>('0xBF25EB89375A37AD', relationship, _h(group1), _h(group2));
  }

  /**
   * @param model 
   * @param toggle 
   */
  static setPedModelIsSuppressed(model: string | number, toggle: boolean): void {
    inv<void>('0xE163A4BCE4DE6F11', _h(model), toggle);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x1D23D3F70606D788(p0: any, p1: any): void {
    inv<void>('0x1D23D3F70606D788', p0, p1);
  }

  /**
   * Only used in SP scripts, for example odriscolls1: BOOLS: true, true, true, false, false
   *
   * @param requestId 
   * @param pos 
   * @param heading 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   * @returns
   */
  static createMetaPed(requestId: int, pos: Vector3, heading: float, p5: boolean, p6: boolean, p7: boolean, p8: boolean, p9: boolean): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0x0BCD4091C8EABA42', requestId, f(pos.x), f(pos.y), f(pos.z), f(heading), p5, p6, p7, p8, p9, rai()));
  }

  /**
   * Returns the number of wearable states available for a shop item / component. p2 seems to be true in scripts. For use with 0x6243635AF2F1B826 (_GET_SHOP_ITEM_AVAILABLE_WEARABLE_STATE_BY_INDEX)
   *
   * @param componentHash 
   * @param isMpFemale 
   * @param p2 
   * @returns
   */
  static getShopItemNumWearableStates(componentHash: string | number, isMpFemale: boolean, p2: boolean): int {
    return inv<number>('0xFFCC2DB2D9953401', _h(componentHash), isMpFemale, p2, rai());
  }

  /**
   * @returns
   */
  static spawnpointsIsSearchActive(): any {
    return inv<number>('0x3C67506996001F5E');
  }

  /**
   * @returns
   */
  static spawnpointsIsSearchFailed(): any {
    return inv<number>('0xF445DE8DA80A1792');
  }

  /**
   * @param p0 
   */
  static N_0x1298B3D8E4C2409F(p0: any): void {
    inv<void>('0x1298B3D8E4C2409F', p0);
  }

  /**
   * Gets an available wearable state by index for a shop item / component - it does not retreive what the current state is. p3 seems to be true in scripts. Use to get the number of available wearable states
   *
   * @param componentHash 
   * @param wearableStateIndex 
   * @param isMpFemale 
   * @param p3 
   * @returns
   */
  static getShopItemWearableStateByIndex(componentHash: string | number, wearableStateIndex: int, isMpFemale: boolean, p3: boolean): number {
    return (inv<number>('0x6243635AF2F1B826', _h(componentHash), wearableStateIndex, isMpFemale, p3, rai())) & 0xFFFFFFFF;
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @returns
   */
  static N_0xA180FBD502A03125(p0: any, p1: any, p2: any): any {
    return inv<number>('0xA180FBD502A03125', p0, p1, p2);
  }

  /**
   * @param requestId 
   */
  static releaseMetaPedAssetRequest(requestId: int): void {
    inv<void>('0x13E7320C762F0477', requestId);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xFA742B82D093D848(p0: any, p1: any, p2: any): void {
    inv<void>('0xFA742B82D093D848', p0, p1, p2);
  }

  /**
   * @param requestId 
   * @returns
   */
  static hasMetaPedOutfitLoaded(requestId: int): any {
    return inv<number>('0x610438375E5D1801', requestId);
  }

  /**
   * @returns
   */
  static getNumFreeSlotsInPedPool(): int {
    return inv<number>('0x313778EDCA9158E2', rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x070A3841406C43D5(p0: any, p1: any): void {
    inv<void>('0x070A3841406C43D5', p0, p1);
  }

  /**
   * _SET_C*
   *
   * @param groupId 
   * @param p1 
   */
  static N_0x89E59DBD15E21177(groupId: int, p1: int): void {
    inv<void>('0x89E59DBD15E21177', groupId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x0FB1BA7FF73B41E1(p0: any, p1: any, p2: any): void {
    inv<void>('0x0FB1BA7FF73B41E1', p0, p1, p2);
  }

  /**
   * @param volume 
   * @param entity 
   * @param offset 
   * @param rot 
   * @param p8 
   * @param p9 
   */
  static attachVolumeToEntity(volume: Volume, entity: Entity, offset: Vector3, rot: Vector3, p8: int, p9: boolean): void {
    inv<void>('0x7C00CFC48A782DC0', volume.handle, entity.handle, f(offset.x), f(offset.y), f(offset.z), f(rot.x), f(rot.y), f(rot.z), p8, p9);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   */
  static N_0xEEDC9B29314B2733(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any): void {
    inv<void>('0xEEDC9B29314B2733', p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
  }

  /**
   * @returns
   */
  static spawnpointsGetNumSearchResults(): int {
    return inv<number>('0xA635C11B8C44AFC2', rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xE0FE107AB174D64A(p0: any, p1: any): void {
    inv<void>('0xE0FE107AB174D64A', p0, p1);
  }

  /**
   * @param volume 
   * @param entity 
   */
  static detachVolumeFromEntity(volume: Volume, entity: Entity): void {
    inv<void>('0x19C975B81BE53C28', volume.handle, entity.handle);
  }

  /**
   * @param textureId 
   * @param layerId 
   * @param albedoHash 
   * @param normalHash 
   * @param materialHash 
   */
  static setTextureLayerTextureMap(textureId: int, layerId: int, albedoHash: string | number, normalHash: string | number, materialHash: string | number): void {
    inv<void>('0x253A63B5BADBC398', textureId, layerId, _h(albedoHash), _h(normalHash), _h(materialHash));
  }

  /**
   * _SET_FORMATION_P*
   *
   * @param groupId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0xDDFAD4DEAA7FA362(groupId: int, p1: float, p2: float, p3: float, p4: float): void {
    inv<void>('0xDDFAD4DEAA7FA362', groupId, f(p1), f(p2), f(p3), f(p4));
  }

  /**
   * @param multiplier 
   */
  static setAmbientAnimalDensityMultiplierThisFrame(multiplier: float): void {
    inv<void>('0xC0258742B034DFAF', f(multiplier));
  }

  /**
   * Returns requestId
   * Params: p1 = 1 in R* Scripts
   *
   * @param asset 
   * @param p1 
   * @returns
   */
  static requestMetaPedAssetBundle(asset: string | number, p1: int): int {
    return inv<number>('0x91FE941F9FCFB702', _h(asset), p1, rai());
  }

  /**
   * Removes every texture layer but the base layer
   * Clearing texture's data: setting params to default values, but keep overlays.
   *
   * @param textureId 
   */
  static resetPedTexture(textureId: int): void {
    inv<void>('0x8472A1789478F82F', textureId);
  }

  /**
   * @param groupId 
   * @param p1 
   */
  static N_0x07EA5B053FA60AC7(groupId: int, p1: boolean): void {
    inv<void>('0x07EA5B053FA60AC7', groupId, p1);
  }

  /**
   * @param textureId 
   * @returns
   */
  static isTextureValid(textureId: int): boolean {
    return !!inv<boolean>('0x31DC8D3F216D8509', textureId, rai());
  }

  /**
   * @param nameHash 
   * @param ped 
   */
  static requestMotionTypeAsset(nameHash: string | number, ped: Ped): void {
    inv<void>('0xF7EA250B9A919E03', _h(nameHash), ped.handle);
  }

  /**
   * @param multiplier 
   */
  static setAmbientPedDensityMultiplierThisFrame(multiplier: float): void {
    inv<void>('0xAB0D553FE20A6E25', f(multiplier));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x34C11114887150FD(p0: any, p1: any): void {
    inv<void>('0x34C11114887150FD', p0, p1);
  }

  /**
   * @param p0 
   * @param pedAttached 
   * @param damageCleanliness 
   * @returns
   */
  static computeSatchelItemForPedDamage(p0: any, pedAttached: Ped, damageCleanliness: int): any {
    return inv<number>('0x9E7738B291706746', p0, pedAttached.handle, damageCleanliness);
  }

  /**
   * @param numPeds 
   */
  static reserveAmbientPedsTotal(numPeds: int): void {
    inv<void>('0xF008E0BA1FE1D644', numPeds);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x53BA7D96B9A421D9(p0: any, p1: any): void {
    inv<void>('0x53BA7D96B9A421D9', p0, p1);
  }

  /**
   * @param p0 
   */
  static N_0xE735A7DA22E88359(p0: any): void {
    inv<void>('0xE735A7DA22E88359', p0);
  }

  /**
   * @param p0 
   */
  static N_0xE6CB36F43A95D75F(p0: any): void {
    inv<void>('0xE6CB36F43A95D75F', p0);
  }

  /**
   * _SET_FORMATION_P*
   *
   * @param groupId 
   * @param p1 
   */
  static N_0x7E5185B979706210(groupId: int, p1: int): void {
    inv<void>('0x7E5185B979706210', groupId, p1);
  }

  /**
   * @param groupId 
   * @param radius 
   * @returns
   */
  static setFormationPositionsTargetRadius(groupId: int, radius: float): any {
    return inv<number>('0x7CC7D3B7AF7FB71F', groupId, f(radius));
  }

  /**
   * @param nameHash 
   * @param ped 
   */
  static removeMotionTypeAsset(nameHash: string | number, ped: Ped): void {
    inv<void>('0xDE7B2B4144906CDF', _h(nameHash), ped.handle);
  }

  /**
   * @param requestId 
   */
  static releaseMetaPedRequest(requestId: int): void {
    inv<void>('0x3972F78A78B5D9DF', requestId);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0xB8E2D655E1D5BD39(p0: any): any {
    return inv<number>('0xB8E2D655E1D5BD39', p0);
  }

  /**
   * @param multiplier 
   */
  static setAmbientHumanDensityMultiplierThisFrame(multiplier: float): void {
    inv<void>('0xBA0980B5C0A11924', f(multiplier));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0x8B74032DDD2156FE(p0: any, p1: any, p2: any, p3: any, p4: any): void {
    inv<void>('0x8B74032DDD2156FE', p0, p1, p2, p3, p4);
  }

  /**
   * @param groupId 
   * @returns hasLeader; numberOfFollowers
   */
  static getGroupSize(groupId: int): [boolean, number] {
    const result = inv<[number, number]>('0x8DE69FE35CA09A45', groupId, pvi(), pvi());
    return [!!result[0], result[1]];
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0xBB3E5370EBB6BE28(p0: any, p1: any): any {
    return inv<number>('0xBB3E5370EBB6BE28', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x00B380FF2DF6AB7A(p0: any, p1: any): void {
    inv<void>('0x00B380FF2DF6AB7A', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x7E8F9949B7AABBF0(p0: any, p1: any, p2: any): void {
    inv<void>('0x7E8F9949B7AABBF0', p0, p1, p2);
  }

  /**
   * *DOES_GROUP** - _DOES_N*
   *
   * @param groupId 
   * @returns
   */
  static N_0x0455546F23FF08E4(groupId: int): boolean {
    return !!inv<boolean>('0x0455546F23FF08E4', groupId, rai());
  }

  /**
   * @param animDict 
   * @param animName 
   * @param pos 
   * @param rot 
   * @param p8 
   * @param p9 
   * @returns
   */
  static getAnimInitialOffsetRotation(animDict: string, animName: string, pos: Vector3, rot: Vector3, p8: float, p9: int): Vector3 {
    return Vector3.fromArray(inv<number[]>('0x4B805E6046EE9E47', animDict, animName, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(p8), p9, rav()));
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0xFEAB3DB4EDB236EB(p0: any): any {
    return inv<number>('0xFEAB3DB4EDB236EB', p0);
  }

  /**
   * @param volume 
   * @param p1 
   * @param flag Refer to {@link eScenarioBlockingFlags}
   * @returns
   */
  static addScenarioBlockingVolume(volume: Volume, p1: boolean, flag: int): any {
    return inv<number>('0x4C39C95AE5DB1329', volume.handle, p1, flag);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xD7D2F45C56A4F4DF(p0: any, p1: any, p2: any): void {
    inv<void>('0xD7D2F45C56A4F4DF', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x0D497AA69059FE40(p0: any, p1: any): void {
    inv<void>('0x0D497AA69059FE40', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0x09171A6F8FDE5DC1(p0: any, p1: any, p2: any, p3: any, p4: any): void {
    inv<void>('0x09171A6F8FDE5DC1', p0, p1, p2, p3, p4);
  }

  /**
   * Related to dead animals items/loots
   * Notice: skinningQuality is partially calculated using pedQuality
   *
   * @param ped 
   * @param damageCleanliness 
   * @param skinningQuality 
   * @returns outInventoryItemArray
   */
  static computeSatchelItemForPedCarcass(ped: Ped, damageCleanliness: int, skinningQuality: int): [int, number] {
    const result = inv<[number, number]>('0x6B89FAA36FC909A3', pvi(), ped.handle, damageCleanliness, skinningQuality, rai());
    return [result[0], result[1]];
  }

  /**
   * @param nameHash 
   * @param ped 
   * @returns
   */
  static hasMotionTypeAssetLoaded(nameHash: string | number, ped: Ped): any {
    return inv<number>('0x854BC9B1A1CCD034', _h(nameHash), ped.handle);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static disableAmbientLookAtRequests(p0: any, p1: any): void {
    inv<void>('0x80038740C96AD17F', p0, p1);
  }

  static removeScenarioBlockingAreas(): void {
    inv<void>('0xD37401D78A929A49');
  }

  /**
   * @param requestId 
   */
  static releaseMetaPedOutfitRequest(requestId: int): void {
    inv<void>('0x4592B8B9B0EF5F48', requestId);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0xFC23348F0F4E245F(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0xFC23348F0F4E245F', p0, p1, p2, p3);
  }

  /**
   * Returns p1 value for 0x8E84119A23C16623
   *
   * @param entity 
   * @param p1 
   * @returns
   */
  static N_0x62FDF4E678E40CC6(entity: Entity, p1: any): any {
    return inv<number>('0x62FDF4E678E40CC6', entity.handle, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @returns
   */
  static N_0xF6A8C4B4A11AE89C(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any): any {
    return inv<number>('0xF6A8C4B4A11AE89C', p0, p1, p2, p3, p4, p5);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @returns
   */
  static N_0xF7327ACC7A89AEF1(p0: any, p1: any, p2: any): any {
    return inv<number>('0xF7327ACC7A89AEF1', p0, p1, p2);
  }

  /**
   * @param p0 
   */
  static N_0xC6981AFF6D2A71C2(p0: any): void {
    inv<void>('0xC6981AFF6D2A71C2', p0);
  }

  /**
   * @param pos1 
   * @param pos2 
   * @param p6 
   * @param blockingFlags Refer to {@link eScenarioBlockingFlags}
   * @returns
   */
  static addScenarioBlockingArea(pos1: Vector3, pos2: Vector3, p6: boolean, blockingFlags: int): int {
    return inv<number>('0x1B5C85C612E5256E', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), p6, blockingFlags, rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @returns
   */
  static N_0x27E8A84C12B0B7D1(p0: any, p1: any, p2: any): any {
    return inv<number>('0x27E8A84C12B0B7D1', p0, p1, p2);
  }

  /**
   * @param componentHash 
   * @param metapedType 
   * @param isMP 
   * @returns
   */
  static getShopItemComponentCategory(componentHash: string | number, metapedType: int, isMP: boolean): number {
    return (inv<number>('0x5FF9A878C3D115B8', _h(componentHash), metapedType, isMP, rai())) & 0xFFFFFFFF;
  }

  /**
   * https://github.com/femga/rdr3_discoveries/blob/master/clothes/metaped_outfits.lua
   * Returns requestId, to be used with 0x74F512E29CB717E2
   *
   * @param model 
   * @param outfit 
   * @returns
   */
  static requestMetaPedOutfit(model: string | number, outfit: string | number): int {
    return inv<number>('0x13154A76CE0CF9AB', _h(model), _h(outfit), rai());
  }

  /**
   * @param textureId 
   * @param layerId 
   * @param texRough 
   */
  static setTextureLayerRoughness(textureId: int, layerId: int, texRough: float): void {
    inv<void>('0x057C4F092E2298BE', textureId, layerId, f(texRough));
  }

  /**
   * Only used in R* Script tg_p (CLIENT__AMBIENT_POPULATION - Player starts the populate in region)
   */
  static N_0xBFA6B7731C3BAF02(): void {
    inv<void>('0xBFA6B7731C3BAF02');
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x7BB810E8B343AC7B(p0: any): any {
    return inv<number>('0x7BB810E8B343AC7B', p0);
  }

  /**
   * @param metaPedType 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @returns
   */
  static requestMetaPedComponent(metaPedType: int, p1: any, p2: int, p3: int, p4: int): any {
    return inv<number>('0xF6D9E1F3560CBF8E', metaPedType, p1, p2, p3, p4);
  }

  /**
   * @param groupId 
   */
  static resetGroupFormationDefaultSpacing(groupId: int): void {
    inv<void>('0x63DAB4CCB3273205', groupId);
  }

  /**
   * @param p0 
   */
  static N_0xAE6B68A83ABBE7C0(p0: any): void {
    inv<void>('0xAE6B68A83ABBE7C0', p0);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0xE8ABE3B73FC7FE17(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0xE8ABE3B73FC7FE17', p0, p1, p2, p3);
  }

  /**
   * *SET_FORMATION**
   *
   * @param groupId 
   * @param p1 
   */
  static N_0x8AFCCC0F18D70018(groupId: int, p1: boolean): void {
    inv<void>('0x8AFCCC0F18D70018', groupId, p1);
  }

  /**
   * @param groupID 
   * @returns
   */
  static getPedAsGroupLeader(groupID: int): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0x5CCE68DBD5FE93EC', groupID, rai()));
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0x5EFA8A3D8A60D662(p0: any, p1: any): any {
    return inv<number>('0x5EFA8A3D8A60D662', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0x16802C32B2FCA06B(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0x16802C32B2FCA06B', p0, p1, p2, p3);
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0xA218D2BBCAA7388C(p0: any, p1: any): any {
    return inv<number>('0xA218D2BBCAA7388C', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xD2F0FE8805D91647(p0: any, p1: any): void {
    inv<void>('0xD2F0FE8805D91647', p0, p1);
  }

  /**
   * @param vehicle 
   * @param p1 
   */
  static N_0x878E8104FA27CDAE(vehicle: Vehicle, p1: string | number): void {
    inv<void>('0x878E8104FA27CDAE', vehicle.handle, _h(p1));
  }

  /**
   * @param textureId 
   * @param layerId 
   * @param texAlpha 
   */
  static setTextureLayerAlpha(textureId: int, layerId: int, texAlpha: float): void {
    inv<void>('0x6C76BC24F8BB709A', textureId, layerId, f(texAlpha));
  }

  /**
   * @param p0 
   */
  static N_0xA064BBABB064446F(p0: any): void {
    inv<void>('0xA064BBABB064446F', p0);
  }

  /**
   * Seem color is not RGB or HSV
   *
   * @param textureId 
   * @param layerId 
   * @param tint0 
   * @param tint1 
   * @param tint2 
   */
  static setTextureLayerTint(textureId: int, layerId: int, tint0: int, tint1: int, tint2: int): void {
    inv<void>('0x2DF59FFE6FFD6044', textureId, layerId, tint0, tint1, tint2);
  }

  /**
   * @param player 
   * @param horseSlot 
   */
  static N_0x6734F0A6A52C371C(player: Player, horseSlot: int): void {
    inv<void>('0x6734F0A6A52C371C', player.handle, horseSlot);
  }

  /**
   * @param multiplier 
   */
  static setScenarioPedDensityMultiplierThisFrame(multiplier: float): void {
    inv<void>('0x7A556143A1C03898', f(multiplier));
  }

  /**
   * @param groupId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @returns
   */
  static addFormationLocation(groupId: int, p1: float, p2: float, p3: float): any {
    return inv<number>('0xB05945C1E9E60D91', groupId, f(p1), f(p2), f(p3));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xEA8763E505AFD49A(p0: any, p1: any, p2: any): void {
    inv<void>('0xEA8763E505AFD49A', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x96C7B659854DE629(p0: any, p1: any): void {
    inv<void>('0x96C7B659854DE629', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xD61FCF9FCFD515B7(p0: any, p1: any, p2: any): void {
    inv<void>('0xD61FCF9FCFD515B7', p0, p1, p2);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0xA31D350D66FA1855(p0: any): any {
    return inv<number>('0xA31D350D66FA1855', p0);
  }

  /**
   * @param relationship 
   * @param group1 
   * @param group2 
   */
  static clearRelationshipBetweenGroups(relationship: int, group1: string | number, group2: string | number): void {
    inv<void>('0x5E29243FB56FC6D4', relationship, _h(group1), _h(group2));
  }

  /**
   * @param pos 
   * @param p3 
   * @param p4 
   * @param p5 
   */
  static N_0x9851DE7AEC10B4E1(pos: Vector3, p3: float, p4: int, p5: any): void {
    inv<void>('0x9851DE7AEC10B4E1', f(pos.x), f(pos.y), f(pos.z), f(p3), p4, p5);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0xD049920CD29F6CC8(p0: any, p1: any, p2: any, p3: any, p4: any): void {
    inv<void>('0xD049920CD29F6CC8', p0, p1, p2, p3, p4);
  }

  /**
   * Removes gravity well by handle returned from 0x4F5EBE70081E5A20
   *
   * @param handle 
   */
  static removeGravityWell(handle: int): void {
    inv<void>('0x87247BC60B60BED8', handle);
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0x32417CB860A3BDC4(p0: any, p1: any): any {
    return inv<number>('0x32417CB860A3BDC4', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x0B787A37EEDD226F(p0: any, p1: any): void {
    inv<void>('0x0B787A37EEDD226F', p0, p1);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x095C2277FED731DB(p0: any): any {
    return inv<number>('0x095C2277FED731DB', p0);
  }

  /**
   * @param modelHash The model to load, you must before calling this or it will fail.
   * @param pos The position to spawn the ped at
   * @param heading The heading at which to spawn the ped
   * @param isNetwork `true` if you want the ped to be networked, `false` if you want it to be a local ped
   * @param bScriptHostPed If we should bind the ped to a script.
   * @param p7 
   * @param p8 
   * @returns Returns the ped handle for the ped, or `0` if the ped failed to spawn
   */
  static createPed(modelHash: string | number, pos: Vector3, heading: float, isNetwork: boolean = false, bScriptHostPed: boolean = true, p7: boolean = false, p8: boolean = false): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0xD49F9B0955C367DE', _h(modelHash), f(pos.x), f(pos.y), f(pos.z), f(heading), isNetwork, bScriptHostPed, p7, p8, rai()));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xC6C4E15CF7D52FEA(p0: any, p1: any): void {
    inv<void>('0xC6C4E15CF7D52FEA', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @returns
   */
  static N_0xCB86D3E3E3708901(p0: any, p1: any, p2: any, p3: any, p4: any): any {
    return inv<number>('0xCB86D3E3E3708901', p0, p1, p2, p3, p4);
  }

  /**
   * *SET_SCENARIO_PED** - *SET_SPAWNER**
   *
   * @param groupId 
   * @param p1 
   */
  static N_0x40C3524D4ED83554(groupId: int, p1: boolean): void {
    inv<void>('0x40C3524D4ED83554', groupId, p1);
  }

  /**
   * The distance between these points, is the diagonal of a box (remember it's 3D).
   *
   * @param pos1 
   * @param pos2 
   */
  static setPedNonCreationArea(pos1: Vector3, pos2: Vector3): void {
    inv<void>('0xEE01041D559983EA', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z));
  }

  /**
   * @param p0 
   */
  static N_0x5C90E20C25E6D83C(p0: any): void {
    inv<void>('0x5C90E20C25E6D83C', p0);
  }

  /**
   * _IS_N* - _IS_P*
   *
   * @param pos 
   * @param p3 
   * @returns
   */
  static N_0x6507AC3BD7C99009(pos: Vector3, p3: float): boolean {
    return !!inv<boolean>('0x6507AC3BD7C99009', f(pos.x), f(pos.y), f(pos.z), f(p3), rai());
  }

  /**
   * Creates a handle to an instance of "CScriptResource_GravityWell", this system forces local ped to target specified position when moving, however player still can interrupt this.
   * Can be useful to "point" player at some specific position.
   * Only works while on-foot. *CREATE*[P-Z]
   *
   * @param pos 
   * @param heading 
   * @param radius 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param stopAtDestination 
   * @returns
   */
  static createGravityWell(pos: Vector3, heading: float, radius: float, p5: float, p6: float, p7: float, stopAtDestination: boolean): int {
    return inv<number>('0x4F5EBE70081E5A20', f(pos.x), f(pos.y), f(pos.z), f(heading), f(radius), f(p5), f(p6), f(p7), stopAtDestination, rai());
  }

  /**
   * @param p0 
   */
  static N_0x28508173C6A7CC18(p0: any): void {
    inv<void>('0x28508173C6A7CC18', p0);
  }

  /**
   * Used for script function PROCESS_PLAYER_HAT_EVENT
   * Returns requestId to be used with 0x13E7320C762F0477
   *
   * @param drawable 
   * @param albedo 
   * @param normal 
   * @param material 
   * @param p4 
   * @returns
   */
  static N_0x3FCBB5FCFD968698(drawable: string | number, albedo: string | number, normal: string | number, material: string | number, p4: any): int {
    return inv<number>('0x3FCBB5FCFD968698', _h(drawable), _h(albedo), _h(normal), _h(material), p4, rai());
  }

  /**
   * _SET_FORMATION_P*
   *
   * @param groupId 
   * @param p1 
   * @param p2 
   */
  static N_0xE1103300F3456DE7(groupId: int, p1: float, p2: float): void {
    inv<void>('0xE1103300F3456DE7', groupId, f(p1), f(p2));
  }

  /**
   * @param p0 
   */
  static N_0x6A190B94C2541A99(p0: any): void {
    inv<void>('0x6A190B94C2541A99', p0);
  }

  /**
   * @param player 
   */
  static updateAnimalDamageModifier(player: Player): void {
    inv<void>('0x0F9E754EBE8FDBFA', player.handle);
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0x273915CE30780986(p0: any, p1: any): any {
    return inv<number>('0x273915CE30780986', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @returns
   */
  static N_0x5DA36CCCB63C0895(p0: any, p1: any, p2: any): any {
    return inv<number>('0x5DA36CCCB63C0895', p0, p1, p2);
  }

  /**
   * @param p0 
   */
  static N_0x9A4AC116CC1EEE14(p0: any): void {
    inv<void>('0x9A4AC116CC1EEE14', p0);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static removeScenarioBlockingArea(p0: any, p1: boolean): void {
    inv<void>('0x31D16B74C6E29D66', p0, p1);
  }

  /**
   * @param multiplier 
   */
  static setScenarioAnimalDensityMultiplierThisFrame(multiplier: float): void {
    inv<void>('0xDB48E99F8E064E56', f(multiplier));
  }

  /**
   * *SET_SCENARIO_PED** - *SET_SPAWNER**
   *
   * @param groupId 
   * @param p1 
   */
  static N_0x154B7E841AC7412F(groupId: int, p1: boolean): void {
    inv<void>('0x154B7E841AC7412F', groupId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x851966E1E35AF491(p0: any, p1: any): void {
    inv<void>('0x851966E1E35AF491', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   */
  static N_0x0FFDF937E5C11382(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any): void {
    inv<void>('0x0FFDF937E5C11382', p0, p1, p2, p3, p4, p5);
  }

  /**
   * @param p0 
   */
  static N_0xF917F92BF22ECBAB(p0: any): void {
    inv<void>('0xF917F92BF22ECBAB', p0);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xB9BDFAE609DFB7C5(p0: any, p1: any, p2: any): void {
    inv<void>('0xB9BDFAE609DFB7C5', p0, p1, p2);
  }

  /**
   * Creates prop from metaped asset bundle
   * https://github.com/femga/rdr3_discoveries/blob/master/objects/metaped_asset_bundles_list.lua
   * Creates a pickup-able metaped component. asset doesn't seems to be related to component hashes. Hash example : 0xD20354AB (https ://i.imgur.com/dzHkcDb.png)
   *
   * @param asset 
   * @param pos 
   * @param rot 
   * @param p7 
   * @param p8 
   * @param p9 
   * @returns
   */
  static createMetaPedAsset(asset: string | number, pos: Vector3, rot: Vector3, p7: boolean, p8: boolean, p9: boolean): Entity | null {
    return createFromHandle<Entity>('Entity', inv<number>('0x9641A9A20310F6B8', _h(asset), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), p7, p8, p9, rai()));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x91BAB9E064F036CD(p0: any, p1: any): void {
    inv<void>('0x91BAB9E064F036CD', p0, p1);
  }

  /**
   * @param volume 
   * @returns
   */
  static N_0xA1FBAC56D38563E2(volume: Volume): boolean {
    return !!inv<boolean>('0xA1FBAC56D38563E2', volume.handle, rai());
  }

  /**
   * @param requestId 
   * @returns
   */
  static hasMetaPedAssetLoaded(requestId: int): any {
    return inv<number>('0xB0B2C6D170B0E8E5', requestId);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @returns
   */
  static getCarriedAttachedInfoForSlot(p0: any, p1: any, p2: any, p3: any): any {
    return inv<number>('0x608BC6A6AACD5036', p0, p1, p2, p3);
  }

  /**
   * @param p0 
   */
  static N_0x6A489892E813951A(p0: any): void {
    inv<void>('0x6A489892E813951A', p0);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x633F83B301C87994(p0: any, p1: any): void {
    inv<void>('0x633F83B301C87994', p0, p1);
  }

  /**
   * @param animDict 
   * @param animName 
   * @param pos 
   * @param rot 
   * @param p8 
   * @param p9 
   * @returns
   */
  static getAnimInitialOffsetPosition(animDict: string, animName: string, pos: Vector3, rot: Vector3, p8: float, p9: int): Vector3 {
    return Vector3.fromArray(inv<number[]>('0xBE22B26DD764C040', animDict, animName, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(p8), p9, rav()));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0x75A082563B4452E5(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0x75A082563B4452E5', p0, p1, p2, p3);
  }

  /**
   * paletteHash: https://raw.githubusercontent.com/femga/rdr3_discoveries/master/clothes/cloth_color_palletes.lua
   *
   * @param textureId 
   * @param layerId 
   * @param paletteHash 
   */
  static setTextureLayerPallete(textureId: int, layerId: int, paletteHash: string | number): void {
    inv<void>('0x1ED8588524AC9BE1', textureId, layerId, _h(paletteHash));
  }

  /**
   * @param textureId 
   * @param layerId 
   * @param modTextureHash 
   * @param modAlpha 
   * @param modChannel 
   */
  static setTextureLayerMod(textureId: int, layerId: int, modTextureHash: string | number, modAlpha: float, modChannel: int): void {
    inv<void>('0xF2EA041F1146D75B', textureId, layerId, _h(modTextureHash), f(modAlpha), modChannel);
  }

  /**
   * _SET_PED_P* - _SET_PED_R*
   *
   * @param entity 
   * @param boneId 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0xC17A94CC8FC3C61A(entity: Entity, boneId: int, p2: float, p3: float, p4: float): void {
    inv<void>('0xC17A94CC8FC3C61A', entity.handle, boneId, f(p2), f(p3), f(p4));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x413697EC260AABBF(p0: any, p1: any, p2: any): void {
    inv<void>('0x413697EC260AABBF', p0, p1, p2);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x0F967019CC853BCC(p0: any, p1: any): void {
    inv<void>('0x0F967019CC853BCC', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   */
  static N_0xD8CEEED54C672B5D(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): void {
    inv<void>('0xD8CEEED54C672B5D', p0, p1, p2, p3, p4, p5, p6);
  }

  /**
   * @param p0 
   */
  static N_0xBC1DC48270468444(p0: any): void {
    inv<void>('0xBC1DC48270468444', p0);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0x6F46F8ACB44C4FC1(p0: any): any {
    return inv<number>('0x6F46F8ACB44C4FC1', p0);
  }

  /**
   * @param p0 
   */
  static N_0x9078FB0557364099(p0: any): void {
    inv<void>('0x9078FB0557364099', p0);
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0x56E4BAD93D33453C(p0: any, p1: any): any {
    return inv<number>('0x56E4BAD93D33453C', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0xFA0D206B489A6846(p0: any, p1: any, p2: any, p3: any, p4: any): void {
    inv<void>('0xFA0D206B489A6846', p0, p1, p2, p3, p4);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   */
  static N_0xB06F5F1DEF417216(p0: any, p1: any, p2: any, p3: any): void {
    inv<void>('0xB06F5F1DEF417216', p0, p1, p2, p3);
  }

  /**
   * Params: p4 = 35.f, duration = 5000 in R* Scripts
   *
   * @param xyzwWidth 
   * @param p4 
   * @param spawnpointsFlag 
   * @param p6 
   * @param duration 
   * @param p8 
   */
  static spawnpointsStartSearch(xyzwWidth: Vector4, p4: float, spawnpointsFlag: int, p6: float, duration: int, p8: float): void {
    inv<void>('0x2DF9038C90AD5264', f(xyzwWidth.x), f(xyzwWidth.y), f(xyzwWidth.z), f(xyzwWidth.w), f(p4), spawnpointsFlag, f(p6), duration, f(p8));
  }

  /**
   * Used in Script Function MP_MAIN_OFFLINE__INITIALIZE_GAME
   * *SET_RELATIONSHIP**
   *
   * @param group 
   * @param p1 
   */
  static N_0xDC91F22F09BC6C2F(group: string | number, p1: boolean): void {
    inv<void>('0xDC91F22F09BC6C2F', _h(group), p1);
  }

  /**
   * Only used in SP R* Script loanshark_hunter
   *
   * @param volume 
   */
  static N_0x9E3842E5DAD69F80(volume: Volume): void {
    inv<void>('0x9E3842E5DAD69F80', volume.handle);
  }

  /**
   * @param pos 
   * @param radius 
   * @returns
   */
  static isAnyPedNearPoint(pos: Vector3, radius: float): boolean {
    return !!inv<boolean>('0x083961498679DC9F', f(pos.x), f(pos.y), f(pos.z), f(radius), rai());
  }

  /**
   * https://github.com/femga/rdr3_discoveries/blob/master/clothes/metaped_outfits.lua
   *
   * @param requestId 
   * @param ped 
   * @param p2 
   * @param p3 
   * @returns
   */
  static applyPedMetaPedOutfit(requestId: int, ped: Ped, p2: boolean, p3: boolean): any {
    return inv<number>('0x74F512E29CB717E2', requestId, ped.handle, p2, p3);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xE9E06EA514A69061(p0: any, p1: any): void {
    inv<void>('0xE9E06EA514A69061', p0, p1);
  }

  /**
   * @param ped 
   * @param damageCleanliness 
   * @param p3 
   * @returns p0
   */
  static N_0x101B45C5F56D970F(ped: Ped, damageCleanliness: int, p3: int): [boolean, number] {
    const result = inv<[boolean, number]>('0x101B45C5F56D970F', pvi(), ped.handle, damageCleanliness, p3, rai());
    return [!!result[0], result[1]];
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x55546004A244302A(p0: any, p1: any): void {
    inv<void>('0x55546004A244302A', p0, p1);
  }

  /**
   * @param p0 
   */
  static N_0x3EFED081B4834BA1(p0: any): void {
    inv<void>('0x3EFED081B4834BA1', p0);
  }

  /**
   * @param outfit 
   * @param model 
   * @returns
   */
  static doesMetaPedOutfitExistForPedModel(outfit: string | number, model: string | number): boolean {
    return !!inv<boolean>('0xC0E880B7A441164D', _h(outfit), _h(model), rai());
  }

  /**
   * Creates a texture override data for ped and returns it's index.
   * So you can replace any texture of any ped's component.
   * Also, you can add overlays on it, such as aging, lipstick and more.
   * Textures can be reused by multiple peds at once.
   * You can keep only 32 textures at once(including other peds). https://github.com/femga/rdr3_discoveries/blob/master/clothes/change_overlays_script.lua
   * materialHash: https://github.com/femga/rdr3_discoveries/blob/master/clothes/cloth_drawable_albedo_normal_material_TEMPORARY.lua
   *
   * @param albedoHash 
   * @param normalHash 
   * @param materialHash 
   * @returns
   */
  static requestTexture(albedoHash: string | number, normalHash: string | number, materialHash: string | number): int {
    return inv<number>('0xC5E7204F322E49EB', _h(albedoHash), _h(normalHash), _h(materialHash), rai());
  }

  /**
   * @returns
   */
  static isInstantlyFillPedPopulationFinished(): boolean {
    return !!inv<boolean>('0x0EE3F0D7FECCC54F', rai());
  }

  /**
   * Returns requestId
   * Params: p1 = 1 in R* Scripts (Used in SP only)
   *
   * @param model 
   * @param p1 
   * @returns
   */
  static requestMetaPed(model: string | number, p1: int): int {
    return inv<number>('0xF97C34C33487D569', _h(model), p1, rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xE20027B414BFE6C7(p0: any, p1: any): void {
    inv<void>('0xE20027B414BFE6C7', p0, p1);
  }

  /**
   * Only used in SP Scripts
   * Returns count / index
   * _C*
   *
   * @param shockingEvent 
   * @param pos 
   * @param p4 
   * @returns p5
   */
  static N_0xF4860514AD354226(shockingEvent: number, pos: Vector3, p4: float): [int, number] {
    const result = inv<[number, number]>('0xF4860514AD354226', shockingEvent, f(pos.x), f(pos.y), f(pos.z), f(p4), pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * Searching area between coords 1 and 2
   *
   * @param pos1 
   * @param pos2 
   * @param width 
   * @param spawnpointsFlag 
   * @param p8 
   * @param duration 
   * @param p10 
   */
  static spawnpointsStartSearchInAngledArea(pos1: Vector3, pos2: Vector3, width: float, spawnpointsFlag: int, p8: float, duration: int, p10: float): void {
    inv<void>('0xB2AFF10216DEFA2F', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), f(width), spawnpointsFlag, f(p8), duration, f(p10));
  }

  /**
   * @param requestId 
   * @returns
   */
  static isMetaPedRequestValid(requestId: int): boolean {
    return !!inv<boolean>('0x43E4DA469541A9C9', requestId, rai());
  }

  /**
   * @param p0 
   */
  static N_0xC6136B40FFFB778B(p0: boolean): void {
    inv<void>('0xC6136B40FFFB778B', p0);
  }

  /**
   * this native checks if player has shot a specific ped for the duration passed p2 is in milliseconds
   *
   * @param player 
   * @param ped 
   * @param duration 
   * @returns
   */
  static hasPedBeenShotByPlayerRecently(player: Player, ped: Ped, duration: int): boolean {
    return !!inv<boolean>('0x9C81338B2E62CE0A', player.handle, ped.handle, duration, rai());
  }

  /**
   * @param value 
   */
  static setAiWeaponDamageModifier(value: float): void {
    inv<void>('0x1B1E2A40A65B8521', f(value));
  }

  /**
   * @param groupHash 
   */
  static removeRelationshipGroup(groupHash: string | number): void {
    inv<void>('0xB6BA2444AB393DA2', _h(groupHash));
  }

  /**
   * @param groupID 
   * @param memberNumber 
   * @returns
   */
  static getPedAsGroupMember(groupID: int, memberNumber: int): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0x51455483CF23ED97', groupID, memberNumber, rai()));
  }

  /**
   * @returns
   */
  static getNumReservedAmbientPedsDesired(): int {
    return inv<number>('0x62DE46F061CAA468', rai());
  }

  /**
   * _SET_FORMATION_P*
   *
   * @param groupId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0x966DE09688A1DE39(groupId: int, p1: float, p2: float, p3: float, p4: float): void {
    inv<void>('0x966DE09688A1DE39', groupId, f(p1), f(p2), f(p3), f(p4));
  }

  /**
   * @param p0 
   * @returns p1
   */
  static spawnpointsGetSearchResultFlags(p0: any): number {
    const result = inv<number>('0xB782F8238512BAD5', p0, pvi());
    return result;
  }

  /**
   * @param groupId 
   * @returns
   */
  static isGroupLocallyControlled(groupId: int): boolean {
    return !!inv<boolean>('0x909AD9E9A92A10DF', groupId, rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0x5B73975B4F12F7F3(p0: any, p1: any, p2: any, p3: any, p4: any): void {
    inv<void>('0x5B73975B4F12F7F3', p0, p1, p2, p3, p4);
  }

  /**
   * @param p0 
   */
  static N_0xE4EF4382E22C780C(p0: any): void {
    inv<void>('0xE4EF4382E22C780C', p0);
  }

  /**
   * @param entity 
   * @returns
   */
  static getCarrierAsHuman(entity: Entity): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0x79443D56C8DF45EE', entity.handle, rai()));
  }

  /**
   * @param modelHash 
   * @returns
   */
  static getDefaultRelationshipGroupHash(modelHash: string | number): number {
    return (inv<number>('0x3CC4A718C258BDD0', _h(modelHash), rai())) & 0xFFFFFFFF;
  }

  static instantlyFillPedPopulation(): void {
    inv<void>('0x4759CC730F947C81');
  }

  /**
   * @param textureId 
   * @param overlayId 
   */
  static removePedOverlay(textureId: int, overlayId: int): void {
    inv<void>('0x96C349DE04C49011', textureId, overlayId);
  }

  /**
   * @param numPeds 
   */
  static unreserveAmbientPeds(numPeds: int): void {
    inv<void>('0x7D4E70A67A651C71', numPeds);
  }

}