@altv/client/index.d.ts

This package contains the type definitions for the alt:V JS module v2 client types

/// <reference types="../shared/index.d.ts" />

/**
 * @module @altv/client
 */

declare module "@altv/client" {
    import * as altShared from "@altv/shared";

    export const isStreamerModeEnabled: boolean;
    export const locale: altShared.Enums.Locale;
    export const licenseHash: string;
    export const clientConfig: Readonly<Record<string, unknown>>;
    export const clientPath: string;

    export const localMeta: Readonly<GlobalLocalMeta & Record<string, unknown>>;

    export function isMenuOpen(): boolean;
    export function isConsoleOpen(): boolean;
    export function isGameFocused(): boolean;
    export function getFps(): number;
    export function getPing(): number;
    export function getTotalPacketsSent(): number;
    export function getTotalPacketsLost(): number;
    export function getServerIp(): string;
    export function getServerPort(): number;
    export function getScreenResolution(): altShared.Vector2;
    export function isFullscreen(): boolean;
    export function areGameControlsActive(): boolean;
    export function setGameControlsActive(state: boolean): boolean;
    export function getMsPerGameMinute(): number;
    export function setMsPerGameMinute(ms: number): void;
    export function getServerTime(): number;
    export function areRmlControlsActive(): boolean;
    export function setRmlControlsActive(state: boolean): void;
    export function getKeyState(key: altShared.Enums.KeyCode): altShared.KeyStateInfo;
    export function beginScaleformMovieMethodMinimap(methodName: string): void;
    export function setWeatherCycle(weathers: altShared.WeatherCycle[]): void;
    export function setWeatherSyncActive(state: boolean): void;
    export function getPermissionState(permission: altShared.Enums.Permission): boolean;
    export function takeScreenshot(gameOnly?: boolean): Promise<string>;
    export function setAngularVelocity(entity: Entity, quaternion: altShared.Quaternion): void;
    export function headshotToBase64(id: number): string;
    export function setDlcClothes(scriptId: number, component: number, drawable: number, texture: number, palette?: number, dlc?: number): void;
    export function setDlcProps(scriptId: number, component: number, drawable: number, texture: number, dlc?: number): void;
    export function clearProps(scriptId: number, component: number): void;
    /** @deprecated This method will be removed in the next major release. (v17)  */
    export function setWatermarkPosition(position: altShared.Enums.WatermarkPosition): void;
    export function copyToClipboard(str: string): void;
    export function toggleRmlDebugger(state: boolean): void;
    export function loadRmlFontFace(path: string, name: string, isItalic?: boolean, isBold?: boolean): void;
    export function worldToScreen(pos: altShared.IVector3): altShared.Vector3;
    export function screenToWorld(pos: altShared.IVector2): altShared.Vector3;
    export function setMinimapComponentPosition(name: string, alignX: string, alignY: string, pos: altShared.IVector2, size: altShared.IVector2): void;
    export function resetMinimapComponentPosition(name: string): void;
    export function setMinimapIsRectangle(state: boolean): void;
    export function getPedBonePos(scriptId: number, boneId: number): altShared.Vector3;
    export function isPointOnScreen(pos: altShared.IVector3): boolean;

    export function getPoolSize(pool: string): number;
    export function getPoolCount(pool: string): number;
    export function getPoolEntities(pool: string): Array<number>;

    export function updateClipContext(context: Record<string, string>): void;

    export interface AudioCreateOptions {
        source: string;
        volume: number;
        radio?: boolean; // default: false
        clearCache?: boolean; // default: true

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    type AudioEventParametersMap = {
        inited: [];
        streamStarted: [];
        streamEnded: [];
        streamPaused: [];
        streamReset: [];
        streamSeek: [time: number];
        volumeChange: [vol: number];
        error: [code: number, message: string];
    };

    export abstract class Audio extends BaseObject {
        source: string;
        loop: boolean;
        volume: number;

        readonly outputs: ReadonlyArray<AudioOutput>;
        readonly currentTime: number;
        readonly maxTime: number;
        readonly isPlaying: boolean;
        readonly listeners: ReadonlyMap<string, Array<(...args: unknown[]) => Promise<void> | void>>;

        addOutput(output: AudioOutput): void;
        removeOutput(output: AudioOutput): void;
        play(): void;
        pause(): void;
        reset(): void;
        seek(time: number): void;

        on<E extends keyof AudioEventParametersMap>(eventName: E, func: (...args: AudioEventParametersMap[E]) => void): void;
        once<E extends keyof AudioEventParametersMap>(eventName: E, func: (...args: AudioEventParametersMap[E]) => void): void;
        off<E extends keyof AudioEventParametersMap>(eventName: E, func: (...args: AudioEventParametersMap[E]) => void): void;

        public onCreate?(opts: AudioCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<Audio>;

        static create(options: AudioCreateOptions): Audio;
        static getByID(id: number): Audio | null;

        static setFactory(factory: typeof Audio): void;
        static getFactory<T extends Audio>(): T;
    }

    export abstract class AudioCategory {
        readonly name: string;
        volume: number;
        distanceRolloffScale: number;
        plateauRolloffScale: number;
        occlusionDamping: number;
        environmentalFilterDamping: number;
        sourceReverbDamping: number;
        distanceReverbDamping: number;
        interiorReverbDamping: number;
        environmentalLoudness: number;
        underwaterWetLevel: number;
        stonedWetLevel: number;
        pitch: number;
        lowPassFilterCutoff: number;
        highPassFilterCutoff: number;

        reset(): void;

        static get(name: string): AudioCategory | undefined;
    }

