import type { Entity } from '../classes/Entity';
import type { ItemSet } from '../classes/ItemSet';
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 { 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 VolumeStatics {
  /**
   * @param p0 
   */
  static N_0x998202B206872672(p0: any): void {
    inv<void>('0x998202B206872672', p0);
  }

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

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

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

  static N_0xC61E2FD926DBB406(): void {
    inv<void>('0xC61E2FD926DBB406');
  }

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

  /**
   * Params: p5 is always 0
   *
   * @param pos 
   * @param radius 
   * @param flag 
   * @param p5 
   * @returns
   */
  static createVolumeLock(pos: Vector3, radius: float, flag: int, p5: any): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x00BBF7CEAE8C666A', f(pos.x), f(pos.y), f(pos.z), f(radius), flag, p5, rai()));
  }

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

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

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

  /**
   * @param volLock 
   * @param pos 
   */
  static modifyVolumeLockLocation(volLock: int, pos: Vector3): void {
    inv<void>('0xEC43C2FFB70E3F30', volLock, f(pos.x), f(pos.y), f(pos.z));
  }

  /**
   * Params: p3 is always 0
   *
   * @param entity 
   * @param radius 
   * @param flag 
   * @param p3 
   * @returns
   */
  static createVolumeLockAttachedToEntity(entity: Entity, radius: float, flag: int, p3: any): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xF383E96C4904DF0C', entity.handle, f(radius), flag, p3, rai()));
  }

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

  /**
   * @param pos 
   * @param rot 
   * @param scale 
   * @returns
   */
  static createVolumeBox(pos: Vector3, rot: Vector3, scale: Vector3): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xDF85637F22706891', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), rai()));
  }

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

  /**
   * @param volLockRequestId 
   * @returns
   */
  static isVolumeLockRequestValid(volLockRequestId: int): boolean {
    return !!inv<boolean>('0xA4A4359320345B34', volLockRequestId, rai());
  }

  /**
   * @param volLockRequestId 
   */
  static releaseLockVolume(volLockRequestId: int): void {
    inv<void>('0xFDFECC6EE4491E11', volLockRequestId);
  }

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

  /**
   * @param pos 
   * @param rot 
   * @param scale 
   * @returns
   */
  static createVolumeCylinder(pos: Vector3, rot: Vector3, scale: Vector3): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x0522D4774B82E3E6', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), rai()));
  }

  /**
   * @returns
   */
  static createVolumeAggregate(): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x59F6F5C1D129F106', rai()));
  }

  /**
   * enum eVolumeLockRequestStatus
   * {
   * VOLUME_LOCK_REQUEST_STATUS_INVALID,
   * VOLUME_LOCK_REQUEST_STATUS_READY,
   * VOLUME_LOCK_REQUEST_STATUS_IN_PROGRESS,
   * VOLUME_LOCK_REQUEST_STATUS_SUCCEEDED,
   * VOLUME_LOCK_REQUEST_STATUS_FAILED
   * };
   *
   * @param volLockRequestId 
   * @returns
   */
  static getVolumeLockRequestStatus(volLockRequestId: int): int {
    return inv<number>('0xB33A604345F58202', volLockRequestId, rai());
  }

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

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

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

  /**
   * @param volLockRequestId 
   * @returns
   */
  static N_0xC4019CF9AE8E931A(volLockRequestId: int): Vector3 {
    return Vector3.fromArray(inv<number[]>('0xC4019CF9AE8E931A', volLockRequestId, rav()));
  }

  /**
   * @param volumeType 
   * @param pos 
   * @param rot 
   * @param scale 
   * @returns
   */
  static createAntiGriefVolume(volumeType: string | number, pos: Vector3, rot: Vector3, scale: Vector3): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x0EB78C2B156635B1', _h(volumeType), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), rai()));
  }

  /**
   * @param pos 
   * @param radius 
   * @param p4 
   * @param p5 
   * @param flags 
   * @returns
   */
  static isPointNearVolumeLockCenter(pos: Vector3, radius: float, p4: int, p5: int, flags: int): boolean {
    return !!inv<boolean>('0x769BB7626B8CDB06', f(pos.x), f(pos.y), f(pos.z), f(radius), p4, p5, flags, rai());
  }

  /**
   * @param volLockRequestId 
   * @returns
   */
  static isVolumeLockRequestValid2(volLockRequestId: int): boolean {
    return !!inv<boolean>('0xF6A8A652A6B186CD', volLockRequestId, rai());
  }

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

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

  /**
   * nullsub, doesn't do anything
   *
   * @param p0 
   */
  static N_0x128FC3A893BF853A(p0: any): void {
    inv<void>('0x128FC3A893BF853A', p0);
  }

  /**
   * @param pos 
   * @param radius 
   * @param p4 
   * @param p5 
   * @param p6 
   * @returns
   */
  static doesVolumeCollideWithAnyVolumeLock(pos: Vector3, radius: float, p4: boolean, p5: int, p6: int): boolean {
    return !!inv<boolean>('0x397769175A7DBB30', f(pos.x), f(pos.y), f(pos.z), f(radius), p4, p5, p6, rai());
  }

  /**
   * @param p0 
   * @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 
   * @returns
   */
  static createSpeedVolume(p0: any, 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): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xBBE768E3AE76E07C', p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, rai()));
  }

  /**
   * @param pos 
   * @param rot 
   * @param scale 
   * @param name 
   * @returns
   */
  static createVolumeSphereWithCustomName(pos: Vector3, rot: Vector3, scale: Vector3, name: string): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x10157BC3247FF3BA', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), name, rai()));
  }

  /**
   * nullsub, doesn't do anything
   *
   * @param p0 
   */
  static N_0x748C5F51A18CB8F0(p0: boolean): void {
    inv<void>('0x748C5F51A18CB8F0', p0);
  }

  /**
   * @param volumeType 
   * @param pos 
   * @param rot 
   * @param scale 
   * @returns
   */
  static createVolumeByHash(volumeType: string | number, pos: Vector3, rot: Vector3, scale: Vector3): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x502022FA1AF9DC86', _h(volumeType), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), rai()));
  }

  /**
   * @param pos 
   * @param radius 
   * @param p4 
   * @param p5 
   * @returns
   */
  static requestVolumeLock(pos: Vector3, radius: float, p4: int, p5: int): int {
    return inv<number>('0xF14BCEF290F869E1', f(pos.x), f(pos.y), f(pos.z), f(radius), p4, p5, rai());
  }

  /**
   * @param pos 
   * @param rot 
   * @param scale 
   * @param name 
   * @returns
   */
  static createVolumeCylinderWithCustomName(pos: Vector3, rot: Vector3, scale: Vector3, name: string): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xDF1E350EDDF06E59', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), name, rai()));
  }

  /**
   * nullsub, doesn't do anything
   */
  static N_0xFA15C9A320E707B0(): void {
    inv<void>('0xFA15C9A320E707B0');
  }

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

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

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

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   * @param p10 
   * @param p11 
   * @param p12 
   * @returns
   */
  static createWalkAndTalkVolume(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any, p10: any, p11: any, p12: any): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xFD0E389CD44434B6', p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, rai()));
  }

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

  /**
   * @param volumeType 
   * @param pos 
   * @param rot 
   * @param scale 
   * @param name 
   * @returns
   */
  static createVolumeByHashWithCustomName(volumeType: string | number, pos: Vector3, rot: Vector3, scale: Vector3, name: string): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x1F85E4AC774A201E', _h(volumeType), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), name, rai()));
  }

  /**
   * @param name 
   * @returns
   */
  static createVolumeAggregateWithCustomName(name: string): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0x5D580DE6398BB162', name, rai()));
  }

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

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

  /**
   * @param pos 
   * @param rot 
   * @param scale 
   * @param name 
   * @returns
   */
  static createVolumeBoxWithCustomName(pos: Vector3, rot: Vector3, scale: Vector3, name: string): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xF68485C7495D848E', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), name, rai()));
  }

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

  /**
   * @param pos 
   * @param rot 
   * @param scale 
   * @returns
   */
  static createVolumeSphere(pos: Vector3, rot: Vector3, scale: Vector3): Volume | null {
    return createFromHandle<Volume>('Volume', inv<number>('0xB3FB80A32BAE3065', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z), rai()));
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @returns
   */
  static N_0xD882C5B3991575B7(p0: any, p1: any, p2: any, p3: any, p4: any): Vector3 {
    return Vector3.fromArray(inv<number[]>('0xD882C5B3991575B7', p0, p1, p2, p3, p4, rav()));
  }

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

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

  /**
   * Indexes items (including entyties and peds) in a set volume
   * Counts up as its the return value of how many items it writes to given itemSet
   *
   * @param pos 
   * @param radius 
   * @param itemSet 
   * @returns
   */
  static getVolumeAmountOfIndexedItems(pos: Vector3, radius: float, itemSet: ItemSet): any {
    return inv<number>('0x2B32B11520626229', f(pos.x), f(pos.y), f(pos.z), f(radius), itemSet.handle);
  }

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

}