@infernus/core/dist/bundle.d.ts

Node.js library for Scripting Open Multiplayer

import * as _infernus_streamer from '@infernus/streamer';
import { MapIconStyles, StreamerItemTypes, StreamerAreaTypes } from '@infernus/streamer';
export { E_STREAMER, MapIconStyles, MaterialTextAlign, MaterialTextSizes, StreamerAreaTypes, StreamerArrayData, StreamerDistances, StreamerItemTypeTuple, StreamerItemTypes, StreamerMiscellaneous, StreamerObjectTypes } from '@infernus/streamer';

declare enum ArtworkEnum {
    DOWNLOAD_REQUEST_EMPTY = 0,
    DOWNLOAD_REQUEST_MODEL_FILE = 1,
    DOWNLOAD_REQUEST_TEXTURE_FILE = 2
}

declare enum ClickSourcesEnum {
    SCOREBOARD = 0
}

declare enum DialogStylesEnum {
    MSGBOX = 0,
    INPUT = 1,
    LIST = 2,
    PASSWORD = 3,
    TABLIST = 4,
    TABLIST_HEADERS = 5
}

declare enum EditResponseTypesEnum {
    CANCEL = 0,
    FINAL = 1,
    UPDATE = 2
}

declare enum ConnectionStatusEnum {
    NO_ACTION = 0,
    DISCONNECT_ASAP = 1,
    DISCONNECT_ASAP_SILENTLY = 2,
    DISCONNECT_ON_NO_ACK = 3,
    REQUESTED_CONNECTION = 4,
    HANDLING_CONNECTION_REQUEST = 5,
    UNVERIFIED_SENDER = 6,
    SET_ENCRYPTION_ON_MULTIPLE_16_BYTE_PACKET = 7,
    CONNECTED = 8
}

declare enum InvalidEnum {
    NO_TEAM = 255,
    PLAYER_ID = 65535,
    VEHICLE_ID = 65535,
    ACTOR_ID = 65535,
    OBJECT_ID = 65535,
    MENU = -1,
    TEXT_DRAW = 65535,
    PLAYER_TEXT_DRAW = 65535,
    GANG_ZONE = -1,
    _3DTEXT_ID = 65535,
    PLAYER_3DTEXT_ID = 65535
}

declare enum KeysEnum {
    NONE = 0,
    ACTION = 1,
    CROUCH = 2,
    FIRE = 4,
    SPRINT = 8,
    SECONDARY_ATTACK = 16,
    JUMP = 32,
    LOOK_RIGHT = 64,
    HANDBRAKE = 128,
    LOOK_LEFT = 256,
    SUBMISSION = 512,
    LOOK_BEHIND = 512,
    WALK = 1024,
    ANALOG_UP = 2048,
    ANALOG_DOWN = 4096,
    ANALOG_LEFT = 8192,
    ANALOG_RIGHT = 16384,
    YES = 65536,
    NO = 131072,
    CTRL_BACK = 262144,
    KEY_UP = -128,
    KEY_DOWN = 128,
    KEY_LEFT = -128,
    KEY_RIGHT = 128
}

declare enum LimitsEnum {
    MAX_PLAYER_NAME = 24,
    MAX_PLAYERS = 1000,
    MAX_VEHICLES = 2000,
    MAX_ACTORS = 1000,
    MAX_OBJECTS = 1000,
    MAX_GANG_ZONES = 1024,
    MAX_TEXT_DRAWS = 2048,
    MAX_PLAYER_TEXT_DRAWS = 256,
    MAX_MENUS = 128,
    MAX_MENU_ROW = 12,
    MAX_MENU_COL = 2,
    MAX_3DTEXT_GLOBAL = 1024,
    MAX_3DTEXT_PLAYER = 1024,
    MAX_PICKUPS = 4096,
    MAX_PLAYER_ATTACHED_OBJECTS = 10,
    MAX_CHATBUBBLE_LENGTH = 144
}

declare enum MarkerModesEnum {
    OFF = 0,
    GLOBAL = 1,
    STREAMED = 2
}

declare enum NPCPlaybackEnum {
    NONE = 1,
    DRIVER = 2,
    ONFOOT = 3
}
declare enum ERecordStatus {
    none = 0,
    start = 1,
    pause = 2
}

declare enum ObjectMaterialTextSizeEnum {
    _32x32 = 10,
    _64x32 = 20,
    _64x64 = 30,
    _128x32 = 40,
    _128x64 = 50,
    _128x128 = 60,
    _256x32 = 70,
    _256x64 = 80,
    _256x128 = 90,
    _256x256 = 100,
    _512x64 = 110,
    _512x128 = 120,
    _512x256 = 130,
    _512x512 = 140
}
declare enum ObjectMaterialAlignmentEnum {
    LEFT = 0,
    CENTER = 1,
    RIGHT = 2
}
declare enum SelectObjectTypesEnum {
    GLOBAL_OBJECT = 1,
    PLAYER_OBJECT = 2
}

