import type { eAddItemReason } from '../enums/eAddItemReason';
import type { eInventoryItemSound } from '../enums/eInventoryItemSound';
import type { eRemoveItemReason } from '../enums/eRemoveItemReason';
import type { Ped } from '../classes/Ped';
import type { Player } from '../classes/Player';
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 Inventory {
  /**
   * Returns stats entry id of CatalogItemInspection container
   *
   * @param entryId 
   * @param name 
   * @param unk1 
   * @param playerid 
   * @returns
   */
  static getCatalogItemInspectionStatsEntry(entryId: int, name: string, unk1: int, playerid: Player): number {
    return (inv<number>('0x9D21B185ABC2DBC5', entryId, name, unk1, playerid.handle, rai())) & 0xFFFFFFFF;
  }

  /**
   * Returns CopyID
   *
   * @param inventoryId 
   * @returns guid
   */
  static getInventoryItemWeaponCopyId(inventoryId: int): [int, number] {
    const result = inv<[number, number]>('0xAB5F12746A099A0E', inventoryId, pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * @param inventoryId 
   * @returns itemGUID
   */
  static N_0xB1DD74A1F5536622(inventoryId: int): [boolean, number] {
    const result = inv<[boolean, number]>('0xB1DD74A1F5536622', inventoryId, pvi(), rai());
    return [!!result[0], result[1]];
  }

  /**
   * @param p0 
   * @param p1 
   * @param bCopySatchelItems 
   * @param bCopyEmotes 
   * @param bCopyHorse 
   * @param p5 
   */
  static copyMpInventoryToMissionInventory(p0: boolean, p1: boolean, bCopySatchelItems: boolean, bCopyEmotes: boolean, bCopyHorse: boolean, p5: boolean): void {
    inv<void>('0x644CCB76A76CFBD6', p0, p1, bCopySatchelItems, bCopyEmotes, bCopyHorse, p5);
  }

  static disableMissionInventoryPickups(): void {
    inv<void>('0xE1F389F03DC83673');
  }

  /**
   * inventoryId: see _INVENTORY_GET_PED_INVENTORY_ID
   *
   * @param inventoryId 
   * @returns
   */
  static areLocalChangesAllowed(inventoryId: int): any {
    return inv<number>('0x0FBBFFC891A97C81', inventoryId);
  }

  /**
   * p1 (out) and p2 (in) are both script arrays?
   * item: can be a component item, see SHOP_CATALOG_BUILD_LIST_OF_WEAPON_COMPONENTS
   *
   * @param item 
   * @returns p1; p2
   */
  static N_0x9AC53CB6907B4428(item: string | number): [boolean, number, number] {
    const result = inv<[boolean, number, number]>('0x9AC53CB6907B4428', _h(item), pvi(), pvi(), rai());
    return [!!result[0], result[1], result[2]];
  }

  /**
   * This native has no functionality.
   *
   * @param toggle 
   */
  static setUseMissionInventory(toggle: boolean): void {
    inv<void>('0x597F571DDEE3FFAC', toggle);
  }

  /**
   * @param inventoryId 
   * @returns parentGuid
   */
  static getChildrenCount(inventoryId: int): [int, number] {
    const result = inv<[number, number]>('0xE843D21A8E2498AA', inventoryId, pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * @returns itemGUID
   */
  static isItemExpired(): [boolean, number] {
    const result = inv<[boolean, number]>('0x0137C77A2EC64536', pvi(), rai());
    return [!!result[0], result[1]];
  }

  /**
   * Alternative Name: _INVENTORY_IS_ITEM_DISABLED
   *
   * @param inventoryId 
   * @param item 
   * @param p2 
   * @returns
   */
  static isInventoryItemEquipped(inventoryId: int, item: string | number, p2: boolean): any {
    return inv<number>('0x3D10D7179D7034AF', inventoryId, _h(item), p2);
  }

  /**
   * @param inventoryId 
   * @param p3 
   * @param p4 
   * @returns guid; p2
   */
  static getFullInventoryItemData(inventoryId: int, p3: int, p4: int): [any, number, number] {
    const result = inv<[number, number, number]>('0x025A1B1FB03FBF61', inventoryId, pvi(), pvi(), p3, p4);
    return [result[0], result[1], result[2]];
  }

  /**
   * @param inventoryId 
   */
  static enableWeapons(inventoryId: int): void {
    inv<void>('0xD5D72F1624F3BA7C', inventoryId);
  }

  /**
   * Params: p3 returns an int between 0 and 20 (?)
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   * @returns guid; p2; p3
   */
  static N_0xD08685BA892DBFAB(inventoryId: int): [boolean, number, number, number] {
    const result = inv<[boolean, number, number, number]>('0xD08685BA892DBFAB', inventoryId, pvi(), pvi(), pvi(), rai());
    return [!!result[0], result[1], result[2], result[3]];
  }

  /**
   * @param p0 
   * @param p2 
   * @returns p1
   */
  static getInventoryItemFitSlot(p0: string | number, p2: int): [any, number] {
    const result = inv<[number, number]>('0xB991FE166FAF84FD', _h(p0), pvi(), p2);
    return [result[0], result[1]];
  }

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

  /**
   * @param inventoryId 
   * @param enabled 
   * @returns p1
   */
  static setInventoryItemInspectionEnabled(inventoryId: int, enabled: boolean): [any, number] {
    const result = inv<[number, number]>('0x227522FD59DDB7E8', inventoryId, pvi(), enabled);
    return [result[0], result[1]];
  }

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

  /**
   * @param inventoryId 
   * @returns guid
   */
  static getInventoryItemInUse(inventoryId: int): [boolean, number] {
    const result = inv<[boolean, number]>('0x70E3A884ED000A01', inventoryId, pvi(), rai());
    return [!!result[0], result[1]];
  }

  /**
   * p1: WARDROBE, KIT_CAMP, CHARACTER, KIT_MOONSHINER_PROPERTY
   * Returns slot hash
   *
   * @param item 
   * @param p1 
   * @returns
   */
  static getDefaultItemSlotInfo(item: string | number, p1: string | number): number {
    return (inv<number>('0x6452B1D357D81742', _h(item), _h(p1), rai())) & 0xFFFFFFFF;
  }

  /**
   * Example: (1, WEAPON_REVOLVER_CATTLEMAN, 0) - disables cattleman revolver on weapon wheel
   *
   * @param inventoryId 
   * @param item 
   * @param gtxReason 
   */
  static disableItem(inventoryId: int, item: string | number, gtxReason: string | number): void {
    inv<void>('0x766315A564594401', inventoryId, _h(item), _h(gtxReason));
  }

  /**
   * @param p1 
   * @returns guid
   */
  static copyItemToMissionInventory(p1: boolean): number {
    const result = inv<number>('0x3112ADB9D5F3426B', pvi(), p1);
    return result;
  }

  /**
   * @param inventoryId 
   * @param quantity 
   * @param removeReason Refer to {@link eRemoveItemReason}
   * @returns guid
   */
  static removeInventoryItemWithGuid(inventoryId: int, quantity: int, removeReason: eRemoveItemReason): [any, number] {
    const result = inv<[number, number]>('0x3E4E811480B3AE79', inventoryId, pvi(), quantity, removeReason);
    return [result[0], result[1]];
  }

  /**
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   */
  static N_0xE1F45A67A9F0DCBC(inventoryId: int): void {
    inv<void>('0xE1F45A67A9F0DCBC', inventoryId);
  }

  /**
   * Used with CClothingItem
   *
   * @param inventoryId 
   * @param hidden 
   * @returns guid
   */
  static setInventoryItemHidden(inventoryId: int, hidden: boolean): number {
    const result = inv<number>('0x9A113C660AEA3832', inventoryId, pvi(), hidden);
    return result;
  }

  /**
   * @param inventoryId 
   * @param p3 
   * @returns inData; outData
   */
  static getInventoryItem(inventoryId: int, p3: boolean): [any, number, number] {
    const result = inv<[number, number, number]>('0x9700E8EFC4AB9089', inventoryId, pvi(), pvi(), p3);
    return [result[0], result[1], result[2]];
  }

  /**
   * eInventoryItem: CLOTHING_FANCY_SUIT, CLOTHING_GUNSLINGER_OUTFIT, etc.
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   * @param eInventoryItem 
   * @param p2 
   */
  static useSatchelItem(inventoryId: int, eInventoryItem: string | number, p2: boolean): void {
    inv<void>('0x46743BBFEDBC859E', inventoryId, _h(eInventoryItem), p2);
  }

  /**
   * @param inventoryId 
   * @param childIndex 
   * @returns parentGuid; outInventoryItem
   */
  static getInventoryItemChild(inventoryId: int, childIndex: any): [any, number, number] {
    const result = inv<[number, number, number]>('0xCD9A485F2B383B44', inventoryId, pvi(), childIndex, pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * Used with CSatchelItem, R* Script usage: fisihing_core
   *
   * @param inventoryId 
   * @param hidden 
   * @returns guid
   */
  static setInventoryItemHidden2(inventoryId: int, hidden: boolean): number {
    const result = inv<number>('0xD740F11FBC8AEF43', inventoryId, pvi(), hidden);
    return result;
  }

  /**
   * @param inventoryId 
   * @param p2 
   * @param slotId 
   * @returns guid; outGuid
   */
  static getGuidFromItemid(inventoryId: int, p2: string | number, slotId: string | number): [any, number, number] {
    const result = inv<[number, number, number]>('0x886DFD3E185C8A89', inventoryId, pvi(), _h(p2), _h(slotId), pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param provision 
   * @param slotId 
   * @returns
   */
  static getItemSlotMaxCount(provision: string | number, slotId: string | number): int {
    return inv<number>('0xE80E50BEE276A54A', _h(provision), _h(slotId), rai());
  }

  /**
   * Params: p0 is only 0 or 1
   * Only used in R* SP Scripts
   *
   * @param p0 
   * @param inventoryId 
   * @returns guid
   */
  static N_0x0349404A22736740(p0: boolean, inventoryId: int): number {
    const result = inv<number>('0x0349404A22736740', p0, inventoryId, pvi());
    return result;
  }

  /**
   * @param inventoryId 
   * @param eInventoryItem 
   * @param p2 
   * @returns
   */
  static getInventoryItemCountWithItemid(inventoryId: int, eInventoryItem: string | number, p2: boolean): int {
    return inv<number>('0xE787F05DFC977BDE', inventoryId, _h(eInventoryItem), p2, rai());
  }

  /**
   * Returns collectionId
   *
   * @returns collectionSize
   */
  static createItemCollection2(): [int, number] {
    const result = inv<[number, number]>('0x97A3646645727F42', pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * @param inventoryId 
   * @param inventoryIdCloned 
   * @param p3 
   * @returns p2
   */
  static copyItemToInventory(inventoryId: int, inventoryIdCloned: int, p3: any): number {
    const result = inv<number>('0xC04F47D488EF9EBA', inventoryId, inventoryIdCloned, pvi(), p3);
    return result;
  }

  /**
   * @param inventoryId 
   * @returns filter; numInCollection
   */
  static createItemCollectionWithFilter(inventoryId: int): [int, number, number] {
    const result = inv<[number, number, number]>('0x640F890C3E5A3FFD', inventoryId, pvi(), pvi(), rai());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param inventoryId 
   * @param p2 
   * @returns guid
   */
  static getInventoryItemCountWithGuid(inventoryId: int, p2: boolean): [int, number] {
    const result = inv<[number, number]>('0xC97E0D2302382211', inventoryId, pvi(), p2, rai());
    return [result[0], result[1]];
  }

  /**
   * filterName (collections): "ALL", "ALL SATCHEL", "ALL HORSES", "ALL COACHES", "ALL MOUNTS", "ALL CLOTHING", "ALL WEAPONS", "ALL SATCHEL EXCLUDING CLOTHING", "ALL EXCLUDING CLOTHING"
   * slotId: -1591664384
   * p3: outCollectionSize (?)
   * Returns collectionId
   *
   * @param inventoryId 
   * @param filterName 
   * @param slotId 
   * @returns size
   */
  static createItemCollection(inventoryId: int, filterName: string, slotId: string | number): [int, number] {
    const result = inv<[number, number]>('0x80D78BDC9D88EF07', inventoryId, filterName, _h(slotId), pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * p1: 32
   * Returns collectionId
   *
   * @param inventoryId 
   * @param p1 
   * @returns size
   */
  static createSortedCollection(inventoryId: int, p1: int): [int, number] {
    const result = inv<[number, number]>('0xBB7F968675B34B0C', inventoryId, p1, pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * @param inventoryId 
   * @param item 
   * @returns guid
   */
  static doesItemOwnEquipment(inventoryId: int, item: string | number): [any, number] {
    const result = inv<[number, number]>('0x88B58B83A43A8CAB', inventoryId, pvi(), _h(item));
    return [result[0], result[1]];
  }

  /**
   * Returns a unique inventory ID for this ped.
   * For the local player ped, it is an eInventories value.
   * For other peds, it is the inventory address casted to unsigned int. enum eInventories
   * {
   * INVENTORY_INVALID,
   * INVENTORY_SP_PLAYER,
   * INVENTORY_MP_PLAYER,
   * INVENTORY_MP_MISSION,
   * INVENTORY_SECOND_SCREEN,
   * INVENTORY_SP_BACKUP,
   * INVENTORY_SP_SNAPSHOT,
   * INVENTORY_0xDE2AE452,
   * INVENTORY_0x399D9B3A,
   * INVENTORY_0x4BD43FA7,
   * INVENTORY_0x9529D251,
   * INVENTORY_0xA75776AC,
   * INVENTORY_MAX_ID = 11,
   * INVENTORY_IDS_COUNT
   * };
   *
   * @param ped 
   * @returns
   */
  static getInventoryIdFromPed(ped: Ped): int {
    return inv<number>('0x13D234A2A3F66E63', ped.handle, rai());
  }

  /**
   * Only works on CClothingItem
   *
   * @param inventoryId 
   * @param inUse 
   * @returns guid
   */
  static setInventoryItemInUse(inventoryId: int, inUse: boolean): number {
    const result = inv<number>('0x65A5F70F4A292EBE', inventoryId, pvi(), inUse);
    return result;
  }

  /**
   * @param inventoryId 
   * @param slotId 
   * @returns guid; outGuid
   */
  static getInventoryItemEquippedInSlotByRef(inventoryId: int, slotId: string | number): [any, number, number] {
    const result = inv<[number, number, number]>('0x22E590F108289A9D', inventoryId, pvi(), _h(slotId), pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * Apply the weapon stats to the CatalogItemInspection stats entry id. get entryId with _INVENTORY_GET_CATALOG_ITEM_INSPECTION_STATS_ENTRY
   *
   * @param entryId 
   * @param weapon 
   * @param ped 
   */
  static applyWeaponStatsToEntry(entryId: int, weapon: string | number, ped: Ped): void {
    inv<void>('0x75CFAC49301E134E', entryId, _h(weapon), ped.handle);
  }

  /**
   * @param inventoryId 
   * @param item 
   */
  static enableItem(inventoryId: int, item: string | number): void {
    inv<void>('0x6A564540FAC12211', inventoryId, _h(item));
  }

  /**
   * Returns databindingEntryId to be used with 0x951847CEF3D829FF (p0)
   *
   * @param data 
   * @param stats 
   * @param ped 
   * @returns guid
   */
  static N_0x46DB71883EE9D5AF(data: any, stats: string, ped: Ped): [number, number] {
    const result = inv<[number, number]>('0x46DB71883EE9D5AF', data, stats, pvi(), ped.handle, rai());
    return [result[0] & 0xFFFFFFFF, result[1]];
  }

  /**
   * collectionId is < outCollectionSize
   *
   * @param collectionId 
   * @param itemIndex 
   * @returns itemData
   */
  static getItemFromCollectionIndex(collectionId: int, itemIndex: int): [any, number] {
    const result = inv<[number, number]>('0x82FA24C3D3FCD9B7', collectionId, itemIndex, pvi());
    return [result[0], result[1]];
  }

  /**
   * @returns p0
   */
  static setItemPromptInfoRequest(): number {
    const result = inv<number>('0xFD41D1D4350F6413', pvi());
    return result;
  }

  /**
   * @param inventoryId 
   * @param item 
   * @param quantity 
   * @param removeReason Refer to {@link eRemoveItemReason}
   * @returns
   */
  static removeInventoryItemWithItemid(inventoryId: int, item: string | number, quantity: int, removeReason: eRemoveItemReason): any {
    return inv<number>('0xB4158C8C9A3B5DCE', inventoryId, _h(item), quantity, removeReason);
  }

  /**
   * Params: p1 = 0
   *
   * @param inventoryId 
   * @param p1 
   */
  static disableWeapons(inventoryId: int, p1: any): void {
    inv<void>('0xE3A46370F70F3607', inventoryId, p1);
  }

  /**
   * @returns guid1; guid2
   */
  static compareGuids(): [any, number, number] {
    const result = inv<[number, number, number]>('0x4C543D5DFCD2DAFD', pvi(), pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param inventoryId 
   * @param bEquipped 
   * @returns guid
   */
  static equipItemWithGuid(inventoryId: int, bEquipped: boolean): [any, number] {
    const result = inv<[number, number]>('0x734311E2852760D0', inventoryId, pvi(), bEquipped);
    return [result[0], result[1]];
  }

  /**
   * @param item 
   * @returns
   */
  static getInventoryItemIsAnimalPelt(item: string | number): any {
    return inv<number>('0x4AEF1FB5B9011D75', _h(item));
  }

  /**
   * @param inventoryId 
   * @param eRoleMaxLevel 
   * @returns
   */
  static getItemRoleMaxLevelCount(inventoryId: int, eRoleMaxLevel: string | number): int {
    return inv<number>('0xADDD1E7C0ECF7D95', inventoryId, _h(eRoleMaxLevel), rai());
  }

  /**
   * Used in function SET_SHOP_BEING_ROBBED and many other shop related scripts and functions.
   * INVENTORY_A*
   */
  static N_0x9B4E793B1CB6550A(): void {
    inv<void>('0x9B4E793B1CB6550A');
  }

  /**
   * @returns guid
   */
  static isGuidValid(): [any, number] {
    const result = inv<[number, number]>('0xB881CA836CC4B6D4', pvi());
    return [result[0], result[1]];
  }

  /**
   * Max num of collections is 5, so release your unused ones.
   *
   * @param collectionId 
   * @returns
   */
  static releaseItemCollection(collectionId: int): any {
    return inv<number>('0x42A2F33A1942E865', collectionId);
  }

  /**
   * @param item 
   * @returns info
   */
  static getInventoryItemInspectionInfo(item: string | number): [any, number] {
    const result = inv<[number, number]>('0x0C093C1787F18519', _h(item), pvi());
    return [result[0], result[1]];
  }

  /**
   * p1, p2: 0
   *
   * @param databindingEntryId 
   * @param p1 
   * @param p2 
   */
  static N_0x75CFAC49301E134F(databindingEntryId: string | number, p1: boolean, p2: boolean): void {
    inv<void>('0x75CFAC49301E134F', _h(databindingEntryId), p1, p2);
  }

  /**
   * @param inventoryId 
   * @param slotId 
   * @returns guid
   */
  static getChildrenInSlotCount(inventoryId: int, slotId: string | number): [int, number] {
    const result = inv<[number, number]>('0x033EE4B89F3AC545', inventoryId, pvi(), _h(slotId), rai());
    return [result[0], result[1]];
  }

  /**
   * Returns item Hash to be used with _IS_SCRIPTED_AUDIO_CUSTOM and _PLAY_SOUND_FROM_ITEM (p0)
   *
   * @param item 
   * @param soundType Refer to {@link eInventoryItemSound}
   * @returns
   */
  static getInventoryItemSound(item: string | number, soundType: eInventoryItemSound): number {
    return (inv<number>('0x2E1CDC1FF3B8473E', _h(item), soundType, rai())) & 0xFFFFFFFF;
  }

  /**
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   * @param p1 
   * @returns year; month; day; hour; minute; second
   */
  static N_0x112BCA290D2EB53C(inventoryId: int, p1: string | number): [boolean, number, number, number, number, number, number] {
    const result = inv<[boolean, number, number, number, number, number, number]>('0x112BCA290D2EB53C', inventoryId, _h(p1), pvi(), pvi(), pvi(), pvi(), pvi(), pvi(), rai());
    return [!!result[0], result[1], result[2], result[3], result[4], result[5], result[6]];
  }

  /**
   * Returns effects entry id of CatalogItemInspection container.
   *
   * @param entryId 
   * @param name 
   * @param unk1 
   * @param unk2 
   * @returns
   */
  static getCatalogItemInspectionEffectsEntry(entryId: int, name: string, unk1: boolean, unk2: boolean): number {
    return (inv<number>('0x9D21B185ABC2DBC4', entryId, name, unk1, unk2, rai())) & 0xFFFFFFFF;
  }

  /**
   * @returns itemGUID
   */
  static getItemExpiryTime(): [int, number] {
    const result = inv<[number, number]>('0x4A606C17276E1BCC', pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * @param inventoryId 
   * @param slotId 
   * @param p3 
   * @returns guid; p4
   */
  static getInventoryItemEquippedInSlot(inventoryId: int, slotId: string | number, p3: int): [int, number, number] {
    const result = inv<[number, number, number]>('0xBE012571B25F5ACA', inventoryId, pvi(), _h(slotId), p3, pvi(), rai());
    return [result[0], result[1], result[2]];
  }

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

  /**
   * flag: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/ItemDatabaseItemFlags
   * 2097152 (is item read?), 8388608 (is item sent/received/mailable?), 16777216 (is item consumable?)
   *
   * @param item 
   * @param flag 
   * @returns
   */
  static isInventoryItemFlagEnabled(item: string | number, flag: int): any {
    return inv<number>('0x245D07651B1D183B', _h(item), flag);
  }

  /**
   * old name _INVENTORY_USE_SP_BACKUP
   *
   * @returns
   */
  static isUsingBackupInventory(): any {
    return inv<number>('0x7C7E4AB748EA3B07');
  }

  /**
   * inventoryItemSlotHash: https://pastebin.com/P6fyr3vr
   *
   * @param inventoryId 
   * @param item 
   * @param inventoryItemSlot 
   * @param p5 
   * @param addReason Refer to {@link eAddItemReason}
   * @returns guid1; guid2
   */
  static addItemWithGuid(inventoryId: int, item: string | number, inventoryItemSlot: string | number, p5: int, addReason: eAddItemReason): [any, number, number] {
    const result = inv<[number, number, number]>('0xCB5D11F9508A928D', inventoryId, pvi(), pvi(), _h(item), _h(inventoryItemSlot), p5, addReason);
    return [result[0], result[1], result[2]];
  }

  /**
   * p0: value returned by 0x46DB71883EE9D5AF
   *
   * @param p0 
   * @param ped 
   * @returns outGuid
   */
  static N_0x951847CEF3D829FF(p0: any, ped: Ped): number {
    const result = inv<number>('0x951847CEF3D829FF', p0, pvi(), ped.handle);
    return result;
  }

  /**
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   */
  static N_0x6968CE7AC32F6788(inventoryId: int): void {
    inv<void>('0x6968CE7AC32F6788', inventoryId);
  }

  /**
   * @param inventoryId 
   * @returns guid1; guid2
   */
  static swapInventoryItem(inventoryId: int): [any, number, number] {
    const result = inv<[number, number, number]>('0xF2753D691BCDA314', inventoryId, pvi(), pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param item 
   * @param slotId 
   * @returns
   */
  static fitsSlotId(item: string | number, slotId: string | number): any {
    return inv<number>('0x780C5B9AE2819807', _h(item), _h(slotId));
  }

  /**
   * @param enable 
   * @param mirrorTransactions 
   */
  static useMissionInventory(enable: boolean, mirrorTransactions: boolean): void {
    inv<void>('0xA6AA9F56BC6CFF58', enable, mirrorTransactions);
  }

  /**
   * guid1: old parent GUID
   * guid2: new parent GUID
   * guid3: new item GUID (out param)
   *
   * @param inventoryId 
   * @param slotId 
   * @param quantity 
   * @returns guid1; guid2; outGuid
   */
  static moveInventoryItem(inventoryId: int, slotId: string | number, quantity: int): [any, number, number, number] {
    const result = inv<[number, number, number, number]>('0xDCCAA7C3BFD88862', inventoryId, pvi(), pvi(), _h(slotId), quantity, pvi());
    return [result[0], result[1], result[2], result[3]];
  }

  /**
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   * @param p2 
   * @returns guid; p3
   */
  static N_0x6862E4D93F64CF01(inventoryId: int, p2: string | number): [boolean, number, number] {
    const result = inv<[boolean, number, number]>('0x6862E4D93F64CF01', inventoryId, pvi(), _h(p2), pvi(), rai());
    return [!!result[0], result[1], result[2]];
  }

  /**
   * removeReason: REMOVE_REASON_DEFAULT (eRemoveItemReason)
   * Example: INVENTORY::_0x5D6182F3BCE1333B(1, joaat("REMOVE_REASON_DEFAULT")); -> clears weapon wheel
   * Only used in R* SP Scripts
   *
   * @param inventoryId 
   * @param removeReason Refer to {@link eRemoveItemReason}
   * @returns
   */
  static removeInventoryItems(inventoryId: int, removeReason: eRemoveItemReason): boolean {
    return !!inv<boolean>('0x5D6182F3BCE1333B', inventoryId, removeReason, rai());
  }

  /**
   * @returns data
   */
  static setCarriableCarryActionPromptOverride(): number {
    const result = inv<number>('0xF666EF30F4F0AC4E', pvi());
    return result;
  }

  /**
   * @param ped 
   * @param p1 
   */
  static N_0x9E58207B194488AC(ped: Ped, p1: int): void {
    inv<void>('0x9E58207B194488AC', ped.handle, p1);
  }

  /**
   * @param inventoryId 
   * @returns guid
   */
  static getInventoryItemHidden(inventoryId: int): [any, number] {
    const result = inv<[number, number]>('0xF9933164965533B7', inventoryId, pvi());
    return [result[0], result[1]];
  }

  /**
   * soundType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/CItemInfoSoundsInterface__sSoundsInfo__eSoundType
   *
   * @param item 
   * @param soundType Refer to {@link eInventoryItemSound}
   * @returns
   */
  static getIsInventoryItemSoundValid(item: string | number, soundType: eInventoryItemSound): any {
    return inv<number>('0x2BAE4880DCDD560B', _h(item), soundType);
  }

  /**
   * Getter: _INVENTORY_GET_FULL_INVENTORY_ITEM_DATA
   *
   * @param inventoryId 
   * @param p3 
   * @returns guid1; guid2
   */
  static updateInventoryItem(inventoryId: int, p3: int): [any, number, number] {
    const result = inv<[number, number, number]>('0xD80A8854DB5CFBA5', inventoryId, pvi(), pvi(), p3);
    return [result[0], result[1], result[2]];
  }

  /**
   * OWE_INVALID = -1,
   * OWE_GOOD_IN_HOT
   * OWE_GOOD_IN_NONE
   * OWE_GOOD_IN_COLD
   * OWE_GOOD_IN_ALL
   *
   * @param inventoryId 
   * @param weatherEffectiveness 
   * @returns guid
   */
  static setInventoryItemWeatherEffectiveness(inventoryId: int, weatherEffectiveness: int): number {
    const result = inv<number>('0x6D2F987736A42D4C', inventoryId, pvi(), weatherEffectiveness);
    return result;
  }

  /**
   * Only used in R* SP Scripts
   *
   * @param p0 
   */
  static useBackupInventory(p0: boolean): void {
    inv<void>('0xE36D4A38D28D9CFB', p0);
  }

}