@nativewrappers/redm-codegen 0.0.2

package/src/namespaces/Misc.ts

@@ -0,0 +1,2603 @@
+import type { eWeaponHash } from '../enums/eWeaponHash';
+import type { Entity } from '../classes/Entity';
+import type { ItemSet } from '../classes/ItemSet';
+import type { Ped } from '../classes/Ped';
+import type { Player } from '../classes/Player';
+import type { Prop } from '../classes/Prop';
+import type { Vehicle } from '../classes/Vehicle';
+import type { Volume } from '../classes/Volume';
+import type { Prompt, 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 } from '../types/NativeAliases';
+
+export class Misc {
+  /**
+   * @param value 
+   * @param digits 
+   * @returns
+   */
+  static getStringFromFloat(value: number, digits: number): string | null {
+    return inv<string>('0x2B6846401D68E563', f(value), digits, ras());
+  }
+
+  /**
+   * Computes a hash for the given string. It is hashed using Jenkins' One-at-a-Time hash algorithm (https://en.wikipedia.org/wiki/Jenkins_hash_function)
+   * Note: this implementation is case-insensitive.
+   *
+   * @param string 
+   * @returns
+   */
+  static getHashKey(string: string | null): string | number {
+    return (inv<number>('0xFD340785ADF8CFB7', string, rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param startRange 
+   * @param endRange 
+   * @returns
+   */
+  static getRandomIntInRange(startRange: number, endRange: number): number {
+    return inv<number>('0xD53343AA4FB7DD28', startRange, endRange, rai());
+  }
+
+  /**
+   * @returns
+   */
+  static getRainLevel(): number {
+    return inv<number>('0x931B5F4CC130224B', raf());
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setFadeInAfterLoad(toggle: boolean): void {
+    inv<void>('0xAC806C4CAB973517', toggle);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @returns
+   */
+  static N_0xDC416CA762BC4F43(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any): any {
+    return inv<number>('0xDC416CA762BC4F43', p0, p1, p2, p3, p4, p5);
+  }
+
+  /**
+   * Begins with START_*. Next character in the name is either D or E. Old name: _START_BENCHMARK_RECORDING
+   */
+  static startEndUserBenchmark(): void {
+    inv<void>('0x29D1F6DF864A094E');
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   */
+  static clearAngledAreaOfVehicles(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
+    inv<void>('0xA4D83115C1E02F8A', p0, p1, p2, p3, p4, p5, p6, p7);
+  }
+
+  /**
+   * @param override 
+   * @param pos 
+   * @param heading 
+   * @param isAutosave 
+   * @returns returnCoords; returnHeading
+   */
+  static overrideSaveHouse(override: boolean, pos: Vector3, heading: number, isAutosave: boolean): [boolean, Vector3, number] {
+    const result = inv<[boolean, number[], number]>('0xB2C69E11A37B5AF0', override, f(pos.x), f(pos.y), f(pos.z), f(heading), isAutosave, pvv(), pvf(), rai());
+    return [!!result[0], Vector3.fromArray(result[1]), result[2]];
+  }
+
+  /**
+   * @param flag 
+   * @returns bitFlags
+   */
+  static isBitFlagSet(flag: number): [any, number] {
+    const result = inv<[number, number]>('0x8F4F050054005C27', pvi(), flag);
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x68319452C5064ABA(p0: any, p1: any): void {
+    inv<void>('0x68319452C5064ABA', p0, p1);
+  }
+
+  /**
+   * @param maxSpawnDistance 
+   */
+  static setDispatchMaxSpawnDistance(maxSpawnDistance: number): void {
+    inv<void>('0x89314FB3463E28DE', f(maxSpawnDistance));
+  }
+
+  /**
+   * Sets whether the game should fade in after the player dies or is arrested.
+   *
+   * @param toggle 
+   */
+  static setFadeInAfterDeathArrest(toggle: boolean): void {
+    inv<void>('0xDF3B5846DE5904AF', toggle);
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   *
+   * @param p0 
+   */
+  static N_0xA9342743B634A462(p0: any): void {
+    inv<void>('0xA9342743B634A462', p0);
+  }
+
+  /**
+   * Maximum value is 1.0f
+   * At a value of 0.0f the game will still run at a minimum time scale.
+   *
+   * @param timeScale 
+   */
+  static setTimeScale(timeScale: number): void {
+    inv<void>('0x9682AF6050854856', f(timeScale));
+  }
+
+  /**
+   * @param pos 
+   * @returns
+   */
+  static getTemperatureAtCoords(pos: Vector3): number {
+    return inv<number>('0xB98B78C3768AF6E0', f(pos.x), f(pos.y), f(pos.z), raf());
+  }
+
+  /**
+   * @param p0 
+   */
+  static removeDispatchSpawnBlockingArea(p0: any): void {
+    inv<void>('0x49F751F6868DDC5B', p0);
+  }
+
+  /**
+   * The entities must be added to itemSet.
+   *
+   * @param dispatchService Refer to [enum: eDispatchType]
+   * @param pos 
+   * @param itemSet 
+   * @param radius 
+   * @returns outIncidentID
+   */
+  static createIncidentWithEntities(dispatchService: number, pos: Vector3, itemSet: ItemSet, radius: number): [any, number] {
+    const result = inv<[number, number]>('0xAB3D3F45436DB1D8', dispatchService, f(pos.x), f(pos.y), f(pos.z), itemSet.handle, f(radius), pvi());
+    return [result[0], result[1]];
+  }
+
+  static resetDispatchMaxSpawnDistance(): void {
+    inv<void>('0x54EC7B6BC72BAD69');
+  }
+
+  /**
+   * *SET_MISSION_NAME**(FOR_ACTIVITY?/MINIGAME?)
+   *
+   * @param name 
+   */
+  static N_0x1096603B519C905F(name: string | null): void {
+    inv<void>('0x1096603B519C905F', name);
+  }
+
+  /**
+   * @returns bitFlags
+   */
+  static countBitFlags(): [number, number] {
+    const result = inv<[number, number]>('0xE704838F36F93B7B', pvi(), rai());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x96282005C5C6801F(p0: any, p1: any): void {
+    inv<void>('0x96282005C5C6801F', p0, p1);
+  }
+
+  static N_0x3C3C7B1B5EC08764(): void {
+    inv<void>('0x3C3C7B1B5EC08764');
+  }
+
+  /**
+   * UPDATE_PICKUP_COLLECTIBLE: set Eagle Eye fountain
+   * _J*, _K*, _L*
+   *
+   * @param entity 
+   */
+  static N_0x553D67295DDD2309(entity: Entity): void {
+    inv<void>('0x553D67295DDD2309', entity.handle);
+  }
+
+  /**
+   * Returns true if the entire string consists only of space characters.
+   *
+   * @param string 
+   * @returns
+   */
+  static isStringNullOrEmptyOrSpaces(string: string | null): any {
+    return inv<number>('0x375F5870A7B8BEC1', string);
+  }
+
+  /**
+   * dx = x1 - x2
+   * dy = y1 - y2
+   *
+   * @param dx 
+   * @param dy 
+   * @returns
+   */
+  static getHeadingFromVector2d(dx: number, dy: number): number {
+    return inv<number>('0x38D5202FF9271C62', f(dx), f(dy), raf());
+  }
+
+  /**
+   * @returns
+   */
+  static shouldUseMetricWeight(): boolean {
+    return inv<boolean>('0x8F24157FEDB85EA2', rai());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0xB08C4FA25BC29DB9(p0: any): void {
+    inv<void>('0xB08C4FA25BC29DB9', p0);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0xF650DCF5D6F312C1(p0: any): void {
+    inv<void>('0xF650DCF5D6F312C1', p0);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @returns
+   */
+  static N_0x0358B8A41916C613(p0: any, p1: any, p2: any, p3: any): any {
+    return inv<number>('0x0358B8A41916C613', p0, p1, p2, p3);
+  }
+
+  /**
+   * @param p0 
+   */
+  static informCodeOfContentIdOfCurrentUgcMission(p0: string | null): void {
+    inv<void>('0x708DF841B8F27AA2', p0);
+  }
+
+  /**
+   * @param seed 
+   */
+  static setRandomSeed(seed: number): void {
+    inv<void>('0x5CD7A49104AFCB6B', seed);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x8C0F6A3D7236DEEB(p0: any, p1: any): void {
+    inv<void>('0x8C0F6A3D7236DEEB', p0, p1);
+  }
+
+  /**
+   * @param milliseconds 
+   */
+  static clearWeatherTypePersistOvertime(milliseconds: number): void {
+    inv<void>('0xCE7690C0A0D1C36D', milliseconds);
+  }
+
+  /**
+   * @returns
+   */
+  static getScriptTimeWithinFrameInMicroseconds(): number {
+    return inv<number>('0x63219768C586667C', rai());
+  }
+
+  /**
+   * Old name: _COPY_MEMORY
+   *
+   * @param size 
+   * @returns dst; src
+   */
+  static copyScriptStruct(size: number): [number, number] {
+    const result = inv<[number, number]>('0xF7AC7DC0DEE7C9BE', pvi(), pvi(), size);
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param ped 
+   * @returns
+   */
+  static isPedDecomposed(ped: Ped): any {
+    return inv<number>('0x5170DDA6D63ACAAA', ped.handle);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x0730E518486DEEC3(p0: any): void {
+    inv<void>('0x0730E518486DEEC3', p0);
+  }
+
+  /**
+   * @returns
+   */
+  static isPlayerOwningStandaloneSp(): boolean {
+    return inv<boolean>('0x36040772DF5E59A0', rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0xBB282CF5D2333FB8(p0: any, p1: any): void {
+    inv<void>('0xBB282CF5D2333FB8', p0, p1);
+  }
+
+  /**
+   * @param incidentId 
+   * @returns
+   */
+  static isIncidentValid(incidentId: number): boolean {
+    return inv<boolean>('0x39F2B1BAD412246A', incidentId, rai());
+  }
+
+  /**
+   * If useZ is false, only the 2D plane (X-Y) will be considered for calculating the distance. Consider using this faster native instead: BUILTIN::VDIST - DVIST always takes in consideration the 3D coordinates.
+   *
+   * @param pos1 
+   * @param pos2 
+   * @param useZ 
+   * @returns
+   */
+  static getDistanceBetweenCoords(pos1: Vector3, pos2: Vector3, useZ: boolean): number {
+    return inv<number>('0x0BE7F4E3CDBAFB28', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), useZ, raf());
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x0D0AE5081F88CFE1(p0: string | number): boolean {
+    return inv<boolean>('0x0D0AE5081F88CFE1', _h(p0), rai());
+  }
+
+  /**
+   * Used in CAIConditionAmbientAIMemoryReactionsEnabled
+   *
+   * @param enabled 
+   */
+  static setAiMemoryReactionsEnabled(enabled: boolean): void {
+    inv<void>('0x6AC4AF46A6B8DFB2', enabled);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @returns
+   */
+  static N_0xCC1BAF72D571DB8D(p0: any, p1: any, p2: any): any {
+    return inv<number>('0xCC1BAF72D571DB8D', p0, p1, p2);
+  }
+
+  /**
+   * p3 is usually the same value of radius
+   * p8 determines whether the ILO prompt is a lock on prompt with RMB
+   *
+   * @param entity 
+   * @param text 
+   * @param radius 
+   * @param p3 
+   * @param flag 
+   * @param p5 
+   * @param p6 
+   * @param prompt 
+   * @param p8 
+   * @param p9 
+   * @returns
+   */
+  static registerInteractionLockonPrompt(entity: Entity, text: string | null, radius: number, p3: number, flag: number, p5: number, p6: number, prompt: number, p8: boolean, p9: number): any {
+    return inv<number>('0x870708A6E147A9AD', entity.handle, text, f(radius), f(p3), flag, f(p5), f(p6), prompt, p8, p9);
+  }
+
+  /**
+   * @param weatherType 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   */
+  static setWeatherType2(weatherType: string | number, p1: number, p2: number, p3: number, p4: boolean): void {
+    inv<void>('0x2C6A07AF9AEDABD8', _h(weatherType), p1, p2, p3, p4);
+  }
+
+  /**
+   * @param string1 
+   * @param string2 
+   * @returns
+   */
+  static areStringsEqual(string1: string | null, string2: string | null): boolean {
+    return inv<boolean>('0xD3852F22AB713A1F', string1, string2, rai());
+  }
+
+  /**
+   * Note: this native was added in build 1232.56
+   */
+  static setGameLogicPaused(): void {
+    inv<void>('0x550F05CFFBD63C8C');
+  }
+
+  /**
+   * @returns
+   */
+  static getRandomEventFlag(): boolean {
+    return inv<boolean>('0x924D54E5698AE3E0', rai());
+  }
+
+  /**
+   * @param string 
+   * @returns
+   */
+  static isStringNullOrEmpty(string: string | null): boolean {
+    return inv<boolean>('0x2CF12F9ACF18F048', string, rai());
+  }
+
+  /**
+   * @param item 
+   * @returns
+   */
+  static doesItemHaveValidBase(item: number): any {
+    return inv<number>('0xBDC6E364C9C78178', item);
+  }
+
+  /**
+   * Hardcoded to return one/true.
+   *
+   * @param p0 
+   * @returns
+   */
+  static N_0xAF530E56505D1BD6(p0: any): any {
+    return inv<number>('0xAF530E56505D1BD6', p0);
+  }
+
+  /**
+   * @param address 
+   * @param offset 
+   * @returns
+   */
+  static isBitSet(address: number, offset: number): boolean {
+    return inv<boolean>('0x4ED6CFDFE8D4131A', address, offset, rai());
+  }
+
+  static clearTacticalNavMeshPoints(): void {
+    inv<void>('0xD93B6516C6878267');
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setWeatherTypeFrozen(toggle: boolean): void {
+    inv<void>('0xD74ACDF7DB8114AF', toggle);
+  }
+
+  /**
+   * p3 is always -1.0f in the scripts
+   *
+   * @param pos 
+   * @param p3 
+   */
+  static forceLightningFlashAtCoords(pos: Vector3, p3: number): void {
+    inv<void>('0x67943537D179597C', f(pos.x), f(pos.y), f(pos.z), f(p3));
+  }
+
+  /**
+   * @param minSpawnDistance 
+   */
+  static setDispatchMinSpawnDistance(minSpawnDistance: number): void {
+    inv<void>('0x27A1B170AA8AF84C', f(minSpawnDistance));
+  }
+
+  static N_0x4B0501A468B749F8(): void {
+    inv<void>('0x4B0501A468B749F8');
+  }
+
+  /**
+   * Params: percentWeather2: 0f - 0.75f in R* Scripts Old name: _GET_WEATHER_TYPE_TRANSITION
+   *
+   * @returns weatherType1; weatherType2; percentWeather2
+   */
+  static getCurrWeatherState(): [number, number, number] {
+    const result = inv<[number, number, number]>('0x0AC679B2342F14F2', pvi(), pvi(), pvf());
+    return [result[0], result[1], result[2]];
+  }
+
+  /**
+   * @returns
+   */
+  static getRandomWeatherType(): string | number {
+    return (inv<number>('0x1359C181BC625503', rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * Hardcoded to return true.
+   *
+   * @returns
+   */
+  static isPcVersion(): boolean {
+    return inv<boolean>('0xB0FB6CFAA5A1C833', rai());
+  }
+
+  /**
+   * Returns value of the '-benchmarkIterations' command line option. Old name: _GET_BENCHMARK_ITERATIONS_FROM_COMMAND_LINE
+   *
+   * @returns
+   */
+  static getBenchmarkIterations(): number {
+    return inv<number>('0x22FC52CF470CC98D', rai());
+  }
+
+  /**
+   * @param offset 
+   * @returns address
+   */
+  static setBit(offset: number): number {
+    const result = inv<number>('0xF73FBE4845C43B5B', pvi(), offset);
+    return result;
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @returns
+   */
+  static N_0x33982467B1E349EF(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): any {
+    return inv<number>('0x33982467B1E349EF', p0, p1, p2, p3, p4, p5, p6);
+  }
+
+  /**
+   * Determines whether there is a projectile of a specific type within the specified coordinates. The coordinates form a rectangle.
+   *
+   * @param min 
+   * @param max 
+   * @param weaponType 
+   * @param isPlayer 
+   * @returns
+   */
+  static isProjectileTypeInArea(min: Vector3, max: Vector3, weaponType: string | number, isPlayer: boolean): boolean {
+    return inv<boolean>('0x04965FB9E14235C7', f(min.x), f(min.y), f(min.z), f(max.x), f(max.y), f(max.z), _h(weaponType), isPlayer, rai());
+  }
+
+  /**
+   * @returns
+   */
+  static getMissionFlag(): boolean {
+    return inv<boolean>('0xB15CD1CF58771DE1', rai());
+  }
+
+  static N_0x4D5C9CC7E7E23E09(): void {
+    inv<void>('0x4D5C9CC7E7E23E09');
+  }
+
+  /**
+   * @returns
+   */
+  static getNextWeatherTypeHashName(): string | number {
+    return (inv<number>('0x51021D36F62AAA83', rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * spawns a few distant/out-of-sight peds, vehicles, animals etc each time it is called
+   */
+  static populateNow(): void {
+    inv<void>('0xEA6DC3A8ADD2005F');
+  }
+
+  /**
+   * Hardcoded to return false.
+   *
+   * @returns
+   */
+  static isStadiaVersion(): boolean {
+    return inv<boolean>('0x268AB8420A9E4ED7', rai());
+  }
+
+  /**
+   * @param ped 
+   * @returns
+   */
+  static N_0x4B101DBCC9482F2D(ped: Ped): boolean {
+    return inv<boolean>('0x4B101DBCC9482F2D', ped.handle, rai());
+  }
+
+  /**
+   * @param entity 
+   * @returns
+   */
+  static unregisterInteractionLockonPrompt(entity: Entity): any {
+    return inv<number>('0xE98D55C5983F2509', entity.handle);
+  }
+
+  /**
+   * @param item 
+   * @returns
+   */
+  static getVolumeFromIndexedItem(item: number): Volume | null {
+    return createFromHandle<Volume>('Volume', inv<number>('0xF18AF483DF70BBDE', item, rai()));
+  }
+
+  /**
+   * @param pos 
+   * @param range 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @returns
+   */
+  static isPositionOccupied(pos: Vector3, range: number, p4: boolean, p5: boolean, p6: boolean, p7: boolean, p8: boolean, p9: any, p10: boolean): boolean {
+    return inv<boolean>('0x825CA3ED43831015', f(pos.x), f(pos.y), f(pos.z), f(range), p4, p5, p6, p7, p8, p9, p10, rai());
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   */
+  static activityFeedPost(): void {
+    inv<void>('0xB16FC7B364D86585');
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @returns
+   */
+  static N_0x8BB99B85444544D9(p0: any, p1: any): any {
+    return inv<number>('0x8BB99B85444544D9', p0, p1);
+  }
+
+  /**
+   * Delete an incident with a given id.
+   *
+   * @param incidentId 
+   */
+  static deleteIncident(incidentId: number): void {
+    inv<void>('0x5CFD0F0D6AAE0AEE', incidentId);
+  }
+
+  /**
+   * @param pos 
+   * @param p4 
+   * @returns groundZ
+   */
+  static getGroundZFor3dCoord(pos: Vector3, p4: boolean): [boolean, number] {
+    const result = inv<[boolean, number]>('0x24FA4267BB8D2431', f(pos.x), f(pos.y), f(pos.z), pvf(), p4, rai());
+    return [!!result[0], result[1]];
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @returns
+   */
+  static isBulletInBox(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: boolean): boolean {
+    return inv<boolean>('0xC128137C52152741', f(p0), f(p1), f(p2), f(p3), f(p4), f(p5), p6, rai());
+  }
+
+  /**
+   * If true, the player can't save the game.
+   *
+   * @param toggle 
+   */
+  static setMissionFlag(toggle: boolean): void {
+    inv<void>('0x36694B456BE80D0A', toggle);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x745808BB01CEC6B9(p0: number): void {
+    inv<void>('0x745808BB01CEC6B9', f(p0));
+  }
+
+  /**
+   * enum eOnscreenKeyboardTextType
+   * {
+   * KTEXTTYPE_INVALID = -1,
+   * KTEXTTYPE_DEFAULT,
+   * KTEXTTYPE_EMAIL,
+   * KTEXTTYPE_PASSWORD,
+   * KTEXTTYPE_NUMERIC,
+   * KTEXTTYPE_ALPHABET,
+   * KTEXTTYPE_GAMERTAG,
+   * KTEXTTYPE_FILENAME,
+   * KTEXTTYPE_COUNT
+   * };
+   *
+   * @param textType 
+   * @param windowTitle 
+   * @param p2 
+   * @param defaultText 
+   * @param defaultConcat1 
+   * @param defaultConcat2 
+   * @param defaultConcat3 
+   * @param maxInputLength 
+   */
+  static displayOnscreenKeyboard(textType: number, windowTitle: string | null, p2: string | null, defaultText: string | null, defaultConcat1: string | null, defaultConcat2: string | null, defaultConcat3: string | null, maxInputLength: number): void {
+    inv<void>('0x044131118D8DB3CD', textType, windowTitle, p2, defaultText, defaultConcat1, defaultConcat2, defaultConcat3, maxInputLength);
+  }
+
+  /**
+   * @param offset 
+   * @returns address
+   */
+  static clearBit(offset: number): number {
+    const result = inv<number>('0x7D1D4A3602B6AD4E', pvi(), offset);
+    return result;
+  }
+
+  /**
+   * Only used in smuggler2 script
+   *
+   * @param maxAmplitude 
+   */
+  static waterOverrideSetOceanwavemaxamplitude(maxAmplitude: number): void {
+    inv<void>('0xF06C5B66DE20B2B8', f(maxAmplitude));
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x7CF96F1250EF3221(p0: any): any {
+    return inv<number>('0x7CF96F1250EF3221', p0);
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   *
+   * @param p0 
+   * @param p1 
+   */
+  static activityFeedActionStartWithCommandLine(p0: string | null, p1: string | null): void {
+    inv<void>('0x91D657230BC208D2', p0, p1);
+  }
+
+  /**
+   * _CLEAR*
+   *
+   * @param p0 
+   */
+  static N_0xA08111B053D84B4D(p0: any): void {
+    inv<void>('0xA08111B053D84B4D', p0);
+  }
+
+  static resetDispatchIdealSpawnDistance(): void {
+    inv<void>('0xC7817264BC4B6377');
+  }
+
+  /**
+   * @returns
+   */
+  static N_0x35165C658077CD0B(): any {
+    return inv<number>('0x35165C658077CD0B');
+  }
+
+  /**
+   * @param handle 
+   * @returns
+   */
+  static isBaseACoverPoint(handle: number): any {
+    return inv<number>('0xFEC1D4B5C82C176F', handle);
+  }
+
+  /**
+   * @param modelHash 
+   * @returns minimum; maximum
+   */
+  static getModelDimensions(modelHash: string | number): [Vector3, Vector3] {
+    const result = inv<[number[], number[]]>('0xDCB8DDD5D054A7E7', _h(modelHash), pvv(), pvv());
+    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
+  }
+
+  /**
+   * Only 0 and 1 are valid for p0, higher values causes the native to return 2.
+   *
+   * @param p0 
+   * @returns
+   */
+  static getStatusOfSavegameOperation(p0: number): number {
+    return inv<number>('0x1B065A2BF7953815', p0, rai());
+  }
+
+  /**
+   * Reads the passed value as floating point value and returns it.
+   * Example: _READ_INT_AS_FLOAT(0x3F800000) returns 1.0f because 0x3F800000 is the hexadecimal representation of 1.0f.
+   *
+   * @param value 
+   * @returns
+   */
+  static readIntAsFloat(value: number): number {
+    return inv<number>('0xD2C9126410DFA1B2', value, raf());
+  }
+
+  /**
+   * @param startRange 
+   * @param endRange 
+   * @returns
+   */
+  static getRandomFloatInRange(startRange: number, endRange: number): number {
+    return inv<number>('0xE29F927A961F8AAA', f(startRange), f(endRange), raf());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0xCC3EDC5614B03F61(p0: number): void {
+    inv<void>('0xCC3EDC5614B03F61', p0);
+  }
+
+  /**
+   * https://easings.net/ enum class eEasingCurveType
+   * {
+   * TYPE_LINEAR,
+   * TYPE_QUADRATIC_IN,
+   * TYPE_QUADRATIC_OUT,
+   * TYPE_QUADRATIC_INOUT,
+   * TYPE_CUBIC_IN,
+   * TYPE_CUBIC_OUT,
+   * TYPE_CUBIC_INOUT,
+   * TYPE_QUARTIC_IN,
+   * TYPE_QUARTIC_OUT,
+   * TYPE_QUARTIC_INOUT,
+   * TYPE_QUINTIC_IN,
+   * TYPE_QUINTIC_OUT,
+   * TYPE_QUINTIC_INOUT,
+   * TYPE_EXPONENTIAL_IN,
+   * TYPE_EXPONENTIAL_OUT,
+   * TYPE_EXPONENTIAL_INOUT,
+   * TYPE_SINE_IN,
+   * TYPE_SINE_OUT,
+   * TYPE_SINE_INOUT,
+   * TYPE_CIRCULAR_IN,
+   * TYPE_CIRCULAR_OUT,
+   * TYPE_CIRCULAR_INOUT,
+   * TYPE_BOUNCE_IN,
+   * TYPE_BOUNCE_OUT,
+   * TYPE_BOUNCE_INOUT,
+   * TYPE_CUSTOM
+   * };
+   *
+   * @param t 
+   * @param b 
+   * @param d 
+   * @param easingCurveType 
+   * @returns
+   */
+  static getEasingCurveValue(t: number, b: number, d: number, easingCurveType: number): number {
+    return inv<number>('0xEF50E344A8F93784', f(t), f(b), f(d), easingCurveType, raf());
+  }
+
+  /**
+   * @returns
+   */
+  static getGameTimer(): number {
+    return inv<number>('0x4F67E8ECA7D3F667', rai());
+  }
+
+  /**
+   * @param level 
+   */
+  static setSnowLevel(level: number): void {
+    inv<void>('0xF6BEE7E80EC5CA40', f(level));
+  }
+
+  /**
+   * @param string1 
+   * @param string2 
+   * @returns
+   */
+  static doesStringExistInString(string1: string | null, string2: string | null): any {
+    return inv<number>('0x9382D5D43D2AA6FF', string1, string2);
+  }
+
+  /**
+   * @returns
+   */
+  static getWindSpeed(): number {
+    return inv<number>('0xFFB7E74E041150A4', raf());
+  }
+
+  /**
+   * Old name: _CANCEL_ONSCREEN_KEYBOARD
+   */
+  static cancelOnscreenKeyboard(): void {
+    inv<void>('0x58A39BE597CE99CD');
+  }
+
+  /**
+   * Hardcoded to return one/true.
+   *
+   * @returns
+   */
+  static N_0xDC057B86FC157031(): any {
+    return inv<number>('0xDC057B86FC157031');
+  }
+
+  /**
+   * @returns
+   */
+  static getWindDirection(): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0xF703E82F3FE14A5F', rav()));
+  }
+
+  static gameFrameworkManagerShutdown(): void {
+    inv<void>('0xAFF2FD8ADD927585');
+  }
+
+  static networkSetScriptIsSafeForNetworkGame(): void {
+    inv<void>('0x3D0EAC6385DD6100');
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static tan(p0: number): number {
+    return inv<number>('0x8C13DB96497B7ABF', f(p0), raf());
+  }
+
+  /**
+   * Returns rage::fwTimer::sm_nonScaledClippedTime
+   *
+   * @returns
+   */
+  static getGameTimerNonScaledClipped(): number {
+    return inv<number>('0x483B8C542103AD72', rai());
+  }
+
+  /**
+   * Returns a formatted string (0x%x)
+   *
+   * @param rgb 
+   * @returns
+   */
+  static createColorString(rgb: number): string | null {
+    return inv<string>('0xBCC2CFADEA1AEA6C', rgb, ras());
+  }
+
+  /**
+   * Outputs the ground Z axis, its material and flags.
+   * Input flags are 17, 129 or 3423 in R* scripts. Surely similar to flags of shapes test.
+   *
+   * @param coords 
+   * @param flags 
+   * @returns groundZ; material; outFlags
+   */
+  static getGroundZAndMaterialFor3dCoord(coords: Vector3, flags: number): [boolean, number, number, number] {
+    const result = inv<[boolean, number, number, number]>('0xBBE5B63EFFB08E68', f(coords.x), f(coords.y), f(coords.z), flags, pvf(), pvi(), pvi(), rai());
+    return [!!result[0], result[1], result[2], result[3]];
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x38C2BF94D15F464D(p0: any): any {
+    return inv<number>('0x38C2BF94D15F464D', p0);
+  }
+
+  /**
+   * @returns
+   */
+  static getMaxNumInstructions(): number {
+    return inv<number>('0xC43CD2668B204419', rai());
+  }
+
+  /**
+   * @returns bitFlags
+   */
+  static clearAllBitFlags(): number {
+    const result = inv<number>('0xD2D74F89DF844A50', pvi());
+    return result;
+  }
+
+  /**
+   * @param fIdealSpawnDistance 
+   */
+  static setDispatchIdealSpawnDistance(fIdealSpawnDistance: number): void {
+    inv<void>('0xEAB6823B82FBD283', f(fIdealSpawnDistance));
+  }
+
+  /**
+   * Only used in script function PROCESS_ZONE_CREATION
+   * Returns Pop multiplier volume ID
+   *
+   * @param volume 
+   * @param pedDensity 
+   * @param vehicleDensity 
+   * @param p3 
+   * @param p4 
+   * @returns
+   */
+  static addPopMultiplierVolume(volume: Volume, pedDensity: number, vehicleDensity: number, p3: boolean, p4: boolean): number {
+    return inv<number>('0x3233C4EC0514C7EC', volume.handle, f(pedDensity), f(vehicleDensity), p3, p4, rai());
+  }
+
+  /**
+   * Begins with STOP_*. Next character in the name is either D or E. Old name: _STOP_BENCHMARK_RECORDING
+   */
+  static stopEndUserBenchmark(): void {
+    inv<void>('0xB89AEC71AFF2B599');
+  }
+
+  /**
+   * Returns the weather type that has been set by a script
+   *
+   * @returns weather; p1
+   */
+  static getForcedWeather(): [number, number] {
+    const result = inv<[number, number]>('0xDD560ABEF5D3784C', pvi(), pvi());
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @returns
+   */
+  static getFrameTime(): number {
+    return inv<number>('0x5E72022914CE3C38', raf());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x9BF2C0C568C61641(p0: any): void {
+    inv<void>('0x9BF2C0C568C61641', p0);
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   *
+   * @param p0 
+   */
+  static activityFeedAddSubstringToCaption(p0: string | null): void {
+    inv<void>('0x9935F76407C32539', p0);
+  }
+
+  /**
+   * @param direction 
+   */
+  static setWindDirection(direction: number): void {
+    inv<void>('0xB56C4F5F57A45600', f(direction));
+  }
+
+  /**
+   * @param fontBitField 
+   */
+  static nextOnscreenKeyboardResultWillDisplayUsingTheseFonts(fontBitField: number): void {
+    inv<void>('0x5CB71EAA1429A358', fontBitField);
+  }
+
+  /**
+   * creates single lightning+thunder at random position
+   */
+  static forceLightningFlash(): void {
+    inv<void>('0x369DB5B2510FA080');
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x5B4A8121A47D844D(p0: any): any {
+    return inv<number>('0x5B4A8121A47D844D', p0);
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x6F02B5E50511721E(p0: any): any {
+    return inv<number>('0x6F02B5E50511721E', p0);
+  }
+
+  /**
+   * @returns data
+   */
+  static N_0x183672FE838A661B(): number {
+    const result = inv<number>('0x183672FE838A661B', pvi());
+    return result;
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @param p10 
+   * @param p11 
+   * @returns p12
+   */
+  static getLinePlaneIntersection(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number, p10: number, p11: number): [boolean, number] {
+    const result = inv<[boolean, number]>('0xAB6A04CEC428258B', f(p0), f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9), f(p10), f(p11), pvf(), rai());
+    return [!!result[0], result[1]];
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static setRandomWeatherType(p0: boolean, p1: boolean): void {
+    inv<void>('0x6E5A7FBEECAB3C72', p0, p1);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @returns
+   */
+  static atan2(p0: number, p1: number): number {
+    return inv<number>('0x965B220A066E3F07', f(p0), f(p1), raf());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @returns
+   */
+  static hasBulletImpactedInBox(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: boolean, p7: boolean): boolean {
+    return inv<boolean>('0x3B6A4C05FB2B33AC', f(p0), f(p1), f(p2), f(p3), f(p4), f(p5), p6, p7, rai());
+  }
+
+  /**
+   * @param part 
+   * @param checkpoint 
+   * @param lap 
+   * @param time 
+   */
+  static scriptRacePlayerHitCheckpoint(part: number, checkpoint: number, lap: number, time: number): void {
+    inv<void>('0xBA62B4D80FA66BD6', part, checkpoint, lap, time);
+  }
+
+  /**
+   * @param volume 
+   * @param flag 
+   */
+  static clearVolumeArea(volume: Volume, flag: number): void {
+    inv<void>('0x2FCD528A397E5C88', volume.handle, flag);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0xF63FA29D4A9ACA86(p0: any, p1: any): void {
+    inv<void>('0xF63FA29D4A9ACA86', p0, p1);
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static acos(p0: number): number {
+    return inv<number>('0x586690F0176DC575', f(p0), raf());
+  }
+
+  /**
+   * Event names in the scripts: MGBegin, MGEnd, ReadyForCut
+   *
+   * @param ped 
+   * @param eventName 
+   * @returns
+   */
+  static getLootingEventHasFired(ped: Ped, eventName: string | null): any {
+    return inv<number>('0xF9B91C5129EABC08', ped.handle, eventName);
+  }
+
+  /**
+   * @param speed 
+   */
+  static setWindSpeed(speed: number): void {
+    inv<void>('0xD00C2D82DC04A99F', f(speed));
+  }
+
+  /**
+   * Only used in smuggler2 script
+   *
+   * @param amplitude 
+   */
+  static waterOverrideSetShorewaveamplitude(amplitude: number): void {
+    inv<void>('0x55123D5A7D9D3C42', f(amplitude));
+  }
+
+  /**
+   * @param player 
+   */
+  static setSuperJumpThisFrame(player: Player): void {
+    inv<void>('0xB3E9BE963F10C445', player.handle);
+  }
+
+  /**
+   * @returns
+   */
+  static getFrameCount(): number {
+    return inv<number>('0x77DFA958FCF100C1', rai());
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   */
+  static N_0xB711EB4BC8D06013(): void {
+    inv<void>('0xB711EB4BC8D06013');
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @param p9 
+   * @returns
+   */
+  static getClosestPointOnLine(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: boolean): Vector3 {
+    return Vector3.fromArray(inv<number[]>('0x83ACC65D9ACEC5EF', f(p0), f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), p9, rav()));
+  }
+
+  /**
+   * @param weatherType 
+   */
+  static setOverrideWeather(weatherType: string | number): void {
+    inv<void>('0xBE83CAE8ED77A94F', _h(weatherType));
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x74ACA66484CEBAF0(p0: any): void {
+    inv<void>('0x74ACA66484CEBAF0', p0);
+  }
+
+  static N_0xF569E33FB72ED28E(): void {
+    inv<void>('0xF569E33FB72ED28E');
+  }
+
+  /**
+   * Params: BOOL p3 is always true Old name: _SET_WEATHER_TYPE_TRANSITION
+   *
+   * @param weatherType1 
+   * @param weatherType2 
+   * @param percentWeather2 
+   * @param enabled 
+   */
+  static setCurrWeatherState(weatherType1: string | number, weatherType2: string | number, percentWeather2: number, enabled: boolean): void {
+    inv<void>('0xFA3E3CA8A1DE6D5D', _h(weatherType1), _h(weatherType2), f(percentWeather2), enabled);
+  }
+
+  /**
+   * disables prompt eat
+   * old name DISABLE_LOOTING_COMPOSITE_LOOTABLE_THIS_FRAME
+   *
+   * @param compositeId 
+   * @param disable 
+   */
+  static disableLootingCompositeLootableThisFrame(compositeId: number, disable: boolean): void {
+    inv<void>('0x40D72189F46D2E15', compositeId, disable);
+  }
+
+  /**
+   * Note: the buffer should be exactly 32 bytes long
+   *
+   * @param value 
+   * @param format 
+   * @param buffer 
+   */
+  static intToString(value: number, format: string | null, buffer: string | null): void {
+    inv<void>('0xCF11C0CEB40C401B', value, format, buffer);
+  }
+
+  /**
+   * @param p1 
+   * @returns args
+   */
+  static getAiPedDoesHaveEventMemory(p1: number): [any, number] {
+    const result = inv<[number, number]>('0xFDF38E2B711BF78E', pvi(), p1);
+    return [result[0], result[1]];
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x4647842FE8F31C1E(p0: any, p1: any): void {
+    inv<void>('0x4647842FE8F31C1E', p0, p1);
+  }
+
+  /**
+   * @returns
+   */
+  static gameFrameworkManagerGetMode(): string | number {
+    return (inv<number>('0xFAED234C7F53ABEB', rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setThisScriptCanRemoveBlipsCreatedByAnyScript(toggle: boolean): void {
+    inv<void>('0x8ABD939C2E5D00ED', toggle);
+  }
+
+  /**
+   * If the parameter is true, sets the random event flag to true, if the parameter is false, the function does nothing at all.
+   * Does nothing if the mission flag is set.
+   *
+   * @param toggle 
+   */
+  static setRandomEventFlag(toggle: boolean): void {
+    inv<void>('0xB1ADCCC4150C6473', toggle);
+  }
+
+  static N_0x9A252AA23D7098F2(): void {
+    inv<void>('0x9A252AA23D7098F2');
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x5801BE2DF2AF07EC(p0: any): void {
+    inv<void>('0x5801BE2DF2AF07EC', p0);
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x6C7B68D3CE60E8DE(p0: any): any {
+    return inv<number>('0x6C7B68D3CE60E8DE', p0);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   */
+  static N_0xAD44856A1CD29635(p0: any, p1: any, p2: any): void {
+    inv<void>('0xAD44856A1CD29635', p0, p1, p2);
+  }
+
+  static clearWeatherTypePersist(): void {
+    inv<void>('0xD85DFE5C131E4AE9');
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/blob/master/weather/weather_types.lua
+   *
+   * @param weatherType 
+   * @param p1 
+   * @param p2 
+   * @param transition 
+   * @param transitionTime 
+   * @param p5 
+   */
+  static setWeatherType(weatherType: string | number, p1: boolean, p2: boolean, transition: boolean, transitionTime: number, p5: boolean): void {
+    inv<void>('0x59174F1AFE095B5A', _h(weatherType), p1, p2, transition, f(transitionTime), p5);
+  }
+
+  /**
+   * @param index 
+   * @param toggle 
+   */
+  static setGlobalBlockIsLoaded(index: number, toggle: boolean): void {
+    inv<void>('0xE97240065406CB80', index, toggle);
+  }
+
+  /**
+   * 0 = invalid
+   * 1 = CEntity
+   * 2 = rage::volBase
+   * 3 = rage::volSphere
+   * 4 = rage::volBox
+   * 5 = rage::volAggregate
+   * 6 = rage::volCylinder
+   * 7 = CScriptedCoverPoint
+   * 8 = rage::ptfxScriptInfo
+   * 9 = CPed
+   * 10 = CVehicle
+   * 11 = CObject
+   * 12 = CItemSet
+   * 13 = CPersistentCharacter
+   *
+   * @param handle 
+   * @returns
+   */
+  static getItemType(handle: number): number {
+    return inv<number>('0xDC8D2FF478DF9553', handle, rai());
+  }
+
+  /**
+   * Possible flag names:
+   * ALL_BASE = 0,
+   * PROJECTILES = 1,
+   * BROADCAST = 524288,
+   * AMBIENT_POPULATION = 1048576
+   *
+   * @param pos 
+   * @param radius 
+   * @param flag 
+   */
+  static clearArea(pos: Vector3, radius: number, flag: number): void {
+    inv<void>('0x3B882A96EA77D5B1', f(pos.x), f(pos.y), f(pos.z), f(radius), flag);
+  }
+
+  /**
+   * @param flag 
+   * @returns bitFlags
+   */
+  static clearBitFlag(flag: number): number {
+    const result = inv<number>('0xB909149F2BB5F6DA', pvi(), flag);
+    return result;
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   *
+   * @param p0 
+   */
+  static activityFeedActionStartWithCommandLineAdd(p0: string | null): void {
+    inv<void>('0x1694A053DFB61A34', p0);
+  }
+
+  /**
+   * @param ped 
+   * @param p1 
+   * @param p2 
+   * @param lootTableKey 
+   * @param p5 
+   * @returns p4
+   */
+  static lootTablesGetInfo(ped: Ped, p1: boolean, p2: boolean, lootTableKey: string | number, p5: any): number {
+    const result = inv<number>('0x48E4D50F87A96AA5', ped.handle, p1, p2, _h(lootTableKey), pvi(), p5);
+    return result;
+  }
+
+  /**
+   * @param volume 
+   * @returns
+   */
+  static doesPopMultiplierAreaExistForVolume(volume: Volume): any {
+    return inv<number>('0x39D6DACE323A20B6', volume.handle);
+  }
+
+  /**
+   * @param id 
+   * @param p1 
+   */
+  static removePopMultiplierArea(id: number, p1: boolean): void {
+    inv<void>('0x88CB484364EFB37A', id, p1);
+  }
+
+  /**
+   * @returns bitFlags
+   */
+  static isAnyBitFlagSet(): [any, number] {
+    const result = inv<[number, number]>('0x80E9C316EF84DD81', pvi());
+    return [result[0], result[1]];
+  }
+
+  static N_0xDBDA48EC456ED908(): void {
+    inv<void>('0xDBDA48EC456ED908');
+  }
+
+  /**
+   * @returns
+   */
+  static N_0xF81C53561D15F330(): string | null {
+    return inv<string>('0xF81C53561D15F330', ras());
+  }
+
+  /**
+   * @param item 
+   * @returns
+   */
+  static getObjectFromIndexedItem(item: number): Prop | null {
+    return createFromHandle<Prop>('Prop', inv<number>('0x18013392501CE5DC', item, rai()));
+  }
+
+  /**
+   * @param stackSize 
+   * @returns
+   */
+  static getNumberOfFreeStacksOfThisSize(stackSize: number): number {
+    return inv<number>('0x40DC2907A9697EF7', stackSize, rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   */
+  static N_0x3A87FDA8F1B6CDFB(p0: any, p1: any, p2: any): void {
+    inv<void>('0x3A87FDA8F1B6CDFB', p0, p1, p2);
+  }
+
+  /**
+   * @param ped 
+   * @param weaponHash Refer to [enum: eWeaponHash]
+   * @param distance 
+   * @param p5 
+   * @param mustBeOwnedByThisPed 
+   * @returns outCoords; outProjectile
+   */
+  static getProjectileOfProjectileTypeWithinDistance(ped: Ped, weaponHash: eWeaponHash, distance: number, p5: boolean, mustBeOwnedByThisPed: boolean): [boolean, Vector3, Prop | null] {
+    const result = inv<[boolean, number[], number]>('0x9578986A6105A6AD', ped.handle, weaponHash, f(distance), pvv(), pvi(), p5, mustBeOwnedByThisPed, rai());
+    return [!!result[0], Vector3.fromArray(result[1]), createFromHandle<Prop>('Prop', result[2])];
+  }
+
+  /**
+   * @returns
+   */
+  static isMinigameInProgress(): boolean {
+    return inv<boolean>('0xF4D8BCD052E7EA1B', rai());
+  }
+
+  /**
+   * Old name: _GET_BENCHMARK_TIME
+   *
+   * @returns
+   */
+  static getSystemTimeStep(): number {
+    return inv<number>('0x3F3172FEAE3AFE1C', raf());
+  }
+
+  /**
+   * Returns a string in the following format: <<%.4f,%.4f,%.4f>>
+   *
+   * @param pos 
+   * @returns
+   */
+  static getStringFromVector(pos: Vector3): string | null {
+    return inv<string>('0x6C4DBF553885F9EB', f(pos.x), f(pos.y), f(pos.z), ras());
+  }
+
+  /**
+   * @param value 
+   * @returns
+   */
+  static absi(value: number): number {
+    return inv<number>('0x0C214D5B8A38C828', value, rai());
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   *
+   * @param p0 
+   */
+  static N_0xFF252E2BAFB7330F(p0: any): void {
+    inv<void>('0xFF252E2BAFB7330F', p0);
+  }
+
+  /**
+   * @returns
+   */
+  static isGameSessionStateMachineIdle(): any {
+    return inv<number>('0xF9E7DBB39080640B');
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0xAF3A84C7DE6A1DC5(p0: any, p1: any): void {
+    inv<void>('0xAF3A84C7DE6A1DC5', p0, p1);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0x7FA58CED69405F9A(p0: any, p1: any): void {
+    inv<void>('0x7FA58CED69405F9A', p0, p1);
+  }
+
+  static resetDispatchMinSpawnDistance(): void {
+    inv<void>('0x96498D922D8D0D0A');
+  }
+
+  /**
+   * @param volume 
+   * @returns
+   */
+  static addDispatchSpawnBlockingArea(volume: Volume): any {
+    return inv<number>('0xA2D5A26208421426', volume.handle);
+  }
+
+  /**
+   * https://github.com/femga/rdr3_discoveries/blob/master/weather/weather_variations.lua
+   *
+   * @param weatherType 
+   * @param variation 
+   */
+  static setWeatherVariation(weatherType: string | null, variation: string | null): void {
+    inv<void>('0x3373779BAF7CAF48', weatherType, variation);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x49C44FE78A135A1D(p0: any): void {
+    inv<void>('0x49C44FE78A135A1D', p0);
+  }
+
+  /**
+   * @param weatherType 
+   * @param p1 
+   */
+  static clearWeatherVariation(weatherType: string | null, p1: boolean): void {
+    inv<void>('0x0E71C80FA4EC8147', weatherType, p1);
+  }
+
+  /**
+   * Not officially named
+   * , Counts the number of segments in a string that are separated by specified delimiter characters, ignoring consecutive delimiters.
+   *
+   * @param inputString 
+   * @param delimiters 
+   * @returns
+   */
+  static stringSplitAndCountSegments(inputString: string | null, delimiters: string | null): any {
+    return inv<number>('0x94E8CA3DEE952789', inputString, delimiters);
+  }
+
+  /**
+   * @param id 
+   * @returns
+   */
+  static doesPopMultiplierAreaExist(id: number): boolean {
+    return inv<boolean>('0x03BA619C81A646B3', id, rai());
+  }
+
+  /**
+   * @param weatherType 
+   */
+  static N_0x2916B30DC6C41179(weatherType: string | number): void {
+    inv<void>('0x2916B30DC6C41179', _h(weatherType));
+  }
+
+  /**
+   * @param ped 
+   * @param weaponHash Refer to [enum: eWeaponHash]
+   * @param distance 
+   * @param p4 
+   * @param mustBeOwnedByThisPed 
+   * @returns outCoords
+   */
+  static getCoordsOfProjectileTypeWithinDistance(ped: Ped, weaponHash: eWeaponHash, distance: number, p4: boolean, mustBeOwnedByThisPed: boolean): [boolean, Vector3] {
+    const result = inv<[boolean, number[]]>('0xD73C960A681052DF', ped.handle, weaponHash, f(distance), pvv(), p4, mustBeOwnedByThisPed, rai());
+    return [!!result[0], Vector3.fromArray(result[1])];
+  }
+
+  /**
+   * Returns NULL unless UPDATE_ONSCREEN_KEYBOARD() returns 1 in the same tick.
+   *
+   * @returns
+   */
+  static getOnscreenKeyboardResult(): string | null {
+    return inv<string>('0xAFB4CF58A4A292B1', ras());
+  }
+
+  /**
+   * Old name: _SET_RAIN_LEVEL
+   *
+   * @param intensity 
+   */
+  static setRain(intensity: number): void {
+    inv<void>('0x193DFC0526830FD6', f(intensity));
+  }
+
+  /**
+   * @param weatherType 
+   */
+  static N_0xD3F943B88F55376A(weatherType: string | number): void {
+    inv<void>('0xD3F943B88F55376A', _h(weatherType));
+  }
+
+  /**
+   * @param dispatchService Refer to [enum: eDispatchType]
+   * @param pos 
+   * @param numUnits 
+   * @param radius 
+   * @param p7 
+   * @param p8 
+   * @returns outIncidentID
+   */
+  static createIncident(dispatchService: number, pos: Vector3, numUnits: number, radius: number, p7: any, p8: any): [boolean, number] {
+    const result = inv<[boolean, number]>('0x3F892CAF67444AE7', dispatchService, f(pos.x), f(pos.y), f(pos.z), numUnits, f(radius), pvi(), p7, p8, rai());
+    return [!!result[0], result[1]];
+  }
+
+  /**
+   * @param volume 
+   * @param p1 
+   */
+  static removePopMultiplierAreaForVolume(volume: Volume, p1: number): void {
+    inv<void>('0xBD090F5B1DB82189', volume.handle, p1);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @returns
+   */
+  static N_0x970339EFA4FDE518(p0: any, p1: any, p2: any): any {
+    return inv<number>('0x970339EFA4FDE518', p0, p1, p2);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @returns
+   */
+  static N_0x8DB104CCEBCD58C5(p0: any, p1: any): any {
+    return inv<number>('0x8DB104CCEBCD58C5', p0, p1);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0xAB26DEEE120FD3FD(p0: any, p1: any): void {
+    inv<void>('0xAB26DEEE120FD3FD', p0, p1);
+  }
+
+  static N_0xA3A8926951471C82(): void {
+    inv<void>('0xA3A8926951471C82');
+  }
+
+  /**
+   * Hardcoded to return false. Old name: _UI_IS_SINGLEPLAYER_PAUSE_MENU_ACTIVE
+   *
+   * @returns
+   */
+  static uiStartedEndUserBenchmark(): boolean {
+    return inv<boolean>('0x4FFA0386A6216113', rai());
+  }
+
+  /**
+   * @returns
+   */
+  static isMissionCreatorActive(): any {
+    return inv<number>('0xF236C84C6ADFCB2F');
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0xB1F6665AA54DCD5C(p0: string | number): any {
+    return inv<number>('0xB1F6665AA54DCD5C', _h(p0));
+  }
+
+  /**
+   * @param dispatchService Refer to [enum: eDispatchType]
+   * @param toggle 
+   */
+  static blockDispatchServiceResourceCreation(dispatchService: number, toggle: boolean): void {
+    inv<void>('0x66947E61A44DE2C6', dispatchService, toggle);
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   */
+  static stopCurrentLoadingProgressTimer(): void {
+    inv<void>('0xA565FAC215CBC77D');
+  }
+
+  /**
+   * @param pos 
+   * @returns groundZ; normal
+   */
+  static getGroundZAndNormalFor3dCoord(pos: Vector3): [boolean, number, Vector3] {
+    const result = inv<[boolean, number, number[]]>('0x2A29CA9A6319E6AB', f(pos.x), f(pos.y), f(pos.z), pvf(), pvv(), rai());
+    return [!!result[0], result[1], Vector3.fromArray(result[2])];
+  }
+
+  /**
+   * @returns
+   */
+  static getSystemTime(): number {
+    return inv<number>('0xBE7F225417E35A7C', rai());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x154340E87D8CC178(p0: any): void {
+    inv<void>('0x154340E87D8CC178', p0);
+  }
+
+  /**
+   * @returns args
+   */
+  static fireSingleBullet(): number {
+    const result = inv<number>('0xCBC9A21F6A2A679C', pvi());
+    return result;
+  }
+
+  /**
+   * @param item 
+   * @returns
+   */
+  static getPedFromIndexedItem(item: number): Ped | null {
+    return createFromHandle<Ped>('Ped', inv<number>('0x3FFB15534067DCD4', item, rai()));
+  }
+
+  /**
+   * @param value 
+   * @returns
+   */
+  static getStringFromBool(value: boolean): string | null {
+    return inv<string>('0xF216F74101968DB0', value, ras());
+  }
+
+  /**
+   * Appears to remove stealth kill action from memory (?)
+   *
+   * @param hash 
+   * @param enable 
+   */
+  static actionManagerEnableAction(hash: string | number, enable: boolean): void {
+    inv<void>('0x7ACF124C12A2B045', _h(hash), enable);
+  }
+
+  /**
+   * @param p0 
+   * @returns p1; p2
+   */
+  static scriptRaceGetPlayerSplitTime(p0: any): [boolean, number, number] {
+    const result = inv<[boolean, number, number]>('0x769E848C66E3C2BB', p0, pvi(), pvi(), rai());
+    return [!!result[0], result[1], result[2]];
+  }
+
+  /**
+   * @param variable 
+   * @param rangeStart 
+   * @param rangeEnd 
+   * @returns
+   */
+  static getBitsInRange(variable: number, rangeStart: number, rangeEnd: number): number {
+    return inv<number>('0x68E1352AF48F905D', variable, rangeStart, rangeEnd, rai());
+  }
+
+  /**
+   * @param item 
+   * @returns
+   */
+  static getVehicleFromIndexedItem(item: number): Vehicle | null {
+    return createFromHandle<Vehicle>('Vehicle', inv<number>('0xE578C8AE173719B3', item, rai()));
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @param p8 
+   * @returns
+   */
+  static isProjectileTypeInAngledArea(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: any, p8: boolean): boolean {
+    return inv<boolean>('0x928431F4133CD3D4', f(p0), f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), p7, p8, rai());
+  }
+
+  static N_0xFC6ECB9170145ECE(): void {
+    inv<void>('0xFC6ECB9170145ECE');
+  }
+
+  /**
+   * @param entity 
+   * @param p1 
+   * @param p2 
+   * @returns
+   */
+  static N_0x7A76104CC2CC69E8(entity: Entity, p1: number, p2: number): any {
+    return inv<number>('0x7A76104CC2CC69E8', entity.handle, p1, p2);
+  }
+
+  /**
+   * Returns false if it's a null or empty string or if the string is too long. outInteger will be set to -999 in that case.
+   *
+   * @param string 
+   * @returns outInteger
+   */
+  static stringToInt(string: string | null): [boolean, number] {
+    const result = inv<[boolean, number]>('0xF2DD2298B3AF23E2', string, pvi(), rai());
+    return [!!result[0], result[1]];
+  }
+
+  /**
+   * @param toggle 
+   */
+  static ignoreNextRestart(toggle: boolean): void {
+    inv<void>('0x6C9FF40FF1B69F8F', toggle);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x49F3241C28EBBFBC(p0: number): void {
+    inv<void>('0x49F3241C28EBBFBC', p0);
+  }
+
+  /**
+   * @param transitionMode 
+   * @returns
+   */
+  static gameFrameworkManagerInit(transitionMode: string | number): any {
+    return inv<number>('0x4CABE596D632E4B0', _h(transitionMode));
+  }
+
+  /**
+   * Not implemented.
+   *
+   * @param ped 
+   * @param p1 
+   */
+  static N_0xEB946B9E579729AD(ped: Ped, p1: any): void {
+    inv<void>('0xEB946B9E579729AD', ped.handle, p1);
+  }
+
+  /**
+   * Returns GET_GAME_TIMER() / 1000
+   * Only used in rcm_pearson1.ysc
+   *
+   * @returns
+   */
+  static getRealWorldTime(): number {
+    return inv<number>('0x2E036F0480B8BF02', rai());
+  }
+
+  /**
+   * Returns the current status of the onscreen keyboard, and updates the output. Status Codes: 0 - User still editing
+   * 1 - User has finished editing
+   * 2 - User has canceled editing
+   * 3 - Keyboard isn't active
+   *
+   * @returns
+   */
+  static updateOnscreenKeyboard(): number {
+    return inv<number>('0x37DF360F235A3893', rai());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x94FCADCF9F0C368E(p0: any): void {
+    inv<void>('0x94FCADCF9F0C368E', p0);
+  }
+
+  /**
+   * @param pos1 
+   * @param pos2 
+   * @returns
+   */
+  static getAngleBetween2dVectors(pos1: Vector2, pos2: Vector2): number {
+    return inv<number>('0xD0DFE1C486097BBB', f(pos1.x), f(pos1.y), f(pos2.x), f(pos2.y), raf());
+  }
+
+  /**
+   * disables composite Pick prompt
+   *
+   * @param compositeId 
+   * @param disable 
+   */
+  static disableCompositePickPromptThisFrame(compositeId: number, disable: boolean): void {
+    inv<void>('0x082C043C7AFC3747', compositeId, disable);
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @param p6 
+   * @param p7 
+   * @returns
+   */
+  static isBulletInAngledArea(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: boolean): boolean {
+    return inv<boolean>('0x9D09D8493747CF02', f(p0), f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), p7, rai());
+  }
+
+  static clearOverrideWeather(): void {
+    inv<void>('0x80A398F16FFE3CC3');
+  }
+
+  /**
+   * @param ped 
+   * @param toggle 
+   */
+  static setPedDecomposed(ped: Ped, toggle: boolean): void {
+    inv<void>('0x674B90BE1115846D', ped.handle, toggle);
+  }
+
+  /**
+   * @param str1 
+   * @param str2 
+   * @param matchCase 
+   * @param maxLength 
+   * @returns
+   */
+  static compareStrings(str1: string | null, str2: string | null, matchCase: boolean, maxLength: number): number {
+    return inv<number>('0xBFBB74A15EFC149B', str1, str2, matchCase, maxLength, rai());
+  }
+
+  /**
+   * Same as SHOULD_USE_METRIC_MEASUREMENTS
+   *
+   * @returns
+   */
+  static shouldUseMetricMeasurements2(): boolean {
+    return inv<boolean>('0x58BCDC75BA52110A', rai());
+  }
+
+  /**
+   * Hardcoded to return false.
+   * Checks for XBOXONE Game Build.
+   *
+   * @returns
+   */
+  static isDurangoVersion(): boolean {
+    return inv<boolean>('0xD1CCC2A2639D325F', rai());
+  }
+
+  /**
+   * @returns
+   */
+  static getRandomWeatherTypeIndex(): number {
+    return inv<number>('0x7F4CE164D9A11DFE', rai());
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x38C0C9CAE1544500(p0: string | number): void {
+    inv<void>('0x38C0C9CAE1544500', _h(p0));
+  }
+
+  /**
+   * @returns
+   */
+  static shouldUseMetricTemperature(): boolean {
+    return inv<boolean>('0xFF4AAF3275BAAB4F', rai());
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setCreditsActive(toggle: boolean): void {
+    inv<void>('0xD37BECF862DA726F', toggle);
+  }
+
+  /**
+   * Make sure to call this from the correct thread if you're using multiple threads because all other threads except the one which is calling SET_GAME_PAUSED will be paused.
+   *
+   * @param toggle 
+   */
+  static setGamePaused(toggle: boolean): void {
+    inv<void>('0xFAEC088D28B1DE4A', toggle);
+  }
+
+  /**
+   * @returns
+   */
+  static getNumberOfMicrosecondsSinceLastCall(): number {
+    return inv<number>('0xB0CE5E5ED8BB3581', rai());
+  }
+
+  static scriptRaceShutdown(): void {
+    inv<void>('0x334CE0DA4FAF330C');
+  }
+
+  /**
+   * @param string 
+   * @returns
+   */
+  static isStringNull(string: string | null): boolean {
+    return inv<boolean>('0x602102324604D96B', string, rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @returns
+   */
+  static isBulletInArea(p0: number, p1: number, p2: number, p3: number, p4: boolean): boolean {
+    return inv<boolean>('0xC652FD308772D79E', f(p0), f(p1), f(p2), f(p3), p4, rai());
+  }
+
+  /**
+   * Params: p3 is 0 in R* Script utopia2
+   *
+   * @param pos 
+   * @param p3 
+   */
+  static addTacticalNavMeshPoint(pos: Vector3, p3: number): void {
+    inv<void>('0xE4EE55E63FA9AF45', f(pos.x), f(pos.y), f(pos.z), p3);
+  }
+
+  /**
+   * *SET_DISPATCH**, unused
+   *
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   */
+  static N_0x6BCF7B5CD338281A(p0: any, p1: any, p2: any): void {
+    inv<void>('0x6BCF7B5CD338281A', p0, p1, p2);
+  }
+
+  /**
+   * p3 - possibly radius?
+   *
+   * @param pos 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @returns
+   */
+  static hasBulletImpactedInArea(pos: Vector3, p3: number, p4: boolean, p5: boolean): boolean {
+    return inv<boolean>('0xC153E5BCCF411814', f(pos.x), f(pos.y), f(pos.z), f(p3), p4, p5, rai());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @param p3 
+   * @param p4 
+   * @param p5 
+   * @returns
+   */
+  static isProjectileTypeWithinDistance(p0: number, p1: number, p2: number, p3: any, p4: number, p5: boolean): boolean {
+    return inv<boolean>('0xF51C9BAAD9ED64C4', f(p0), f(p1), f(p2), p3, f(p4), p5, rai());
+  }
+
+  /**
+   * @param pos1 
+   * @param pos2 
+   * @param damage 
+   * @param p7 
+   * @param weaponHash Refer to [enum: eWeaponHash]
+   * @param ownerPed 
+   * @param isAudible 
+   * @param isInvisible 
+   * @param speed 
+   * @param p13 
+   */
+  static shootSingleBulletBetweenCoords(pos1: Vector3, pos2: Vector3, damage: number, p7: boolean, weaponHash: eWeaponHash, ownerPed: Ped, isAudible: boolean, isInvisible: boolean, speed: number, p13: boolean): void {
+    inv<void>('0x867654CBC7606F2C', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), damage, p7, weaponHash, ownerPed.handle, isAudible, isInvisible, f(speed), p13);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0xDA4D8EB04E8E2928(p0: any): void {
+    inv<void>('0xDA4D8EB04E8E2928', p0);
+  }
+
+  /**
+   * @param hash 
+   * @returns
+   */
+  static actionManagerIsActionEnabled(hash: string | number): any {
+    return inv<number>('0xFD0759658268FD8E', _h(hash));
+  }
+
+  /**
+   * Begins with RESET_*. Next character in the name is either D or E. Old name: _RESET_BENCHMARK_RECORDING
+   */
+  static resetEndUserBenchmark(): void {
+    inv<void>('0xECBABD0307FB216F');
+  }
+
+  /**
+   * @param p1 
+   * @returns p0
+   */
+  static N_0x6BED40493A1AFDB8(p1: number): number {
+    const result = inv<number>('0x6BED40493A1AFDB8', pvi(), f(p1));
+    return result;
+  }
+
+  /**
+   * @param ped 
+   * @param item 
+   */
+  static setLootPeltSatchelItem(ped: Ped, item: any): void {
+    inv<void>('0x9B47971234169990', ped.handle, item);
+  }
+
+  /**
+   * @param toggle 
+   */
+  static setThisScriptCanBePaused(toggle: boolean): void {
+    inv<void>('0x3215376E79F6EA18', toggle);
+  }
+
+  /**
+   * Hardcoded to return false.
+   * Checks for PS4 Game Build.
+   *
+   * @returns
+   */
+  static isOrbisVersion(): boolean {
+    return inv<boolean>('0x88CFAE250D3E0C71', rai());
+  }
+
+  /**
+   * @returns
+   */
+  static getSnowLevel(): number {
+    return inv<number>('0x1E5D727041BE1709', raf());
+  }
+
+  /**
+   * @param value 
+   * @returns
+   */
+  static absf(value: number): number {
+    return inv<number>('0x134549B388167CBF', f(value), raf());
+  }
+
+  /**
+   * @param numCheckpoints 
+   * @param numLaps 
+   * @param numPlayers 
+   * @param p3 
+   */
+  static scriptRaceInit(numCheckpoints: number, numLaps: number, numPlayers: number, p3: any): void {
+    inv<void>('0x8AE059F47158417E', numCheckpoints, numLaps, numPlayers, p3);
+  }
+
+  /**
+   * p0 must be < 2
+   *
+   * @param p0 
+   * @returns
+   */
+  static queueSavegameOperation(p0: number): any {
+    return inv<number>('0x279B0696DA4657EB', p0);
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static atan(p0: number): number {
+    return inv<number>('0x503054DED0B78027', f(p0), raf());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   */
+  static N_0xDE2C3B74D2B3705C(p0: any, p1: any): void {
+    inv<void>('0xDE2C3B74D2B3705C', p0, p1);
+  }
+
+  /**
+   * Determines whether there is a projectile within the specified coordinates. The coordinates form a rectangle. ownedByPlayer = only projectiles fired by the player will be detected.
+   *
+   * @param pos1 
+   * @param pos2 
+   * @param ownedByPlayer 
+   * @returns
+   */
+  static isProjectileInArea(pos1: Vector3, pos2: Vector3, ownedByPlayer: boolean): boolean {
+    return inv<boolean>('0x05B0061EFDFC8941', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), ownedByPlayer, rai());
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static asin(p0: number): number {
+    return inv<number>('0x6E3C15D296C15583', f(p0), raf());
+  }
+
+  /**
+   * @param p0 
+   * @param p1 
+   * @param p2 
+   * @returns
+   */
+  static N_0x8314FC2013ECE2DA(p0: any, p1: any, p2: any): any {
+    return inv<number>('0x8314FC2013ECE2DA', p0, p1, p2);
+  }
+
+  /**
+   * @param index 
+   * @returns
+   */
+  static isGlobalBlockValid(index: number): any {
+    return inv<number>('0xACB7E1418A8B6E32', index);
+  }
+
+  /**
+   * @param p0 
+   */
+  static N_0x0A487CC74A517FB5(p0: any): void {
+    inv<void>('0x0A487CC74A517FB5', p0);
+  }
+
+  /**
+   * aiMemoryType: https://github.com/Halen84/RDR3-Native-Flags-And-Enums/tree/main/_CREATE_AI_MEMORY
+   *
+   * @param aiMemoryType 
+   * @returns args
+   */
+  static createAiMemory(aiMemoryType: number): number {
+    const result = inv<number>('0x88BC5F4AEF77FC4E', pvi(), aiMemoryType);
+    return result;
+  }
+
+  static N_0x243CEDE8F916B994(): void {
+    inv<void>('0x243CEDE8F916B994');
+  }
+
+  /**
+   * Returns whether the game's measurement system is set to metric.
+   *
+   * @returns
+   */
+  static shouldUseMetricMeasurements(): boolean {
+    return inv<boolean>('0x4FB556ACEFA93098', rai());
+  }
+
+  /**
+   * @param toggle 
+   */
+  static pauseDeathArrestRestart(toggle: boolean): void {
+    inv<void>('0x66AB6B6C7E72F393', toggle);
+  }
+
+  /**
+   * @param incidentId 
+   */
+  static setIncidentUnk(incidentId: number): void {
+    inv<void>('0x9617B6E5F6537B63', incidentId);
+  }
+
+  /**
+   * @returns
+   */
+  static shouldUse24HourClock(): boolean {
+    return inv<boolean>('0x0177CF20345F44DD', rai());
+  }
+
+  /**
+   * @param dispatchService Refer to [enum: eDispatchType]
+   * @param toggle 
+   */
+  static enableDispatchService(dispatchService: number, toggle: boolean): void {
+    inv<void>('0x50E52637EF70EF77', dispatchService, toggle);
+  }
+
+  /**
+   * Similar to SET_BIT but specifically designed for large (>32 flags) bit flag sets.
+   * The flags are stored in an int array where each int has the ability to hold 32 flags.
+   * Flags 0-31 would be stored in the first int, flags 32-63 in the second int, etc.
+   *
+   * @param flag 
+   * @returns bitFlags
+   */
+  static setBitFlag(flag: number): number {
+    const result = inv<number>('0xE84AAC1B22A73E99', pvi(), flag);
+    return result;
+  }
+
+  /**
+   * Saves the benchmark recording to %USERPROFILE%\Documents\Rockstar Games\Red Dead Redemption 2\Benchmarks and submits some metrics. Old name: _SAVE_BENCHMARK_RECORDING
+   */
+  static saveEndUserBenchmark(): void {
+    inv<void>('0xF4743E2ECC02B3DA');
+  }
+
+  /**
+   * magdemo = magazine demo, i. e. for magazines such as IGN, pre play phases to prepare articles etc. - example 2012 builds for V
+   * Hardcoded to return false.
+   *
+   * @returns
+   */
+  static isMagDemo1Active(): any {
+    return inv<number>('0x5FC9357C26DAEFCE');
+  }
+
+  static resetWantedResponseNumPedsToSpawn(): void {
+    inv<void>('0xEF42F56F69877125');
+  }
+
+  /**
+   * Returns value of the '-benchmarkPass' command line option. Old name: _GET_BENCHMARK_PASS_FROM_COMMAND_LINE
+   *
+   * @returns
+   */
+  static getBenchmarkPass(): number {
+    return inv<number>('0x9297DACF3A2CDFF7', rai());
+  }
+
+  /**
+   * nullsub, doesn't do anything
+   *
+   * @param p0 
+   * @param p1 
+   */
+  static activityFeedCreate(p0: string | null, p1: string | null): void {
+    inv<void>('0xCC7FC854B956A128', p0, p1);
+  }
+
+  /**
+   * Cheats are GTA IV cheats: 0 = unknown
+   * 1 = unknown (same as 0)
+   * 2 = Max Health and Armor
+   * 3 = Raise Wanted Level
+   * 4 = Lower Wanted Level
+   * 5 = unknown (does nothing)
+   * 6 = Change Weather
+   * 7 = Spawn Annihilator
+   * 8 = Spawn NRG 900
+   * 9 = Spawn FBI
+   * 10 = Spawn Jetmax
+   * 11 = Spawn Comet
+   * 12 = Spawn Turismo
+   * 13 = Spawn Cognoscenti
+   * 14 = Spawn Super GT
+   * 15 = Spawn Sanchez Initially used in Max Payne 3, that's why we know the name.
+   *
+   * @param cheatId 
+   */
+  static setCheatActive(cheatId: number): void {
+    inv<void>('0xD4958E8CF0DE0DD0', cheatId);
+  }
+
+  /**
+   * Note: The first bit in 'flags' must not be set.
+   * It is also required to pass at least one extra argument (this must be a text label string or hash).
+   * When passing a hash, flags should be 0.
+   *
+   * @param flags 
+   * @param ...args 
+   * @returns
+   */
+  static varString(flags: number, ...args: any[]): number {
+    return inv<number>('0xFA925AC00EB830B9', flags, ...args, rai());
+  }
+
+  static resetScriptTimeWithinFrame(): void {
+    inv<void>('0x1411A7CBC3A6EB7B');
+  }
+
+  /**
+   * @param item 
+   * @returns
+   */
+  static getEntityFromItem(item: number): Entity | null {
+    return createFromHandle<Entity>('Entity', inv<number>('0xEE04C0AFD4EFAF0E', item, rai()));
+  }
+
+  /**
+   * @param handle 
+   * @returns
+   */
+  static isBaseAPersistentCharacter(handle: number): any {
+    return inv<number>('0x716F17F8A0419F95', handle);
+  }
+
+  /**
+   * @returns
+   */
+  static getPrevWeatherTypeHashName(): string | number {
+    return (inv<number>('0x4BEB42AEBCA732E9', rai())) & 0xFFFFFFFF;
+  }
+
+  /**
+   * @param p0 
+   * @returns
+   */
+  static N_0x627B68D9CE6EE8DE(p0: any): any {
+    return inv<number>('0x627B68D9CE6EE8DE', p0);
+  }
+
+  /**
+   * @returns
+   */
+  static getNumberOfInstructions(): number {
+    return inv<number>('0x72904D3D62AF5839', rai());
+  }
+
+  /**
+   * @param pos1 
+   * @param pos2 
+   * @param pedDensity 
+   * @param trafficDensity 
+   * @param p8 
+   * @param p9 
+   * @returns
+   */
+  static addPopMultiplierArea(pos1: Vector3, pos2: Vector3, pedDensity: number, trafficDensity: number, p8: boolean, p9: boolean): number {
+    return inv<number>('0x5EBDA1A3B8CB5EF7', f(pos1.x), f(pos1.y), f(pos1.z), f(pos2.x), f(pos2.y), f(pos2.z), f(pedDensity), f(trafficDensity), p8, p9, rai());
+  }
+
+  /**
+   * @param rangeStart 
+   * @param rangeEnd 
+   * @param p3 
+   * @returns var
+   */
+  static setBitsInRange(rangeStart: number, rangeEnd: number, p3: number): number {
+    const result = inv<number>('0x324DC1CEF57F31E6', pvi(), rangeStart, rangeEnd, p3);
+    return result;
+  }
+
+}