declare enum FightingStylesEnum {
    NORMAL = 0,
    BOXING = 1,
    KUNGFU = 2,
    KNEEHEAD = 3,
    GRABKICK = 4,
    ELBOW = 5
}
declare enum MapIconStylesEnum {
    LOCAL = 0,
    GLOBAL = 1,
    LOCAL_CHECKPOINT = 2,
    GLOBAL_CHECKPOINT = 3
}
declare enum CameraCutStylesEnum {
    MOVE = 1,
    CUT = 2
}
declare enum CameraModesEnum {
    BEHINDCAR = 3,
    FOLLOWPED = 4,
    SNIPER = 7,
    ROCKETLAUNCHER = 8,
    FIXED = 15,
    _1STPERSON = 16,
    CAM_ON_A_STRING = 18,
    BEHINDBOAT = 22,
    CAMERA = 46,
    ROCKETLAUNCHER_HS = 51,
    AIMWEAPON = 53,
    AIMWEAPON_FROMCAR = 55,
    DW_HELI_CHASE = 56,
    DW_CAM_MAN = 57,
    DW_BIRDY = 58,
    DW_PLANE_SPOTTER = 59,
    DW_PLANECAM1 = 62,
    DW_PLANECAM2 = 63,
    DW_PLANECAM3 = 64
}
declare enum SpectateModesEnum {
    NORMAL = 1,
    FIXED = 2,
    SIDE = 3
}
declare enum PlayerStateEnum {
    NONE = 0,
    ONFOOT = 1,
    DRIVER = 2,
    PASSENGER = 3,
    EXIT_VEHICLE = 4,
    ENTER_VEHICLE_DRIVER = 5,
    ENTER_VEHICLE_PASSENGER = 6,
    WASTED = 7,
    SPAWNED = 8,
    SPECTATING = 9
}
declare enum BodyPartsEnum {
    TORSO = 3,
    GROIN = 4,
    LEFT_ARM = 5,
    RIGHT_ARM = 6,
    LEFT_LEG = 7,
    RIGHT_LEG = 8,
    HEAD = 9
}
declare enum BoneIdsEnum {
    Spine = 1,
    Head = 2,
    LeftUpperArm = 3,
    RightUpperArm = 4,
    LeftHand = 5,
    RightHand = 6,
    LeftThigh = 7,
    RightThigh = 8,
    LeftFoot = 9,
    RightFoot = 10,
    RightCalf = 11,
    LeftCalf = 12,
    LeftForearm = 13,
    RightForearm = 14,
    LeftClavicle = 15,
    RightClavicle = 16,
    Neck = 17,
    Jaw = 18
}
declare enum ForceSyncEnum {
    UNKNOWN = -1,
    NONE = 0,
    ALL = 1,
    OTHER = 2
}

declare enum SpecialActionsEnum {
    NONE = 0,
    DUCK = 1,
    USEJETPACK = 2,
    ENTER_VEHICLE = 3,
    EXIT_VEHICLE = 4,
    DANCE1 = 5,
    DANCE2 = 6,
    DANCE3 = 7,
    DANCE4 = 8,
    HANDSUP = 10,
    USECELLPHONE = 11,
    SITTING = 12,
    STOPUSECELLPHONE = 13,
    DRINK_BEER = 20,
    SMOKE_CIGGY = 21,
    DRINK_WINE = 22,
    DRINK_SPRUNK = 23,
    CUFFED = 24,
    CARRY = 25,
    PISSING = 68
}

declare enum TextDrawFontsEnum {
    FONT_0 = 0,
    FONT_1 = 1,
    FONT_2 = 2,
    FONT_3 = 3,
    SPRITE_DRAW = 4,
    MODEL_PREVIEW = 5,
    BANK = 0,
    STANDARD = 1,
    SPACEAGE = 2,
    HEADING = 3,
    BECKETT_REGULAR = 0,
    AHARONI_BOLD = 1,
    BANK_GOTHIC = 2,
    PRICEDOWN = 3,
    SPRITE = 4,
    PREVIEW = 5
}
declare enum TextDrawAlignEnum {
    LEFT = 1,
    CENTER = 2,
    RIGHT = 3
}

declare enum CarModTypeEnum {
    UNKNOWN = -1,
    NONE = -1,
    SPOILER = 0,
    HOOD = 1,
    ROOF = 2,
    SIDESKIRT = 3,
    LAMPS = 4,
    NITRO = 5,
    EXHAUST = 6,
    WHEELS = 7,
    STEREO = 8,
    HYDRAULICS = 9,
    FRONT_BUMPER = 10,
    REAR_BUMPER = 11,
    VENT_RIGHT = 12,
    VENT_LEFT = 13,
    FRONT_BULLBAR = 14,
    REAR_BULLBAR = 15
}
declare enum VehicleParamsEnum {
    UNSET = -1,
    OFF = 0,
    ON = 1
}
declare enum VehicleModelInfoEnum {
    SIZE = 1,
    FRONTSEAT = 2,
    REARSEAT = 3,
    PETROLCAP = 4,
    WHEELSFRONT = 5,
    WHEELSREAR = 6,
    WHEELSMID = 7,
    FRONT_BUMPER_Z = 8,
    REAR_BUMPER_Z = 9
}

