@open.mp/node/dist/bundle.d.ts

open.mp nodejs package. contains constants, type definitions, and initializers

/**
 * Player class
 */
declare class Player {
    /**
     * @var ptr
     * @description Player pointer
     * @type {number|null}
     * @private
     */
    private ptr;
    /**
     * @var id
     * @description Player ID
     * @type {number|null}
     * @private
     */
    private id;
    /**
     * @constructor
     * @param {number} id
     * @throws Will throw an error if the player retrieval fails
     */
    constructor(id: number);
    /**
     * @method getPtr
     * @description get player pointer
     * @returns {number|null} player pointer
     */
    getPtr(): number | null;
    /**
     * @method getID
     * @description get player id
     * @returns {number|null} player id
     */
    getID(): number | null;
    /**
     * @method setSpawnInfo
     * @param {number} team
     * @param {number} skin
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} angle
     * @param {number} weapon1
     * @param {number} ammo1
     * @param {number} weapon2
     * @param {number} ammo2
     * @param {number} weapon3
     * @param {number} ammo3
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setSpawnInfo(team: number, skin: number, x: number, y: number, z: number, angle: number, weapon1: number, ammo1: number, weapon2: number, ammo2: number, weapon3: number, ammo3: number): boolean;
    /**
     * @method getSpawnInfo
     * @returns {{ret: boolean, team: number,skin: number,x: number,y: number,z: number,angle: number,weapon1: number,ammo1: number,weapon2: number,ammo2: number,weapon3: number,ammo3: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getSpawnInfo(): {
        ret: boolean;
        team: number;
        skin: number;
        x: number;
        y: number;
        z: number;
        angle: number;
        weapon1: number;
        ammo1: number;
        weapon2: number;
        ammo2: number;
        weapon3: number;
        ammo3: number;
    };
    /**
     * @method getNetworkStats
     * @returns {{ret: boolean, output: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    getNetworkStats(): {
        ret: boolean;
        output: string;
    };
    /**
     * @method netStatsBytesReceived
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsBytesReceived(): number;
    /**
     * @method netStatsBytesSent
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsBytesSent(): number;
    /**
     * @method netStatsConnectionStatus
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsConnectionStatus(): number;
    /**
     * @method netStatsGetConnectedTime
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsGetConnectedTime(): number;
    /**
     * @method netStatsGetIpPort
     * @returns {{ret: boolean, output: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    netStatsGetIpPort(): {
        ret: boolean;
        output: string;
    };
    /**
     * @method netStatsMessagesReceived
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsMessagesReceived(): number;
    /**
     * @method netStatsMessagesRecvPerSecond
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsMessagesRecvPerSecond(): number;
    /**
     * @method netStatsMessagesSent
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsMessagesSent(): number;
    /**
     * @method netStatsPacketLossPercent
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    netStatsPacketLossPercent(): number;
    /**
     * @method getCustomSkin
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getCustomSkin(): number;
    /**
     * @method getDialog
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getDialog(): number;
    /**
     * @method getDialogData
     * @returns {{ret: boolean, dialogid: number,style: number,title: string,body: string,button1: string,button2: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    getDialogData(): {
        ret: boolean;
        dialogid: number;
        style: number;
        title: string;
        body: string;
        button1: string;
        button2: string;
    };
    /**
     * @method getMenu
     * @returns {Menu|undefined}
     * @throws Will throw an error if the player is invalid
     */
    getMenu(): Menu | undefined;
    /**
     * @method getSurfingPlayerObject
     * @returns {PlayerObject}
     * @throws Will throw an error if the player is invalid
     */
    getSurfingPlayerObject(): PlayerObject;
    /**
     * @method getCameraTargetPlayerObject
     * @returns {PlayerObject}
     * @throws Will throw an error if the player is invalid
     */
    getCameraTargetPlayerObject(): PlayerObject;
    /**
     * @method sendClientMessage
     * @param {number} color
     * @param {string} text
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    sendClientMessage(color: number, text: string): boolean;
    /**
     * @method setCameraPos
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setCameraPos(x: number, y: number, z: number): boolean;
    /**
     * @method setDrunkLevel
     * @param {number} level
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setDrunkLevel(level: number): boolean;
    /**
     * @method setInterior
     * @param {number} interior
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setInterior(interior: number): boolean;
    /**
     * @method setWantedLevel
     * @param {number} level
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setWantedLevel(level: number): boolean;
    /**
     * @method setWeather
     * @param {number} weather
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setWeather(weather: number): boolean;
    /**
     * @method getWeather
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getWeather(): number;
    /**
     * @method setSkin
     * @param {number} skin
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setSkin(skin: number): boolean;
    /**
     * @method setShopName
     * @param {string} name
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setShopName(name: string): boolean;
    /**
     * @method giveMoney
     * @param {number} amount
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    giveMoney(amount: number): boolean;
    /**
     * @method setCameraLookAt
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} cutType
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setCameraLookAt(x: number, y: number, z: number, cutType: number): boolean;
    /**
     * @method setCameraBehind
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setCameraBehind(): boolean;
    /**
     * @method createExplosion
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} type
     * @param {number} radius
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    createExplosion(x: number, y: number, z: number, type: number, radius: number): boolean;
    /**
     * @method playAudioStream
     * @param {string} url
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} distance
     * @param {boolean} usePos
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    playAudioStream(url: string, x: number, y: number, z: number, distance: number, usePos: boolean): boolean;
    /**
     * @method stopAudioStream
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    stopAudioStream(): boolean;
    /**
     * @method toggleWidescreen
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    toggleWidescreen(enable: boolean): boolean;
    /**
     * @method isWidescreenToggled
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isWidescreenToggled(): boolean;
    /**
     * @method setHealth
     * @param {number} health
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setHealth(health: number): boolean;
    /**
     * @method getHealth
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getHealth(): number;
    /**
     * @method setArmor
     * @param {number} armor
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setArmor(armor: number): boolean;
    /**
     * @method getArmor
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getArmor(): number;
    /**
     * @method setTeam
     * @param {number} team
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setTeam(team: number): boolean;
    /**
     * @method getTeam
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getTeam(): number;
    /**
     * @method setScore
     * @param {number} score
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setScore(score: number): boolean;
    /**
     * @method getScore
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getScore(): number;
    /**
     * @method getSkin
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getSkin(): number;
    /**
     * @method setColor
     * @param {number} color
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setColor(color: number): boolean;
    /**
     * @method getColor
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getColor(): number;
    /**
     * @method getDefaultColor
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getDefaultColor(): number;
    /**
     * @method getDrunkLevel
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getDrunkLevel(): number;
    /**
     * @method giveWeapon
     * @param {number} weapon
     * @param {number} ammo
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    giveWeapon(weapon: number, ammo: number): boolean;
    /**
     * @method removeWeapon
     * @param {number} weapon
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    removeWeapon(weapon: number): boolean;
    /**
     * @method getMoney
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getMoney(): number;
    /**
     * @method resetMoney
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    resetMoney(): boolean;
    /**
     * @method setName
     * @param {string} name
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    setName(name: string): number;
    /**
     * @method getName
     * @returns {{ret: boolean, name: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    getName(): {
        ret: boolean;
        name: string;
    };
    /**
     * @method getState
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getState(): number;
    /**
     * @method getPing
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getPing(): number;
    /**
     * @method getWeapon
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getWeapon(): number;
    /**
     * @method setTime
     * @param {number} hour
     * @param {number} minute
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setTime(hour: number, minute: number): boolean;
    /**
     * @method getTime
     * @returns {{ret: boolean, hour: number,minute: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getTime(): {
        ret: boolean;
        hour: number;
        minute: number;
    };
    /**
     * @method toggleClock
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    toggleClock(enable: boolean): boolean;
    /**
     * @method hasClock
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    hasClock(): boolean;
    /**
     * @method forceClassSelection
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    forceClassSelection(): boolean;
    /**
     * @method getWantedLevel
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getWantedLevel(): number;
    /**
     * @method setFightingStyle
     * @param {number} style
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setFightingStyle(style: number): boolean;
    /**
     * @method getFightingStyle
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getFightingStyle(): number;
    /**
     * @method setVelocity
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setVelocity(x: number, y: number, z: number): boolean;
    /**
     * @method getVelocity
     * @returns {{ret: boolean, x: number,y: number,z: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getVelocity(): {
        ret: boolean;
        x: number;
        y: number;
        z: number;
    };
    /**
     * @method getCameraPos
     * @returns {{ret: boolean, x: number,y: number,z: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getCameraPos(): {
        ret: boolean;
        x: number;
        y: number;
        z: number;
    };
    /**
     * @method getDistanceFromPoint
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getDistanceFromPoint(x: number, y: number, z: number): number;
    /**
     * @method getInterior
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getInterior(): number;
    /**
     * @method setPos
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setPos(x: number, y: number, z: number): boolean;
    /**
     * @method getPos
     * @returns {{ret: boolean, x: number,y: number,z: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getPos(): {
        ret: boolean;
        x: number;
        y: number;
        z: number;
    };
    /**
     * @method getVirtualWorld
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getVirtualWorld(): number;
    /**
     * @method isNPC
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isNPC(): boolean;
    /**
     * @method isStreamedIn
     * @param {Player} other
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isStreamedIn(other: Player): boolean;
    /**
     * @method playGameSound
     * @param {number} sound
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    playGameSound(sound: number, x: number, y: number, z: number): boolean;
    /**
     * @method spectatePlayer
     * @param {Player} target
     * @param {number} mode
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    spectatePlayer(target: Player, mode: number): boolean;
    /**
     * @method spectateVehicle
     * @param {Player} target
     * @param {number} mode
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    spectateVehicle(target: Player, mode: number): boolean;
    /**
     * @method setVirtualWorld
     * @param {number} vw
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setVirtualWorld(vw: number): boolean;
    /**
     * @method setWorldBounds
     * @param {number} xMax
     * @param {number} xMin
     * @param {number} yMax
     * @param {number} yMin
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setWorldBounds(xMax: number, xMin: number, yMax: number, yMin: number): boolean;
    /**
     * @method clearWorldBounds
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    clearWorldBounds(): boolean;
    /**
     * @method getWorldBounds
     * @returns {{ret: boolean, xmax: number,xmin: number,ymax: number,ymin: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getWorldBounds(): {
        ret: boolean;
        xmax: number;
        xmin: number;
        ymax: number;
        ymin: number;
    };
    /**
     * @method clearAnimations
     * @param {number} syncType
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    clearAnimations(syncType: number): boolean;
    /**
     * @method getLastShotVectors
     * @returns {{ret: boolean, origin_x: number,origin_y: number,origin_z: number,hit_x: number,hit_y: number,hit_z: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getLastShotVectors(): {
        ret: boolean;
        originX: number;
        originY: number;
        originZ: number;
        hitX: number;
        hitY: number;
        hitZ: number;
    };
    /**
     * @method getCameraTargetPlayer
     * @returns {Player}
     * @throws Will throw an error if the player is invalid
     */
    getCameraTargetPlayer(): Player;
    /**
     * @method getCameraTargetActor
     * @returns {Actor}
     * @throws Will throw an error if the player is invalid
     */
    getCameraTargetActor(): Actor;
    /**
     * @method getCameraTargetObject
     * @returns {ObjectMp}
     * @throws Will throw an error if the player is invalid
     */
    getCameraTargetObject(): ObjectMp;
    /**
     * @method getCameraTargetVehicle
     * @returns {Vehicle}
     * @throws Will throw an error if the player is invalid
     */
    getCameraTargetVehicle(): Vehicle;
    /**
     * @method putInVehicle
     * @param {Vehicle} vehicle
     * @param {number} seat
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    putInVehicle(vehicle: Vehicle, seat: number): boolean;
    /**
     * @method removeBuilding
     * @param {number} model
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} radius
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    removeBuilding(model: number, x: number, y: number, z: number, radius: number): boolean;
    /**
     * @method getBuildingsRemoved
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getBuildingsRemoved(): number;
    /**
     * @method removeFromVehicle
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    removeFromVehicle(): boolean;
    /**
     * @method removeMapIcon
     * @param {number} icon
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    removeMapIcon(icon: number): boolean;
    /**
     * @method setMapIcon
     * @param {number} iconID
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} type
     * @param {number} color
     * @param {number} style
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setMapIcon(iconID: number, x: number, y: number, z: number, type: number, color: number, style: number): boolean;
    /**
     * @method resetWeapons
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    resetWeapons(): boolean;
    /**
     * @method setAmmo
     * @param {number} id
     * @param {number} ammo
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setAmmo(id: number, ammo: number): boolean;
    /**
     * @method setArmedWeapon
     * @param {number} weapon
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setArmedWeapon(weapon: number): boolean;
    /**
     * @method setChatBubble
     * @param {string} text
     * @param {number} color
     * @param {number} drawdistance
     * @param {number} expiretime
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setChatBubble(text: string, color: number, drawdistance: number, expiretime: number): boolean;
    /**
     * @method setPosFindZ
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setPosFindZ(x: number, y: number, z: number): boolean;
    /**
     * @method setSkillLevel
     * @param {number} weapon
     * @param {number} level
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setSkillLevel(weapon: number, level: number): boolean;
    /**
     * @method setSpecialAction
     * @param {number} action
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setSpecialAction(action: number): boolean;
    /**
     * @method showNameTagForPlayer
     * @param {Player} other
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    showNameTagForPlayer(other: Player, enable: boolean): boolean;
    /**
     * @method toggleControllable
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    toggleControllable(enable: boolean): boolean;
    /**
     * @method toggleSpectating
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    toggleSpectating(enable: boolean): boolean;
    /**
     * @method applyAnimation
     * @param {string} animlib
     * @param {string} animname
     * @param {number} delta
     * @param {boolean} loop
     * @param {boolean} lockX
     * @param {boolean} lockY
     * @param {boolean} freeze
     * @param {number} time
     * @param {number} sync
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    applyAnimation(animlib: string, animname: string, delta: number, loop: boolean, lockX: boolean, lockY: boolean, freeze: boolean, time: number, sync: number): boolean;
    /**
     * @method getAnimationName
     * @param {number} index
     * @returns {{ret: boolean, lib: string,name: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    static getAnimationName(index: number): {
        ret: boolean;
        lib: string;
        name: string;
    };
    /**
     * @method editAttachedObject
     * @param {number} index
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    editAttachedObject(index: number): boolean;
    /**
     * @method enableCameraTarget
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    enableCameraTarget(enable: boolean): boolean;
    /**
     * @method enableStuntBonus
     * @param {boolean} enable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    enableStuntBonus(enable: boolean): boolean;
    /**
     * @method getPlayerAmmo
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getPlayerAmmo(): number;
    /**
     * @method getAnimationIndex
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getAnimationIndex(): number;
    /**
     * @method getFacingAngle
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getFacingAngle(): number;
    /**
     * @method getIp
     * @returns {{ret: boolean, ip: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    getIp(): {
        ret: boolean;
        ip: string;
    };
    /**
     * @method getSpecialAction
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getSpecialAction(): number;
    /**
     * @method getVehicleID
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getVehicleID(): number;
    /**
     * @method getVehicleSeat
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getVehicleSeat(): number;
    /**
     * @method getWeaponData
     * @param {number} slot
     * @returns {{ret: boolean, weaponid: number,ammo: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getWeaponData(slot: number): {
        ret: boolean;
        weaponid: number;
        ammo: number;
    };
    /**
     * @method getWeaponState
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getWeaponState(): number;
    /**
     * @method interpolateCameraPos
     * @param {number} from_x
     * @param {number} from_y
     * @param {number} from_z
     * @param {number} to_x
     * @param {number} to_y
     * @param {number} to_z
     * @param {number} time
     * @param {number} cut
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    interpolateCameraPos(from_x: number, from_y: number, from_z: number, to_x: number, to_y: number, to_z: number, time: number, cut: number): boolean;
    /**
     * @method interpolateCameraLookAt
     * @param {number} from_x
     * @param {number} from_y
     * @param {number} from_z
     * @param {number} to_x
     * @param {number} to_y
     * @param {number} to_z
     * @param {number} time
     * @param {number} cut
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    interpolateCameraLookAt(from_x: number, from_y: number, from_z: number, to_x: number, to_y: number, to_z: number, time: number, cut: number): boolean;
    /**
     * @method isPlayerAttachedObjectSlotUsed
     * @param {number} index
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isPlayerAttachedObjectSlotUsed(index: number): boolean;
    /**
     * @method attachCameraToObject
     * @param {ObjectMp} object
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    attachCameraToObject(object: ObjectMp): boolean;
    /**
     * @method attachCameraToPlayerObject
     * @param {ObjectMp} object
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    attachCameraToPlayerObject(object: ObjectMp): boolean;
    /**
     * @method getCameraAspectRatio
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getCameraAspectRatio(): number;
    /**
     * @method getCameraFrontVector
     * @returns {{ret: boolean, x: number,y: number,z: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getCameraFrontVector(): {
        ret: boolean;
        x: number;
        y: number;
        z: number;
    };
    /**
     * @method getCameraMode
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getCameraMode(): number;
    /**
     * @method getKeys
     * @returns {{ret: boolean, keys: number,updown: number,leftright: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getKeys(): {
        ret: boolean;
        keys: number;
        updown: number;
        leftright: number;
    };
    /**
     * @method getSurfingVehicle
     * @returns {Vehicle}
     * @throws Will throw an error if the player is invalid
     */
    getSurfingVehicle(): Vehicle;
    /**
     * @method getSurfingObject
     * @returns {ObjectMp}
     * @throws Will throw an error if the player is invalid
     */
    getSurfingObject(): ObjectMp;
    /**
     * @method getTargetPlayer
     * @returns {Player}
     * @throws Will throw an error if the player is invalid
     */
    getTargetPlayer(): Player;
    /**
     * @method getTargetActor
     * @returns {Actor}
     * @throws Will throw an error if the player is invalid
     */
    getTargetActor(): Actor;
    /**
     * @method isInVehicle
     * @param {Vehicle} targetVehicle
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isInVehicle(targetVehicle: Vehicle): boolean;
    /**
     * @method isInAnyVehicle
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isInAnyVehicle(): boolean;
    /**
     * @method isInRangeOfPoint
     * @param {number} range
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isInRangeOfPoint(range: number, x: number, y: number, z: number): boolean;
    /**
     * @method playCrimeReport
     * @param {Player} suspect
     * @param {number} crime
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    playCrimeReport(suspect: Player, crime: number): boolean;
    /**
     * @method removeAttachedObject
     * @param {number} index
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    removeAttachedObject(index: number): boolean;
    /**
     * @method setAttachedObject
     * @param {number} index
     * @param {number} modelid
     * @param {number} bone
     * @param {number} offsetX
     * @param {number} offsetY
     * @param {number} offsetZ
     * @param {number} rotationX
     * @param {number} rotationY
     * @param {number} rotationZ
     * @param {number} scaleX
     * @param {number} scaleY
     * @param {number} scaleZ
     * @param {number} materialcolor1
     * @param {number} materialcolor2
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setAttachedObject(index: number, modelid: number, bone: number, offsetX: number, offsetY: number, offsetZ: number, rotationX: number, rotationY: number, rotationZ: number, scaleX: number, scaleY: number, scaleZ: number, materialcolor1: number, materialcolor2: number): boolean;
    /**
     * @method getAttachedObject
     * @param {number} index
     * @returns {{ret: boolean, modelid: number,bone: number,offsetX: number,offsetY: number,offsetZ: number,rotationX: number,rotationY: number,rotationZ: number,scaleX: number,scaleY: number,scaleZ: number,materialcolor1: number,materialcolor2: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getAttachedObject(index: number): {
        ret: boolean;
        modelid: number;
        bone: number;
        offsetX: number;
        offsetY: number;
        offsetZ: number;
        rotationX: number;
        rotationY: number;
        rotationZ: number;
        scaleX: number;
        scaleY: number;
        scaleZ: number;
        materialcolor1: number;
        materialcolor2: number;
    };
    /**
     * @method setFacingAngle
     * @param {number} angle
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setFacingAngle(angle: number): boolean;
    /**
     * @method setMarkerForPlayer
     * @param {Player} other
     * @param {number} color
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setMarkerForPlayer(other: Player, color: number): boolean;
    /**
     * @method getMarkerForPlayer
     * @param {Player} other
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getMarkerForPlayer(other: Player): number;
    /**
     * @method allowTeleport
     * @param {boolean} allow
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    allowTeleport(allow: boolean): boolean;
    /**
     * @method isTeleportAllowed
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isTeleportAllowed(): boolean;
    /**
     * @method disableRemoteVehicleCollisions
     * @param {boolean} disable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    disableRemoteVehicleCollisions(disable: boolean): boolean;
    /**
     * @method getCameraZoom
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getCameraZoom(): number;
    /**
     * @method selectTextDraw
     * @param {number} hoverColour
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    selectTextDraw(hoverColour: number): boolean;
    /**
     * @method cancelSelectTextDraw
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    cancelSelectTextDraw(): boolean;
    /**
     * @method sendClientCheck
     * @param {number} actionType
     * @param {number} address
     * @param {number} offset
     * @param {number} count
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    sendClientCheck(actionType: number, address: number, offset: number, count: number): boolean;
    /**
     * @method spawn
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    spawn(): boolean;
    /**
     * @method gPCI
     * @returns {{ret: boolean, gpci: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    gPCI(): {
        ret: boolean;
        gpci: string;
    };
    /**
     * @method isAdmin
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isAdmin(): boolean;
    /**
     * @method kick
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    kick(): boolean;
    /**
     * @method showGameText
     * @param {string} text
     * @param {number} time
     * @param {number} style
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    showGameText(text: string, time: number, style: number): boolean;
    /**
     * @method hideGameText
     * @param {number} style
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    hideGameText(style: number): boolean;
    /**
     * @method hasGameText
     * @param {number} style
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    hasGameText(style: number): boolean;
    /**
     * @method getGameText
     * @param {number} style
     * @returns {{ret: boolean, message: string,time: number,remaining: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getGameText(style: number): {
        ret: boolean;
        message: string;
        time: number;
        remaining: number;
    };
    /**
     * @method ban
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    ban(): boolean;
    /**
     * @method banEx
     * @param {string} reason
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    banEx(reason: string): boolean;
    /**
     * @method sendDeathMessage
     * @param {Player} killer
     * @param {Player} killee
     * @param {number} weapon
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    sendDeathMessage(killer: Player, killee: Player, weapon: number): boolean;
    /**
     * @method sendMessageToPlayer
     * @param {Player} sender
     * @param {string} message
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    sendMessageToPlayer(sender: Player, message: string): boolean;
    /**
     * @method getVersion
     * @returns {{ret: boolean, version: string}} return object
     * @throws Will throw an error if the player is invalid
     */
    getVersion(): {
        ret: boolean;
        version: string;
    };
    /**
     * @method getSkillLevel
     * @param {number} skill
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getSkillLevel(skill: number): number;
    /**
     * @method getZAim
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getZAim(): number;
    /**
     * @method getSurfingOffsets
     * @returns {{ret: boolean, offsetX: number,offsetY: number,offsetZ: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getSurfingOffsets(): {
        ret: boolean;
        offsetX: number;
        offsetY: number;
        offsetZ: number;
    };
    /**
     * @method getRotationQuat
     * @returns {{ret: boolean, x: number,y: number,z: number,w: number}} return object
     * @throws Will throw an error if the player is invalid
     */
    getRotationQuat(): {
        ret: boolean;
        x: number;
        y: number;
        z: number;
        w: number;
    };
    /**
     * @method getPlayerSpectateID
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getPlayerSpectateID(): number;
    /**
     * @method getSpectateType
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getSpectateType(): number;
    /**
     * @method getRawIp
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getRawIp(): number;
    /**
     * @method setGravity
     * @param {number} gravity
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setGravity(gravity: number): boolean;
    /**
     * @method getGravity
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getGravity(): number;
    /**
     * @method setAdmin
     * @param {boolean} set
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    setAdmin(set: boolean): boolean;
    /**
     * @method isSpawned
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isSpawned(): boolean;
    /**
     * @method isControllable
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isControllable(): boolean;
    /**
     * @method isCameraTargetEnabled
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isCameraTargetEnabled(): boolean;
    /**
     * @method toggleGhostMode
     * @param {boolean} toggle
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    toggleGhostMode(toggle: boolean): boolean;
    /**
     * @method getGhostMode
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    getGhostMode(): boolean;
    /**
     * @method allowWeapons
     * @param {boolean} allow
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    allowWeapons(allow: boolean): boolean;
    /**
     * @method areWeaponsAllowed
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    areWeaponsAllowed(): boolean;
    /**
     * @method isPlayerUsingOfficialClient
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isPlayerUsingOfficialClient(): boolean;
    /**
     * @method getAnimationFlags
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getAnimationFlags(): number;
    /**
     * @method isInDriveByMode
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isInDriveByMode(): boolean;
    /**
     * @method isCuffed
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isCuffed(): boolean;
    /**
     * @method isInModShop
     * @returns {boolean}
     * @throws Will throw an error if the player is invalid
     */
    isInModShop(): boolean;
    /**
     * @method getSirenState
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getSirenState(): number;
    /**
     * @method getLandingGearState
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getLandingGearState(): number;
    /**
     * @method getHydraReactorAngle
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getHydraReactorAngle(): number;
    /**
     * @method getTrainSpeed
     * @returns {number}
     * @throws Will throw an error if the player is invalid
     */
    getTrainSpeed(): number;
}

