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

Node.js library for Scripting Open Multiplayer

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 enum StreamerAreaTypes {
    CIRCLE = 0,
    CYLINDER = 1,
    SPHERE = 2,
    RECTANGLE = 3,
    CUBOID = 4,
    POLYGON = 5
}

declare enum StreamerDistances {
    OBJECT_SD = 300,
    OBJECT_DD = 0,
    PICKUP_SD = 200,
    CP_SD = 200,
    RACE_CP_SD = 200,
    MAP_ICON_SD = 200,
    TEXT_3D_LABEL_SD = 200,
    ACTOR_SD = 200
}

declare enum StreamerItemTypes {
    OBJECT = 0,
    PICKUP = 1,
    CP = 2,
    RACE_CP = 3,
    MAP_ICON = 4,
    TEXT_3D_LABEL = 5,
    AREA = 6,
    ACTOR = 7
}
type StreamerItemTypeTuple = [
    StreamerItemTypes,
    StreamerItemTypes,
    StreamerItemTypes,
    StreamerItemTypes,
    StreamerItemTypes,
    StreamerItemTypes,
    StreamerItemTypes,
    StreamerItemTypes
];

declare enum StreamerMiscellaneous {
    MAX_TYPES = 8,
    MAX_AREA_TYPES = 5,
    MAX_OBJECT_TYPES = 3,
    INVALID_ID = 0
}

declare enum StreamerObjectTypes {
    GLOBAL = 0,
    PLAYER = 1,
    DYNAMIC = 2
}

declare enum E_STREAMER {
    AREA_ID = 0,
    ATTACHED_OBJECT = 1,
    ATTACHED_PLAYER = 2,
    ATTACHED_VEHICLE = 3,
    ATTACH_OFFSET_X = 4,
    ATTACH_OFFSET_Y = 5,
    ATTACH_OFFSET_Z = 6,
    ATTACH_R_X = 7,
    ATTACH_R_Y = 8,
    ATTACH_R_Z = 9,
    ATTACH_X = 10,
    ATTACH_Y = 11,
    ATTACH_Z = 12,
    COLOR = 13,
    DRAW_DISTANCE = 14,
    EXTRA_ID = 15,
    HEALTH = 16,
    INTERIOR_ID = 17,
    INVULNERABLE = 18,
    MAX_X = 19,
    MAX_Y = 20,
    MAX_Z = 21,
    MIN_X = 22,
    MIN_Y = 23,
    MIN_Z = 24,
    MODEL_ID = 25,
    MOVE_R_X = 26,
    MOVE_R_Y = 27,
    MOVE_R_Z = 28,
    MOVE_SPEED = 29,
    MOVE_X = 30,
    MOVE_Y = 31,
    MOVE_Z = 32,
    NEXT_X = 33,
    NEXT_Y = 34,
    NEXT_Z = 35,
    PLAYER_ID = 36,
    PRIORITY = 37,
    ROTATION = 38,
    R_X = 39,
    R_Y = 40,
    R_Z = 41,
    SIZE = 42,
    STREAM_DISTANCE = 43,
    STYLE = 44,
    SYNC_ROTATION = 45,
    TEST_LOS = 46,
    TYPE = 47,
    WORLD_ID = 48,
    X = 49,
    Y = 50,
    Z = 51
}
declare enum MaterialTextAlign {
    LEFT = 0,
    CENTER = 1,
    RIGHT = 2
}
declare enum MaterialTextSizes {
    SIZE_32x32 = 10,
    SIZE_64x32 = 20,
    SIZE_64x64 = 30,
    SIZE_128x32 = 40,
    SIZE_128x64 = 50,
    SIZE_128x128 = 60,
    SIZE_256x32 = 70,
    SIZE_256x64 = 80,
    SIZE_256x128 = 90,
    SIZE_256x256 = 100,
    SIZE_512x64 = 110,
    SIZE_512x128 = 120,
    SIZE_512x256 = 130,
    SIZE_512x512 = 140
}

type StreamerArrayData = E_STREAMER.AREA_ID | E_STREAMER.EXTRA_ID | E_STREAMER.INTERIOR_ID | E_STREAMER.PLAYER_ID | E_STREAMER.WORLD_ID;