declare enum WeaponEnum {
    UNKNOWN = -1,
    REASON_VEHICLE = 49,
    REASON_DROWN = 53,
    REASON_COLLISION = 54,
    REASON_SPLAT = 54,
    REASON_CONNECT = 200,
    REASON_DISCONNECT = 200,
    REASON_SUICIDE = 255,
    FIST = 0,
    BRASSKNUCKLE = 1,
    GOLFCLUB = 2,
    NITESTICK = 3,
    KNIFE = 4,
    BAT = 5,
    SHOVEL = 6,
    POOLSTICK = 7,
    KATANA = 8,
    CHAINSAW = 9,
    DILDO = 10,
    DILDO2 = 11,
    VIBRATOR = 12,
    VIBRATOR2 = 13,
    FLOWER = 14,
    CANE = 15,
    GRENADE = 16,
    TEARGAS = 17,
    MOLTOV = 18,
    COLT45 = 22,
    SILENCED = 23,
    DEAGLE = 24,
    SHOTGUN = 25,
    SAWEDOFF = 26,
    SHOTGSPA = 27,
    UZI = 28,
    MP5 = 29,
    AK47 = 30,
    M4 = 31,
    TEC9 = 32,
    RIFLE = 33,
    SNIPER = 34,
    ROCKETLAUNCHER = 35,
    HEATSEEKER = 36,
    FLAMETHROWER = 37,
    MINIGUN = 38,
    SATCHEL = 39,
    BOMB = 40,
    SPRAYCAN = 41,
    FIREEXTINGUISHER = 42,
    CAMERA = 43,
    NIGHT_VISION_GOGGLES = 44,
    THERMAL_GOGGLES = 45,
    PARACHUTE = 46
}
declare enum WeaponSkillsEnum {
    PISTOL = 0,
    PISTOL_SILENCED = 1,
    DESERT_EAGLE = 2,
    SHOTGUN = 3,
    SAWNOFF_SHOTGUN = 4,
    SPAS12_SHOTGUN = 5,
    MICRO_UZI = 6,
    MP5 = 7,
    AK47 = 8,
    M4 = 9,
    SNIPERRIFLE = 10
}
declare enum BulletHitTypesEnum {
    NONE = 0,
    PLAYER = 1,
    VEHICLE = 2,
    OBJECT = 3,
    PLAYER_OBJECT = 4
}
declare enum WeaponStatesEnum {
    UNKNOWN = -1,
    NO_BULLETS = 0,
    LAST_BULLET = 1,
    MORE_BULLETS = 2,
    RELOADING = 3
}
declare enum DamageDeathReasonEnum {
    VEHICLE = 49,
    HELICOPTERBLADES = 50,
    EXPLOSION = 51,
    DROWN = 53,
    COLLISION = 54,
    CONNECT = 200,
    DISCONNECT = 201,
    SUICIDE = 255
}

declare enum RecordTypesEnum {
    NONE = 0,
    DRIVER = 1,
    ONFOOT = 2
}