/**
 * Vehicle class
 */
declare class Vehicle {
    /**
     * @var ptr
     * @description Vehicle pointer
     * @type {number|null}
     * @private
     */
    private ptr;
    /**
     * @var id
     * @description Vehicle ID
     * @type {number|null}
     * @private
     */
    private id;
    /**
     * @constructor
     * @param {number} modelid
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} rotation
     * @param {number} color1
     * @param {number} color2
     * @param {number} respawnDelay
     * @param {boolean} addSiren
     * @throws Will throw an error if the vehicle creation fails
     */
    constructor(modelid: number, x: number, y: number, z: number, rotation: number, color1: number, color2: number, respawnDelay: number, addSiren: boolean);
    /**
     * @method destroy
     * @param {number} id
     * @throws Will throw an error if the vehicle retrieval fails
     */
    destroy(): void;
    /**
     * @method getPtr
     * @description get vehicle pointer
     * @returns {number|null} vehicle pointer
     */
    getPtr(): number | null;
    /**
     * @method getID
     * @description get vehicle id
     * @returns {number|null} vehicle id
     */
    getID(): number | null;
    /**
     * @method getMaxPassengerSeats
     * @param {number} modelid
     * @returns {number}
     * @throws Will throw an error if the vehicle is invalid
     */
    static getMaxPassengerSeats(modelid: number): number;
    /**
     * @method isStreamedIn
     * @param {Player} player
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    isStreamedIn(player: Player): boolean;
    /**
     * @method getPos
     * @returns {{ret: boolean, x: number,y: number,z: number}} return object
     * @throws Will throw an error if the vehicle is invalid
     */
    getPos(): {
        ret: boolean;
        x: number;
        y: number;
        z: number;
    };
    /**
     * @method setPos
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setPos(x: number, y: number, z: number): boolean;
    /**
     * @method getZAngle
     * @returns {number}
     * @throws Will throw an error if the vehicle is invalid
     */
    getZAngle(): number;
    /**
     * @method getRotationQuat
     * @returns {{ret: boolean, w: number,x: number,y: number,z: number}} return object
     * @throws Will throw an error if the vehicle is invalid
     */
    getRotationQuat(): {
        ret: boolean;
        w: number;
        x: number;
        y: number;
        z: number;
    };
    /**
     * @method getDistanceFromPoint
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {number}
     * @throws Will throw an error if the vehicle is invalid
     */
    getDistanceFromPoint(x: number, y: number, z: number): number;
    /**
     * @method setZAngle
     * @param {number} angle
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setZAngle(angle: number): boolean;
    /**
     * @method setParamsForPlayer
     * @param {Player} player
     * @param {number} objective
     * @param {number} doors
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setParamsForPlayer(player: Player, objective: number, doors: number): boolean;
    /**
     * @method useManualEngineAndLights
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    static useManualEngineAndLights(): boolean;
    /**
     * @method setParamsEx
     * @param {number} engine
     * @param {number} lights
     * @param {number} alarm
     * @param {number} doors
     * @param {number} bonnet
     * @param {number} boot
     * @param {number} objective
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setParamsEx(engine: number, lights: number, alarm: number, doors: number, bonnet: number, boot: number, objective: number): boolean;
    /**
     * @method getParamsEx
     * @returns {{ret: boolean, engine: number,lights: number,alarm: number,doors: number,bonnet: number,boot: number,objective: number}} return object
     * @throws Will throw an error if the vehicle is invalid
     */
    getParamsEx(): {
        ret: boolean;
        engine: number;
        lights: number;
        alarm: number;
        doors: number;
        bonnet: number;
        boot: number;
        objective: number;
    };
    /**
     * @method getParamsSirenState
     * @returns {number}
     * @throws Will throw an error if the vehicle is invalid
     */
    getParamsSirenState(): number;
    /**
     * @method setParamsCarDoors
     * @param {number} frontLeft
     * @param {number} frontRight
     * @param {number} rearLeft
     * @param {number} rearRight
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setParamsCarDoors(frontLeft: number, frontRight: number, rearLeft: number, rearRight: number): boolean;
    /**
     * @method getParamsCarDoors
     * @returns {{ret: boolean, frontLeft: number,frontRight: number,rearLeft: number,rearRight: number}} return object
     * @throws Will throw an error if the vehicle is invalid
     */
    getParamsCarDoors(): {
        ret: boolean;
        frontLeft: number;
        frontRight: number;
        rearLeft: number;
        rearRight: number;
    };
    /**
     * @method setParamsCarWindows
     * @param {number} frontLeft
     * @param {number} frontRight
     * @param {number} rearLeft
     * @param {number} rearRight
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setParamsCarWindows(frontLeft: number, frontRight: number, rearLeft: number, rearRight: number): boolean;
    /**
     * @method getParamsCarWindows
     * @returns {{ret: boolean, frontLeft: number,frontRight: number,rearLeft: number,rearRight: number}} return object
     * @throws Will throw an error if the vehicle is invalid
     */
    getParamsCarWindows(): {
        ret: boolean;
        frontLeft: number;
        frontRight: number;
        rearLeft: number;
        rearRight: number;
    };
    /**
     * @method setToRespawn
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    setToRespawn(): boolean;
    /**
     * @method linkToInterior
     * @param {number} interiorid
     * @returns {boolean}
     * @throws Will throw an error if the vehicle is invalid
     */
    linkToInterior(interiorid: number): boolean;
    /**
     * @method addComponent
     * @param {numb