@infernus/core 0.9.8 → 0.10.0-beta.10

package/dist/bundle.d.ts

@@ -1,8 +1,5 @@
-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';
+import { MapIconStyles, StreamerItemTypes, StreamerAreaTypes } from '@infernus/streamer';
 export { E_STREAMER, MapIconStyles, MaterialTextSizes, StreamerAreaTypes, StreamerArrayData, StreamerDistances, StreamerItemTypeTuple, StreamerItemTypes, StreamerMiscellaneous, StreamerObjectTypes } from '@infernus/streamer';
 
 declare enum ArtworkEnum {
@@ -321,7 +318,7 @@ declare enum WeaponEnum {
     REASON_CONNECT = 200,
     REASON_DISCONNECT = 200,
     REASON_SUICIDE = 255,
-    WEAPON_FIST = 0,
+    FIST = 0,
     BRASSKNUCKLE = 1,
     GOLFCLUB = 2,
     NITESTICK = 3,
@@ -410,17 +407,429 @@ 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];
+
+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.PLAYER_ID;
+        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.PLAYER_ID;
+        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;
+    info?: string;
+    button1?: string;
+    button2?: string;
+}
+interface IDialogResCommon {
+    response: number;
+    listItem: number;
+}
+interface IDialogResRaw extends IDialogResCommon {
+    buffer: number[];
+}
+interface IDialogResResult extends IDialogResCommon {
+    inputText: string;
+}
+interface IVehicle {
+    modelId: number;
+    x: number;
+    y: number;
+    z: number;
+    z_angle: number;
+    color: [string | number, string | number];
+    respawn_delay?: number;
+    addSiren?: boolean;
+}
+interface IAnimateInfo {
+    n: string;
+    d: number;
+}
+interface IGangZone {
+    player?: Player;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+interface ICommonTextDrawKey {
+    id: number;
+    global: boolean;
+}
+interface ITextDraw {
+    player?: Player;
+    x: number;
+    y: number;
+    text: string;
+}
+interface IDialogFuncQueue {
+    showId: number;
+    resolve: (value: IDialogResRaw | PromiseLike<IDialogResRaw>) => void;
+    reject: (reason: string) => void;
+}
+interface IDynamic {
+    worldId?: TStreamerExtendable;
+    interiorId?: TStreamerExtendable;
+    playerId?: TStreamerExtendable;
+    extended?: boolean;
+}
+interface IDynamicCommon extends IDynamic {
+    x: number;
+    y: number;
+    z: number;
+    areaId?: TStreamerExtendable;
+    streamDistance?: number;
+    priority?: number;
+}
+interface IDynamicMapIcon extends IDynamicCommon {
+    type: number;
+    color: string | number;
+    style?: MapIconStyles;
+}
+interface IDynamicPickup extends IDynamicCommon {
+    type: number;
+    modelId: number;
+}
+interface IDynamicCheckPoint extends IDynamicCommon {
+    size: number;
+}
+interface IDynamicRaceCp extends IDynamicCheckPoint {
+    type: number;
+    nextX: number;
+    nextY: number;
+    nextZ: number;
+}
+interface IDynamicActor extends IDynamicCommon {
+    r: number;
+    modelId: number;
+    invulnerable: boolean;
+    health: number;
+}
+interface IDynamic3DTextLabel extends IDynamicCommon {
+    charset?: string;
+    text: string;
+    color: string | number;
+    attachedPlayer?: number;
+    attachedVehicle?: number;
+    testLos?: boolean;
+    drawDistance: number;
+}
+interface IDynamicObject extends IDynamicCommon {
+    charset?: string;
+    modelId: number;
+    rx: number;
+    ry: number;
+    rz: number;
+    drawDistance?: number;
+}
+interface IClientResRaw {
+    actionId: number;
+    memAddr: number;
+    data: number;
+}
+interface IDynamicCircleCommon extends IDynamic {
+    x: number;
+    y: number;
+    size: number;
+}
+interface IDynamicCircle extends IDynamicCircleCommon {
+    type: "circle";
+}
+interface IDynamicCylinder extends IDynamicCircleCommon {
+    type: "cylinder";
+    minZ: number;
+    maxZ: number;
+}
+interface IDynamicSphere extends IDynamicCircleCommon {
+    type: "sphere";
+    z: number;
+}
+interface IDynamicRectangleCommon extends IDynamic {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+interface IDynamicRectangle extends IDynamicRectangleCommon {
+    type: "rectangle";
+}
+interface IDynamicCuboid extends IDynamicRectangleCommon {
+    type: "cuboid";
+    minZ: number;
+    maxZ: number;
+}
+interface IDynamicPolygon extends IDynamic {
+    type: "polygon";
+    points: number[];
+    minZ: number;
+    maxZ: number;
+}
+interface IDynamicAreaKey {
+    id: number;
+    type: TDynamicAreaTypes;
+}
+interface IFilterScript {
+    name: string;
+    load: (...args: Array<any>) => any;
+    unload: () => any;
+    [propName: string | number | symbol]: any;
+}
+
 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;
@@ -431,15 +840,15 @@ declare class Vehicle {
     getPos(): void | TPos;
     getHealth(): number;
     setHealth(health: number): number;
-    isPlayerIn<P extends Player>(player: P): boolean;
-    putPlayerIn<P extends Player>(player: P, seatid: number): number;
+    isPlayerIn(player: Player): boolean;
+    putPlayerIn(player: Player, seatId: number): number;
     getZAngle(): number;
     setZAngle(z_angle: number): number;
     setNumberPlate(numberplate: string): number;
-    static getPoolSize(): number;
-    changeColours(colour1: string | number, colour2: string | number): number;
-    setVelocity(X: number, Y: number, Z: number): number;
+    changeColors(color1: string | number, color2: string | number): number;
+    setVelocity(X: number, Y: number, Z: number): boolean;
     getVelocity(): void | TPos;
+    getSpeed(magic?: number): number;
     setAngularVelocity(X: number, Y: number, Z: number): number;
     getDamageStatus(): {
         panels: number;
@@ -450,8 +859,8 @@ declare class Vehicle {
     updateDamageStatus(panels: number, doors: number, lights: number, tires: number): void;
     getDistanceFromPoint(X: number, Y: number, Z: number): number;
     getModel(): number;
-    static getModelInfo(vehiclemodel: number, infotype: VehicleModelInfoEnum): TPos;
-    getModelInfo(infotype: VehicleModelInfoEnum): void | TPos;
+    static getModelInfo(vehicleModel: number, infoType: VehicleModelInfoEnum): TPos;
+    getModelInfo(infoType: VehicleModelInfoEnum): void | TPos;
     getRotationQuat(): {
         w: number;
         x: number;
@@ -459,20 +868,20 @@ declare class Vehicle {
         z: number;
     } | undefined;
     setRespawn(): number;
-    isStreamedIn<P extends Player>(forplayer: P): boolean;
-    setParamsCarDoors(driver: boolean, passenger: boolean, backleft: boolean, backright: boolean): number;
-    setParamsCarWindows(driver: boolean, passenger: boolean, backleft: boolean, backright: boolean): number;
+    isStreamedIn(forPlayer: Player): boolean;
+    setParamsCarDoors(driver: boolean, passenger: boolean, backLeft: boolean, backRight: boolean): number;
+    setParamsCarWindows(driver: boolean, passenger: boolean, backLeft: boolean, backRight: boolean): number;
     getParamsCarDoors(): {
         driver: 0 | 1 | -1;
         passenger: 0 | 1 | -1;
-        backleft: 0 | 1 | -1;
-        backright: 0 | 1 | -1;
+        backLeft: 0 | 1 | -1;
+        backRight: 0 | 1 | -1;
     } | undefined;
     getParamsCarWindows(): {
         driver: 0 | 1 | -1;
         passenger: 0 | 1 | -1;
-        backleft: 0 | 1 | -1;
-        backright: 0 | 1 | -1;
+        backLeft: 0 | 1 | -1;
+        backRight: 0 | 1 | -1;
     } | undefined;
     setParamsEx(engine: boolean, lights: boolean, alarm: boolean, doors: boolean, bonnet: boolean, boot: boolean, objective: boolean): number;
     getParamsEx(): {
@@ -485,66 +894,56 @@ declare class Vehicle {
         objective: number;
     } | undefined;
     getParamsSirenState(): number;
-    setParamsForPlayer<P extends Player>(player: P, objective: boolean, doorslocked: boolean): number;
+    setParamsForPlayer(player: Player, objective: boolean, doorsLocked: boolean): number;
     isTrailerAttached(): boolean;
-    changePaintjob(paintjobid: 0 | 1 | 2): number;
-    attachTrailer<V extends Vehicle>(trailer: V): number;
+    changePaintjob(paintjobId: 0 | 1 | 2): number;
+    attachTrailer(trailer: Vehicle): number;
     detachTrailer(): void;
-    getTrailer<V extends Vehicle>(vehicles: Array<V>): V | undefined;
+    getTrailer(): Vehicle | undefined;
     isValid(): boolean;
     static isValid(id: number): boolean;
-    getMatrix(): _infernus_wrapper.IVehMatrix | undefined;
+    getMatrix(): IVehMatrix | undefined;
     getTrainSpeed(): number;
     getHydraReactorAngle(): number;
     getLandingGearState(): number;
     getSirenState(): number;
     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;
+    getDriver(players: Map<number, Player>): Player | undefined;
+    getLastDriver(players: Map<number, Player>): Player | undefined;
+    static getModelCount: (modelId: number) => number;
     isSirenEnabled(): boolean;
     toggleSirenEnabled(enabled: boolean): number;
+    setParamsSirenState(enabled: boolean): number;
     isDead(): boolean;
+    setDead(dead: boolean): boolean;
+    setBeenOccupied(occupied: boolean): boolean;
     getRespawnTick(): number;
+    setRespawnTick(ticks: number): number | false;
     isOccupied(): boolean;
     hasBeenOccupied(): boolean;
     getOccupiedTick(): number;
+    setOccupiedTick(ticks: number): number;
     getCab(): number;
     getRespawnDelay(): number;
     setRespawnDelay(delay: number): number;
     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;
-}
-
-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>;
+    getColors(): 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(): IVehSpawnInfo | undefined;
+    getRandomColorPair(): {
+        color: [number, number, number, number];
+    } | undefined;
+    static getRandomColorPair(modelId: number): {
+        color: [number, number, number, number];
+    };
+    static getInstance(id: number): Vehicle | undefined;
+    static getInstances(): Vehicle[];
 }
 
 declare class DynamicMapIcon {
+    static readonly mapIcons: Map<number, DynamicMapIcon>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -554,19 +953,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 +983,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;
@@ -597,27 +1017,45 @@ declare class DynamicCheckpoint {
     create(): void | this;
     destroy(): void | this;
     isValid(): boolean;
-    togglePlayer<P extends Player>(player: P, toggle: boolean): void | this;
-    static togglePlayerAll<P extends Player>(player: P, toggle: boolean): number;
-    isPlayerIn<P extends Player>(player: P): boolean;
-    static getPlayerVisible<P extends Player, C extends DynamicCheckpoint>(player: P, checkpoints: Map<number, C>): C | undefined;
+    togglePlayer(player: Player, toggle: boolean): void | this;
+    static togglePlayerAll(player: Player, toggle: boolean): number;
+    isPlayerIn(player: Player): boolean;
+    static getPlayerVisible(player: Player): DynamicCheckpoint | 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;
@@ -625,27 +1063,192 @@ declare class DynamicRaceCP {
     create(): void | this;
     destroy(): void | this;
     isValid(): boolean;
-    togglePlayer<P extends Player>(player: P, toggle: boolean): void | this;
-    static togglePlayerAll<P extends Player>(player: P, toggle: boolean): number;
-    isPlayerIn<P extends Player>(player: P): boolean;
-    static getPlayerVisible<P extends Player, C extends DynamicRaceCP>(player: P, checkpoints: Map<number, C>): C | undefined;
+    togglePlayer(player: Player, toggle: boolean): void | this;
+    static togglePlayerAll(player: Player, toggle: boolean): number;
+    isPlayerIn(player: Player): boolean;
+    static getPlayerVisible(player: Player): DynamicRaceCP | undefined;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    static getInstance(id: number): DynamicRaceCP | undefined;
+    static getInstances(): DynamicRaceCP[];
+}
+
+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;
+}>;
+
+interface IActorSpawn {
+    skinId: number;
+    fX: number;
+    fY: number;
+    fZ: number;
+    fAngle: number;
+}
+interface IActorAnimation {
+    animLib: string;
+    animName: string;
+    fDelta: number;
+    loop: number;
+    lockX: number;
+    lockY: number;
+    freeze: number;
+    time: number;
+}
+
+interface IBounds {
+    x_max: number;
+    x_min: number;
+    y_max: number;
+    y_min: number;
+}
+
+interface ICheckPoint {
+    fX: number;
+    fY: number;
+    fZ: number;
+    fSize: number;
+}
+interface IRaceCheckPoint extends ICheckPoint {
+    fNextX: number;
+    fNextY: number;
+    fNextZ: number;
+}
+
+interface GangZonePos {
+    fMinX: number;
+    fMinY: number;
+    fMaxX: number;
+    fMaxY: number;
+}
+type GangZoneCb = (playerId: number, zoneId: number) => void;
+
+interface IObjectPos {
+    fX: number;
+    fY: number;
+    fZ: number;
+}
+interface IObjectRotPos extends IObjectPos {
+    fRotX: number;
+    fRotY: number;
+    fRotZ: number;
+}
+interface IAttachedObject extends IObjectRotPos {
+    modelId: number;
+    bone: number;
+    fScaleX: number;
+    fScaleY: number;
+    fScaleZ: number;
+    materialColor1: number;
+    materialColor2: number;
+}
+interface IMaterial {
+    modelId: number;
+    txdName: string;
+    textureName: string;
+    materialColor: number;
+}
+interface IMaterialText {
+    text: string;
+    materialSize: number;
+    fontFace: string;
+    fontsize: number;
+    bold: number;
+    fontColor: number;
+    backColor: number;
+    textAlignment: number;
+}
+interface IAttachedData {
+    attached_vehicleId: number;
+    attached_objectId?: number;
+    attached_playerId: number;
+}
+
+interface IOffsets {
+    fOffsetX: number;
+    fOffsetY: number;
+    fOffsetZ: number;
 }
 
-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>;
+interface IPlayerClass {
+    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;
+}
+
+interface IQuat {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+}
+
+interface ITextDrawCommonSize {
+    fX: number;
+    fY: number;
+}
+interface ITextDrawRot {
+    fRotX: number;
+    fRotY: number;
+    fRotZ: number;
+    fZoom: number;
+}
+
+interface IVehColor {
+    color1: number;
+    color2: number;
+}
+interface IVehSpawnInfo extends IVehColor {
+    fX: number;
+    fY: number;
+    fZ: number;
+    fRot: number;
+}
+interface IVehMatrix {
+    rightX: number;
+    rightY: number;
+    rightZ: number;
+    upX: number;
+    upY: number;
+    upZ: number;
+    atX: number;
+    atY: number;
+    atZ: number;
 }
 
 declare class DynamicActor {
+    static readonly actors: Map<number, DynamicActor>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -653,9 +1256,9 @@ declare class DynamicActor {
     create(): void | this;
     destroy(): void | this;
     isValid(): boolean;
-    isStreamedIn<P extends Player>(forplayer: P): boolean;
+    isStreamedIn(forPlayer: Player): 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;
@@ -670,28 +1273,44 @@ declare class DynamicActor {
     setHealth(health: number): void | number;
     isInvulnerable(): boolean;
     setInvulnerable(invulnerable?: boolean): void | number;
-    getPlayerTarget<P extends Player, A extends DynamicActor>(player: P, actors: Map<number, A>): void | A;
-    getPlayerCameraTarget<P extends Player, A extends DynamicActor>(player: P, actors: Map<number, A>): void | A;
+    getPlayerTarget(player: Player): DynamicActor | undefined;
+    getPlayerCameraTarget(player: Player): DynamicActor | undefined;
     getSkin(): void | number;
     setSkin(model: number, ignoreRange?: boolean): void | number;
-    getSpawnInfo(): void | _infernus_wrapper.IActorSpawn;
-    getAnimation(): void | _infernus_wrapper.IActorAnimation;
+    getSpawnInfo(): void | IActorSpawn;
+    getAnimation(): void | 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 +1318,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 +1377,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 +1422,103 @@ 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 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 DynamicObject {
+    static readonly objects: Map<number, DynamicObject>;
     private sourceInfo;
     private _id;
     get id(): number;
@@ -825,51 +1542,112 @@ declare class DynamicObject {
     move(x: number, y: number, z: number, speed: number, rx?: number, ry?: number, rz?: number): void | number;
     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;
-    edit<P extends Player>(player: P): void | number;
+    attachCamera(player: Player): void | number;
+    attachToObject(attachTo: DynamicObject, offsetX: number, offsetY: number, offsetZ: number, rx: number, ry: number, rz: number, syncRotation?: boolean): void | number;
+    attachToPlayer(player: Player, offsetX: number, offsetY: number, offsetZ: number, rx: number, ry: number, rz: number): void | number;
+    attachToVehicle(vehicle: Vehicle, offsetX: number, offsetY: number, offsetZ: number, rx: number, ry: number, rz: number): void | number;
+    edit(player: Player): 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;
-    getPlayerCameraTarget<P extends Player, O extends DynamicObject>(player: P, objMap: Map<number, O>): void | O;
+    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(player: Player): DynamicObject | undefined;
     toggleCallbacks(toggle?: boolean): void | number;
     isToggleCallbacks(): boolean;
+    setNoCameraCollision(): boolean;
+    getNoCameraCollision(): 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;
@@ -881,63 +1659,74 @@ declare class DynamicArea {
     getType(): void | StreamerAreaTypes;
     getPolygonPoints(): void | number[];
     getPolygonNumberPoints(): void | number;
-    isPlayerIn<P extends Player>(player: P, recheck?: boolean): boolean;
-    static isPlayerInAny<P extends Player>(player: P, recheck?: boolean): boolean;
+    isPlayerIn(player: Player, recheck?: boolean): boolean;
+    static isPlayerInAny(player: Player, recheck?: boolean): boolean;
     isAnyPlayerIn(recheck?: boolean): boolean;
     static isAnyPlayerInAny(recheck?: boolean): boolean;
-    static getPlayerAreas<P extends Player, A extends DynamicArea>(player: P, areas: Map<number, A>): Array<A | undefined>;
-    static getPlayerAreasNumber<P extends Player>(player: P): any;
+    static getPlayerAreas(player: Player): Array<DynamicArea | undefined>;
+    static getPlayerAreasNumber(player: Player): any;
     isPointIn(x: number, y: number, z: number): boolean;
     static isPointInAny(x: number, y: number, z: number): boolean;
     isLineIn(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): boolean;
     static isLineInAny(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): boolean;
-    static getForPoint<A extends DynamicArea>(x: number, y: number, z: number, areas: Map<number, A>): Array<A | undefined>;
+    static getForPoint(x: number, y: number, z: number): 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 getForLine(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): DynamicArea[];
     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(obj: DynamicObject, offsetX?: number, offsetY?: number, offsetZ?: number): void | number;
+    attachToPlayer(player: Player, offsetX?: number, offsetY?: number, offsetZ?: number): void | number;
+    attachToVehicle(vehicle: Vehicle, 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(color: string | number, msg: string): void;
+    sendMessageToPlayer(player: Player, message: string): number;
+    sendMessageToAll(message: string): number;
     isNpc(): boolean;
     getFps(): number;
     getDrunkLevel(): number;
@@ -948,10 +1737,11 @@ 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;
+    showNameTag(showPlayer: Player, show: boolean): void;
+    setColor(color: string | number): void;
     getColor(): number;
-    setPlayerMarker<P extends Player>(showPlayer: P, colour: string | number): void;
+    setMarker(showPlayer: Player, color: string | number): void;
+    getMarker(targetPlayer: Player): number;
     resetMoney(): number;
     getMoney(): number;
     giveMoney(money: number): number;
@@ -962,15 +1752,15 @@ declare class Player {
     toggleClock(toggle: boolean): number;
     toggleControllable(toggle: boolean): number;
     toggleSpectating(toggle: boolean): number;
-    spectatePlayer<P extends Player>(targetPlayer: P, mode?: SpectateModesEnum): number;
-    spectateVehicle<V extends Vehicle>(targetVehicle: V, mode?: SpectateModesEnum): number;
+    spectatePlayer(targetPlayer: Player, mode?: SpectateModesEnum): number;
+    spectateVehicle(targetVehicle: Vehicle, mode?: SpectateModesEnum): number;
     forceClassSelection(): void;
     kick(): void;
     ban(): void;
     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 +1789,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;
@@ -1009,8 +1799,8 @@ declare class Player {
     getVelocity(): TPos;
     getKeys(): {
         keys: KeysEnum;
-        updown: KeysEnum;
-        leftright: KeysEnum;
+        upDown: KeysEnum;
+        leftRight: KeysEnum;
     };
     getIp(): string;
     getFightingStyle(): FightingStylesEnum;
@@ -1024,24 +1814,23 @@ declare class Player {
     getCameraFrontVector(): TPos;
     getCameraMode(): CameraModesEnum;
     getCameraPos(): TPos;
-    getCameraTargetPlayer<P extends Player>(players: Array<P>): P | undefined;
-    getCameraTargetVehicle<V extends Vehicle>(vehicles: Array<V>): V | undefined;
+    getCameraTargetPlayer(players: Array<Player>): Player | undefined;
+    getCameraTargetVehicle(vehicles: Array<Vehicle>): Vehicle | undefined;
     getCameraZoom(): number;
     playAudioStream(url: string, posX?: number, posY?: number, posZ?: number, distance?: number): number;
     stopAudioStream(): void;
     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;
     static isConnected(id: number): boolean;
     isConnected(): boolean;
     disableRemoteVehicleCollisions(disable: boolean): number;
-    getVehicle<V extends Vehicle>(vehicles: Array<V>): V | undefined;
+    getVehicle(vehicles: Array<Vehicle>): Vehicle | undefined;
     getVehicleSeat(): number;
-    getSurfingVehicle<V extends Vehicle>(vehicles: Array<V>): V | undefined;
+    getSurfingVehicle(vehicles: Array<Vehicle>): Vehicle | undefined;
     applyAnimation(animLib: string, animName: string, loop?: boolean, lockX?: boolean, lockY?: boolean, freeze?: boolean, forceSync?: boolean): void;
     clearAnimations(forceSync?: boolean): void;
     getAnimationIndex(): number;
@@ -1052,10 +1841,11 @@ 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;
+    clearWorldBounds(): boolean;
+    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 +1860,36 @@ 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;
+    getAnimationFlags(): number;
+    getLastSyncedTrailerID(): number;
+    getLastSyncedVehicleID(): number;
     toggleWidescreen(set: boolean): number;
-    isPlayerWidescreenToggled(): boolean;
-    getSpawnInfo(): _infernus_wrapper.IPlayerClass;
+    isWidescreenToggled(): boolean;
+    getSpawnInfo(): IPlayerClass;
     getSkillLevel(skill: WeaponSkillsEnum): number;
     isCheckpointActive(): boolean;
-    getCheckpoint(): _infernus_wrapper.ICheckPoint;
+    getCheckpoint(): ICheckPoint;
     isRaceCheckpointActive(): boolean;
-    getRaceCheckpoint(): _infernus_wrapper.IRaceCheckPoint;
+    getRaceCheckpoint(): IRaceCheckPoint;
     getWorldBounds(): void;
     isInModShop(): boolean;
     getSirenState(): number;
@@ -1104,8 +1897,8 @@ declare class Player {
     getHydraReactorAngle(): number;
     getTrainSpeed(): number;
     getZAim(): number;
-    getSurfingOffsets(): _infernus_wrapper.IOffsets;
-    getRotationQuat(): _infernus_wrapper.IQuat;
+    getSurfingOffsets(): IOffsets;
+    getRotationQuat(): IQuat;
     getDialogID(): number;
     getSpectateID(): number;
     getSpectateType(): SpectateModesEnum;
@@ -1119,231 +1912,18 @@ declare class Player {
     toggleGhostMode(toggle: boolean): number;
     getGhostMode(): boolean;
     getBuildingsRemoved(): number;
-    getAttachedObject(index: number): _infernus_wrapper.IAttachedObject;
-    removeWeapon(weaponid: number): number;
+    getAttachedObject(index: number): IAttachedObject;
+    removeWeapon(weaponId: number): number;
     isUsingOfficialClient(): boolean;
     allowWeapons(allow: boolean): boolean;
     areWeaponsAllowed(): boolean;
     gpci(charset?: string): string;
-}
-
-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;
-}
-
-interface IDialog {
-    style?: DialogStylesEnum;
-    caption?: string;
-    info?: string;
-    button1?: string;
-    button2?: string;
-}
-interface IDialogResCommon {
-    response: number;
-    listitem: number;
-}
-interface IDialogResRaw extends IDialogResCommon {
-    inputbuf: number[];
-}
-interface IDialogResResult extends IDialogResCommon {
-    inputtext: string;
-}
-interface ICmdErr {
-    code: number;
-    msg: string;
-}
-interface IVehicle {
-    modelid: number;
-    x: number;
-    y: number;
-    z: number;
-    z_angle: number;
-    colour1: string | number;
-    colour2: string | number;
-    respawn_delay?: number;
-    addsiren?: boolean;
-}
-interface IAnimateInfo {
-    n: string;
-    d: number;
-}
-interface IGangZone<P extends Player> {
-    player?: P;
-    minx: number;
-    miny: number;
-    maxx: number;
-    maxy: number;
-}
-interface ICommonTextDrawKey {
-    id: number;
-    global: boolean;
-}
-interface ITextDraw<P extends Player> {
-    player?: P;
-    x: number;
-    y: number;
-    text: string;
-}
-interface IDialogFuncQueue {
-    showId: number;
-    resolve: (value: IDialogResRaw | PromiseLike<IDialogResRaw>) => void;
-    reject: (reason: string) => void;
-}
-interface IDynamic {
-    worldid?: TStreamerExtendable;
-    interiorid?: TStreamerExtendable;
-    playerid?: TStreamerExtendable;
-    extended?: boolean;
-}
-interface IDynamicCommon extends IDynamic {
-    x: number;
-    y: number;
-    z: number;
-    areaid?: TStreamerExtendable;
-    streamdistance?: number;
-    priority?: number;
-}
-interface IDynamicMapIcon extends IDynamicCommon {
-    type: number;
-    colour: string | number;
-    style?: MapIconStyles;
-}
-interface IDynamicPickup extends IDynamicCommon {
-    type: number;
-    modelid: number;
-}
-interface IDynamicCheckPoint extends IDynamicCommon {
-    size: number;
-}
-interface IDynamicRaceCp extends IDynamicCheckPoint {
-    type: number;
-    nextx: number;
-    nexty: number;
-    nextz: number;
-}
-interface IDynamicActor extends IDynamicCommon {
-    r: 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;
-}
-interface IDynamicObject extends IDynamicCommon {
-    charset?: string;
-    modelid: number;
-    rx: number;
-    ry: number;
-    rz: 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;
-}
-interface ICommonGangZoneKey {
-    id: number;
-    global: boolean;
-}
-interface IDynamicCircleCommon extends IDynamic {
-    x: number;
-    y: number;
-    size: number;
-}
-interface IDynamicCircle extends IDynamicCircleCommon {
-    type: "circle";
-}
-interface IDynamicCylinder extends IDynamicCircleCommon {
-    type: "cylinder";
-    minz: number;
-    maxz: number;
-}
-interface IDynamicSphere extends IDynamicCircleCommon {
-    type: "sphere";
-    z: number;
-}
-interface IDynamicRectangleCommon extends IDynamic {
-    minx: number;
-    miny: number;
-    maxx: number;
-    maxy: number;
-}
-interface IDynamicRectangle extends IDynamicRectangleCommon {
-    type: "rectangle";
-}
-interface IDynamicCuboid extends IDynamicRectangleCommon {
-    type: "cuboid";
-    minz: number;
-    maxz: number;
-}
-interface IDynamicPolygon extends IDynamic {
-    type: "polygon";
-    points: number[];
-    minz: number;
-    maxz: number;
-}
-interface IDynamicAreaKey {
-    id: number;
-    type: TDynamicAreaTypes;
-}
-
-interface IFilterScript {
-    name: string;
-    load: (...args: Array<any>) => any;
-    unload: () => any;
-    [propName: string | number | symbol]: any;
+    static getInstance(id: number): Player | undefined;
+    static getInstances(): Player[];
 }
 
 type TEventName = string | string[];
-type TEventFunc<EventInstance, P> = (this: EventInstance, player: P, ...args: string[]) => boolean | number | void | Promise<boolean | number | void>;
+type TEventFunc<EventInstance> = (this: EventInstance, player: Player, ...args: string[]) => boolean | number | void | Promise<boolean | number | void>;
 type TLocales = Record<string, Record<string, any>>;
 type TPos = {
     x: number;
@@ -1364,146 +1944,236 @@ 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;
+        getWorldTime: () => 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;
+        getRestartTime: () => number;
+        setRestartTime: (seconds: number) => boolean;
+        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 | 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;
+        getWeather: () => number;
+        getServerRuleFlag: (rule: string) => number;
+        setServerRuleFlags: (rule: string, flags: number) => boolean;
+    };
+    loadUseScript: (scriptName: string) => void;
+    reloadUseScript: (scriptName: string) => void;
+    unloadUseScript: (scriptName: string) => void;
+    supportAllNickname(): void;
+    setWeather(weather: number): number;
+    setWorldTime(hour: number): number;
+    getWorldTime: () => 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;
+    getRestartTime: () => number;
+    setRestartTime: (seconds: number) => boolean;
+    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 | 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;
+    getWeather: () => number;
+    getServerRuleFlag: (rule: string) => number;
+    setServerRuleFlags: (rule: string, flags: number) => 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();
     static getNetworkStats(): string;
-    static getPlayerNetworkStats<P extends Player>(player: P): string;
-    static getBytesReceived<P extends Player>(player: P): number;
-    static getBytesSent<P extends Player>(player: P): number;
-    static getConnectionStatus<P extends Player>(player: P): ConnectionStatusEnum;
-    static getConnectedTime<P extends Player>(player: P): number;
-    static getIpPort<P extends Player>(player: P): string;
-    static getMessagesReceived<P extends Player>(player: P): number;
-    static getMessagesRecvPerSecond<P extends Player>(player: P): number;
-    static getMessagesSent<P extends Player>(player: P): number;
-    static getPacketLossPercent<P extends Player>(player: P): number;
-}
-
-declare class GameText<P extends Player = Player> {
+    static getPlayerNetworkStats(player: Player): string;
+    static getBytesReceived(player: Player): number;
+    static getBytesSent(player: Player): number;
+    static getConnectionStatus(player: Player): ConnectionStatusEnum;
+    static getConnectedTime(player: Player): number;
+    static getIpPort(player: Player): string;
+    static getMessagesReceived(player: Player): number;
+    static getMessagesRecvPerSecond(player: Player): number;
+    static getMessagesSent(player: Player): number;
+    static getPacketLossPercent(player: Player): number;
+}
+
+declare class GameText {
     private _text;
     private _time;
     private _style;
@@ -1515,17 +2185,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 +2223,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 +2238,113 @@ 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> {
+declare class GangZone {
+    static readonly globalGangZones: Map<number, GangZone>;
+    static readonly playerGangZones: Map<number, GangZone>;
+    readonly sourceInfo: IGangZone;
+    constructor(gangZone: IGangZone);
     private _id;
-    private static createdGlobalCount;
-    private static createdPlayerCount;
-    readonly sourceInfo: IGangZone<P>;
-    constructor(gangZone: IGangZone<P>);
     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(id: number, isGlobal: boolean): GangZone | undefined;
+    static getInstances(isGlobal: boolean): 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;
+    onPlayerClickGlobal: (cb: (ret: {
+        player: Player;
+        gangZone: GangZone;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+    onPlayerClickPlayer: (cb: (ret: {
+        player: Player;
+        gangZone: GangZone;
+    } & {
+        next: () => CallbackRet;
+    }) => PromisifyCallbackRet) => () => void;
+}>;
 
-declare class TextDraw<P extends Player> {
-    private static createdGlobalCount;
-    private static createdPlayerCount;
+declare class TextDraw {
+    static readonly globalTextDraws: Map<number, TextDraw>;
+    static readonly playerTextDraws: Map<number, TextDraw>;
     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;
@@ -1645,21 +2352,20 @@ declare class TextDraw<P extends Player> {
     setTextSize(x: number, y: number): void | this;
     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 | ITextDrawCommonSize;
+    getTextSize(): void | ITextDrawCommonSize;
+    getPos(): void | ITextDrawCommonSize;
+    getColor(): number | void;
+    getBoxColor(): number | void;
+    getBackgroundColor(): number | void;
     getShadow(): number | void;
     getOutline(): number | void;
     getFont(): number | void;
@@ -1668,21 +2374,36 @@ declare class TextDraw<P extends Player> {
     isSelectable(): boolean;
     getAlignment(): number | void;
     getPreviewModel(): number | void;
-    getPreviewRot(): void | _infernus_wrapper.ITextDrawRot;
-    getPreviewVehColours(): void | {
+    getPreviewRot(): void | ITextDrawRot;
+    getPreviewVehColors(): void | {
         color1: number;
         color2: number;
     };
     isGlobal(): boolean;
+    static getInstance(id: number, isGlobal: boolean): TextDraw | undefined;
+    static getInstances(isGlobal: boolean): 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 };
+declare function isHolding(newKeys: KeysEnum, key: KeysEnum): boolean;
+declare function isPressed(newKeys: KeysEnum, oldKeys: KeysEnum, key: KeysEnum): boolean;
+declare function isPressing(keys: KeysEnum, key: KeysEnum): boolean;
+declare function isReleased(newKeys: KeysEnum, oldKeys: KeysEnum, key: KeysEnum): boolean;
+
+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, GangZoneCb, GangZoneEvent, GangZonePos, I18n, IActorAnimation, IActorSpawn, IAnimateInfo, IAttachedData, IAttachedObject, IBounds, ICheckPoint, IClientResRaw, 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, IMaterial, IMaterialText, IObjectPos, IObjectRotPos, IOffsets, IPlayerClass, IQuat, IRaceCheckPoint, ITextDraw, ITextDrawCommonSize, ITextDrawRot, IVehColor, IVehMatrix, IVehSpawnInfo, 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, isHolding, isPressed, isPressing, isReleased, rgba };