type CallbackRet = boolean | number | void;
type PromisifyCallbackRet = CallbackRet | Promise<CallbackRet>;
interface defineEventOptions<T extends object> {
    name: string;
    defaultValue?: boolean;
    identifier?: string;
    isNative?: boolean;
    beforeEach?: (...args: any[]) => Exclude<T, Array<any> | Function>;
    afterEach?: (arg: T) => void;
    throwOnError?: boolean;
}
interface ExecMiddlewareOptions {
    args: any[];
    skipToNext?: (...args: any[]) => any;
}
declare function defineEvent<T extends object>(options: defineEventOptions<T>): readonly [(cb: (ret: T & {
    next: (value?: Partial<T>) => CallbackRet;
    defaultValue: defineEventOptions<T>["defaultValue"];
}) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined, (...argsOrOptions: any[]) => number];
declare function useTrigger(eventName: string): ((...args: any[]) => number) | undefined;
declare function withTriggerOptions(options: ExecMiddlewareOptions): ExecMiddlewareOptions & {
    __trigger__: boolean;
};

interface CmdBusCallback {
    player: Player;
    mainCommand: string;
    subcommand: string[];
    cmdText: string;
    buffer: number[];
    isStrict: boolean;
    next: (value?: any) => CallbackRet;
}
type CommandErrorTypes = "NOT_EXIST" | "REJECTED" | "PERFORMED" | "RECEIVED_THROW" | "RECEIVED_REJECTED";
interface CommandErrorRet {
    code: number;
    msg: string;
    error?: any;
}
interface ICmdOptions {
    caseSensitive?: boolean;
    command: string | string[];
    run: (ret: CmdBusCallback) => PromisifyCallbackRet;
}
declare const CommandErrors: Record<CommandErrorTypes, CommandErrorRet>;
declare class CmdBus {
    static caseSensitive: boolean;
    private constructor();
    static on(command: ICmdOptions["command"], run: ICmdOptions["run"]): () => void;
    static on(options: ICmdOptions): () => void;
    static off(command: string | string[]): void;
    static enableCaseSensitive(): void;
    static disableCaseSensitive(): void;
    static isCaseSensitive(): boolean;
    static simulate(player: Player, cmdText: string | number[]): number;
}

/**
 * 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 maxDialogId;
    private dialog;
    static waitingQueue: WeakMap<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<IDialogResCommon>;
    static close(player: Player): void;
    static __inject__ShowPlayerDialog: (player: Player, id: number, dialog: IDialog) => boolean;
}

declare const PlayerEvent: Readonly<{
    onConnect: (cb: (ret: {
        player: Player;
    } & {
        next: (value?: Partial<{
            player: Player;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onDisconnect: (cb: (ret: {
        player: Player;
        reason: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            reason: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onPause: (cb: (ret: {
        player: Player;
        pausedAt: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            pausedAt: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onResume: (cb: (ret: {
        player: Player;
        pausedAt: number;
        now: number;
        diff: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            pausedAt: number;
            now: number;
            diff: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onUpdate: (cb: (ret: {
        player: Player;
    } & {
        next: (value?: Partial<{
            player: Player;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onText: (cb: (ret: {
        player: Player;
        text: string;
        buffer: number[];
    } & {
        next: (value?: Partial<{
            player: Player;
            text: string;
            buffer: number[];
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onEnterExitModShop: (cb: (ret: {
        player: Player;
        enterExit: number;
        interior: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            enterExit: number;
            interior: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onClickMap: (cb: (ret: {
        player: Player;
        fX: number;
        fY: number;
        fZ: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            fX: number;
            fY: number;
            fZ: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onClickPlayer: (cb: (ret: {
        player: Player;
        clickedPlayer: Player;
        source: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            clickedPlayer: Player;
            source: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onDeath: (cb: (ret: {
        player: Player;
        killer: Player | InvalidEnum.PLAYER_ID;
        reason: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            killer: Player | InvalidEnum.PLAYER_ID;
            reason: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onGiveDamage: (cb: (ret: {
        player: Player;
        damage: Player;
        amount: number;
        weapon: WeaponEnum;
        bodyPart: BodyPartsEnum;
    } & {
        next: (value?: Partial<{
            player: Player;
            damage: Player;
            amount: number;
            weapon: WeaponEnum;
            bodyPart: BodyPartsEnum;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onKeyStateChange: (cb: (ret: {
        player: Player;
        newKeys: KeysEnum;
        oldKeys: KeysEnum;
    } & {
        next: (value?: Partial<{
            player: Player;
            newKeys: KeysEnum;
            oldKeys: KeysEnum;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onRequestClass: (cb: (ret: {
        player: Player;
        classId: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            classId: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onRequestSpawn: (cb: (ret: {
        player: Player;
    } & {
        next: (value?: Partial<{
            player: Player;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onSpawn: (cb: (ret: {
        player: Player;
    } & {
        next: (value?: Partial<{
            player: Player;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStateChange: (cb: (ret: {
        player: Player;
        newState: PlayerStateEnum;
        oldState: PlayerStateEnum;
    } & {
        next: (value?: Partial<{
            player: Player;
            newState: PlayerStateEnum;
            oldState: PlayerStateEnum;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamIn: (cb: (ret: {
        player: Player;
        forPlayer: Player | undefined;
    } & {
        next: (value?: Partial<{
            player: Player;
            forPlayer: Player | undefined;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamOut: (cb: (ret: {
        player: Player;
        forPlayer: Player | undefined;
    } & {
        next: (value?: Partial<{
            player: Player;
            forPlayer: Player | undefined;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onTakeDamage: (cb: (ret: {
        player: Player;
        damage: Player | InvalidEnum.PLAYER_ID;
        amount: number;
        weapon: WeaponEnum;
        bodyPart: BodyPartsEnum;
    } & {
        next: (value?: Partial<{
            player: Player;
            damage: Player | InvalidEnum.PLAYER_ID;
            amount: number;
            weapon: WeaponEnum;
            bodyPart: BodyPartsEnum;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onInteriorChange: (cb: (ret: {
        player: Player;
        newInteriorId: number;
        oldInteriorId: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            newInteriorId: number;
            oldInteriorId: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onRequestDownload: (cb: (ret: {
        player: Player;
        type: number;
        crc: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            type: number;
            crc: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onFinishedDownloading: (cb: (ret: {
        player: Player;
        virtualWorld: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            virtualWorld: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCheckResponse: (cb: (ret: {
        player: Player;
        actionId: number;
        memAddr: number;
        data: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            actionId: number;
            memAddr: number;
            data: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCommandReceived: (cb: (ret: {
        player: Player;
        command: string;
        cmdText: string;
        buffer: number[];
        strictMainCmd: string;
        noStrictMainCmd: string;
        hasStrict: boolean;
        hasNoStrict: boolean;
        subcommand: string[];
    } & {
        next: (value?: Partial<{
            player: Player;
            command: string;
            cmdText: string;
            buffer: number[];
            strictMainCmd: string;
            noStrictMainCmd: string;
            hasStrict: boolean;
            hasNoStrict: boolean;
            subcommand: string[];
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCommandPerformed: (cb: (ret: {
        player: Player;
        command: string;
        cmdText: string;
        buffer: number[];
        strictMainCmd: string;
        noStrictMainCmd: string;
        hasStrict: boolean;
        hasNoStrict: boolean;
        subcommand: string[];
    } & {
        next: (value?: Partial<{
            player: Player;
            command: string;
            cmdText: string;
            buffer: number[];
            strictMainCmd: string;
            noStrictMainCmd: string;
            hasStrict: boolean;
            hasNoStrict: boolean;
            subcommand: string[];
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCommandError: (cb: (ret: {
        player: Player;
        error: CommandErrorRet;
        command: string;
        cmdText: string;
        buffer: number[];
        strictMainCmd: string;
        noStrictMainCmd: string;
        hasStrict: boolean;
        hasNoStrict: boolean;
        subcommand: string[];
        getSuggestion(): {
            suggestion: string;
            distance: number;
        };
    } & {
        next: (value?: Partial<{
            player: Player;
            error: CommandErrorRet;
            command: string;
            cmdText: string;
            buffer: number[];
            strictMainCmd: string;
            noStrictMainCmd: string;
            hasStrict: boolean;
            hasNoStrict: boolean;
            subcommand: string[];
            getSuggestion(): {
                suggestion: string;
                distance: number;
            };
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCommandText: typeof CmdBus.on;
    offCommandText: typeof CmdBus.off;
    onDialogResponse: (cb: (ret: {
        player: Player;
        dialogId: number;
        response: number;
        listItem: number;
        buffer: number[];
        inputText: string;
    } & {
        next: (value?: Partial<{
            player: Player;
            dialogId: number;
            response: number;
            listItem: number;
            buffer: number[];
            inputText: string;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onLocaleChange: (cb: (ret: {
        player: Player;
        newLocale: string;
        oldLocale: string;
    } & {
        next: (value?: Partial<{
            player: Player;
            newLocale: string;
            oldLocale: string;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCharsetChange: (cb: (ret: {
        player: Player;
        newCharset: string;
        oldCharset: string;
    } & {
        next: (value?: Partial<{
            player: Player;
            newCharset: string;
            oldCharset: string;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onFpsUpdate: (cb: (ret: {
        player: Player;
        newFps: number;
        oldFps: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            newFps: number;
            oldFps: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onWeaponShot: (cb: (ret: {
        player: Player;
        weapon: WeaponEnum;
        hitType: BulletHitTypesEnum;
        hitId: number;
        fX: number;
        fY: number;
        fZ: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            weapon: WeaponEnum;
            hitType: BulletHitTypesEnum;
            hitId: number;
            fX: number;
            fY: number;
            fZ: number;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onAndroidCheck: (cb: (ret: {
        player: Player;
        result: boolean;
    } & {
        next: (value?: Partial<{
            player: Player;
            result: boolean;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onCommandTextRaw: (cb: (ret: {
        player: Player;
        buffer: number[];
        cmdText: string;
    } & {
        next: (value?: Partial<{
            player: Player;
            buffer: number[];
            cmdText: string;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
}>;

interface IDialog {
    style?: DialogStylesEnum;
    caption?: string;
    info?: string;
    button1?: string;
    button2?: string;
}
interface IDialogResCommon {
    buffer: number[];
    inputText: string;
    response: number;
    listItem: number;
}
interface IVehicle {
    modelId: number;
    x: number;
    y: number;
    z: number;
    zAngle: number;
    color: [string | number, string | number];
    respawnDelay?: 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;
    charset?: string;
}
interface IDialogFuncQueue {
    showId: number;
    resolve: (value: IDialogResCommon | PromiseLike<IDialogResCommon>) => 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>) => Array<() => void> | Promise<Array<() => void>>;
    unload: () => any;
    [propName: string | number | symbol]: any;
}
interface ICommonRetVal {
    ret: number;
}

declare class Vehicle {
    private sourceInfo;
    private readonly isStatic;
    private static createdCount;
    private _id;
    get id(): number;
    constructor(vehOrId: IVehicle | number, isStatic?: boolean);
    create(ignoreRange?: boolean): void;
    destroy(): void;
    addComponent(componentId: number): number;
    removeComponent(componentId: number): number;
    getComponentInSlot(slot: CarModTypeEnum): number;
    linkToInterior(interiorId: number): number;
    setVirtualWorld(worldId: number): number;
    getVirtualWorld(): number;
    repair(): number;
    setPos(x: number, y: number, z: number): boolean;
    getPos(): {
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    getHealth(): {
        health: number;
        ret: number;
    };
    setHealth(health: number): number;
    isPlayerIn(player: Player): boolean;
    putPlayerIn(player: Player, seatId: number): boolean | 0;
    getZAngle(): {
        angle: number;
        ret: number;
    };
    setZAngle(zAngle: number): number;
    setNumberPlate(numberplate: string): number;
    changeColors(color1: string | number, color2: string | number): number;
    setVelocity(X: number, Y: number, Z: number): boolean;
    getVelocity(): {
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    getSpeed(magic?: number): number;
    setAngularVelocity(X: number, Y: number, Z: number): boolean;
    getDamageStatus(): {
        panels: number;
        doors: number;
        lights: number;
        tires: number;
        ret: number;
    };
    updateDamageStatus(panels: number, doors: number, lights: number, tires: number): number;
    getDistanceFromPoint(X: number, Y: number, Z: number): number;
    getModel(): number;
    static getModelInfo(vehicleModel: number, infoType: VehicleModelInfoEnum): {
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    getModelInfo(infoType: VehicleModelInfoEnum): {
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    getRotationQuat(): {
        w: number;
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    setRespawn(): 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;
        ret: number;
    };
    getParamsCarWindows(): {
        driver: 0 | 1 | -1;
        passenger: 0 | 1 | -1;
        backLeft: 0 | 1 | -1;
        backRight: 0 | 1 | -1;
        ret: number;
    };
    setParamsEx(engine: boolean | VehicleParamsEnum, lights: boolean | VehicleParamsEnum, alarm: boolean | VehicleParamsEnum, doors: boolean | VehicleParamsEnum, bonnet: boolean | VehicleParamsEnum, boot: boolean | VehicleParamsEnum, objective: boolean | VehicleParamsEnum): number;
    getParamsEx(): {
        engine: number;
        lights: number;
        alarm: number;
        doors: number;
        bonnet: number;
        boot: number;
        objective: number;
    };
    toggleEngine(value: boolean | VehicleParamsEnum): number;
    toggleLights(value: boolean | VehicleParamsEnum): number;
    toggleAlarm(value: boolean | VehicleParamsEnum): number;
    toggleDoors(value: boolean | VehicleParamsEnum): number;
    toggleBonnet(value: boolean | VehicleParamsEnum): number;
    toggleBoot(value: boolean | VehicleParamsEnum): number;
    toggleObjective(value: boolean | VehicleParamsEnum): number;
    getParamsSirenState(): number;
    setParamsForPlayer(player: Player, objective: boolean, doorsLocked: boolean): number;
    isTrailerAttached(): boolean;
    changePaintjob(paintjobId: 0 | 1 | 2): number;
    attachTrailer(trailer: Vehicle): number;
    detachTrailer(): void;
    getTrailer(): Vehicle | undefined;
    isValid(): boolean;
    getMatrix(): IVehMatrix & ICommonRetVal;
    getTrainSpeed(): number;
    getHydraReactorAngle(): number;
    getLandingGearState(): number;
    getSirenState(): number;
    getDriver(): Player | undefined;
    getLastDriver(): Player | undefined;
    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(): {
        plate: string;
        ret: number;
    };
    getInterior(): number;
    getPaintjob(): number;
    getColors(): IVehColor & ICommonRetVal;
    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 & ICommonRetVal;
    getRandomColorPair(): {
        color: [number, number, number, number];
        ret: number;
    };
    show(): boolean;
    hide(): boolean;
    isHidden(): boolean;
    getVehicleOccupant(seatId: number): number;
    getVehicleMaxPassengers(): number;
    countVehicleOccupants(): number;
    static getVehicleMaxPassengers: (modelId: number) => number;
    static getRandomColorPair: (modelId: number) => {
        color: [number, number, number, number];
        ret: number;
    };
    static getComponentType: (component: number) => CarModTypeEnum;
    static colorIndexToColor: (index: number, alpha?: number) => number;
    static isValid: (vehicleId: number) => boolean;
    static getModelsUsed: () => number;
    static getModelCount: (modelId: number) => number;
    static getInstance(id: number): Vehicle | undefined;
    static getInstances(): Vehicle[];
    static __inject_AddStaticVehicle: (modelId: number, spawnX: number, spawnY: number, spawnZ: number, zAngle: number, color1: string | number, color2: string | number) => number;
    static __inject_AddStaticVehicleEx: (modelId: number, spawnX: number, spawnY: number, spawnZ: number, zAngle: number, color1: string | number, color2: string | number, respawnDelay: number, addSiren: boolean) => number;
    static __inject_CreateVehicle: (vehicleType: number, x: number, y: number, z: number, rotation: number, color1: string | number, color2: string | number, respawnDelay: number, addSiren: boolean) => number;
    static __inject_DestroyVehicle: (vehicleId: number) => number;
}

declare class DynamicMapIcon {
    private sourceInfo;
    private _id;
    get id(): number;
    constructor(mapIconOrId: IDynamicMapIcon | null);
    create(): this;
    destroy(): this;
    isValid(): boolean;
    toggleCallbacks(toggle?: boolean): number;
    isToggleCallbacks(): boolean;
    static isValid: (iconId: number) => boolean;
    static togglePlayerUpdate(player: Player, update?: boolean): number;
    static hideForPlayer(player: Player, z?: number): number;
    static showForPlayer(player: Player, z?: number): number;
    static getInstance(id: number): DynamicMapIcon | undefined;
    static getInstances(): DynamicMapIcon[];
}

declare const DynamicMapIconEvent: Readonly<{
    onStreamIn: (cb: (ret: {
        player: Player;
        instance: DynamicMapIcon;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicMapIcon;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamOut: (cb: (ret: {
        player: Player;
        instance: DynamicMapIcon;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicMapIcon;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
}>;

declare class DynamicPickup {
    private sourceInfo;
    private _id;
    get id(): number;
    constructor(pickupOrId: IDynamicPickup | null);
    create(): this;
    destroy(): this;
    isValid(): boolean;
    toggleCallbacks(toggle?: boolean): number;
    isToggleCallbacks(): boolean;
    static isValid: (pickupId: number) => boolean;
    static togglePlayerUpdate(player: Player, update?: boolean): number;
    static hideForPlayer(player: Player, z?: number): number;
    static showForPlayer(player: Player, z?: number): number;
    static getInstance(id: number): DynamicPickup | undefined;
    static getInstances(): DynamicPickup[];
    static __inject_CreateDynamicPickup: (modelId: number, type: number, x: number, y: number, z: number, worldId?: number, interiorId?: number, playerId?: number, streamDistance?: number, areaId?: number, priority?: number) => number;
    static __inject_CreateDynamicPickupEx: (modelId: number, type: number, x: number, y: number, z: number, streamDistance?: number, worlds?: number[], interiors?: number[], players?: number[], areas?: number[], priority?: number) => number;
    static __inject_DestroyDynamicPickup: (pickupId: number) => boolean;
}

declare const DynamicPickupEvent: Readonly<{
    onPlayerPickUp: (cb: (ret: {
        player: Player;
        pickup: DynamicPickup;
    } & {
        next: (value?: Partial<{
            player: Player;
            pickup: DynamicPickup;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamIn: (cb: (ret: {
        player: Player;
        instance: DynamicPickup;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicPickup;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamOut: (cb: (ret: {
        player: Player;
        instance: DynamicPickup;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicPickup;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
}>;

declare class DynamicCheckpoint {
    private sourceInfo;
    private _id;
    get id(): number;
    constructor(checkPointOrId: IDynamicCheckPoint | number);
    create(): this;
    destroy(): this;
    isValid(): boolean;
    togglePlayer(player: Player, toggle: boolean): this;
    isPlayerIn(player: Player): boolean;
    toggleCallbacks(toggle?: boolean): number;
    isToggleCallbacks(): boolean;
    static isValid: (checkpointId: number) => boolean;
    static togglePlayerAll(player: Player, toggle: boolean): number;
    static getPlayerVisible(player: Player): DynamicCheckpoint | undefined;
    static togglePlayerUpdate(player: Player, update?: boolean): number;
    static hideForPlayer(player: Player, z?: number): number;
    static showForPlayer(player: Player, z?: number): number;
    static getInstance(id: number): DynamicCheckpoint | undefined;
    static getInstances(): DynamicCheckpoint[];
}

declare const DynamicCheckPointEvent: Readonly<{
    onPlayerEnter: (cb: (ret: {
        player: Player;
        cp: DynamicCheckpoint;
    } & {
        next: (value?: Partial<{
            player: Player;
            cp: DynamicCheckpoint;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onPlayerLeave: (cb: (ret: {
        player: Player;
        cp: DynamicCheckpoint;
    } & {
        next: (value?: Partial<{
            player: Player;
            cp: DynamicCheckpoint;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamIn: (cb: (ret: {
        player: Player;
        instance: DynamicCheckpoint;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicCheckpoint;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamOut: (cb: (ret: {
        player: Player;
        instance: DynamicCheckpoint;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicCheckpoint;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
}>;

declare class DynamicRaceCP {
    private sourceInfo;
    private _id;
    get id(): number;
    constructor(checkPointOrId: IDynamicRaceCp | number);
    create(): this;
    destroy(): this;
    isValid(): boolean;
    togglePlayer(player: Player, toggle: boolean): this;
    static togglePlayerAll(player: Player, toggle: boolean): number;
    isPlayerIn(player: Player): boolean;
    static getPlayerVisible(player: Player): DynamicRaceCP | undefined;
    toggleCallbacks(toggle?: boolean): number;
    isToggleCallbacks(): boolean;
    static isValid: (checkpointId: number) => boolean;
    static togglePlayerUpdate(player: Player, update?: boolean): number;
    static hideForPlayer(player: Player, z?: number): number;
    static showForPlayer(player: Player, z?: number): number;
    static getInstance(id: number): DynamicRaceCP | undefined;
    static getInstances(): DynamicRaceCP[];
}

declare const DynamicRaceCPEvent: Readonly<{
    onPlayerEnter: (cb: (ret: {
        player: Player;
        raceCP: DynamicRaceCP;
    } & {
        next: (value?: Partial<{
            player: Player;
            raceCP: DynamicRaceCP;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onPlayerLeave: (cb: (ret: {
        player: Player;
        raceCp: DynamicRaceCP;
    } & {
        next: (value?: Partial<{
            player: Player;
            raceCp: DynamicRaceCP;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamIn: (cb: (ret: {
        player: Player;
        instance: DynamicRaceCP;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicRaceCP;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamOut: (cb: (ret: {
        player: Player;
        instance: DynamicRaceCP;
    } & {
        next: (value?: Partial<{
            player: Player;
            instance: DynamicRaceCP;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
}>;

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 {
    xMax: number;
    xMin: number;
    yMax: number;
    yMin: number;
}

interface ICheckPoint {
    fX: number;
    fY: number;
    fZ: number;
    fSize: number;
}
interface IRaceCheckPoint extends ICheckPoint {
    fNextX: number;
    fNextY: number;
    fNextZ: number;
}

interface IGangZonePos {
    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 {
    attachedVehicleId: number;
    attachedObjectId?: number;
    attachedPlayerId: number;
}

interface IOffsets {
    fOffsetX: number;
    fOffsetY: number;
    fOffsetZ: number;
}

interface IPlayerClass {
    teamId: number;
    modelId: number;
    spawnX: number;
    spawnY: number;
    spawnZ: number;
    zAngle: number;
    weapon1: number;
    weapon1Ammo: number;
    weapon2: number;
    weapon2Ammo: number;
    weapon3: number;
    weapon3Ammo: 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 {
    private sourceInfo;
    private _id;
    get id(): number;
    constructor(actorOrId: IDynamicActor | number);
    create(): this;
    destroy(): this;
    isValid(): boolean;
    isStreamedIn(forPlayer: Player): boolean;
    getVirtualWorld(): number;
    setVirtualWorld(vWorld: number): number;
    applyAnimation(animLib: string, animName: string, speed?: number, loop?: boolean, lockX?: boolean, lockY?: boolean, freeze?: boolean, time?: number): number;
    clearAnimations(): number;
    getFacingAngle(): {
        angle: number;
        ret: number;
    };
    setFacingAngle(ang: number): number;
    getPos(): {
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    setPos(x: number, y: number, z: number): number;
    getHealth(): {
        health: number;
        ret: number;
    };
    setHealth(health: number): number;
    isInvulnerable(): boolean;
    setInvulnerable(invulnerable?: boolean): number;
    getPlayerTarget(player: Player): DynamicActor | undefined;
    getPlayerCameraTarget(player: Player): DynamicActor | undefined;
    getSkin(): number;
    setSkin(model: number, ignoreRange?: boolean): number;
    getSpawnInfo(): IActorSpawn & ICommonRetVal;
    getAnimation(): {
        animLib: string;
        animName: string;
        fDelta: number;
        loop: number;
        lockX: number;
        lockY: number;
        freeze: number;
        time: number;
        ret: number;
    };
    toggleCallbacks(toggle?: boolean): number;
    isToggleCallbacks(): boolean;
    static isValid: (actorId: number) => boolean;
    static togglePlayerUpdate(player: Player, update?: boolean): number;
    static hideForPlayer(player: Player, z?: number): number;
    static showForPlayer(player: Player, z?: number): number;
    static getInstance(id: number): DynamicActor | undefined;
    static getInstances(): DynamicActor[];
}

declare const DynamicActorEvent: Readonly<{
    onStreamIn: (cb: (ret: {
        actor: DynamicActor;
        forPlayer: Player;
    } & {
        next: (value?: Partial<{
            actor: DynamicActor;
            forPlayer: Player;
        }> | undefined) => CallbackRet;
        defaultValue: boolean | undefined;
    }) => PromisifyCallbackRet, unshift?: boolean) => () => number | undefined;
    onStreamOut: (cb: (ret: {
        actor: DynamicActor;
        forPlayer: Player;
    } & {
        next: (value?: