@infernus/core 0.9.8 → 0.10.0-beta.6

package/dist/bundle.d.ts

@@ -1,9 +1,9 @@
-import * as _infernus_wrapper from '@infernus/wrapper';
-import { GangZonePos } from '@infernus/wrapper';
-export { GangZonePos, IActorAnimation, IActorSpawn, IAttachedData, IAttachedObject, IBounds, ICheckPoint, IMaterial, IMaterialText, IObjectPos, IObjectRotPos, IOffsets, IPlayerClass, IQuat, IRaceCheckPoint, ITextDrawCommonSize, ITextDrawRot, IVehColor, IVehMatrix, IVehSpawnInfo } from '@infernus/wrapper';
 import * as _infernus_streamer from '@infernus/streamer';
 import { StreamerItemTypes, StreamerAreaTypes, MapIconStyles } from '@infernus/streamer';
 export { E_STREAMER, MapIconStyles, MaterialTextSizes, StreamerAreaTypes, StreamerArrayData, StreamerDistances, StreamerItemTypeTuple, StreamerItemTypes, StreamerMiscellaneous, StreamerObjectTypes } from '@infernus/streamer';
+import * as w from '@infernus/wrapper';
+import { GangZonePos } from '@infernus/wrapper';
+export { GangZonePos, IActorAnimation, IActorSpawn, IAttachedData, IAttachedObject, IBounds, ICheckPoint, IMaterial, IMaterialText, IObjectPos, IObjectRotPos, IOffsets, IPlayerClass, IQuat, IRaceCheckPoint, ITextDrawCommonSize, ITextDrawRot, IVehColor, IVehMatrix, IVehSpawnInfo } from '@infernus/wrapper';
 
 declare enum ArtworkEnum {
     DOWNLOAD_REQUEST_EMPTY = 0,
@@ -410,17 +410,32 @@ declare enum RecordTypesEnum {
     ONFOOT = 2
 }
 
+type CallbackRet = boolean | number | void;
+type PromisifyCallbackRet = CallbackRet | Promise<CallbackRet>;
+type Options<T extends object> = {
+    name: string;
+    defaultValue?: boolean;
+    identifier?: string;
+    isNative?: boolean;
+    beforeEach?: (...args: any[]) => Exclude<T, Array<any> | Function>;
+    afterEach?: (arg: T) => void;
+};
+declare function defineEvent<T extends object>(options: Options<T>): [(cb: (ret: T & {
+    next: () => CallbackRet;
+}) => PromisifyCallbackRet) => () => void, (...args: any[]) => number];
+
 declare class Vehicle {
-    private _id;
+    static readonly vehicles: Map<number, Vehicle>;
     private static createdCount;
     private readonly sourceInfo;
     private readonly isStatic;
+    private _id;
     get id(): number;
     constructor(veh: IVehicle, isStatic?: boolean);
     create(ignoreRange?: boolean): void;
     destroy(): void;
-    addComponent(componentid: number): number;
-    removeComponent(componentid: number): number;
+    addComponent(componentId: number): number;
+    removeComponent(componentId: number): number;
     getComponentInSlot(slot: CarModTypeEnum): number;
     static getComponentType(component: number): CarModTypeEnum;
     linkToInterior(interiorId: number): number;
@@ -437,7 +452,7 @@ declare class Vehicle {
     setZAngle(z_angle: number): number;
     setNumberPlate(numberplate: string): number;
     static getPoolSize(): number;
-    changeColours(colour1: string | number, colour2: string | number): number;
+    changeColors(color1: string | number, color2: string | number): number;
     setVelocity(X: number, Y: number, Z: number): number;
     getVelocity(): void | TPos;
     setAngularVelocity(X: number, Y: number, Z: number): number;
@@ -487,13 +502,13 @@ declare class Vehicle {
     getParamsSirenState(): number;
     setParamsForPlayer<P extends Player>(player: P, objective: boolean, doorslocked: boolean): number;
     isTrailerAttached(): boolean;
-    changePaintjob(paintjobid: 0 | 1 | 2): number;
+    changePaintjob(paintjobId: 0 | 1 | 2): number;
     attachTrailer<V extends Vehicle>(trailer: V): number;
     detachTrailer(): void;
     getTrailer<V extends Vehicle>(vehicles: Array<V>): V | undefined;
     isValid(): boolean;
     static isValid(id: number): boolean;
-    getMatrix(): _infernus_wrapper.IVehMatrix | undefined;
+    getMatrix(): w.IVehMatrix | undefined;
     getTrainSpeed(): number;
     getHydraReactorAngle(): number;
     getLandingGearState(): number;
@@ -501,7 +516,7 @@ declare class Vehicle {
     static getModelsUsed: () => number;
     getDriver<P extends Player>(players: Map<number, P>): P | undefined;
     getLastDriver<P extends Player>(players: Map<number, P>): P | undefined;
-    static getModelCount: (modelid: number) => number;
+    static getModelCount: (modelId: number) => number;
     isSirenEnabled(): boolean;
     toggleSirenEnabled(enabled: boolean): number;
     isDead(): boolean;
@@ -515,36 +530,103 @@ declare class Vehicle {
     getNumberPlate(): string;
     getInterior(): number;
     getPaintjob(): number;
-    getColours(): _infernus_wrapper.IVehColor | undefined;
-    setSpawnInfo(modelid: number, fX: number, fY: number, fZ: number, fAngle: number, colour1: string | number, colour2: string | number, respawntime?: number, interior?: number, ignoreRange?: boolean): number;
-    getSpawnInfo(): _infernus_wrapper.IVehSpawnInfo | undefined;
+    getColors(): w.IVehColor | undefined;
+    setSpawnInfo(modelId: number, fX: number, fY: number, fZ: number, fAngle: number, color1: string | number, color2: string | number, respawnTime?: number, interior?: number, ignoreRange?: boolean): number;
+    getSpawnInfo(): w.IVehSpawnInfo | undefined;
+    static getInstance(id: number): Vehicle | undefined;
+    static getInstances(): Vehicle[];
 }
 
-declare class VehicleEvent<P extends Player, V extends Vehicle> {
-    private readonly vehicles;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onDamageStatusUpdate?(vehicle: V, player: P): TCommonCallback;
-    onDeath?(vehicle: V, killer: P): TCommonCallback;
-    onMod?(player: P, vehicle: V, componentid: number): TCommonCallback;
-    onPaintjob?(player: P, vehicle: V, paintjobid: number): TCommonCallback;
-    onRespray?(player: P, vehicle: V, colour1: number, colour2: number): TCommonCallback;
-    onSirenStateChange?(player: P, vehicle: V, newstate: boolean): TCommonCallback;
-    onSpawn?(vehicle: V): TCommonCallback;
-    onStreamIn?(vehicle: V, forplayer: P): TCommonCallback;
-    onStreamOut?(vehicle: V, forplayer: P): TCommonCallback;
-    onPlayerEnter?(player: P, vehicle: V, isPassenger: boolean): TCommonCallback;
-    onPlayerExit?(player: P, vehicle: V): TCommonCallback;
-    onNpcEnter?(vehicle: V, seatid: number): TCommonCallback;
-    onNpcExit?(): TCommonCallback;
-    onTrailerUpdate?(player: P, vehicle: V): TCommonCallback;
-    findVehicleById(vehicleid: number): V | undefined;
-    private findPlayerById;
-    getVehiclesArr(): Array<V>;
-    getVehiclesMap(): Map<number, V>;
-}
+declare const VehicleEvent: Readonly<{
+    onDamageStatusUpdate: (cb: (ret: {
+        vehicle: Vehicle;
+        player: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onDeath: (cb: (ret: {
+        vehicle: Vehicle;
+        killer: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onMod: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+        componentId: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPaintjob: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+        paintjobId: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onRespray: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+        color: number[];
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onSirenStateChange: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+        state: boolean;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onSpawn: (cb: (ret: {
+        vehicle: Vehicle;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamIn: (cb: (ret: {
+        vehicle: Vehicle;
+        forPlayer: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        vehicle: Vehicle;
+        forPlayer: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerEnter: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+        isPassenger: boolean;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerExit: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onNpcEnter: (cb: (ret: {
+        vehicle: Vehicle;
+        seatId: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onNpcExit: (cb: (ret: object & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onTrailerUpdate: (cb: (ret: {
+        player: Player;
+        vehicle: Vehicle;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class DynamicMapIcon {
+    static readonly mapIcons: Map<number, DynamicMapIcon>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -554,19 +636,27 @@ declare class DynamicMapIcon {
     isValid(): boolean;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicMapIcon | undefined;
+    static getInstances(): DynamicMapIcon[];
 }
 
-declare class DynamicMapIconEvent<P extends Player, M extends DynamicMapIcon> {
-    private readonly mapIcons;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onStreamIn?(mapIcon: M, player: P): TCommonCallback;
-    onStreamOut?(mapIcon: M, player: P): TCommonCallback;
-    getMapIconsArr(): Array<M>;
-    getMapIconsMap(): Map<number, M>;
-}
+declare const DynamicMapIconEvent: Readonly<{
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: DynamicMapIcon;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: DynamicMapIcon;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class DynamicPickup {
+    static readonly pickups: Map<number, DynamicPickup>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -576,20 +666,33 @@ declare class DynamicPickup {
     isValid(): boolean;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicPickup | undefined;
+    static getInstances(): DynamicPickup[];
 }
 
-declare class DynamicPickupEvent<P extends Player, K extends DynamicPickup> {
-    private readonly pickups;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerPickUp?(player: P, pickup: K): TCommonCallback;
-    onStreamIn?(pickup: K, player: P): TCommonCallback;
-    onStreamOut?(pickup: K, player: P): TCommonCallback;
-    getPickupsArr(): Array<K>;
-    getPickupsMap(): Map<number, K>;
-}
+declare const DynamicPickupEvent: Readonly<{
+    onPlayerPickUp: (cb: (ret: {
+        player: Player;
+        pickup: DynamicPickup;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: DynamicPickup;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: DynamicPickup;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class DynamicCheckpoint {
+    static readonly checkpoints: Map<number, DynamicCheckpoint>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -603,21 +706,39 @@ declare class DynamicCheckpoint {
     static getPlayerVisible<P extends Player, C extends DynamicCheckpoint>(player: P, checkpoints: Map<number, C>): C | undefined;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicCheckpoint | undefined;
+    static getInstances(): DynamicCheckpoint[];
 }
 
-declare class DynamicCheckPointEvent<P extends Player, C extends DynamicCheckpoint> {
-    private readonly checkpoints;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerEnter?(player: P, checkpoint: C): TCommonCallback;
-    onPlayerLeave?(player: P, checkpoint: C): TCommonCallback;
-    onStreamIn?(checkpoint: C, player: P): TCommonCallback;
-    onStreamOut?(checkpoint: C, player: P): TCommonCallback;
-    getCheckPointsArr(): Array<C>;
-    getCheckPointsMap(): Map<number, C>;
-}
+declare const DynamicCheckPointEvent: Readonly<{
+    onPlayerEnter: (cb: (ret: {
+        player: Player;
+        pickup: DynamicCheckpoint;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerLeave: (cb: (ret: {
+        player: Player;
+        pickup: DynamicCheckpoint;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: DynamicCheckpoint;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: DynamicCheckpoint;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class DynamicRaceCP {
+    static readonly checkpoints: Map<number, DynamicRaceCP>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -631,21 +752,39 @@ declare class DynamicRaceCP {
     static getPlayerVisible<P extends Player, C extends DynamicRaceCP>(player: P, checkpoints: Map<number, C>): C | undefined;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicRaceCP | undefined;
+    static getInstances(): DynamicRaceCP[];
 }
 
-declare class DynamicRaceCPEvent<P extends Player, R extends DynamicRaceCP> {
-    private readonly raceCPs;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerEnter?(player: P, checkpoint: R): TCommonCallback;
-    onPlayerLeave?(player: P, checkpoint: R): TCommonCallback;
-    onStreamIn?(checkpoint: R, player: P): TCommonCallback;
-    onStreamOut?(checkpoint: R, player: P): TCommonCallback;
-    getRaceCPsArr(): Array<R>;
-    getRaceCPsMap(): Map<number, R>;
-}
+declare const DynamicRaceCPEvent: Readonly<{
+    onPlayerEnter: (cb: (ret: {
+        player: Player;
+        pickup: DynamicRaceCP;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerLeave: (cb: (ret: {
+        player: Player;
+        pickup: DynamicRaceCP;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: DynamicRaceCP;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: DynamicRaceCP;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class DynamicActor {
+    static readonly actors: Map<number, DynamicActor>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -655,7 +794,7 @@ declare class DynamicActor {
     isValid(): boolean;
     isStreamedIn<P extends Player>(forplayer: P): boolean;
     getVirtualWorld(): void | number;
-    setVirtualWorld(vworld: number): void | number;
+    setVirtualWorld(vWorld: number): void | number;
     applyAnimation(animLib: string, animName: string, loop?: boolean, lockX?: boolean, lockY?: boolean, freeze?: boolean): void | number;
     clearAnimations(): void | number;
     getFacingAngle(): void | number;
@@ -674,24 +813,40 @@ declare class DynamicActor {
     getPlayerCameraTarget<P extends Player, A extends DynamicActor>(player: P, actors: Map<number, A>): void | A;
     getSkin(): void | number;
     setSkin(model: number, ignoreRange?: boolean): void | number;
-    getSpawnInfo(): void | _infernus_wrapper.IActorSpawn;
-    getAnimation(): void | _infernus_wrapper.IActorAnimation;
+    getSpawnInfo(): void | w.IActorSpawn;
+    getAnimation(): void | w.IActorAnimation;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicActor | undefined;
+    static getInstances(): DynamicActor[];
 }
 
-declare class DynamicActorEvent<P extends Player, A extends DynamicActor> {
-    private readonly actors;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onStreamIn?(actor: A, player: P): TCommonCallback;
-    onStreamOut?(actor: A, player: P): TCommonCallback;
-    onPlayerGiveDamage?(player: P, actor: A, amount: number, weaponid: number, bodypart: BodyPartsEnum): TCommonCallback;
-    getActorsArr(): Array<A>;
-    getActorsMap(): Map<number, A>;
-}
+declare const DynamicActorEvent: Readonly<{
+    onStreamIn: (cb: (ret: {
+        actor: DynamicActor;
+        forPlayer: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        actor: DynamicActor;
+        forPlayer: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerGiveDamage: (cb: (ret: {
+        player: Player;
+        actor: DynamicActor;
+        amount: number;
+        weapon: WeaponEnum;
+        bodyPart: BodyPartsEnum;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class Dynamic3DTextLabel {
+    static readonly texts: Map<number, Dynamic3DTextLabel>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -699,42 +854,49 @@ declare class Dynamic3DTextLabel {
     create(): void | this;
     destroy(): void | this;
     isValid(): boolean;
-    getColour(): void | string | number;
+    getColor(): void | string | number;
     getCharset(): void | string;
     getText(): void | string;
-    updateText(colour: string | number, text: string, charset?: string | undefined): void | number;
+    updateText(color: string | number, text: string, charset?: string | undefined): void | number;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): Dynamic3DTextLabel | undefined;
+    static getInstances(): Dynamic3DTextLabel[];
 }
 
-declare class Dynamic3dTextLabelEvent<P extends Player, D extends Dynamic3DTextLabel> {
-    private readonly _3dTexts;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onStreamIn?(label: D, player: P): TCommonCallback;
-    onStreamOut?(label: D, player: P): TCommonCallback;
-    get3dTextLabelsArr(): Array<D>;
-    get3dTextLabelsMap(): Map<number, D>;
-}
+declare const Dynamic3DTextLabelEvent: Readonly<{
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: Dynamic3DTextLabel;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: Dynamic3DTextLabel;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class Streamer {
     private constructor();
     static getTickRate: () => number;
     static setTickRate: (rate?: number | undefined) => number;
-    static getPlayerTickRate<P extends Player>(player: P): number;
-    static setPlayerTickRate<P extends Player>(player: P, rate?: number): number;
+    static getPlayerTickRate(player: Player): number;
+    static setPlayerTickRate(player: Player, rate?: number): number;
     static toggleChunkStream: (toggle?: boolean | undefined) => number;
     static isToggleChunkStream: () => boolean;
-    static getChunkTickRate<P extends Player>(type: StreamerItemTypes, player?: number | P): number;
-    static setChunkTickRate<P extends Player>(type: StreamerItemTypes, rate: number, player?: number | P): number;
+    static getChunkTickRate(type: StreamerItemTypes, player?: number | Player): number;
+    static setChunkTickRate(type: StreamerItemTypes, rate: number, player?: number | Player): number;
     static getChunkSize: (type: StreamerItemTypes) => number;
     static setChunkSize: (type: StreamerItemTypes, size: number) => number;
     static getMaxItems: (type: StreamerItemTypes) => number;
     static setMaxItems: (type: StreamerItemTypes, items: number) => number;
-    static getVisibleItems<P extends Player>(type: StreamerItemTypes, player?: number | P): number;
-    static setVisibleItems<P extends Player>(type: StreamerItemTypes, items: number, player?: number | P): number;
-    static getRadiusMultiplier<P extends Player>(type: StreamerItemTypes, player?: number | P): number;
-    static setRadiusMultiplier<P extends Player>(type: StreamerItemTypes, multiplier: number, player?: number | P): number;
+    static getVisibleItems(type: StreamerItemTypes, player?: number | Player): number;
+    static setVisibleItems(type: StreamerItemTypes, items: number, player?: number | Player): number;
+    static getRadiusMultiplier(type: StreamerItemTypes, player?: number | Player): number;
+    static setRadiusMultiplier(type: StreamerItemTypes, multiplier: number, player?: number | Player): number;
     static getTypePriority: () => number | _infernus_streamer.StreamerItemTypeTuple;
     static setTypePriority: (types: _infernus_streamer.StreamerItemTypeTuple) => number;
     static getCellDistance: () => number;
@@ -751,28 +913,28 @@ declare class Streamer {
     static isToggleErrorCallback: () => boolean;
     static amxUnloadDestroyItems: (toggle: boolean) => number;
     static processActiveItems: () => number;
-    static toggleIdleUpdate<P extends Player>(player: P, toggle: boolean): number;
-    static isToggleIdleUpdate<P extends Player>(player: P): boolean;
-    static toggleCameraUpdate<P extends Player>(player: P, toggle: boolean): number;
-    static isToggleCameraUpdate<P extends Player>(player: P): boolean;
-    static toggleItemUpdate<P extends Player>(player: P, type: StreamerItemTypes, toggle: boolean): number;
-    static isToggleItemUpdate<P extends Player>(player: P, type: StreamerItemTypes): boolean;
+    static toggleIdleUpdate(player: Player, toggle: boolean): number;
+    static isToggleIdleUpdate(player: Player): boolean;
+    static toggleCameraUpdate(player: Player, toggle: boolean): number;
+    static isToggleCameraUpdate(player: Player): boolean;
+    static toggleItemUpdate(player: Player, type: StreamerItemTypes, toggle: boolean): number;
+    static isToggleItemUpdate(player: Player, type: StreamerItemTypes): boolean;
     static getLastUpdateTime(): number;
-    static update<P extends Player>(player: P, type?: StreamerItemTypes | -1): number;
-    static updateEx<P extends Player>(player: P, x: number, y: number, z: number, worldid?: number, interiorid?: number, type?: StreamerItemTypes | -1, compensatedtime?: number, freezeplayer?: boolean): number;
+    static update(player: Player, type?: StreamerItemTypes | -1): number;
+    static updateEx(player: Player, x: number, y: number, z: number, worldId?: number, interiorId?: number, type?: StreamerItemTypes | -1, compensatedTime?: number, freezePlayer?: boolean): number;
     static getDistanceToItem: (x: number, y: number, z: number, type: StreamerItemTypes, id: number, dimensions?: 2 | 3 | undefined) => number;
-    static toggleItem<P extends Player>(player: P, type: StreamerItemTypes, id: number, toggle: boolean): number;
-    static isToggleItem<P extends Player>(player: P, type: StreamerItemTypes, id: number): boolean;
-    static toggleAllItems<P extends Player>(player: P, type: StreamerItemTypes, toggle: boolean, exceptions?: number[]): number;
-    static getItemInternalID<P extends Player>(player: P, type: StreamerItemTypes, streamerid: number): number;
-    static getItemStreamerID<P extends Player>(player: P, type: StreamerItemTypes, internalid: number): number;
-    static isItemVisible<P extends Player>(player: P, type: StreamerItemTypes, id: number): boolean;
-    static destroyAllVisibleItems<P extends Player>(player: P, type: StreamerItemTypes, serverwide?: number): number;
-    static countVisibleItems<P extends Player>(player: P, type: StreamerItemTypes, serverwide?: number): number;
-    static destroyAllItems: (type: StreamerItemTypes, serverwide?: number | undefined) => number;
-    static countItems: (type: StreamerItemTypes, serverwide?: number | undefined) => number;
-    static getNearbyItems: (x: number, y: number, z: number, type: StreamerItemTypes, items: number[], maxitems?: number | undefined, range?: number | undefined, worldid?: number | undefined) => void;
-    static getAllVisibleItems<P extends Player>(player: P, type: StreamerItemTypes, items: number[]): void;
+    static toggleItem(player: Player, type: StreamerItemTypes, id: number, toggle: boolean): number;
+    static isToggleItem(player: Player, type: StreamerItemTypes, id: number): boolean;
+    static toggleAllItems(player: Player, type: StreamerItemTypes, toggle: boolean, exceptions?: number[]): number;
+    static getItemInternalID(player: Player, type: StreamerItemTypes, streamerId: number): number;
+    static getItemStreamerID(player: Player, type: StreamerItemTypes, internalId: number): number;
+    static isItemVisible(player: Player, type: StreamerItemTypes, id: number): boolean;
+    static destroyAllVisibleItems(player: Player, type: StreamerItemTypes, serverWide?: number): number;
+    static countVisibleItems(player: Player, type: StreamerItemTypes, serverWide?: number): number;
+    static destroyAllItems: (type: StreamerItemTypes, serverWide?: number | undefined) => number;
+    static countItems: (type: StreamerItemTypes, serverWide?: number | undefined) => number;
+    static getNearbyItems: (x: number, y: number, z: number, type: StreamerItemTypes, items: number[], maxItems?: number | undefined, range?: number | undefined, worldId?: number | undefined) => void;
+    static getAllVisibleItems(player: Player, type: StreamerItemTypes, items: number[]): void;
     static getItemPos: (type: StreamerItemTypes, id: number) => {
         x: number;
         y: number;
@@ -796,12 +958,15 @@ declare class Streamer {
     static removeArrayData: (type: StreamerItemTypes, id: number, data: _infernus_streamer.StreamerArrayData, value: number) => number;
     static getArrayDataLength: (type: StreamerItemTypes, id: number, data: _infernus_streamer.StreamerArrayData) => number;
     static getUpperBound: (type: StreamerItemTypes) => number;
-    static onItemStreamIn: (fn: (type: StreamerItemTypes, id: number, forplayerid: number) => number) => void;
-    static onItemStreamOut: (fn: (type: StreamerItemTypes, id: number, forplayerid: number) => number) => void;
-    static onPluginError: (fn: (error: string) => number) => void;
+    static onPluginError: (cb: (ret: {
+        error: string;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
 }
 
 declare class DynamicObject {
+    static readonly objects: Map<number, DynamicObject>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -826,50 +991,109 @@ declare class DynamicObject {
     stop(): void | number;
     isMoving(): boolean;
     attachCamera<P extends Player>(player: P): void | number;
-    attachToObject<O extends DynamicObject>(attachto: O, offsetx: number, offsety: number, offsetz: number, rx: number, ry: number, rz: number, syncrotation?: boolean): void | number;
-    attachToPlayer<P extends Player>(player: P, offsetx: number, offsety: number, offsetz: number, rx: number, ry: number, rz: number): void | number;
-    attachToVehicle<V extends Vehicle>(vehicle: V, offsetx: number, offsety: number, offsetz: number, rx: number, ry: number, rz: number): void | number;
+    attachToObject<O extends DynamicObject>(attachto: O, offsetX: number, offsetY: number, offsetZ: number, rx: number, ry: number, rz: number, syncRotation?: boolean): void | number;
+    attachToPlayer<P extends Player>(player: P, offsetX: number, offsetY: number, offsetZ: number, rx: number, ry: number, rz: number): void | number;
+    attachToVehicle<V extends Vehicle>(vehicle: V, offsetX: number, offsetY: number, offsetZ: number, rx: number, ry: number, rz: number): void | number;
     edit<P extends Player>(player: P): void | number;
     isMaterialUsed(materialIndex: number): boolean;
     removeMaterial(materialIndex: number): number;
-    getMaterial(materialIndex: number, txdname: string, texturename: string): void | {
-        modelid: number;
-        materialcolor: string | number;
+    getMaterial(materialIndex: number, txdName: string, textureName: string): void | {
+        modelId: number;
+        materialColor: string | number;
     };
-    setMaterial(materialindex: number, modelid: number, txdname: string, texturename: string, materialcolour?: string): void | number;
+    setMaterial(materialIndex: number, modelId: number, txdName: string, textureName: string, materialColor?: string): void | number;
     isMaterialTextUsed(materialIndex: number): boolean;
     removeMaterialText(materialIndex: number): number;
     getMaterialText(materialIndex: number): void | {
         text: string;
-        materialsize: number;
-        fontface: string;
+        materialSize: number;
+        fontFace: string;
         bold: number;
-        fontcolour: number;
-        backcolour: number;
-        textalignment: number;
+        fontColor: number;
+        backColor: number;
+        textAlignment: number;
     };
-    setMaterialText(charset: string | undefined, materialIndex: number, text: string, materialSize?: number, fontFace?: string, fontSize?: number, bold?: number, fontColour?: string, backColour?: string, textAlignment?: number): void | number;
+    setMaterialText(charset: string | undefined, materialIndex: number, text: string, materialSize?: number, fontFace?: string, fontSize?: number, bold?: number, fontColor?: string, backColor?: string, textAlignment?: number): void | number;
     getPlayerCameraTarget<P extends Player, O extends DynamicObject>(player: P, objMap: Map<number, O>): void | O;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicObject | undefined;
+    static getInstances(): DynamicObject[];
 }
 
-declare class DynamicObjectEvent<P extends Player, O extends DynamicObject> {
-    private readonly objects;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onMoved?(object: O): TCommonCallback;
-    onPlayerEdit?(player: P, object: O, response: EditResponseTypesEnum, x: number, y: number, z: number, rx: number, ry: number, rz: number): TCommonCallback;
-    onPlayerSelect?(player: P, object: O, modelid: number, x: number, y: number, z: number): TCommonCallback;
-    onPlayerShoot?(player: P, weaponid: number, object: O, x: number, y: number, z: number): TCommonCallback;
-    onPlayerEditAttached?(player: P, response: number, index: number, modelid: number, boneid: number, fOffsetX: number, fOffsetY: number, fOffsetZ: number, fRotX: number, fRotY: number, fRotZ: number, fScaleX: number, fScaleY: number, fScaleZ: number): TCommonCallback;
-    onStreamIn?(object: O, player: P): TCommonCallback;
-    onStreamOut?(object: O, player: P): TCommonCallback;
-    getObjectsArr(): Array<O>;
-    getObjectsMap(): Map<number, O>;
-}
+declare const DynamicObjectEvent: Readonly<{
+    onMoved: (cb: (ret: {
+        object: DynamicObject;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerEdit: (cb: (ret: {
+        player: Player;
+        object: DynamicObject;
+        response: number;
+        x: number;
+        y: number;
+        z: number;
+        rX: number;
+        rY: number;
+        rZ: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerSelect: (cb: (ret: {
+        player: Player;
+        object: DynamicObject;
+        modelId: number;
+        x: number;
+        y: number;
+        z: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerShoot: (cb: (ret: {
+        player: Player;
+        object: DynamicObject;
+        weapon: WeaponEnum;
+        x: number;
+        y: number;
+        z: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerEditAttached: (cb: (ret: {
+        player: Player;
+        response: number;
+        index: number;
+        modelId: number;
+        boneId: number;
+        fOffsetX: number;
+        fOffsetY: number;
+        fOffsetZ: number;
+        fRotX: number;
+        fRotY: number;
+        fRotZ: number;
+        fScaleX: number;
+        fScaleY: number;
+        fScaleZ: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: DynamicObject;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: DynamicObject;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class DynamicArea {
+    static readonly areas: Map<number, DynamicArea>;
     private sourceInfo;
     private _id;
     get type(): TDynamicAreaTypes;
@@ -895,49 +1119,60 @@ declare class DynamicArea {
     static getNumberForPoint(x: number, y: number, z: number): number;
     static getForLine<A extends DynamicArea>(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, areas: Map<number, A>): Array<A | undefined>;
     static getNumberForLine(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
-    attachToObject<O extends DynamicObject>(obj: O, offsetx?: number, offsety?: number, offsetz?: number): void | number;
-    attachToPlayer<P extends Player>(player: P, offsetx?: number, offsety?: number, offsetz?: number): void | number;
-    attachToVehicle<V extends Vehicle>(vehicle: V, offsetx?: number, offsety?: number, offsetz?: number): void | number;
+    attachToObject<O extends DynamicObject>(obj: O, offsetX?: number, offsetY?: number, offsetZ?: number): void | number;
+    attachToPlayer<P extends Player>(player: P, offsetX?: number, offsetY?: number, offsetZ?: number): void | number;
+    attachToVehicle<V extends Vehicle>(vehicle: V, offsetX?: number, offsetY?: number, offsetZ?: number): void | number;
     toggleSpectateMode(toggle: boolean): void | number;
     isToggleSpectateMode(): boolean;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicArea | undefined;
+    static getInstances(): DynamicArea[];
 }
 
-declare class DynamicAreaEvent<P extends Player, A extends DynamicArea> {
-    private readonly areas;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerEnter?(player: P, area: A): TCommonCallback;
-    onPlayerLeave?(player: P, area: A): TCommonCallback;
-    onStreamIn?(area: A, player: P): TCommonCallback;
-    onStreamOut?(area: A, player: P): TCommonCallback;
-    getAreasArr(): Array<A>;
-    getAreasMap(): Map<number, A>;
-}
+declare const DynamicAreaEvent: Readonly<{
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        instance: DynamicArea;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        instance: DynamicArea;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerEnter: (cb: (ret: {
+        player: Player;
+        pickup: DynamicArea;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerLeave: (cb: (ret: {
+        player: Player;
+        pickup: DynamicArea;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare class Player {
-    private _id;
-    private _isNpc;
-    private _locale;
-    private _charset;
-    private _isRecording;
+    readonly id: number;
+    static readonly players: Map<number, Player>;
+    charset: string;
+    locale: string;
     lastDrunkLevel: number;
     lastFps: number;
-    isPaused: boolean;
     lastUpdateTick: number;
-    get id(): number;
-    get locale(): string;
-    set locale(value: string);
-    get charset(): string;
-    set charset(value: string);
-    get isRecording(): boolean;
-    set isRecording(value: boolean);
+    lastUpdateFpsTick: number;
+    isPaused: boolean;
+    isRecording: boolean;
     constructor(id: number);
-    sendClientMessage(colour: string | number, msg: string): number;
-    static sendClientMessageToAll<P extends Player>(players: Array<P>, colour: string | number, msg: string): void;
-    sendPlayerMessage<P extends Player>(player: P, message: string): number;
-    sendPlayerMessageToAll<P extends Player>(players: Array<P>, message: string): number;
+    sendClientMessage(color: string | number, msg: string): number;
+    static sendClientMessageToAll(players: Array<Player>, color: string | number, msg: string): void;
+    sendPlayerMessage(player: Player, message: string): number;
+    sendPlayerMessageToAll(players: Array<Player>, message: string): number;
     isNpc(): boolean;
     getFps(): number;
     getDrunkLevel(): number;
@@ -948,10 +1183,10 @@ declare class Player {
     enableStuntBonus(enable: boolean): void;
     getInterior(): number;
     setInterior(interiorId: number): number;
-    showPlayerNameTag<P extends Player>(showPlayer: P, show: boolean): void;
-    setColor(colour: string | number): void;
+    showPlayerNameTag(showPlayer: Player, show: boolean): void;
+    setColor(color: string | number): void;
     getColor(): number;
-    setPlayerMarker<P extends Player>(showPlayer: P, colour: string | number): void;
+    setPlayerMarker(showPlayer: Player, color: string | number): void;
     resetMoney(): number;
     getMoney(): number;
     giveMoney(money: number): number;
@@ -962,7 +1197,7 @@ declare class Player {
     toggleClock(toggle: boolean): number;
     toggleControllable(toggle: boolean): number;
     toggleSpectating(toggle: boolean): number;
-    spectatePlayer<P extends Player>(targetPlayer: P, mode?: SpectateModesEnum): number;
+    spectatePlayer(targetPlayer: Player, mode?: SpectateModesEnum): number;
     spectateVehicle<V extends Vehicle>(targetVehicle: V, mode?: SpectateModesEnum): number;
     forceClassSelection(): void;
     kick(): void;
@@ -970,7 +1205,7 @@ declare class Player {
     banEx(reason: string, charset: string): void;
     isAdmin(): boolean;
     isInRangeOfPoint(range: number, x: number, y: number, z: number): boolean;
-    isStreamedIn<P extends Player>(forplayer: P): boolean;
+    isStreamedIn(forplayer: Player): boolean;
     setSkin(skinId: number, ignoreRange?: boolean): number;
     getSkin(): number;
     isInAnyVehicle(): boolean;
@@ -999,7 +1234,7 @@ declare class Player {
         hour: number;
         minute: number;
     };
-    removeBuilding(modelid: number, fX: number, fY: number, fZ: number, fRadius: number): void;
+    removeBuilding(modelId: number, fX: number, fY: number, fZ: number, fRadius: number): void;
     setTeam(team: number): void;
     getTeam(): number;
     setSkillLevel(skill: WeaponSkillsEnum, level: number): void;
@@ -1024,7 +1259,7 @@ declare class Player {
     getCameraFrontVector(): TPos;
     getCameraMode(): CameraModesEnum;
     getCameraPos(): TPos;
-    getCameraTargetPlayer<P extends Player>(players: Array<P>): P | undefined;
+    getCameraTargetPlayer(players: Array<Player>): Player | undefined;
     getCameraTargetVehicle<V extends Vehicle>(vehicles: Array<V>): V | undefined;
     getCameraZoom(): number;
     playAudioStream(url: string, posX?: number, posY?: number, posZ?: number, distance?: number): number;
@@ -1032,7 +1267,7 @@ declare class Player {
     playSound(soundid: number, relativeX?: number, relativeY?: number, relativeZ?: number): number;
     static getPoolSize(): number;
     static getMaxPlayers(): number;
-    playCrimeReport<P extends Player>(suspect: P, crimeId: number): number;
+    playCrimeReport(suspect: Player, crimeId: number): number;
     interpolateCameraPos(FromX: number, FromY: number, FromZ: number, ToX: number, ToY: number, ToZ: number, time: number, cut?: CameraCutStylesEnum): void;
     interpolateCameraLookAt(FromX: number, FromY: number, FromZ: number, ToX: number, ToY: number, ToZ: number, time: number, cut?: CameraCutStylesEnum): void;
     createExplosion(X: number, Y: number, Z: number, type: number, Radius: number): number;
@@ -1052,10 +1287,10 @@ declare class Player {
     setShopName(shopName: string): void;
     setPosFindZ(x: number, y: number, z?: number): Promise<number>;
     setWorldBounds(x_max: number, x_min: number, y_max: number, y_min: number): void;
-    setChatBubble(text: string, colour: string | number, drawDistance: number, expireTime: number): void;
+    setChatBubble(text: string, color: string | number, drawDistance: number, expireTime: number): void;
     getDistanceFromPoint(X: number, Y: number, Z: number): number;
     getCustomSkin(): number;
-    getTargetPlayer<P extends Player>(players: Array<P>): undefined | P;
+    getTargetPlayer(players: Array<Player>): undefined | Player;
     getLastShotVectors(): {
         fOriginX: number;
         fOriginY: number;
@@ -1070,33 +1305,33 @@ declare class Player {
         ammo: number;
     } | undefined;
     getWeaponState(): WeaponStatesEnum;
-    giveWeapon(weaponid: WeaponEnum, ammo: number): number;
-    setAmmo(weaponid: number, ammo: number): number;
+    giveWeapon(weaponId: WeaponEnum, ammo: number): number;
+    setAmmo(weaponId: number, ammo: number): number;
     getAmmo(): number;
-    setArmedWeapon(weaponid: number): number;
+    setArmedWeapon(weaponId: number): number;
     clearDeathMessage(): void;
-    sendDeathMessage<P extends Player>(killer: P | InvalidEnum.PLAYER_ID, weapon: WeaponEnum | DamageDeathReasonEnum): void;
-    sendDeathMessageToPlayer<P extends Player>(killer: P | InvalidEnum.PLAYER_ID, killee: P | InvalidEnum.PLAYER_ID, weapon: WeaponEnum | DamageDeathReasonEnum): void;
+    sendDeathMessage(killer: Player | InvalidEnum.PLAYER_ID, weapon: WeaponEnum | DamageDeathReasonEnum): void;
+    sendDeathMessageToPlayer(killer: Player | InvalidEnum.PLAYER_ID, killee: Player | InvalidEnum.PLAYER_ID, weapon: WeaponEnum | DamageDeathReasonEnum): void;
     setSpawnInfo(team: number, skin: number, x: number, y: number, z: number, rotation: number, weapon1: WeaponEnum, weapon1_ammo: number, weapon2: WeaponEnum, weapon2_ammo: number, weapon3: WeaponEnum, weapon3_ammo: number): void;
     redirectDownload(url: string): number;
     sendClientCheck(type: number, memAddr: number, memOffset: number, byteCount: number): void | Promise<IClientResRaw>;
-    selectTextDraw(colour: string | number): void;
+    selectTextDraw(color: string | number): void;
     cancelSelectTextDraw(): void;
     beginObjectSelecting(): void;
     endObjectEditing(): void;
-    getSurfingObject<O extends DynamicObject>(objects: Map<number, O>): void | O;
-    getSurfingPlayerObject<O extends DynamicObject>(objects: Map<number, O>): void | O;
+    getSurfingObject(objects: Map<number, DynamicObject>): void | DynamicObject;
+    getSurfingPlayerObject(objects: Map<number, DynamicObject>): void | DynamicObject;
     isAttachedObjectSlotUsed(index: number): boolean;
-    setAttachedObject(index: number, modelid: number, bone: BoneIdsEnum, fOffsetX: number, fOffsetY: number, fOffsetZ: number, fRotX: number, fRotY: number, fRotZ: number, fScaleX: number, fScaleY: number, fScaleZ: number, materialcolour1: string | number, materialcolour2: string | number): void | number;
+    setAttachedObject(index: number, modelId: number, bone: BoneIdsEnum, fOffsetX: number, fOffsetY: number, fOffsetZ: number, fRotX: number, fRotY: number, fRotZ: number, fScaleX: number, fScaleY: number, fScaleZ: number, materialColor1: string | number, materialColor2: string | number): void | number;
     removeAttachedObject(index: number): number;
     toggleWidescreen(set: boolean): number;
     isPlayerWidescreenToggled(): boolean;
-    getSpawnInfo(): _infernus_wrapper.IPlayerClass;
+    getSpawnInfo(): w.IPlayerClass;
     getSkillLevel(skill: WeaponSkillsEnum): number;
     isCheckpointActive(): boolean;
-    getCheckpoint(): _infernus_wrapper.ICheckPoint;
+    getCheckpoint(): w.ICheckPoint;
     isRaceCheckpointActive(): boolean;
-    getRaceCheckpoint(): _infernus_wrapper.IRaceCheckPoint;
+    getRaceCheckpoint(): w.IRaceCheckPoint;
     getWorldBounds(): void;
     isInModShop(): boolean;
     getSirenState(): number;
@@ -1104,8 +1339,8 @@ declare class Player {
     getHydraReactorAngle(): number;
     getTrainSpeed(): number;
     getZAim(): number;
-    getSurfingOffsets(): _infernus_wrapper.IOffsets;
-    getRotationQuat(): _infernus_wrapper.IQuat;
+    getSurfingOffsets(): w.IOffsets;
+    getRotationQuat(): w.IQuat;
     getDialogID(): number;
     getSpectateID(): number;
     getSpectateType(): SpectateModesEnum;
@@ -1119,53 +1354,252 @@ declare class Player {
     toggleGhostMode(toggle: boolean): number;
     getGhostMode(): boolean;
     getBuildingsRemoved(): number;
-    getAttachedObject(index: number): _infernus_wrapper.IAttachedObject;
-    removeWeapon(weaponid: number): number;
+    getAttachedObject(index: number): w.IAttachedObject;
+    removeWeapon(weaponId: number): number;
     isUsingOfficialClient(): boolean;
     allowWeapons(allow: boolean): boolean;
     areWeaponsAllowed(): boolean;
     gpci(charset?: string): string;
+    static getInstance(id: number): Player | undefined;
+    static getInstances(): Player[];
 }
 
-declare class PlayerEvent<P extends Player> {
-    private readonly players;
-    private static cmdBus;
-    constructor(newPlayerFn: (id: number) => P);
-    findPlayerById(playerid: number): P | undefined;
-    getPlayersArr(): Array<P>;
-    getPlayersMap(): Map<number, P>;
-    readonly throttleUpdate: any;
-    private static fpsHeartbeat;
-    readonly onCommandText: (name: TEventName, fn: TEventFunc<this, P> | TEventFunc<this, P>[]) => (() => void);
-    readonly offCommandText: (name: TEventName, fn: TEventFunc<this, P> | TEventFunc<this, P>[]) => void;
-    private promiseCommand;
-    onConnect?(player: P): TCommonCallback;
-    onDisconnect?(player: P, reason: number): TCommonCallback;
-    onText?(player: P, text: string): TCommonCallback;
-    onCommandReceived?(player: P, command: string): TCommonCallback;
-    onCommandPerformed?(player: P, command: string): TCommonCallback;
-    onCommandError?(player: P, command: string, err: ICmdErr): TCommonCallback;
-    onEnterExitModShop?(player: P, enterexit: number, interiorid: number): TCommonCallback;
-    onClickMap?(player: P, fX: number, fY: number, fZ: number): TCommonCallback;
-    onClickPlayer?(player: P, clickedPlayer: P, source: number): TCommonCallback;
-    onDeath?(player: P, killer: P | InvalidEnum.PLAYER_ID, reason: number): TCommonCallback;
-    onGiveDamage?(player: P, damage: P, amount: number, weaponid: WeaponEnum, bodypart: BodyPartsEnum): TCommonCallback;
-    onKeyStateChange?(player: P, newkeys: KeysEnum, oldkeys: KeysEnum): TCommonCallback;
-    onRequestClass?(player: P, classid: number): TCommonCallback;
-    onRequestSpawn?(player: P): TCommonCallback;
-    onSpawn?(player: P): TCommonCallback;
-    onStateChange?(player: P, newstate: PlayerStateEnum, oldstate: PlayerStateEnum): TCommonCallback;
-    onStreamIn?(player: P, forPlayer: P): TCommonCallback;
-    onStreamOut?(player: P, forPlayer: P): TCommonCallback;
-    onTakeDamage?(player: P, damage: P | InvalidEnum.PLAYER_ID, amount: number, weaponid: WeaponEnum, bodypart: BodyPartsEnum): TCommonCallback;
-    onUpdate?(player: P): TCommonCallback;
-    onInteriorChange?(player: P, newinteriorid: number, oldinteriorid: number): TCommonCallback;
-    onPause?(player: P, timestamp: number): TCommonCallback;
-    onResume?(player: P, pauseMs: number): TCommonCallback;
-    onRequestDownload?(player: P, type: number, crc: number): TCommonCallback;
-    onFinishedDownloading?(player: P, virtualworld: number): TCommonCallback;
+type CmdBusCallback = {
+    player: Player;
+    subcommand: string[];
+    next: () => CallbackRet;
+};
+declare const CommandErrors: {
+    NOT_EXIST: {
+        code: number;
+        msg: string;
+    };
+    REJECTED: {
+        code: number;
+        msg: string;
+    };
+    PERFORMED: {
+        code: number;
+        msg: string;
+    };
+};
+
+/**
+ * You don't need to care about the dialog id.
+ * If you need to change the value dynamically, you should do it by setter method.
+ */
+declare class Dialog {
+    private id;
+    private static showingIds;
+    private static max_dialogId;
+    private dialog;
+    static waitingQueue: Map<Player, IDialogFuncQueue>;
+    constructor(dialog?: IDialog);
+    get style(): DialogStylesEnum | undefined;
+    set style(v: DialogStylesEnum | undefined);
+    get caption(): string | undefined;
+    set caption(v: string | undefined);
+    get info(): string | undefined;
+    set info(v: string | undefined);
+    get button1(): string | undefined;
+    set button1(v: string | undefined);
+    get button2(): string | undefined;
+    set button2(v: string | undefined);
+    private static delDialogTask;
+    show(player: Player): Promise<IDialogResResult>;
+    static close(player: Player): void;
 }
 
+declare const PlayerEvent: Readonly<{
+    onConnect: (cb: (ret: {
+        player: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onDisconnect: (cb: (ret: {
+        player: Player;
+        reason: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPause: (cb: (ret: {
+        player: Player;
+        pausedAt: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onResume: (cb: (ret: {
+        player: Player;
+        pausedAt: number;
+        now: number;
+        diff: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onUpdate: (cb: (ret: {
+        player: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onText: (cb: (ret: {
+        player: Player;
+        text: string;
+        buffer: number[];
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onEnterExitModShop: (cb: (ret: {
+        player: Player;
+        enterExit: boolean;
+        interior: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onClickMap: (cb: (ret: {
+        player: Player;
+        fX: number;
+        fY: number;
+        fZ: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onClickPlayer: (cb: (ret: {
+        player: Player;
+        clickedPlayer: Player;
+        source: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onDeath: (cb: (ret: {
+        player: Player;
+        killer: Player | InvalidEnum;
+        reason: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onGiveDamage: (cb: (ret: {
+        player: Player;
+        damage: Player;
+        amount: number;
+        weapon: WeaponEnum;
+        bodyPart: BodyPartsEnum;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onKeyStateChange: (cb: (ret: {
+        player: Player;
+        newKeys: KeysEnum;
+        oldKeys: KeysEnum;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onRequestClass: (cb: (ret: {
+        player: Player;
+        classId: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onRequestSpawn: (cb: (ret: {
+        player: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onSpawn: (cb: (ret: {
+        player: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStateChange: (cb: (ret: {
+        player: Player;
+        newState: PlayerStateEnum;
+        oldState: PlayerStateEnum;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamIn: (cb: (ret: {
+        player: Player;
+        forPlayer: Player | undefined;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onStreamOut: (cb: (ret: {
+        player: Player;
+        forPlayer: Player | undefined;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onTakeDamage: (cb: (ret: {
+        player: Player;
+        damage: Player | InvalidEnum;
+        amount: number;
+        weapon: WeaponEnum;
+        bodyPart: BodyPartsEnum;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onInteriorChange: (cb: (ret: {
+        player: Player;
+        newInteriorId: number;
+        oldInteriorId: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onRequestDownload: (cb: (ret: {
+        player: Player;
+        type: number;
+        crc: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onFinishedDownloading: (cb: (ret: {
+        player: Player;
+        virtualWorld: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onCheckResponse: (cb: (ret: {
+        player: Player;
+        actionId: number;
+        memAddr: number;
+        data: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onCommandReceived: (cb: (ret: {
+        player: Player;
+        command: string;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onCommandPerformed: (cb: (ret: {
+        player: Player;
+        command: string;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onCommandError: (cb: (ret: {
+        player: Player;
+        command: string;
+        error: {
+            code: number;
+            msg: string;
+        };
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onCommandText: (command: string | string[], cb: (ret: CmdBusCallback) => PromisifyCallbackRet) => () => void;
+    offCommandText: (command: string | string[]) => void;
+    onDialogResponse: (cb: (ret: {
+        player: Player;
+        dialogId: number;
+        response: number;
+        listItem: number;
+        buffer: number[];
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
+
 interface IDialog {
     style?: DialogStylesEnum;
     caption?: string;
@@ -1175,46 +1609,41 @@ interface IDialog {
 }
 interface IDialogResCommon {
     response: number;
-    listitem: number;
+    listItem: number;
 }
 interface IDialogResRaw extends IDialogResCommon {
-    inputbuf: number[];
+    buffer: number[];
 }
 interface IDialogResResult extends IDialogResCommon {
-    inputtext: string;
-}
-interface ICmdErr {
-    code: number;
-    msg: string;
+    inputText: string;
 }
 interface IVehicle {
-    modelid: number;
+    modelId: number;
     x: number;
     y: number;
     z: number;
     z_angle: number;
-    colour1: string | number;
-    colour2: string | number;
+    color: [string | number, string | number];
     respawn_delay?: number;
-    addsiren?: boolean;
+    addSiren?: boolean;
 }
 interface IAnimateInfo {
     n: string;
     d: number;
 }
-interface IGangZone<P extends Player> {
-    player?: P;
-    minx: number;
-    miny: number;
-    maxx: number;
-    maxy: number;
+interface IGangZone {
+    player?: Player;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
 }
 interface ICommonTextDrawKey {
     id: number;
     global: boolean;
 }
-interface ITextDraw<P extends Player> {
-    player?: P;
+interface ITextDraw {
+    player?: Player;
     x: number;
     y: number;
     text: string;
@@ -1225,69 +1654,64 @@ interface IDialogFuncQueue {
     reject: (reason: string) => void;
 }
 interface IDynamic {
-    worldid?: TStreamerExtendable;
-    interiorid?: TStreamerExtendable;
-    playerid?: TStreamerExtendable;
+    worldId?: TStreamerExtendable;
+    interiorId?: TStreamerExtendable;
+    playerId?: TStreamerExtendable;
     extended?: boolean;
 }
 interface IDynamicCommon extends IDynamic {
     x: number;
     y: number;
     z: number;
-    areaid?: TStreamerExtendable;
-    streamdistance?: number;
+    areaId?: TStreamerExtendable;
+    streamDistance?: number;
     priority?: number;
 }
 interface IDynamicMapIcon extends IDynamicCommon {
     type: number;
-    colour: string | number;
+    color: string | number;
     style?: MapIconStyles;
 }
 interface IDynamicPickup extends IDynamicCommon {
     type: number;
-    modelid: number;
+    modelId: number;
 }
 interface IDynamicCheckPoint extends IDynamicCommon {
     size: number;
 }
 interface IDynamicRaceCp extends IDynamicCheckPoint {
     type: number;
-    nextx: number;
-    nexty: number;
-    nextz: number;
+    nextX: number;
+    nextY: number;
+    nextZ: number;
 }
 interface IDynamicActor extends IDynamicCommon {
     r: number;
-    modelid: number;
+    modelId: number;
     invulnerable: boolean;
     health: number;
 }
 interface IDynamic3DTextLabel extends IDynamicCommon {
     charset?: string;
     text: string;
-    colour: string | number;
-    attachedplayer?: number;
-    attachedvehicle?: number;
-    testlos?: boolean;
-    drawdistance: number;
+    color: string | number;
+    attachedPlayer?: number;
+    attachedVehicle?: number;
+    testLos?: boolean;
+    drawDistance: number;
 }
 interface IDynamicObject extends IDynamicCommon {
     charset?: string;
-    modelid: number;
+    modelId: number;
     rx: number;
     ry: number;
     rz: number;
-    drawdistance?: number;
+    drawDistance?: number;
 }
 interface IClientResRaw {
-    actionid: number;
-    memaddr: number;
-    retndata: number;
-}
-interface IClientFuncQueue {
-    resolve: (value: IClientResRaw | PromiseLike<IClientResRaw>) => void;
-    reject: (reason: string) => void;
-    timeout: NodeJS.Timeout;
+    actionId: number;
+    memAddr: number;
+    data: number;
 }
 interface ICommonGangZoneKey {
     id: number;
@@ -1303,32 +1727,32 @@ interface IDynamicCircle extends IDynamicCircleCommon {
 }
 interface IDynamicCylinder extends IDynamicCircleCommon {
     type: "cylinder";
-    minz: number;
-    maxz: number;
+    minZ: number;
+    maxZ: number;
 }
 interface IDynamicSphere extends IDynamicCircleCommon {
     type: "sphere";
     z: number;
 }
 interface IDynamicRectangleCommon extends IDynamic {
-    minx: number;
-    miny: number;
-    maxx: number;
-    maxy: number;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
 }
 interface IDynamicRectangle extends IDynamicRectangleCommon {
     type: "rectangle";
 }
 interface IDynamicCuboid extends IDynamicRectangleCommon {
     type: "cuboid";
-    minz: number;
-    maxz: number;
+    minZ: number;
+    maxZ: number;
 }
 interface IDynamicPolygon extends IDynamic {
     type: "polygon";
     points: number[];
-    minz: number;
-    maxz: number;
+    minZ: number;
+    maxZ: number;
 }
 interface IDynamicAreaKey {
     id: number;
@@ -1364,129 +1788,207 @@ declare class I18n {
     $t: (key: string, replaceable?: any[] | undefined | null, locale?: keyof TLocales) => string;
     static isValidate(charset: string): void;
     static encodeToBuf(content: string, charset: string): number[];
-    static decodeFromBuf(buf: Buffer | number[], charset: string): string;
+    static decodeFromBuf(buf: Buffer | number[], charset?: string): string;
     static getValidStr(byteArr: number[]): number[];
     static snakeLocaleKeys(locales: TLocales): any;
 }
 
-declare class Dialog<T extends Player> {
-    private id;
-    private static showingIds;
-    private static max_dialogId;
-    private dialog;
-    static waitingQueue: Map<number, IDialogFuncQueue>;
-    constructor(dialog?: IDialog);
-    get style(): DialogStylesEnum | undefined;
-    set style(v: DialogStylesEnum | undefined);
-    get caption(): string | undefined;
-    set caption(v: string | undefined);
-    get info(): string | undefined;
-    set info(v: string | undefined);
-    get button1(): string | undefined;
-    set button1(v: string | undefined);
-    get button2(): string | undefined;
-    set button2(v: string | undefined);
-    private static delDialogTask;
-    show(player: T): Promise<IDialogResResult>;
-    static close<T extends Player>(player: T): void;
-}
-
-declare class NpcEvent {
-    constructor();
-    onConnect?(myplayerid: number): TCommonCallback;
-    onDisconnect?(reason: string): TCommonCallback;
-    onModeInit?(): TCommonCallback;
-    onModeExit?(): TCommonCallback;
-    onSpawn?(): TCommonCallback;
-    onClientMessage?(colour: number, text: string): TCommonCallback;
-}
+declare const NpcEvent: Readonly<{
+    onConnect: (cb: (ret: {
+        myPlayerId: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onDisconnect: (cb: (ret: {
+        reason: string;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onModeInit: (cb: (ret: object & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onModeExit: (cb: (ret: object & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onSpawn: (cb: (ret: object & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onClientMessage: (cb: (ret: {
+        color: number;
+        buffer: number[];
+        string: string;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
-declare class NpcFunc {
+declare class Npc {
     private constructor();
     private static recordStatus;
     static readonly connectNPC: (name: string, script: string) => number;
-    static startRecordingPlayerData<P extends Player>(player: P, recordtype: RecordTypesEnum, recordname: string): void;
-    static stopRecordingPlayerData<P extends Player>(player: P): void;
+    static startRecordingPlayerData(player: Player, recordtype: RecordTypesEnum, recordname: string): void;
+    static stopRecordingPlayerData(player: Player): void;
     static startRecordingPlayback(playbacktype: RecordTypesEnum, recordname: string): void;
     static stopRecordingPlayback(): void;
     static pauseRecordingPlayback(): void;
     static resumeRecordingPlayback(): void;
 }
 
-declare class GameMode {
-    static charset: string;
-    private initialized;
-    constructor();
-    isInitialized(): boolean;
-    static exit(): void;
-    static use: (plugin: IFilterScript, ...options: Array<any>) => typeof GameMode;
-    static loadScript: (scriptName: string) => void;
-    static unloadScript: (scriptName: string) => void;
-    static reloadScript: (scriptName: string) => void;
-    static supportAllNickname(): void;
-    onInit?(): void;
-    onExit?(): void;
-    onIncomingConnection?(playerid: number, ipAddress: string, port: number): TCommonCallback;
-    onRconCommand?(cmd: string): TCommonCallback;
-    onRconLoginAttempt?(ip: string, password: string, success: boolean): TCommonCallback;
-    static allowAdminTeleport: (allow: boolean) => void;
-    static isAdminTeleportAllowed: () => boolean;
-    static allowInteriorWeapons: (allow: boolean) => void;
-    static areInteriorWeaponsAllowed: () => boolean;
-    static areAllAnimationsEnabled: () => boolean;
-    static enableAllAnimations: (enable: boolean) => void;
-    static enableStuntBonusForAll: (enable: boolean) => number;
-    static enableVehicleFriendlyFire: () => number;
-    static enableZoneNames: (enable: boolean) => number;
-    static disableInteriorEnterExits: () => number;
-    static setGameModeText: (string: string) => number;
-    static getGravity: () => number;
-    static setGravity: (gravity: number) => number;
-    static showNameTags: (show: boolean) => number;
-    static disableNameTagLOS: () => number;
-    static usePlayerPedAnims: () => number;
-    static showPlayerMarkers: (mode: MarkerModesEnum) => number;
-    static limitPlayerMarkerRadius: (marker_radius: number) => number;
-    static limitGlobalChatRadius: (chat_radius: number) => number;
-    static setNameTagDrawDistance: (distance: number) => number;
-    static setWeather(weather: number): number;
-    static setWorldTime(hour: number): number;
-    static setTeamCount: (count: number) => number;
-    static sendRconCommand: (command: string) => number;
-    static addPlayerClass: (modelid: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => number;
-    static addPlayerClassEx: (teamid: number, modelid: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => number;
-    static createExplosion(X: number, Y: number, Z: number, type: number, Radius: number): number;
-    static manualVehicleEngineAndLights: () => number;
-    static blockIpAddress: (ip_address: string, timems: number) => number;
-    static unBlockIpAddress: (ip_address: string) => number;
-    static getServerTickRate: () => number;
-    static addSimpleModel(virtualworld: number, baseid: number, newid: number, dffname: string, txdname: string): number;
-    static addSimpleModelTimed(virtualworld: number, baseid: number, newid: number, dffname: string, txdname: string, timeon: number, timeoff: number): number;
-    private static checkSimpleModel;
-    static findModelFileNameFromCRC: (crc: number) => string;
-    static findTextureFileNameFromCRC: (crc: number) => string;
-    static getWeaponName: (weaponid: number) => string;
-    static setObjectsDefaultCameraCollision: (disable: boolean) => boolean;
-    static vectorSize: (x1: number, y1: number, z1: number, x2: number, y2: number, z2: number) => number;
-    static clearBanList: () => void;
-    static isBanned: (ipaddress: string) => boolean;
-    static isValidNickName: (name: string) => boolean;
-    static allowNickNameCharacter: (byte: number, allow: boolean) => void;
-    static isNickNameCharacterAllowed: (byte: number) => boolean;
-    static addServerRule: (name: string, value: string) => boolean;
-    static setServerRule: (name: string, value: string) => boolean;
-    static isValidServerRule: (name: string) => boolean;
-    static removeServerRule: (name: string) => boolean;
-    static getWeaponSlot: (weaponid: number) => number;
-    static getAvailableClasses: () => number;
-    static getPlayerClass: (classid: number) => boolean | _infernus_wrapper.IPlayerClass;
-    static editPlayerClass: (classid: number, teamid: number, modelid: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => boolean;
-    static toggleChatTextReplacement: (toggle: boolean) => void;
-    static chatTextReplacementToggled: () => boolean;
-    static getConsoleVarAsString(varname: string): string;
-    static getConsoleVarAsInt: (varname: string) => number;
-    static getConsoleVarAsBool: (varname: string) => boolean;
-}
+declare const GameMode: {
+    use(plugin: IFilterScript, ...options: any[]): {
+        use(plugin: IFilterScript, ...options: any[]): any;
+        loadUseScript: (scriptName: string) => void;
+        reloadUseScript: (scriptName: string) => void;
+        unloadUseScript: (scriptName: string) => void;
+        supportAllNickname(): void;
+        setWeather(weather: number): number;
+        setWorldTime(hour: number): number;
+        setTeamCount: (count: number) => number;
+        sendRconCommand: (command: string) => number;
+        addPlayerClass: (modelId: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => number;
+        addPlayerClassEx: (teamId: number, modelId: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => number;
+        createExplosion(X: number, Y: number, Z: number, type: number, radius: number): number;
+        manualVehicleEngineAndLights: () => number;
+        blockIpAddress: (ip_address: string, timems: number) => number;
+        unBlockIpAddress: (ip_address: string) => number;
+        getServerTickRate: () => number;
+        addSimpleModel(virtualWorld: number, baseid: number, newid: number, dffname: string, txdName: string): number;
+        addSimpleModelTimed(virtualWorld: number, baseid: number, newid: number, dffname: string, txdName: string, timeon: number, timeoff: number): number;
+        checkSimpleModel(virtualWorld: number, baseid: number, newid: number, dffname: string, txdName: string, timeon?: number | undefined, timeoff?: number | undefined): number;
+        getConsoleVarAsString(varname: string, charset?: string): string;
+        allowAdminTeleport: (allow: boolean) => void;
+        isAdminTeleportAllowed: () => boolean;
+        allowInteriorWeapons: (allow: boolean) => void;
+        areInteriorWeaponsAllowed: () => boolean;
+        areAllAnimationsEnabled: () => boolean;
+        enableAllAnimations: (enable: boolean) => void;
+        enableStuntBonusForAll: (enable: boolean) => number;
+        enableVehicleFriendlyFire: () => number;
+        enableZoneNames: (enable: boolean) => number;
+        disableInteriorEnterExits: () => number;
+        setGameModeText: (string: string) => number;
+        getGravity: () => number;
+        setGravity: (gravity: number) => number;
+        showNameTags: (show: boolean) => number;
+        disableNameTagLOS: () => number;
+        usePlayerPedAnims: () => number;
+        showPlayerMarkers: (mode: MarkerModesEnum) => number;
+        limitPlayerMarkerRadius: (marker_radius: number) => number;
+        limitGlobalChatRadius: (chat_radius: number) => number;
+        setNameTagDrawDistance: (distance: number) => number;
+        findModelFileNameFromCRC: (crc: number) => string;
+        findTextureFileNameFromCRC: (crc: number) => string;
+        getWeaponName: (weaponId: number) => string;
+        setObjectsDefaultCameraCollision: (disable: boolean) => boolean;
+        vectorSize: (x1: number, y1: number, z1: number, x2: number, y2: number, z2: number) => number;
+        clearBanList: () => void;
+        isBanned: (ipAddress: string) => boolean;
+        isValidNickName: (name: string) => boolean;
+        allowNickNameCharacter: (byte: number, allow: boolean) => void;
+        isNickNameCharacterAllowed: (byte: number) => boolean;
+        addServerRule: (name: string, value: string) => boolean;
+        setServerRule: (name: string, value: string) => boolean;
+        isValidServerRule: (name: string) => boolean;
+        removeServerRule: (name: string) => boolean;
+        getWeaponSlot: (weaponId: number) => number;
+        getAvailableClasses: () => number;
+        getPlayerClass: (classId: number) => boolean | w.IPlayerClass;
+        editPlayerClass: (classId: number, teamId: number, modelId: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => boolean;
+        toggleChatTextReplacement: (toggle: boolean) => void;
+        chatTextReplacementToggled: () => boolean;
+        getConsoleVarAsInt: (varname: string) => number;
+        getConsoleVarAsBool: (varname: string) => boolean;
+    };
+    loadUseScript: (scriptName: string) => void;
+    reloadUseScript: (scriptName: string) => void;
+    unloadUseScript: (scriptName: string) => void;
+    supportAllNickname(): void;
+    setWeather(weather: number): number;
+    setWorldTime(hour: number): number;
+    setTeamCount: (count: number) => number;
+    sendRconCommand: (command: string) => number;
+    addPlayerClass: (modelId: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => number;
+    addPlayerClassEx: (teamId: number, modelId: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => number;
+    createExplosion(X: number, Y: number, Z: number, type: number, radius: number): number;
+    manualVehicleEngineAndLights: () => number;
+    blockIpAddress: (ip_address: string, timems: number) => number;
+    unBlockIpAddress: (ip_address: string) => number;
+    getServerTickRate: () => number;
+    addSimpleModel(virtualWorld: number, baseid: number, newid: number, dffname: string, txdName: string): number;
+    addSimpleModelTimed(virtualWorld: number, baseid: number, newid: number, dffname: string, txdName: string, timeon: number, timeoff: number): number;
+    checkSimpleModel(virtualWorld: number, baseid: number, newid: number, dffname: string, txdName: string, timeon?: number | undefined, timeoff?: number | undefined): number;
+    getConsoleVarAsString(varname: string, charset?: string): string;
+    allowAdminTeleport: (allow: boolean) => void;
+    isAdminTeleportAllowed: () => boolean;
+    allowInteriorWeapons: (allow: boolean) => void;
+    areInteriorWeaponsAllowed: () => boolean;
+    areAllAnimationsEnabled: () => boolean;
+    enableAllAnimations: (enable: boolean) => void;
+    enableStuntBonusForAll: (enable: boolean) => number;
+    enableVehicleFriendlyFire: () => number;
+    enableZoneNames: (enable: boolean) => number;
+    disableInteriorEnterExits: () => number;
+    setGameModeText: (string: string) => number;
+    getGravity: () => number;
+    setGravity: (gravity: number) => number;
+    showNameTags: (show: boolean) => number;
+    disableNameTagLOS: () => number;
+    usePlayerPedAnims: () => number;
+    showPlayerMarkers: (mode: MarkerModesEnum) => number;
+    limitPlayerMarkerRadius: (marker_radius: number) => number;
+    limitGlobalChatRadius: (chat_radius: number) => number;
+    setNameTagDrawDistance: (distance: number) => number;
+    findModelFileNameFromCRC: (crc: number) => string;
+    findTextureFileNameFromCRC: (crc: number) => string;
+    getWeaponName: (weaponId: number) => string;
+    setObjectsDefaultCameraCollision: (disable: boolean) => boolean;
+    vectorSize: (x1: number, y1: number, z1: number, x2: number, y2: number, z2: number) => number;
+    clearBanList: () => void;
+    isBanned: (ipAddress: string) => boolean;
+    isValidNickName: (name: string) => boolean;
+    allowNickNameCharacter: (byte: number, allow: boolean) => void;
+    isNickNameCharacterAllowed: (byte: number) => boolean;
+    addServerRule: (name: string, value: string) => boolean;
+    setServerRule: (name: string, value: string) => boolean;
+    isValidServerRule: (name: string) => boolean;
+    removeServerRule: (name: string) => boolean;
+    getWeaponSlot: (weaponId: number) => number;
+    getAvailableClasses: () => number;
+    getPlayerClass: (classId: number) => boolean | w.IPlayerClass;
+    editPlayerClass: (classId: number, teamId: number, modelId: number, spawn_x: number, spawn_y: number, spawn_z: number, z_angle: number, weapon1: number, weapon1_ammo: number, weapon2: number, weapon2_ammo: number, weapon3: number, weapon3_ammo: number) => boolean;
+    toggleChatTextReplacement: (toggle: boolean) => void;
+    chatTextReplacementToggled: () => boolean;
+    getConsoleVarAsInt: (varname: string) => number;
+    getConsoleVarAsBool: (varname: string) => boolean;
+    onInit: (cb: (ret: object & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onExit: (cb: (ret: object & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onIncomingConnection: (cb: (ret: {
+        playerId: number;
+        ipAddress: string;
+        port: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onRconCommand: (cb: (ret: {
+        buffer: number[];
+        cmd: string;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onRconLoginAttempt: (cb: (ret: {
+        ip: string;
+        password: string;
+        success: boolean;
+        ipBuffer: number[];
+        passwordBuffer: number[];
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+};
 
 declare class NetStats {
     private constructor();
@@ -1503,7 +2005,7 @@ declare class NetStats {
     static getPacketLossPercent<P extends Player>(player: P): number;
 }
 
-declare class GameText<P extends Player = Player> {
+declare class GameText {
     private _text;
     private _time;
     private _style;
@@ -1515,17 +2017,17 @@ declare class GameText<P extends Player = Player> {
     set style(value: number);
     constructor(str: string, time: number, style: number);
     static hideForAll(style: number): void;
-    static has<P extends Player>(player: P, style: number): boolean;
+    static has(player: Player, style: number): boolean;
     forAll(): void;
-    forPlayer(player: P): void;
-    hideForPlayer(player: P): boolean;
+    forPlayer(player: Player): void;
+    hideForPlayer(player: Player): boolean;
 }
 
 declare class Menu {
-    private static menuCount;
-    private _id;
+    private static readonly menus;
     private _itemCount;
     get itemCount(): number;
+    private _id;
     get id(): number;
     private _title;
     get title(): string;
@@ -1553,9 +2055,8 @@ declare class Menu {
     disable(): void | this;
     disableRow(row: number): void;
     isValid(): boolean;
-    showForPlayer<P extends Player>(player: P): void | number;
-    hideForPlayer<P extends Player>(player: P): void | number;
-    static getMenu<M extends Menu, P extends Player>(player: P, menus: Array<M>): M | undefined;
+    showForPlayer(player: Player): void | number;
+    hideForPlayer(player: Player): void | number;
     isDisabled(): boolean;
     isRowDisabled(row: number): boolean;
     getItems(column: number): number;
@@ -1569,75 +2070,109 @@ declare class Menu {
     };
     getColumnHeader(column: number): void | string;
     getItem(column: number, item: number): void | string;
+    static getInstance(id: number): Menu | undefined;
+    static getInstances(): Menu[];
+    static getInstanceByPlayer(player: Player): Menu | undefined;
 }
 
-declare class MenuEvent<P extends Player, M extends Menu> {
-    private readonly menus;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerExited?(player: P, menu: M): TCommonCallback;
-    onPlayerSelectedRow?(player: P, menu: M, row: number): TCommonCallback;
-    private findPlayerById;
-    findMenuById(menuId: number): M | undefined;
-    getMenusArr(): Array<M>;
-    getMenusMap(): Map<number, M>;
-}
+declare const MenuEvent: Readonly<{
+    onPlayerExited: (cb: (ret: {
+        player: Player;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerSelectedRow: (cb: (ret: {
+        player: Player;
+        menu: Menu;
+        row: number;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
-declare class GangZone<P extends Player> {
-    private _id;
+declare class GangZone {
+    static readonly gangZones: Map<ICommonGangZoneKey, GangZone>;
     private static createdGlobalCount;
     private static createdPlayerCount;
-    readonly sourceInfo: IGangZone<P>;
-    constructor(gangZone: IGangZone<P>);
+    readonly sourceInfo: IGangZone;
+    constructor(gangZone: IGangZone);
+    private _id;
     get id(): number;
     create(): void;
     destroy(): void;
-    showForAll(colour: string | number): void | this;
-    showForPlayer(colour: string | number, player?: P): void | this;
+    showForAll(color: string | number): void | this;
+    showForPlayer(color: string | number, player?: Player): void | this;
     hideForAll(): void | this;
-    hideForPlayer(player?: P): void | this;
-    flashForAll(flashcolour: string | number): void | this;
-    flashForPlayer(player: P, flashcolour: string | number): void | this;
-    StopFlashForAll(): void | this;
-    StopFlashForPlayer(player: P): void | this;
+    hideForPlayer(player?: Player): void | this;
+    flashForAll(flashColor: string | number): void | this;
+    flashForPlayer(player: Player, flashColor: string | number): void | this;
+    stopFlashForAll(): void | this;
+    stopFlashForPlayer(player: Player): void | this;
     isValid(): boolean;
-    isPlayerIn(player: P): boolean;
-    isVisibleForPlayer(player: P): boolean;
-    getColourForPlayer(player: P): void | number;
-    getFlashColourForPlayer(player: P): void | number;
-    isFlashingForPlayer(player: P): boolean;
+    isPlayerIn(player: Player): boolean;
+    isVisibleForPlayer(player: Player): boolean;
+    getColorForPlayer(player: Player): void | number;
+    getFlashColorForPlayer(player: Player): void | number;
+    isFlashingForPlayer(player: Player): boolean;
     getPos(): void | GangZonePos;
     useCheck(toggle: boolean): void | this;
-    private unregisterEvent;
+    static getInstance(g: {
+        id: number;
+        global: boolean;
+    }): GangZone | undefined;
+    static getInstances(): GangZone[];
 }
 
-declare class GangZoneEvent<P extends Player, G extends GangZone<P>> {
-    readonly gangZones: Map<ICommonGangZoneKey, G>;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerEnter?(player: P, gangZone: G): TCommonCallback;
-    onPlayerLeave?(player: P, gangZone: G): TCommonCallback;
-}
+declare const GangZoneEvent: Readonly<{
+    onPlayerEnterGlobal: (cb: (ret: {
+        player: Player;
+        gangZone: GangZone;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerLeaveGlobal: (cb: (ret: {
+        player: Player;
+        gangZone: GangZone;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerEnterPlayer: (cb: (ret: {
+        player: Player;
+        gangZone: GangZone;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerLeavePlayer: (cb: (ret: {
+        player: Player;
+        gangZone: GangZone;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
-declare class TextDraw<P extends Player> {
+declare class TextDraw {
+    static readonly textDraws: Map<{
+        id: number;
+        global: boolean;
+    }, TextDraw>;
     private static createdGlobalCount;
     private static createdPlayerCount;
     private readonly sourceInfo;
     private _id;
     get id(): number;
-    constructor(textDraw: ITextDraw<P>);
+    constructor(textDraw: ITextDraw);
     create(): void | this;
     destroy(): void | this;
     setFont(style: 0 | 1 | 2 | 3 | TextDrawFontsEnum): void | this;
-    setColour(Colour: string | number): void | this;
-    setBoxColours(Colour: string | number): void | this;
-    setBackgroundColours(Colour: string | number): void | this;
+    setColor(color: string | number): void | this;
+    setBoxColors(color: string | number): void | this;
+    setBackgroundColors(color: string | number): void | this;
     setAlignment(alignment: TextDrawAlignEnum): void | this;
     setLetterSize(x: number, y: number): void | this;
     setOutline(size: number): void | this;
     setPreviewModel(modelIndex: number): void | this;
     setPreviewRot(fRotX: number, fRotY: number, fRotZ: number, fZoom?: number): void | this;
-    setPreviewVehColours(Colour1: string, Colour2: string): void | this;
+    setPreviewVehColors(color1: string, color2: string): void | this;
     setProportional(set?: boolean): void | this;
     setSelectable(set: boolean): void | this;
     setShadow(size: number): void | this;
@@ -1646,20 +2181,20 @@ declare class TextDraw<P extends Player> {
     useBox(use: boolean): void | this;
     private static beforeCreateWarn;
     private unregisterEvent;
-    show(player?: P): void | this;
-    hide(player?: P): void | this;
+    show(player?: Player): void | this;
+    hide(player?: Player): void | this;
     showAll(): void | this;
     hideAll(): void | this;
     isValid(): boolean;
-    isVisibleForPlayer<P extends Player>(player: P): boolean;
+    isVisibleForPlayer(player: Player): boolean;
     getString(): string;
     setPos(fX: number, fY: number): void | this;
-    getLetterSize(): void | _infernus_wrapper.ITextDrawCommonSize;
-    getTextSize(): void | _infernus_wrapper.ITextDrawCommonSize;
-    getPos(): void | _infernus_wrapper.ITextDrawCommonSize;
-    getColour(): number | void;
-    getBoxColour(): number | void;
-    getBackgroundColour(): number | void;
+    getLetterSize(): void | w.ITextDrawCommonSize;
+    getTextSize(): void | w.ITextDrawCommonSize;
+    getPos(): void | w.ITextDrawCommonSize;
+    getColor(): number | void;
+    getBoxColor(): number | void;
+    getBackgroundColor(): number | void;
     getShadow(): number | void;
     getOutline(): number | void;
     getFont(): number | void;
@@ -1668,21 +2203,34 @@ declare class TextDraw<P extends Player> {
     isSelectable(): boolean;
     getAlignment(): number | void;
     getPreviewModel(): number | void;
-    getPreviewRot(): void | _infernus_wrapper.ITextDrawRot;
-    getPreviewVehColours(): void | {
+    getPreviewRot(): void | w.ITextDrawRot;
+    getPreviewVehColors(): void | {
         color1: number;
         color2: number;
     };
     isGlobal(): boolean;
+    static getInstance(t: {
+        id: number;
+        global: boolean;
+    }): TextDraw | undefined;
+    static getInstances(): TextDraw[];
 }
 
-declare class TextDrawEvent<P extends Player, T extends TextDraw<P>> {
-    readonly textDraws: Map<ICommonTextDrawKey, T>;
-    private readonly players;
-    constructor(playersMap: Map<number, P>, destroyOnExit?: boolean);
-    onPlayerClick?(player: P, textdraw: T | InvalidEnum.TEXT_DRAW): TCommonCallback;
-}
+declare const TextDrawEvent: Readonly<{
+    onPlayerClickGlobal: (cb: (ret: {
+        player: Player;
+        textDraw: InvalidEnum | TextDraw;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerClickPlayer: (cb: (ret: {
+        player: Player;
+        textDraw: InvalidEnum | TextDraw;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
 declare const rgba: (value: string | number) => number;
 
-export { ArtworkEnum, BodyPartsEnum, BoneIdsEnum, BulletHitTypesEnum, CameraCutStylesEnum, CameraModesEnum, CarModTypeEnum, ClickSourcesEnum, ConnectionStatusEnum, DamageDeathReasonEnum, Dialog, DialogStylesEnum, Dynamic3DTextLabel, Dynamic3dTextLabelEvent, DynamicActor, DynamicActorEvent, DynamicArea, DynamicAreaEvent, DynamicCheckPointEvent, DynamicCheckpoint, DynamicMapIcon, DynamicMapIconEvent, DynamicObject, DynamicObjectEvent, DynamicPickup, DynamicPickupEvent, DynamicRaceCP, DynamicRaceCPEvent, ERecordStatus, EditResponseTypesEnum, FightingStylesEnum, GameMode, GameText, GangZone, GangZoneEvent, I18n, IAnimateInfo, IClientFuncQueue, IClientResRaw, ICmdErr, ICommonGangZoneKey, ICommonTextDrawKey, IDialog, IDialogFuncQueue, IDialogResCommon, IDialogResRaw, IDialogResResult, IDynamic, IDynamic3DTextLabel, IDynamicActor, IDynamicAreaKey, IDynamicCheckPoint, IDynamicCircle, IDynamicCircleCommon, IDynamicCommon, IDynamicCuboid, IDynamicCylinder, IDynamicMapIcon, IDynamicObject, IDynamicPickup, IDynamicPolygon, IDynamicRaceCp, IDynamicRectangle, IDynamicRectangleCommon, IDynamicSphere, IFilterScript, IGangZone, ITextDraw, IVehicle, InvalidEnum, KeysEnum, LimitsEnum, MapIconStylesEnum, MarkerModesEnum, Menu, MenuEvent, NPCPlaybackEnum, NetStats, NpcEvent, NpcFunc, ObjectMaterialAlignmmentEnum, ObjectMaterialTextSizeEnum, Player, PlayerEvent, PlayerStateEnum, RecordTypesEnum, SelectObjectTypesEnum, SpecialActionsEnum, SpectateModesEnum, Streamer, TCommonCallback, TDynamicArea, TDynamicAreaTypes, TEventFunc, TEventName, TLocales, TPos, TStreamerExtendable, TextDraw, TextDrawAlignEnum, TextDrawEvent, TextDrawFontsEnum, Vehicle, VehicleEvent, VehicleModelInfoEnum, VehicleParamsEnum, WeaponEnum, WeaponSkillsEnum, WeaponStatesEnum, rgba };
+export { ArtworkEnum, BodyPartsEnum, BoneIdsEnum, BulletHitTypesEnum, CameraCutStylesEnum, CameraModesEnum, CarModTypeEnum, ClickSourcesEnum, CmdBusCallback, CommandErrors, ConnectionStatusEnum, DamageDeathReasonEnum, Dialog, DialogStylesEnum, Dynamic3DTextLabel, Dynamic3DTextLabelEvent, DynamicActor, DynamicActorEvent, DynamicArea, DynamicAreaEvent, DynamicCheckPointEvent, DynamicCheckpoint, DynamicMapIcon, DynamicMapIconEvent, DynamicObject, DynamicObjectEvent, DynamicPickup, DynamicPickupEvent, DynamicRaceCP, DynamicRaceCPEvent, ERecordStatus, EditResponseTypesEnum, FightingStylesEnum, GameMode, GameText, GangZone, GangZoneEvent, I18n, IAnimateInfo, IClientResRaw, ICommonGangZoneKey, ICommonTextDrawKey, IDialog, IDialogFuncQueue, IDialogResCommon, IDialogResRaw, IDialogResResult, IDynamic, IDynamic3DTextLabel, IDynamicActor, IDynamicAreaKey, IDynamicCheckPoint, IDynamicCircle, IDynamicCircleCommon, IDynamicCommon, IDynamicCuboid, IDynamicCylinder, IDynamicMapIcon, IDynamicObject, IDynamicPickup, IDynamicPolygon, IDynamicRaceCp, IDynamicRectangle, IDynamicRectangleCommon, IDynamicSphere, IFilterScript, IGangZone, ITextDraw, IVehicle, InvalidEnum, KeysEnum, LimitsEnum, MapIconStylesEnum, MarkerModesEnum, Menu, MenuEvent, NPCPlaybackEnum, NetStats, Npc, NpcEvent, ObjectMaterialAlignmmentEnum, ObjectMaterialTextSizeEnum, Player, PlayerEvent, PlayerStateEnum, RecordTypesEnum, SelectObjectTypesEnum, SpecialActionsEnum, SpectateModesEnum, Streamer, TCommonCallback, TDynamicArea, TDynamicAreaTypes, TEventFunc, TEventName, TLocales, TPos, TStreamerExtendable, TextDraw, TextDrawAlignEnum, TextDrawEvent, TextDrawFontsEnum, Vehicle, VehicleEvent, VehicleModelInfoEnum, VehicleParamsEnum, WeaponEnum, WeaponSkillsEnum, WeaponStatesEnum, defineEvent, rgba };