    export interface AudioFilterCreateOptions {
        hash: number | string;

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    export abstract class AudioFilter {
        audioCategory: AudioCategory;
        readonly hash: number;

        addRotateEffect(rate: number, priority: number): number;
        addVolumeEffect(volume: number, priority: number, channel?: number): number;
        addPeakeqEffect(band: number, bandwidth: number, q: number, center: number, gain: number, priority: number): number;
        addDampEffect(target: number, quiet: number, rate: number, gain: number, delay: number, priority: number): number;
        addAutowahEffect(dryMix: number, wetMix: number, feedback: number, rate: number, range: number, freq: number, priority: number): number;
        addPhaserEffect(dryMix: number, wetMix: number, feedback: number, rate: number, range: number, freq: number, priority: number): number;
        addChorusEffect(dryMix: number, wetMix: number, feedback: number, minSweep: number, maxSweep: number, rate: number, priority: number): number;
        addDistortionEffect(drive: number, dryMix: number, wetMix: number, feedback: number, volume: number, priority: number): number;
        addCompressor2Effect(gain: number, threshold: number, ratio: number, attack: number, release: number, priority: number): number;
        addBqfEffect(filter: number, center: number, gain: number, bandwidth: number, q: number, s: number, priority: number): number;
        addEcho4Effect(dryMix: number, wetMix: number, feedback: number, delay: number, priority: number): number;
        addPitchshiftEffect(pitchShift: number, semitones: number, fftSize: number, osamp: number, priority: number): number;
        addFreeverbEffect(dryMix: number, wetMix: number, roomSize: number, damp: number, width: number, mode: number, priority: number): number;

        removeEffect(fxHandler: number): boolean;

        public onCreate?(opts: AudioFilterCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<AudioFilter>;

        static create(options: AudioFilterCreateOptions): AudioFilter;
        static getByID(id: number): AudioFilter | null;

        static setFactory(factory: typeof AudioFilter): void;
        static getFactory<T extends AudioFilter>(): T;
    }

    export abstract class AudioOutput extends BaseObject {
        muted: boolean;
        volume: number;
        readonly category: number;
        readonly owner: BaseObject;

        filter: AudioFilter | null;

        static getByID(id: number): AudioOutput | null;
    }

    export interface AudioOutputAttachedCreateOptions {
        entity: WorldObject;
        categoryHash?: number; // default: 'radio' hashed

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    export abstract class AudioOutputAttached extends AudioOutput {
        entity: WorldObject;

        public onCreate?(opts: AudioOutputAttachedCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<AudioOutputAttached>;

        static create(options: AudioOutputAttachedCreateOptions): AudioOutputAttached;

        static setFactory(factory: typeof AudioOutputAttached): void;
        static getFactory<T extends AudioOutputAttached>(): T;
    }

    export interface AudioOutputFrontendCreateOptions {
        categoryHash?: number; // default: 'radio' hashed

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    export abstract class AudioOutputFrontend extends AudioOutput {
        public onCreate?(opts: AudioOutputFrontendCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<AudioOutputFrontend>;

        static create(options: AudioOutputFrontendCreateOptions): AudioOutputFrontend;

        static setFactory(factory: typeof AudioOutputFrontend): void;
        static getFactory<T extends AudioOutputFrontend>(): T;
    }

    export interface AudioOutputWorldCreateOptions {
        pos: altShared.Vector3;
        categoryHash?: number; // default: 'radio' hashed
    }

    export abstract class AudioOutputWorld extends AudioOutput {
        pos: altShared.Vector3;

        public onCreate?(opts: AudioOutputWorldCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<AudioOutputWorld>;

        static create(options: AudioOutputWorldCreateOptions): AudioOutputWorld;

        static setFactory(factory: typeof AudioOutputWorld): void;
        static getFactory<T extends AudioOutputWorld>(): T;
    }

    export class BaseObject extends altShared.BaseObject {
        readonly isRemote: boolean;
        readonly remoteID: number;

        static getByID(type: altShared.Enums.BaseObjectType, id: number): BaseObject | null;
        static getByRemoteID(type: altShared.Enums.BaseObjectType, id: number): BaseObject | null;

        readonly meta: BaseObjectMeta & Record<string, unknown>;
        readonly syncedMeta: Readonly<altShared.BaseObjectSyncedMeta & Record<string, unknown>>;
    }

    export type PointBlipCreateOptions =
        | { pos: altShared.IVector3; entity?: never }
        | ({ entity: Entity; pos?: never } & {
              initialMeta?: Partial<{
                  meta: BlipMeta & Record<string, unknown>;
              }>;
          });

    type BlipCreateOptions =
        | ({ blipType: altShared.Enums.BlipType.AREA } & altShared.AreaBlipCreateOptions)
        | ({ blipType: altShared.Enums.BlipType.RADIUS } & altShared.RadiusBlipCreateOptions)
        | (({ blipType: altShared.Enums.BlipType.DESTINATION } & PointBlipCreateOptions) & {
              initialMeta?: Partial<{
                  meta: BlipMeta & Record<string, unknown>;
              }>;
          });

    export interface MarkerCreateOptions {
        type: altShared.Enums.MarkerType;
        pos: altShared.IVector3;
        color?: altShared.IRGBA; // default: {r: 255, g: 255, b: 255, a: 100}
        useStreaming?: boolean; // default: false
        streamingDistance?: number; // default: 0

        initialMeta?: Partial<{
            meta: MarkerMeta & Record<string, unknown>;
        }>;
    }

    export abstract class Blip extends WorldObject {
        readonly scriptID: number;
        readonly isStreamedIn: boolean;
        readonly global: boolean;
        readonly isAttached: boolean;
        readonly attachedTo?: Entity;

        readonly meta: BlipMeta & Record<string, unknown>;
        readonly syncedMeta: Readonly<altShared.BlipSyncedMeta & Record<string, unknown>>;

        blipType: altShared.Enums.BlipType;
        scaleXY: altShared.Vector2;
        display: number;
        sprite: number;
        color: number;
        secondaryColor: number;
        alpha: number;
        flashTimer: number;
        flashInterval: number;
        friendly: boolean;
        route: boolean;
        bright: boolean;
        number: number;
        showCone: boolean;
        flashes: boolean;
        flashesAlternate: boolean;
        shortRange: boolean;
        priority: number;
        rotation: number;
        gxtName: string;
        name: string;
        routeColor: altShared.RGBA;
        pulse: boolean;
        missionCreator: boolean;
        tickVisible: boolean;
        headingIndicatorVisible: boolean;
        outlineIndicatorVisible: boolean;
        friendIndicatorVisible: boolean;
        crewIndicatorVisible: boolean;
        category: number;
        highDetail: boolean;
        shrinked: boolean;
        visible: boolean;
        hiddenOnLegend: boolean;
        minimalOnEdge: boolean;
        useHeightIndicatorOnEdge: boolean;
        shortHeightThreshold: boolean;

        attachTo(entity: Entity): boolean;
        fade(opacity: number, duration: number): void;

        static create(options: BlipCreateOptions): Blip;

        public onCreate?(opts: BlipCreateOptions): void;
        public onDestroy?(): void;

        static getByID(id: number): Blip | null;
        static getByRemoteID(id: number): Blip | null;
        static getByScriptID(id: number): Blip | null;

        static setFactory(factory: typeof Blip): void;
        static getFactory<T extends Blip>(): T;
    }

    export abstract class Marker extends WorldObject {
        readonly isGlobal: boolean;
        readonly streamingDistance: number;

        readonly meta: MarkerMeta & Record<string, unknown>;

        color: altShared.RGBA;
        visible: boolean;
        markerType: altShared.Enums.MarkerType;
        scale: altShared.IVector3;
        rot: altShared.IVector3;
        direction: altShared.IVector3;
        faceCamera: boolean;
        rotating: boolean;
        bobUpDown: boolean;

        static readonly all: ReadonlyArray<Marker>;

        public onCreate?(opts: MarkerCreateOptions): void;
        public onDestroy?(): void;

        static getByID(id: number): Marker | null;
        static getByRemoteID(id: number): Marker | null;
        static create(opts: MarkerCreateOptions): Marker;

        static setFactory(factory: typeof Marker): void;
        static getFactory<T extends Marker>(): T;
    }

    export abstract class ColShape extends WorldObject {
        readonly colShapeType: altShared.Enums.ColShapeType;
        playersOnly: boolean;

        isEntityIn(entity: Entity): boolean;
        isEntityIdIn(id: number): boolean;
        isPointIn(pos: altShared.Vector3): boolean;

        static readonly all: ReadonlyArray<ColShape>;

        static getByID(id: number): ColShape | null;
        static getByRemoteID(id: number): ColShape | null;

        static setFactory(factory: typeof ColShape): void;
        static getFactory<T extends ColShape>(): T;
    }

    export interface CheckpointCreateOptions {
        type: altShared.Enums.CheckpointType;
        pos: altShared.IVector3;
        radius: number;
        height: number;
        color: altShared.RGBA;
        iconColor: altShared.RGBA;
        nextPos: altShared.IVector3;
        streamingDistance: number;

        initialMeta?: Partial<{
            meta: CheckpointMeta & Record<string, unknown>;
        }>;
    }

    // @ts-expect-error setFactory is not compatible with ColShape setFactory
    export abstract class Checkpoint extends ColShape {
        readonly scriptID: number;
        readonly isStreamedIn: boolean;

        checkpointType: number;
        radius: number;
        height: number;
        color: altShared.RGBA;
        iconColor: altShared.RGBA;
        nextPos: altShared.IVector3;
        readonly streamingDistance: number;
        visible: boolean;

        isEntityIn(entity: Entity): boolean;
        isEntityIdIn(id: number): boolean;
        isPointIn(point: altShared.Vector3): boolean;

        public onCreate?(opts: CheckpointCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<Checkpoint>;

        static create(opts: CheckpointCreateOptions): Checkpoint;
        static getByID(id: number): Checkpoint | null;
        static getByRemoteID(id: number): Checkpoint | null;
        static getByScriptID(scriptId: number): Checkpoint | null;

        static setFactory(factory: typeof Checkpoint): void;
        static getFactory<T extends Checkpoint>(): T;
    }

    export abstract class Entity extends WorldObject {
        readonly scriptID: number;

        get model(): number;
        readonly netOwner?: Player;
        readonly visible: boolean;
        readonly isStreamedIn: boolean;

        readonly syncedMeta: Readonly<altShared.EntitySyncedMeta & Record<string, unknown>>;
        readonly streamSyncedMeta: Readonly<altShared.EntityStreamSyncedMeta & Record<string, unknown>>;

        frozen: boolean;
        rot: altShared.Vector3;

        getSyncInfo(): Data.ISyncInfo;

        static readonly all: ReadonlyArray<Entity>;
        static getByScriptID(scriptId: number): Entity | null;
    }

    export abstract class Font extends BaseObject {
        static register(path: string): Font | undefined;
    }

    export abstract class Handling extends HandlingData {
        readonly isModified: boolean;

        reset(): void;
    }

    export abstract class HandlingData {
        readonly handlingNameHash: number;

        mass: number;
        initialDragCoeff: number;
        downforceModifier: number;
        unkFloat1: number;
        unkFloat2: number;
        unkFloat4: number;
        unkFloat5: number;
        centreOfMassOffset: altShared.Vector3;
        inertiaMultiplier: altShared.Vector3;
        percentSubmerged: number;
        percentSubmergedRatio: number;
        driveBiasFront: number;
        driveBiasRear: number;
        acceleration: number;
        initialDriveGears: number;
        driveInertia: number;
        clutchChangeRateScaleUpShift: number;
        clutchChangeRateScaleDownShift: number;
        initialDriveForce: number;
        driveMaxFlatVel: number;
        initialDriveMaxFlatVel: number;
        brakeForce: number;
        brakeBiasFront: number;
        brakeBiasRear: number;
        handBrakeForce: number;
        steeringLock: number;
        steeringLockRatio: number;
        tractionCurveMax: number;
        tractionCurveMaxRatio: number;
        tractionCurveMin: number;
        tractionCurveMinRatio: number;
        tractionCurveLateral: number;
        tractionCurveLateralRatio: number;
        tractionSpringDeltaMax: number;
        tractionSpringDeltaMaxRatio: number;
        lowSpeedTractionLossMult: number;
        camberStiffness: number;
        tractionBiasFront: number;
        tractionBiasRear: number;
        tractionLossMult: number;
        suspensionForce: number;
        suspensionCompDamp: number;
        suspensionReboundDamp: number;
        suspensionUpperLimit: number;
        suspensionLowerLimit: number;
        suspensionRaise: number;
        suspensionBiasFront: number;
        suspensionBiasRear: number;
        antiRollBarForce: number;
        antiRollBarBiasFront: number;
        antiRollBarBiasRear: number;
        rollCentreHeightFront: number;
        rollCentreHeightRear: number;
        collisionDamageMult: number;
        weaponDamageMult: number;
        deformationDamageMult: number;
        engineDamageMult: number;
        petrolTankVolume: number;
        oilVolume: number;
        seatOffsetDistX: number;
        seatOffsetDistY: number;
        seatOffsetDistZ: number;
        monetaryValue: number;
        modelFlags: number;
        handlingFlags: number;
        damageFlags: number;

        static get(modelHash: number | string): HandlingData | undefined;
        // static reloadVehiclePhysics(modelHash: number | string): boolean;
    }

    export type HttpResponse = { statusCode: number; headers: Readonly<Record<string, string>>; body: string };

    export abstract class HttpClient extends BaseObject {
        get(url: string): Promise<HttpResponse>;
        head(url: string): Promise<HttpResponse>;
        post(url: string, body: string): Promise<HttpResponse>;
        put(url: string, body: string): Promise<HttpResponse>;
        delete(url: string, body: string): Promise<HttpResponse>;
        connect(url: string, body: string): Promise<HttpResponse>;
        options(url: string, body: string): Promise<HttpResponse>;
        trace(url: string, body: string): Promise<HttpResponse>;
        patch(url: string, body: string): Promise<HttpResponse>;

        readonly extraHeaders: Record<string, string>;

        public onCreate?(): void;
        public onDestroy?(): void;

        static create(): HttpClient;

        static getByID(id: number): HttpClient | null;

        static setFactory(factory: typeof HttpClient): void;
        static getFactory<T extends HttpClient>(): T;
    }

    export abstract class Object extends Entity {
        readonly alpha: number;
        readonly textureVariation: number;
        readonly lodDistance: number;

        static readonly all: ReadonlyArray<Object>;
        static readonly streamedIn: ReadonlyArray<Object>;

        static getByID(id: number): Object | null;
        static getByRemoteID(id: number): Object | null;
        static getByScriptID(id: number): Object | null;

        static setFactory(factory: typeof Object): void;
        static getFactory<T extends Object>(): T;
    }

    export interface LocalObjectCreateOptions {
        model: number | string;
        pos: altShared.Vector3;
        rot: altShared.Vector3;
        noOffset?: boolean; // default: false
        dynamic?: boolean; // default: false
        useStreaming?: boolean; // default: false
        streamingDistance?: number; // default: 0

        initialMeta?: Partial<{
            meta: ObjectMeta & Record<string, unknown>;
        }>;
    }

    // @ts-expect-error - Suppress "Class static side 'typeof LocalObject' incorrectly extends base class static side 'typeof Object'.""
    export abstract class LocalObject extends Object {
        get model(): number;
        set model(value: number | string);
        alpha: number;
        readonly isDynamic: boolean;
        lodDistance: number;
        hasGravity: number;
        readonly isCollisionEnabled: boolean;
        positionFrozen: boolean;
        textureVariation: number;
        readonly isWorldObject: boolean;
        readonly isWeaponObject: boolean;
        readonly useStreaming: boolean;
        readonly streamingDistance: number;
        visible: boolean;

        // WeaponObject related
        weaponTintIndex: number;
        setWeaponComponentTintIndex(componentType: number, tintIndex: number): void;
        getWeaponComponentTintIndex(componentType: number): number;
        giveWeaponComponent(componentType: number): void;
        removeWeaponComponent(componentType: number): void;

        resetAlpha(): void;
        attachTo(target: number | Entity, boneIndex: number, pos: altShared.Vector3, rot: altShared.Vector3, useSoftPinning: boolean, collision: boolean, fixedRot: boolean): void;
        detach(dynamic: boolean): void;
        toggleCollision(toggle: boolean, keepPhysics: boolean): void;
        placeOnGroundProperly(): void;
        activatePhysics(): void;

        public waitForSpawn(timeout?: number): Promise<void>;

        public onCreate?(opts: LocalObjectCreateOptions): void;
        public onDestroy?(): void;

        static readonly allWorld: ReadonlyArray<LocalObject>;

        static create(options: LocalObjectCreateOptions): LocalObject;
        static getByID(id: number): LocalObject | null;
        static getByScriptID(scriptId: number): LocalObject | null;

        static setFactory(factory: typeof LocalObject): void;
        static getFactory<T extends LocalObject>(): T;
    }

    export interface WeaponObjectCreateOptions {
        pos: altShared.Vector3;
        rot: altShared.Vector3;
        weapon: number | string;
        model?: number | string; // default: weapon value
        ammoCount?: number; // default: 100
        createDefaultComponents?: boolean; // default: true
        scale?: number; // default: 1
        useStreaming?: boolean; // default: false
        streamingDistance?: number; // default: 0

        inititalData?: Partial<{
            meta: ObjectMeta & Record<string, unknown>;
        }>;
    }

    export namespace WeaponObject {
        export function create(options: WeaponObjectCreateOptions): LocalObject;
    }

    export abstract class Ped extends Entity {
        readonly health: number;
        readonly maxHealth: number;
        readonly armour: number;
        readonly currentWeapon: number;

        readonly meta: PedMeta & Record<string, unknown>;
        readonly syncedMeta: Readonly<altShared.PedSyncedMeta & Record<string, unknown>>;
        readonly streamSyncedMeta: Readonly<altShared.PedStreamSyncedMeta & Record<string, unknown>>;

        static readonly all: ReadonlyArray<Ped>;
        static readonly streamedIn: ReadonlyArray<Ped>;

        static getByID(id: number): Ped | null;
        static getByRemoteID(id: number): Ped | null;
        static getByScriptID(scriptID: number): Ped | LocalPed | null;

        static setFactory(factory: typeof Ped): void;
        static getFactory<T extends Ped>(): T;
    }

    export interface LocalPedCreateOptions {
        model: number | string;
        dimension: number;
        pos: altShared.Vector3;
        heading?: number; // default: 0
        useStreaming?: boolean; // default: true
        streamingDistance?: number; // default: 0

        initialMeta?: Partial<{
            meta: PedMeta & Record<string, unknown>;
        }>;
    }

    // @ts-expect-error  Suppress "Class static side 'typeof LocalPed' incorrectly extends base class static side 'typeof Ped'."
    export abstract class LocalPed extends Ped {
        get model(): number;
        set model(value: number | string);
        readonly streamingDistance: number;
        visible: boolean;
        readonly scriptID: number;
        readonly isStreamedIn: boolean;

        public waitForSpawn(timeout?: number): Promise<void>;

        public onCreate?(opts: LocalPedCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<Ped>;

        static create(options: LocalPedCreateOptions): LocalPed;
        static getByID(id: number): LocalPed | null;
        static getByScriptID(scriptId: number): LocalPed | null;

        static setFactory(factory: typeof LocalPed): void;
        static getFactory<T extends LocalPed>(): T;
    }

    // @ts-expect-error Suppress "Class static side 'typeof LocalPlayer' incorrectly extends base class static side 'typeof Player'."
    export abstract class LocalPlayer extends Player {
        readonly currentAmmo: number;
        stamina: number;
        maxStamina: number;
        readonly currentWeaponData: WeaponData;
        readonly weapons: ReadonlyArray<{ hash: number; tintIndex: number; components: ReadonlyArray<number> }>;

        getWeaponAmmo(wepaonHash: number | string): number | undefined;
        hasWeapon(wepaonHash: number | string): boolean;
        getWeaponComponents(wepaonHash: number | string): ReadonlyArray<number> | undefined;

        static setFactory(factory: typeof LocalPlayer): void;
        static getFactory<T extends LocalPlayer>(): T;
    }

    export interface LocalVehicleCreateOptions {
        model: number | string;
        dimension: number;
        pos: altShared.Vector3;
        rot: altShared.Vector3;
        useStreaming?: boolean; // default: true
        streamingDistance?: number; // default: 300

        initialMeta?: Partial<{
            meta: VehicleMeta & Record<string, unknown>;
        }>;
    }

    // @ts-expect-error Supress "Class static side 'typeof LocalVehicle' incorrectly extends base class static side 'typeof Vehicle'.""
    export abstract class LocalVehicle extends Vehicle {
        get model(): number;
        set model(value: number | string);

        readonly streamingDistance: number;
        visible: boolean;
        readonly scriptID: number;
        readonly isStreamedIn: boolean;

        public waitForSpawn(timeout?: number): Promise<void>;

        public onCreate?(opts: LocalVehicleCreateOptions): void;
        public onDestroy?(): void;

        static create(opts: LocalVehicleCreateOptions): LocalVehicle;
        static getByID(id: number): LocalVehicle | null;
        static getByScriptID(scriptId: number): LocalVehicle | null;

        static setFactory(factory: typeof LocalVehicle): void;
        static getFactory<T extends LocalVehicle>(): T;
    }

    export abstract class MapZoomData {
        fZoomScale: number;
        fZoomSpeed: number;
        fScrollSpeed: number;
        vTilesX: number;
        vTilesY: number;

        reset(): void;

        static get(idOrAlias: number | string): MapZoomData | undefined;
        static resetAll(): void;
    }

    export abstract class Player extends Entity {
        readonly name: string;

        readonly isTalking: boolean;
        readonly micLevel: number;
        readonly taskData: string;
        spatialVolume: number;
        nonSpatialVolume: number;
        readonly filter: AudioFilter;

        readonly health: number;
        readonly maxHealth: number;
        readonly currentWeaponComponents: ReadonlyArray<number>;
        readonly currentWeaponTintIndex: number;
        get currentWeapon(): number;
        readonly isDead: boolean;
        readonly isJumping: boolean;
        readonly isInRagdoll: boolean;
        readonly isAiming: boolean;
        readonly isShooting: boolean;
        readonly isReloading: boolean;
        readonly isEnteringVehicle: boolean;
        readonly isLeavingVehicle: boolean;
        readonly isOnLadder: boolean;
        readonly isInMelee: boolean;
        readonly isInCover: boolean;
        readonly isParachuting: boolean;
        readonly armour: number;
        readonly maxArmour: number;
        readonly moveSpeed: number;
        readonly aimPos: altShared.Vector3;
        readonly headRotation: altShared.Vector3;
        readonly isInVehicle: boolean;
        readonly vehicle?: Vehicle;
        readonly seat: number;
        readonly entityAimingAt: Entity;
        readonly entityAimOffset: altShared.Vector3;
        readonly isFlashlightActive: boolean;
        readonly isSuperJumpEnabled: boolean;
        readonly isCrouching: boolean;
        readonly isStealthy: boolean;
        readonly currentAnimationDict: number;
        readonly currentAnimationName: number;
        readonly isSpawned: boolean;
        readonly forwardSpeed: number;
        readonly strafeSpeed: number;

        getWeaponTintIndex(weaponHash: number | string): number | undefined;
        hasWeaponComponent(weaponHash: number | string, componentHash: number | string): boolean;

        readonly meta: PlayerMeta & Record<string, unknown>;
        readonly syncedMeta: Readonly<altShared.PlayerSyncedMeta & Record<string, unknown>>;
        readonly streamSyncedMeta: Readonly<altShared.PlayerStreamSyncedMeta & Record<string, unknown>>;

        static readonly local: LocalPlayer;
        static readonly all: ReadonlyArray<Player>;
        static readonly streamedIn: ReadonlyArray<Player>;

        static getByID(id: number): Player | null;
        static getByRemoteID(id: number): Player | null;

        static setFactory(factory: typeof Player): void;
        static getFactory<T extends Player>(): T;
    }

    export interface RmlDocumentCreateOptions {
        url: string;

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    export abstract class RmlDocument extends RmlElement {
        title: string;
        readonly sourceUrl: string;
        readonly isVisible: boolean;
        readonly isModal: boolean;

        readonly body: RmlElement;

        show(isModal?: boolean, focused?: boolean): void;
        hide(): void;
        update(): void;

        createElement(tag: string): RmlElement;
        createTextNode(text: string): RmlElement;

        public onCreate?(opts: RmlDocumentCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<RmlDocument>;

        static create(options: RmlDocumentCreateOptions): RmlDocument;

        static getByID(id: string): RmlDocument | null;

        static setFactory(factory: typeof RmlDocument): void;
        static getFactory<T extends RmlDocument>(): T;
    }

    // @ts-ignore - Suppresses "Class static side incorrectly extends base class static side"
    export abstract class RmlElement extends BaseObject {
        readonly listeners: ReadonlyMap<string, Array<(...args: unknown[]) => Promise<void> | void>>;

        readonly relativeOffset: altShared.Vector2;
        readonly absoluteOffset: altShared.Vector2;
        readonly baseline: number;
        readonly zIndex: number;
        readonly containingBlock: altShared.Vector2;

        readonly focusedElement?: RmlElement;
        readonly tagName: string;
        rmlID: string;
        readonly isOwned: boolean;
        readonly absoluteLeft: number;
        readonly absoluteTop: number;
        readonly clientLeft: number;
        readonly clientTop: number;
        readonly clientWidth: number;
        readonly clientHeight: number;
        readonly offsetLeft: number;
        readonly offsetTop: number;
        readonly offsetWidth: number;
        readonly offsetHeight: number;
        scrollLeft: number;
        scrollTop: number;
        readonly scrollWidth: number;
        readonly scrollHeight: number;
        readonly isVisible: boolean;

        readonly parent?: RmlElement;
        readonly nextSibling?: RmlElement;
        readonly previousSibling?: RmlElement;
        readonly firstChild?: RmlElement;
        readonly lastChild?: RmlElement;
        readonly childCount: number;
        readonly hasChildren: boolean;
        innerRML: string;
        readonly childNodes: ReadonlyArray<RmlElement>;

        readonly ownerDocument: RmlDocument;
        readonly attributes: Readonly<Record<string, string>>;
        readonly classList: ReadonlyArray<string>;
        readonly pseudoClassList: ReadonlyArray<string>;

        readonly style: Record<string, string>;

        addClass(name: string): boolean;
        removeClass(name: string): boolean;
        hasClass(name: string): boolean;
        addPseudoClass(name: string): boolean;
        removePseudoClass(name: string): boolean;
        hasPseudoClass(name: string): boolean;
        setOffset(offsetParent: RmlElement, offset: altShared.Vector2, fixed?: boolean): void;
        isPointWithinElement(point: altShared.Vector2): boolean;
        setProperty(name: string, value: string): boolean;
        removeProperty(name: string): boolean;
        hasProperty(name: string): boolean;
        hasLocalProperty(name: string): boolean;
        getProperty(name: string): string;
        getLocalProperty(name: string): string;
        getPropertyAbsoluteValue(): number;
        setAttribute(name: string, value: string): void;
        removeAttribute(name: string): boolean;
        hasAttribute(name: string): boolean;
        getAttribute(name: string): string;
        getClosest(selectors: string): RmlElement | null;
        getChild(index: number): RmlElement | null;
        appendChild(child: RmlElement): void;
        insertBefore(element: RmlElement, adjacentElement: RmlElement): void;
        replaceChild(element: RmlElement, oldElement: RmlElement): void;
        removeChild(child: RmlElement): void;

        focus(): boolean;
        blur(): void;
        click(): void;

        scrollIntoView(alignWithTop?: boolean): void;
        getElementByID(id: string): RmlElement | null;
        getElementsByTagName(tag: string): ReadonlyArray<RmlElement>;
        getElementsByClassName(tag: string): ReadonlyArray<RmlElement>;
        querySelector(selector: string): RmlElement | null;
        querySelectorAll(selector: string): ReadonlyArray<RmlElement>;

        on(eventName: string, func: (...args: unknown[]) => void): void;
        once(eventName: string, func: (...args: unknown[]) => void): void;
        off(eventName: string, func: (...args: unknown[]) => void): void;

        static getByID(id: string): RmlElement | null;
    }

    export abstract class TextLabel extends WorldObject {
        readonly isStreamedIn: boolean;
        readonly isGlobal: boolean;
        readonly target: Entity;
        visible: boolean;
        color: altShared.RGBA;
        scale: number;
        rot: altShared.Vector3;
        faceCamera: boolean;

        outlineColor: altShared.RGBA;
        outlineWidth: number;
        fontSize: number;
        textAlign: altShared.Enums.TextLabelAlignment;
        text: string;
        font: string;

        readonly streamingDistance: number;

        public onCreate?(opts: TextLabelCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<TextLabel>;

        static create(opts: TextLabelCreateOptions): TextLabel | null;

        static getByID(id: number): TextLabel | null;
        // static getByRemoteID(id: number): TextLabel | null;

        static setFactory(factory: typeof TextLabel): void;
        static getFactory<T extends TextLabel>(): T;
    }

    export abstract class Vehicle extends Entity {
        readonly neon: Readonly<altShared.VehicleNeonState>;

        readonly driver?: Player;
        readonly isDestroyed: boolean;
        readonly modKitsCount: number;
        readonly modKit: number;
        readonly IsPrimaryColorRGB: boolean;
        readonly primaryColor: number;
        readonly primaryColorRGB: altShared.RGBA;
        readonly isSecondaryColorRGB: boolean;
        readonly secondaryColor: number;
        readonly secondaryColorRGB: altShared.RGBA;
        readonly pearlColor: number;
        readonly wheelColor: number;
        readonly interiorColor: number;
        readonly dashboardColor: number;
        readonly isTireSmokeColorCustom: boolean;
        readonly tireSmokeColor: altShared.RGBA;
        readonly wheelType: number;
        readonly wheelVariation: number;
        readonly customTires: boolean;
        readonly specialDarkness: number;
        readonly numberplateIndex: number;
        readonly numberplateText: string;
        readonly windowTint: number;
        readonly dirtLevel: number;
        readonly isNeonActive: boolean;
        readonly neonColor: altShared.RGBA;
        readonly livery: number;
        readonly roofLivery: number;
        readonly appearanceDataBase64: string;
        readonly engineOn: boolean;
        readonly isHandbrakeActive: boolean;
        readonly headlightColor: number;
        readonly radioStationIndex: number;
        readonly isSirenActive: boolean;
        readonly lockState: altShared.Enums.VehicleLockState;
        readonly isDaylightOn: boolean;
        readonly isNightlightOn: boolean;
        readonly roofState: number;
        readonly isFlamethrowerActive: boolean;
        readonly lightsMultiplier: number;
        readonly gameStateBase64: string;
        readonly engineHealth: number;
        readonly petrolTankHealth: number;
        readonly wheelsCount: number;
        readonly repairsCount: number;
        readonly bodyHealth: number;
        readonly bodyAdditionalHealth: number;
        readonly hasArmoredWindows: boolean;
        readonly damageDataBase64: string;
        readonly manualEngineControl: boolean;
        readonly scriptDataBase64: string;
        readonly healthDataBase64: string;
        readonly velocity: altShared.Vector3;
        readonly steeringAngle: number;
        readonly rearWheelVariation: number;

        readonly streamSyncedMeta: Readonly<altShared.VehicleStreamSyncedMeta & Record<string, unknown>>;

        readonly speed: number;
        gear: number;
        readonly maxGear: number;
        readonly rpm: number;
        readonly speedVector: altShared.Vector3;
        readonly handling: Handling;
        readonly isHandlingModified: boolean;
        indicatorLights: number;
        seatCount: number;
        readonly occupiedSeatsCount: number;
        readonly isTaxiLightOn: boolean;
        engineTemperature: number;
        fuelLevel: number;
        oilLevel: number;
        engineLightState: boolean;
        absLightState: boolean;
        petrolLightState: boolean;
        oilLightState: boolean;
        batteryLightState: boolean;
        suspensionHeight: number;

        getNeonActive(): altShared.VehicleNeonState;

        getMod(category: number): number;
        getModsCount(category: number): number;
        isExtraOn(extraId: number): boolean;
        getDoorState(doorId: number): number;
        isWindowOpened(windowId: number): boolean;
        isWheelBurst(wheelId: number): boolean;
        getWheelHasTire(wheelId: number): boolean;
        isWheelDetached(wheelId: number): boolean;
        isWheelOnFire(wheelId: number): boolean;
        getWheelHealth(wheelId: number): number;

        getPartDamageLevel(partId: number): number;
        getPartBulletHoles(partId: number): number;

        isLightDamaged(lightId: number): boolean;
        isWindowDamaged(windowId: number): boolean;

        isSpecialLightDamaged(specialLightId: number): boolean;
        getArmoredWindowHealth(windowId: number): number;
        getArmoredWindowShootCount(windowId: number): number;
        getBumperDamageLevel(bumperId: number): number;
        toggleExtra(extraId: number, state: boolean): void;

        resetHandling(): void;
        replaceHandling(): void;
        toggleTaxiLight(state: boolean): void;
        getWheelCamber(wheelId: number): number;
        setWheelCamber(wheelId: number, value: number): void;
        getWheelTrackWidth(wheelId: number): number;
        setWheelTrackWidth(wheelId: number, value: number): void;
        getWheelHeight(wheelId: number): number;
        setWheelHeight(wheelId: number, value: number): void;
        getWheelTyreRadius(wheelId: number): number;
        setWheelTyreRadius(wheelId: number, radius: number): void;
        getWheelRimRadius(wheelId: number): number;
        setWheelRimRadius(wheelId: number, radius: number): void;
        getWheelTyreWidth(wheelId: number): number;
        setWheelTyreWidth(wheelId: number, width: number): void;
        getWheelSurfaceMaterial(wheelId: number): number;
        resetDashboardLights(): void;

        getWheelDynamicFlag(wheelId: number, flag: number): boolean;
        setWheelDynamicFlag(wheelId: number, flag: number, state: boolean): void;
        getWheelConfigFlag(wheelId: number, flag: number): boolean;
        setWheelConfigFlag(wheelId: number, flag: number, state: boolean): void;

        setupTransmission(): void;

        static readonly all: ReadonlyArray<Vehicle>;
        static readonly streamedIn: ReadonlyArray<Vehicle>;

        static getByID(id: number): Vehicle | null;
        static getByRemoteID(id: number): Vehicle | null;
        static getByScriptID(scriptId: number): Vehicle | null;

        static setFactory(factory: typeof Vehicle): void;
        static getFactory<T extends Vehicle>(): T;
    }

    export interface TextLabelCreateOptions {
        text: string;
        fontName: string;
        fontSize: number;
        pos: altShared.IVector3;
        rot?: altShared.IVector3; // default: { x: 0, y: 0, z: 0 }
        color?: altShared.RGBA; // default: { r: 255, g: 255, b: 255, a: 255 }
        outlineColor?: altShared.RGBA; // default: { r: 0, g: 0, b: 0, a: 255 }
        outlineWidth?: number; // default: 0
        fontScale?: number; // default: 1
        useStreaming?: boolean; // default: false
        streamingDistance?: number; // default: 0

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    export interface VirtualEntityCreateOptions {
        group: VirtualEntityGroup;
        pos: altShared.IVector3;
        streamingDistance: number;
        data?: Record<string, unknown>;

        initialMeta?: Partial<{
            meta: VirtualEntityMeta & Record<string, unknown>;
        }>;
    }

    export abstract class VirtualEntityGroup extends BaseObject {
        readonly maxEntitiesInStream: number;

        public onCreate?(opts: altShared.VirtualEntityGroupCreateOptions): void;
        public onDestroy?(): void;

        static create(opts: altShared.VirtualEntityGroupCreateOptions): VirtualEntityGroup;

        static setFactory(factory: typeof VirtualEntityGroup): void;
        static getFactory<T extends VirtualEntityGroup>(): T;
    }

    export abstract class VirtualEntity extends WorldObject {
        readonly isStreamedIn: boolean;

        readonly group: VirtualEntityGroup;
        readonly streamingDistance: number;

        visible: boolean;

        readonly meta: VirtualEntityMeta & Record<string, unknown>;
        // readonly syncedMeta: altShared.VirtualEntitySyncedMeta & Record<string, unknown>;
        readonly streamSyncedMeta: Readonly<altShared.VirtualEntityStreamSyncedMeta & Record<string, unknown>>;

        static readonly all: ReadonlyArray<VirtualEntity>;
        static readonly streamedIn: ReadonlyArray<VirtualEntity>;

        public onCreate?(opts: VirtualEntityCreateOptions): void;
        public onDestroy?(): void;

        static create(opts: VirtualEntityCreateOptions): VirtualEntity;

        static getByID(id: number): VirtualEntity | null;
        static getByRemoteID(id: number): VirtualEntity | null;

        static setFactory(factory: typeof VirtualEntity): void;
        static getFactory<T extends VirtualEntity>(): T;
    }

    export abstract class WeaponData {
        readonly modelHash: number;
        readonly nameHash: number;

        recoilShakeAmplitude: number;
        recoilAccuracyMax: number;
        recoilAccuracyToAllowHeadshotPlayer: number;
        recoilRecoveryRate: number;
        animReloadRate: number;
        vehicleReloadTime: number;
        lockOnRange: number;
        accuracySpread: number;
        range: number;
        damage: number;
        readonly clipSize: number;
        readonly timeBetweenShots: number;
        headshotDamageModifier: number;
        playerDamageModifier: number;

        static readonly all: ReadonlyArray<WeaponData>;

        static get(weaponHash: number | string): WeaponData | undefined;
    }

    export interface WebSocketClientCreateOptions {
        url: string;

        initialMeta?: Partial<{
            meta: Record<string, unknown>;
        }>;
    }

    export abstract class WebSocketClient extends BaseObject {
        url: string;
        autoReconnect: boolean;
        perMessageDeflate: boolean;
        pingInterval: number;
        readonly readyState: boolean;

        on<E extends keyof altShared.Events.WebSocketClientEvent>(eventName: E, listener: altShared.Events.WebSocketClientEvent[E]): void;
        on<E extends string>(eventName: Exclude<E, keyof altShared.Events.WebSocketClientEvent>, listener: Events.CustomEventCallback<unknown[]>): void;

        once<E extends keyof altShared.Events.WebSocketClientEvent>(eventName: E, listener: altShared.Events.WebSocketClientEvent[E]): void;
        once<E extends string>(eventName: Exclude<E, keyof altShared.Events.WebSocketClientEvent>, listener: Events.CustomEventCallback<unknown[]>): void;

        off<E extends keyof altShared.Events.WebSocketClientEvent>(eventName: E, listener: altShared.Events.WebSocketClientEvent[E]): void;
        off<E extends string>(eventName: Exclude<E, keyof altShared.Events.WebSocketClientEvent>, listener: Events.CustomEventCallback<unknown[]>): void;

        readonly listeners: ReadonlyMap<string, Array<(...args: unknown[]) => Promise<void> | void>>;

        start(): void;
        stop(): void;

        send(message: string | altShared.Buffer): boolean;

        addSubProtocol(protocol: string): void;
        getSubProtocols(): ReadonlyArray<string>;
        setExtraHeader(name: string, value: string): void;
        getExtraHeaders(): Readonly<Record<string, string>>;

        public onCreate?(opts: WebSocketClientCreateOptions): void;
        public onDestroy?(): void;

        static readonly all: ReadonlyArray<WebSocketClient>;

        static create(options: WebSocketClientCreateOptions): WebSocketClient;
        static getByID(id: number): WebSocketClient | null;

        static setFactory(factory: typeof WebSocketClient): void;
        static getFactory<T extends WebSocketClient>(): T;
    }

    export class TextEncoder {
        public rea