declare enum MapIconStyles {
    LOCAL = 0,
    GLOBAL = 1,
    LOCAL_CHECKPOINT = 2,
    GLOBAL_CHECKPOINT = 3
}

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 {
    UNKNOWN = -1,
    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,
    NPC_ID = -1,
    PATH_ID = -1,
    NODE_ID = -1,
    RECORD_ID = -1,
    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,
    PICKUP_ID = -1
}

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,
    NPC_MAX_NODES = 64,
    MAX_NPCS = 1000,
    MAX_WORLD_BOUNDS = 20000,
    MIN_WORLD_BOUNDS = -20000,
    MAX_TEXTDRAW_STR_LENGTH = 800,
    MAX_VEHICLE_CARRIAGES = 3,
    MAX_GAMETEXT_STYLES = 16,
    MIN_CUSTOM_SKIN_ID = 20001,
    MAX_CUSTOM_SKIN_ID = 30000,
    MIN_CUSTOM_OBJECT_ID = -30000,
    MAX_CUSTOM_OBJECT_ID = -1000
}

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

declare enum NPCPlaybackEnum {
    NONE = 1,
    DRIVER = 2,
    ONFOOT = 3
}
declare enum NPCRecordStatusEnum {
    NONE = 0,
    START = 1,
    PAUSE = 2
}
declare enum NPCMoveTypeEnum {
    UNKNOWN = -1,
    NONE = 0,
    WALK = 1,
    JOG = 2,
    SPRINT = 3,
    DRIVE = 4,
    AUTO = 5
}
declare enum NPCEntityCheckEnum {
    NONE = 0,
    PLAYER = 1,
    NPC = 2,
    ACTOR = 4,
    VEHICLE = 8,
    OBJECT = 16,
    POBJECT_ORIG = 32,
    POBJECT_TARG = 64,
    MAP = 128,
    ALL = 255
}
declare enum NPCMoveSpeedEnum {
    AUTO = -1,
    WALK = 0.1552086,
    JOG = 0.56444,
    SPRINT = 0.926784
}

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 {
    UNKNOWN = -1,
    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 LandingGearStateEnum {
    DOWN = 0,
    UP = 1
}

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,
    NIGHTSTICK = 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;
};

declare function GetPlayerMarkerForPlayer(playerId: number, targetId: number): number;

declare function CreatePlayerPickup(playerId: number, model: number, type: number, x: number, y: number, z: number, virtualWorld?: number): any;
declare function DestroyPlayerPickup(playerId: number, pickupId: number): boolean;
declare function IsValidPlayerPickup(playerId: number, pickupId: number): boolean;
declare function IsPlayerPickupStreamedIn(playerId: number, pickupId: number): boolean;
declare function GetPlayerPickupPos(playerId: number, pickupId: number): {
    x: any;
    y: any;
    z: any;
    ret: boolean;
};
declare function SetPlayerPickupPos(playerId: number, pickupId: number, x: number, y: number, z: number, update?: boolean): boolean;
declare function SetPlayerPickupModel(playerId: number, pickupId: number, model: number, update?: boolean): boolean;
declare function SetPlayerPickupType(playerId: number, pickupId: number, type: number, update?: boolean): boolean;
declare function SetPlayerPickupVirtualWorld(playerId: number, pickupId: number, virtualWorld: number): boolean;
declare function GetPlayerPickupModel(playerId: number, pickupId: number): number;
declare function GetPlayerPickupType(playerId: number, pickupId: number): number;
declare function GetPlayerPickupVirtualWorld(playerId: number, pickupId: number): number;

declare class Vehicle {
    private sourceInfo;
    private readonly isStatic;
    private static createdCount;
    private _id;
    get id(): number;
    constructor(vehOrId: IVehicle | number, isStatic?: boolean);
    create(): void;
    destroy(): void;
    addComponent(componentId: number): boolean;
    removeComponent(componentId: number): boolean;
    getComponentInSlot(slot: CarModTypeEnum): number;
    linkToInterior(interiorId: number): boolean;
    setVirtualWorld(worldId: number): boolean;
    getVirtualWorld(): number;
    repair(): boolean;
    setPos(x: number, y: number, z: number): boolean;
    getPos(): {
        x: number;
        y: number;
        z: number;
        ret: boolean;
    };
    getHealth(): {
        health: number;
        ret: boolean;
    };
    setHealth(health: number): boolean;
    isPlayerIn(player: Player): boolean;
    putPlayerIn(player: Player, seatId: number): boolean | 0;
    getZAngle(): {
        angle: number;
        ret: boolean;
    };
    setZAngle(zAngle: number): boolean;
    setNumberPlate(numberplate: string): boolean;
    changeColors(color1: string | number, color2: string | number): boolean;
    setVelocity(X: number, Y: number, Z: number): boolean;
    getVelocity(): {
        x: number;
        y: number;
        z: number;
        ret: boolean;
    };
    getSpeed(magic?: number): number;
    setAngularVelocity(X: number, Y: number, Z: number): boolean;
    getDamageStatus(): {
        panels: number;
        doors: number;
        lights: number;
        tires: number;
        ret: boolean;
    };
    updateDamageStatus(panels: number, doors: number, lights: number, tires: number): boolean;
    getDistanceFromPoint(X: number, Y: number, Z: number): number;
    getModel(): number;
    static getModelInfo(vehicleModel: number, infoType: VehicleModelInfoEnum): {
        x: number;
        y: number;
        z: number;
        ret: boolean;
    };
    getModelInfo(infoType: VehicleModelInfoEnum): {
        x: number;
        y: number;
        z: number;
        ret: boolean;
    };
    getRotation(): {
        x: number;
        y: number;
        z: number;
        ret: number;
    };
    getRotationQuat(): {
        w: number;
        x: number;
        y: number;
        z: number;
        ret: boolean;
    };
    setRespawn(): boolean;
    isStreamedIn(forPlayer: Player): boolean;
    setParamsCarDoors(driver?: boolean | VehicleParamsEnum, passenger?: boolean | VehicleParamsEnum, backLeft?: boolean | VehicleParamsEnum, backRight?: boolean | VehicleParamsEnum): boolean;
    setParamsCarWindows(driver?: boolean | VehicleParamsEnum, passenger?: boolean | VehicleParamsEnum, backLeft?: boolean | VehicleParamsEnum, backRight?: boolean | VehicleParamsEnum): boolean | 0;
    getParamsCarDoors(): {
        driver: VehicleParamsEnum;
        passenger: VehicleParamsEnum;
        backLeft: VehicleParamsEnum;
        backRight: VehicleParamsEnum;
        ret: boolean;
    };
    getParamsCarWindows(): {
        driver: VehicleParamsEnum;
        passenger: VehicleParamsEnum;
        backLeft: VehicleParamsEnum;
        backRight: VehicleParamsEnum;
        ret: boolean;
    };
    setParamsEx(engine: boolean | VehicleParamsEnum, lights: boolean | VehicleParamsEnum, alarm: boolean | VehicleParamsEnum, doors: boolean | VehicleParamsEnum, bonnet: boolean | VehicleParamsEnum, boot: boolean | VehicleParamsEnum, objective: boolean | VehicleParamsEnum): boolean;
    getParamsEx(): {
        engine: VehicleParamsEnum;
        lights: VehicleParamsEnum;
        alarm: VehicleParamsEnum;
        doors: VehicleParamsEnum;
        bonnet: VehicleParamsEnum;
        boot: VehicleParamsEnum;
        objective: VehicleParamsEnum;
        ret: boolean;
    };
    toggleEngine(value: boolean | VehicleParamsEnum): boolean | 0;
    toggleLights(value: boolean | VehicleParamsEnum): boolean | 0;
    toggleAlarm(value: boolean | VehicleParamsEnum): boolean | 0;
    toggleDoors(value: boolean | VehicleParamsEnum): boolean | 0;
    toggleBonnet(value: boolean | VehicleParamsEnum): boolean | 0;
    toggleBoot(value: boolean | VehicleParamsEnum): boolean | 0;
    toggleObjective(value: boolean | VehicleParamsEnum): boolean | 0;
    getParamsSirenState(): VehicleParamsEnum;
    setParamsForPlayer(player: Player, objective?: boolean | VehicleParamsEnum, doorsLocked?: boolean | VehicleParamsEnum): boolean;
    isTrailerAttached(): boolean;
    changePaintjob(paintjobId: number): boolean;
    attachTrailer(trailer: Vehicle): boolean;
    detachTrailer(): void;
    getTrailer(): Vehicle | undefined;
    isValid(): boolean;
    getMatrix(): IVehMatrix & ICommonRetVal<boolean>;
    getTrainSpeed(): number;
    getHydraReactorAngle(): number;
    getLandingGearState(): LandingGearStateEnum;
    getSirenState(): boolean;
    getDriver(): Player | undefined;
    getLastDriver(): Player | undefined;
    isSirenEnabled(): boolean;
    toggleSirenEnabled(enabled: boolean): boolean;
    setParamsSirenState(enabled: boolean | VehicleParamsEnum): boolean;
    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): boolean;
    getNumberPlate(): {
        plate: string;
        ret: boolean;
    };
    getInterior(): number;
    getPaintjob(): number;
    getColors(): IVehColor & ICommonRetVal<boolean>;
    setSpawnInfo(modelId: number, fX: number, fY: number, fZ: number, fAngle: number, color1: string | number, color2: string | number, respawnTime?: number, interior?: number): boolean;
    getSpawnInfo(): IVehSpawnInfo & ICommonRetVal<boolean>;
    getRandomColorPair(): {
        color: [number, number, number, number];
        ret: boolean;
    };
    show(): boolean;
    hide(): boolean;
    isHidden(): boolean;
    getOccupant(seatId: number): number;
    getMaxPassengers(): number;
    countOccupants(): number;
    canHaveComponent(componentId: number): boolean;
    getSeats(): number;
    static getMaxPassengers(modelId: number): number;
    static getRandomColorPair(modelId: number): {
        color: [number, number, number, number];
        ret: boolean;
    };
    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 canHaveComponent(modelId: number, componentId: number): boolean;
    static getSeats(modelId: number): number;
    static getInstance(id: number): Vehicle | undefined;
    static getInstances(): Vehicle[];
    static __inject__: {
        addStatic: (modelId: number, spawnX: number, spawnY: number, spawnZ: number, zAngle: number, color1: string | number, color2: string | number) => number;
        addStaticEx: (modelId: number, spawnX: number, spawnY: number, spawnZ: number, zAngle: number, color1: string | number, color2: string | number, respawnDelay: number, addSiren: boolean) => number;
        create: (vehicleType: number, x: number, y: number, z: number, rotation: number, color1: string | number, color2: string | number, respawnDelay: number, addSiren: boolean) => number;
        destroy: (vehicleId: number) => boolean;
        addComponent: (vehicleId: number, componentId: number) => boolean;
        removeComponent: (vehicleId: number, componentId: number) => boolean;
        getComponentInSlot: (vehicleId: number, slot: CarModTypeEnum) => number;
        linkToInterior: (vehicleId: number, interiorId: number) => boolean;
        setVirtualWorld: (vehicleId: number, worldId: number) => boolean;
        getVirtualWorld: (vehicleId: number) => number;
        repair: (vehicleId: number) => boolean;
        setPos: (vehicleId: number, x: number, y: number, z: number) => boolean;
        getPos: (vehicleId: number) => {
            x: number;
            y: number;
            z: number;
            ret: boolean;
        };
        getHealth: (vehicleId: number) => {
            health: number;
            ret: boolean;
        };
        setHealth: (vehicleId: number, health: number) => boolean;
        isPlayerIn: (playerId: number, vehicleId: number) => boolean;
        putPlayerIn: (playerId: number, vehicleId: number, seatId: number) => boolean;
        getZAngle: (vehicleId: number) => {
            angle: number;
            ret: boolean;
        };
        setZAngle: (vehicleId: number, zAngle: number) => boolean;
        setNumberPlate: (vehicleId: number, numberplate: string) => boolean;
        changeColors: (vehicleId: number, color1: string | number, color2: string | number) => boolean;
        setVelocity: (vehicleId: number, x: number, y: number, z: number) => boolean;
        getVelocity: (vehicleId: number) => {
            x: number;
            y: number;
            z: number;
            ret: boolean;
        };
        setAngularVelocity: (vehicleId: number, x: number, y: number, z: number) => boolean;
        getDamageStatus: (vehicleId: number) => {
            panels: number;
            doors: number;
            lights: number;
            tires: number;
            ret: boolean;
        };
        updateDamageStatus: (vehicleId: number, panels: number, doors: number, lights: number, tires: number) => boolean;
        getDistanceFromPoint: (vehicleId: number, x: number, y: number, z: number) => number;
        getModel: (vehicleId: number) => number;
        getModelInfo: (vehicleModel: number, infoType: VehicleModelInfoEnum) => {
            x: number;
            y: number;
            z: number;
            ret: boolean;
        };
        getRotation: (vehicleId: number) => {
            x: number;
            y: number;
            z: number;
            ret: number;
        };
        getRotationQuat: (vehicleId: number) => {
            w: number;
            x: number;
            y: number;
            z: number;
            ret: boolean;
        };
        setRespawn: (vehicleId: number) => boolean;
        isStreamedIn: (vehicleId: number, forPlayerId: number) => boolean;
        setParamsCarDoors: (vehicleId: number, driver?: boolean | VehicleParamsEnum, passenger?: boolean | VehicleParamsEnum, backLeft?: boolean | VehicleParamsEnum, backRight?: boolean | VehicleParamsEnum) => boolean;
        setParamsCarWindows: (vehicleId: number, driver?: boolean | VehicleParamsEnum, passenger?: boolean | VehicleParamsEnum, backLeft?: boolean | VehicleParamsEnum, backRight?: boolean | VehicleParamsEnum) => boolean;
        getParamsCarDoors: (vehicleId: number) => {
            driver: VehicleParamsEnum;
            passenger: VehicleParamsEnum;
            backLeft: VehicleParamsEnum;
            backRight: VehicleParamsEnum;
            ret: boolean;
        };
        getParamsCarWindows: (vehicleId: number) => {
            driver: VehicleParamsEnum;
            passenger: VehicleParamsEnum;
            backLeft: VehicleParamsEnum;
            backRight: VehicleParamsEnum;
            ret: boolean;
        };
        setParamsEx: (vehicleId: number, engine: boolean | VehicleParamsEnum, lights: boolean | VehicleParamsEnum, alarm: boolean | VehicleParamsEnum, doors: boolean | VehicleParamsEnum, bonnet: boolean | VehicleParamsEnum, boot: boolean | VehicleParamsEnum, objective: boolean | VehicleParamsEnum) => boolean;
        getParamsEx: (vehicleId: number) => [VehicleParamsEnum, VehicleParamsEnum, VehicleParamsEnum, VehicleParamsEnum, VehicleParamsEnum, VehicleParamsEnum, VehicleParamsEnum, number];
        getParamsSirenState: (vehicleId: number) => VehicleParamsEnum;
        setParamsForPlayer: (vehicleId: number, playerId: number, objective?: boolean | VehicleParamsEnum, doorsLocked?: boolean | VehicleParamsEnum) => boolean;
        isTrailerAttached: (vehicleId: number) => boolean;
        changePaintjob: (vehicleId: number, paintjobId: number) => boolean;
        attachTrailer: (trailerid: number, vehicleId: number) => boolean;
        detachTrailer: (vehicleId: number) => boolean;
        getMatrix: (vehicleId: number) => IVehMatrix & ICommonRetVal;
        getTrainSpeed: (vehicleId: number) => number;
        getHydraReactorAngle: (vehicleId: number) => number;
        getLandingGearState: (vehicleId: number) => LandingGearStateEnum;
        getSirenState: (vehicleId: number) => boolean;
        getDriver: (vehicleId: number) => number;
        getLastDriver: (vehicleId: number) => number;
        isSirenEnabled: (vehicleId: number) => boolean;
        toggleSirenEnabled: (vehicleId: number, enabled: boolean) => boolean;
        setParamsSirenState: (vehicleId: number, enabled: boolean | VehicleParamsEnum) => boolean;
        isDead: (vehicleId: number) => boolean;
        setDead: (vehicleId: number, dead: boolean) => boolean;
        setBeenOccupied: (vehicleId: number, occupied: boolean) => boolean;
        getRespawnTick: (vehicleId: number) => number;
        setRespawnTick: (vehicleId: number, ticks: number) => number;
        isOccupied: (vehicleId: number) => boolean;
        hasBeenOccupied: (vehicleId: number) => boolean;
        getOccupiedTick: (vehicleId: number) => number;
        setOccupiedTick: (vehicleId: number, ticks: number) => number;
        getCab: (vehicleId: number) => number;
        getRespawnDelay: (vehicleId: number) => number;
        setRespawnDelay: (vehicleId: number, delay: number) => boolean;
        getNumberPlate: (vehicleId: number) => {
            plate: string;
            ret: boolean;
        };
        getInterior: (vehicleId: number) => number;
        getPaintjob: (vehicleId: number) => number;
        getColors: (vehicleId: number) => IVehColor & ICommonRetVal;
        setSpawnInfo: (vehicleId: number, modelId: number, fX: number, fY: number, fZ: number, fAngle: number, color1: number, color2: number, respawnTime?: number, interior?: number) => boolean;
        getSpawnInfo: (vehicleId: number) => IVehSpawnInfo & ICommonRetVal;
        getRandomColorPair: (modelId: number) => {
            color: [number, number, number, number];
            ret: boolean;
        };
        show: (vehicleId: number) => boolean;
        hide: (vehicleId: number) => boolean;
        isHidden: (vehicleId: number) => boolean;
        getOccupant: (vehicleId: number, seatId: number) => number;
        getMaxPassengers: (modelId: number) => number;
        countOccupants: (vehicleId: number) => number;
        getComponentType: (component: number) => CarModTypeEnum;
        colorIndexToColor: (index: number, alpha?: number) => number;
        isValid: (vehicleId: number) => boolean;
        getModelsUsed: () => number;
        getModelCount: (modelId: number) => number;
        canHaveComponent: (modelId: number, componentId: number) => boolean;
        getSeats: (modelId: number) => number;
    };
}

declare class Actor {
    private _id;
    readonly sourceInfo: IActor | null;
    get id(): number;
    constructor(actorOrId: IActor | number);
    create(): this;
    destroy(): this;
    isStreamIn(forPlayer: Player): boolean;
    setVirtualWorld(vWorld: number): boolean;
    getVirtualWorld(): number;
    applyAnimation(animLib: string, animName: string, fDelta: number, loop: boolean, lockX: boolean, lockY: boolean, freeze: boolean, time: number): boolean;
    clearAnimations(): boolean;
    setPos(x: number, y: number, z: number): boolean;
    getPos(): {
        x: number;
        y: number;
        z: number;
        ret: boolean;
    };
    setFacingAngle(ang: number): boolean;
    getFacingAngle(): {
        angle: number;
        ret: boolean;
    };
    setHealth(health: number): boolean;
    getHealth(): {
        health: number;
        ret: boolean;
    };
    setInvulnerable(invulnerable: boolean): boolean;
    isInvulnerable(): boolean;
    isValid(): boolean;
    setSkin(skin: number): boolean;
    getSkin(): number;
    getAnimation(): IActorAnimation & ICommonRetVal<boolean>;
    getSpawnInfo(): IActorSpawn & ICommonRetVal<boolean>;
    static isValid(id: number): boolean;
    static getInstance(id: number): Actor | undefined;
    static getInstances(): Actor[];
    static __inject__: {
        create: (skin: number, x: number, y: number, z: number, rotation: number) => number;
        destroy: (actorId: number) => boolean;
        applyAnimation: (actorId: number, animLib: string, animName: string, fDelta: number, loop: boolean, lockX: boolean, lockY: boolean, freeze: boolean, time: number) => boolean;
        clearAnimations: (actorId: number) => boolean;
        getAnimation: (actorId: number) => IActorAnimation & ICommonRetVal;
        getFacingAngle: (actorId: number) => {
            angle: number;
            ret: boolean;
        };
        getHealth: (actorId: number) => {
            health: number;
            ret: boolean;
        };
        getPos: (actorId: number) => {
            x: number;
            y: number;
            z: number;
            ret: boolean;
        };
        getSkin: (actorId: number) => number;
        getSpawnInfo: (actorId: number) => IActorSpawn & ICommonRetVal;
        getVirtualWorld: (actorId: number) => number;
        isInvulnerable: (actorId: number) => boolean;
        isStreamedIn: (actorId: number, forPlayerId: number) => boolean;
        isValid: (actorId: number) => boolean;
        setFacingAngle: (actorId: number, ang: number) => boolean;
        setHealth: (actorId: number, health: number) => boolean;
        setInvulnerable: (actorId: number, invulnerable: boolean) => boolean;
        setPos: (actorId: number, x: number, y: number, z: number) => boolean;
        setSkin: (actorId: number, model: number) => boolean;
        setVirtualWorld: (actorId: number, vWorld: number) => 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__: {
        show: (player: Player, id: number, dialog: IDialog) => boolean;
        hide: (playerId: number) => 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: InvalidEnum.PLAYER_ID | Player;
        reason: number;
    } & {
        next: (value?: Partial<{
            player: Player;
            killer: InvalidEnum.PLAYER_ID | Player;
            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: InvalidEnum.PLAYER_ID | Player;
        amount: number;
        weapon: WeaponEnum;
        bodyPart: BodyPartsEnum;
    } & {
        next: (value?: Partial<{
            player: Player;
            damage: InvalidEnum.PLAYER_ID | Player;
            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;
        h