rock-mod 0.20.0 → 0.21.0

package/dist/client/RockMod.d.ts

@@ -4,7 +4,7 @@ import { type IUtilsManager } from "./utils";
 import { type IManagersFactory } from "./factories/common/IManagersFactory";
 import { type IGameManagers } from "./game";
 import { type IConsoleManager } from "./console";
-type MultiplayerType = "RageMP" | "AltV" | "Mock";
+type MultiplayerType = "RageMP" | "AltV" | "Mock" | "CCMP";
 export interface RockModOptions {
     multiplayer: MultiplayerType;
 }

package/dist/client/RockMod.js

@@ -20,6 +20,10 @@ export class RockMod {
                 const { RageManagersFactory } = await import("./factories/ragemp/RageManagersFactory");
                 return new RageManagersFactory();
             }
+            case "CCMP": {
+                const { CCMPManagersFactory } = await import("./factories/ccmp/CCMPManagersFactory");
+                return new CCMPManagersFactory();
+            }
             case "AltV":
             case "Mock": {
                 throw new Error("This multiplayer type is not implemented yet on client side");

package/dist/client/entities/ccmp/camera/CCMPCamera.d.ts

@@ -0,0 +1,24 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type Camera as CcmpCamera } from "@classic-mp/types/client";
+import { type ICamera } from "../../common/camera/ICamera";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+export declare class CCMPCamera implements ICamera {
+    private readonly _camera;
+    constructor(_camera: CcmpCamera);
+    get id(): number;
+    get remoteId(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get isActive(): boolean;
+    setIsActive(value: boolean): void;
+    get direction(): IVector3D;
+    get fov(): number;
+    setFov(value: number): void;
+    pointAtCoord(value: IVector3D): void;
+    setPosition(value: Vector3D): void;
+    get position(): Vector3D;
+    get rotation(): IVector3D;
+    setRotation(value: IVector3D): void;
+}

package/dist/client/entities/ccmp/camera/CCMPCamera.js

@@ -0,0 +1,58 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+export class CCMPCamera {
+    constructor(_camera) {
+        this._camera = _camera;
+    }
+    get id() {
+        return this._camera.id;
+    }
+    get remoteId() {
+        return 0;
+    }
+    get type() {
+        return BaseObjectType.Camera;
+    }
+    get isExists() {
+        return this._camera.isAlive;
+    }
+    get handle() {
+        return this._camera.handle;
+    }
+    destroy() {
+        this._camera.destroy();
+    }
+    get isActive() {
+        return this._camera.isActive;
+    }
+    setIsActive(value) {
+        this._camera.setActive(value);
+    }
+    get direction() {
+        const { x, y, z } = this._camera.direction;
+        return new Vector3D(x, y, z);
+    }
+    get fov() {
+        return this._camera.fov;
+    }
+    setFov(value) {
+        this._camera.setFov(value);
+    }
+    pointAtCoord(value) {
+        this._camera.pointAtCoord(value);
+    }
+    setPosition(value) {
+        this._camera.setPosition(value);
+    }
+    get position() {
+        const { x, y, z } = this._camera.position;
+        return new Vector3D(x, y, z);
+    }
+    get rotation() {
+        const { x, y, z } = this._camera.rotation;
+        return new Vector3D(x, y, z);
+    }
+    setRotation(value) {
+        this._camera.setRotation(value);
+    }
+}

package/dist/client/entities/ccmp/camera/CCMPCameraManager.d.ts

@@ -0,0 +1,16 @@
+import { type IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+import { type ICameraCreateOptions, type ICameraManager } from "../../common/camera/ICameraManager";
+import { CCMPCamera } from "./CCMPCamera";
+export declare class CCMPCameraManager implements ICameraManager {
+    private readonly _cameras;
+    private readonly _iterator;
+    get iterator(): IBaseObjectsIterator<CCMPCamera>;
+    create(options: ICameraCreateOptions): CCMPCamera;
+    renderScriptCams(render: boolean, ease: boolean, easeTime: number, freezePreviousCamera: boolean): void;
+    getGameplayCamera(): CCMPCamera;
+    getByID(id: number): CCMPCamera;
+    findByID(id: number): CCMPCamera | null;
+    getByRemoteID(remoteId: number): CCMPCamera;
+    findByRemoteID(remoteId: number): CCMPCamera | null;
+    deleteById(id: number): CCMPCamera;
+}

package/dist/client/entities/ccmp/camera/CCMPCameraManager.js

@@ -0,0 +1,50 @@
+import { CCMPCamera } from "./CCMPCamera";
+export class CCMPCameraManager {
+    constructor() {
+        this._cameras = new Map();
+        this._iterator = {
+            all: () => this._cameras.values(),
+        };
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    create(options) {
+        const camera = new CCMPCamera(ccmp.cameras.create(options.name, options.position, options.rotation, options.fov));
+        this._cameras.set(camera.id, camera);
+        return camera;
+    }
+    renderScriptCams(render, ease, easeTime, freezePreviousCamera) {
+        ccmp.cameras.renderScriptCams(render, ease, easeTime, freezePreviousCamera);
+    }
+    getGameplayCamera() {
+        return new CCMPCamera(ccmp.cameras.getGameplayCamera());
+    }
+    getByID(id) {
+        const camera = this.findByID(id);
+        if (!camera) {
+            throw new Error(`CCMPCameraManager.getByID(${id}): camera not found.`);
+        }
+        return camera;
+    }
+    findByID(id) {
+        var _a;
+        return (_a = this._cameras.get(id)) !== null && _a !== void 0 ? _a : null;
+    }
+    getByRemoteID(remoteId) {
+        const camera = this.findByRemoteID(remoteId);
+        if (!camera) {
+            throw new Error(`CCMPCameraManager.getByRemoteID(${remoteId}): camera not found.`);
+        }
+        return camera;
+    }
+    findByRemoteID(remoteId) {
+        return remoteId === 0 ? null : this.findByID(remoteId);
+    }
+    deleteById(id) {
+        const camera = this.getByID(id);
+        camera.destroy();
+        this._cameras.delete(id);
+        return camera;
+    }
+}

package/dist/client/entities/ccmp/ped/CCMPPed.d.ts

@@ -0,0 +1,65 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IVector3D, Vector3D } from "../../../../shared/common/utils";
+import { type Ped as CcmpPed } from "@classic-mp/types/client";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type IPed } from "../../common/ped/IPed";
+export declare class CCMPPed implements IPed {
+    private readonly _ccmpPed;
+    private readonly _onDestroy;
+    private _destroyed;
+    constructor(_ccmpPed: CcmpPed, _onDestroy?: (ped: CCMPPed) => void);
+    get id(): number;
+    get remoteId(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): Vector3D;
+    get dimension(): number;
+    setPosition(value: IVector3D): void;
+    setDimension(value: number): void;
+    setCoords(xPos: number, yPos: number, zPos: number, xAxis: boolean, yAxis: boolean, zAxis: boolean, clearArea: boolean): void;
+    get model(): number;
+    get heading(): number;
+    setHeading(heading: number): void;
+    setModel(value: string): void;
+    get rotation(): Vector3D;
+    setRotation(value: IVector3D): void;
+    get forwardVector(): Vector3D;
+    freezePosition(freeze: boolean): void;
+    setCollision(collision: boolean, keepPhysics: boolean): void;
+    setInvincible(invincible: boolean): void;
+    setVisible(visible: boolean): void;
+    setAlpha(alpha: number): void;
+    get alpha(): number;
+    resetAlpha(): void;
+    getOffsetFromInWorldCoords(offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    getBoneIndexByName(boneName: string): number;
+    getWorldPositionOfBone(boneIndex: number): IVector3D;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    attachToEntity(target: IBaseObject, boneIndex: number, offset: IVector3D, rotation: IVector3D, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
+    detach(useDetachVelocity: boolean, collision: boolean): void;
+    getSpeed(): number;
+    isPlayingAnim(dictionary: string, name: string, taskFlag: number): boolean;
+    setDecoration(collection: string, overlay: string): void;
+    removeDecoration(collection: string, overlay: string): void;
+    clearDecorations(): void;
+    setHeadBlendData(shapeFirstId: number, shapeSecondId: number, shapeThirdId: number, skinFirstId: number, skinSecondId: number, skinThirdId: number, shapeMix: number, skinMix: number, thirdMix: number, isParent: boolean): void;
+    setFaceFeature(index: number, value: number): void;
+    setHeadOverlay(overlayId: number, index: number, opacity: number): void;
+    setHeadOverlayColor(overlayId: number, colorTypeId: number, firstColor: number, secondColor: number): void;
+    setEyeColor(eyeColor: number): void;
+    setHairColor(colorId: number, highlightColorId: number): void;
+    setComponentVariation(componentId: number, drawableId: number, textureId: number, paletteId: number): void;
+    setPropertyVariation(componentId: number, drawableId: number, textureId: number, attach: boolean): void;
+    clearProp(componentId: number): void;
+    getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    clearTasks(): void;
+    taskPlayAnim(dictionary: string, name: string, blendInSpeed: number, blendOutSpeed: number, duration: number, flag: number, playbackRate: number): void;
+    taskGoToCoordAnyMeans(x: number, y: number, z: number, speed: number, walkingStyle?: number, drivingFlags?: number): void;
+    stopAnim(dictionary: string, name: string, blendOutSpeed: number): void;
+    setBlockingOfNonTemporaryEvents(blocking: boolean): void;
+}

package/dist/client/entities/ccmp/ped/CCMPPed.js

@@ -0,0 +1,185 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+export class CCMPPed {
+    constructor(_ccmpPed, _onDestroy = () => { }) {
+        this._ccmpPed = _ccmpPed;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpPed.id;
+    }
+    get remoteId() {
+        return this._ccmpPed.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Ped;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpPed.isAlive;
+    }
+    get handle() {
+        return this._ccmpPed.handle;
+    }
+    destroy() {
+        if (this._destroyed) {
+            return;
+        }
+        this._destroyed = true;
+        this._ccmpPed.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpPed.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpPed.dimension;
+    }
+    setPosition(value) {
+        this._ccmpPed.setPosition(value);
+    }
+    setDimension(value) {
+        this._ccmpPed.setDimension(value);
+    }
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        this._ccmpPed.setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
+    }
+    get model() {
+        return this._ccmpPed.model;
+    }
+    get heading() {
+        return this._ccmpPed.heading;
+    }
+    setHeading(heading) {
+        this._ccmpPed.setHeading(heading);
+    }
+    setModel(value) {
+        this._ccmpPed.setModel(value);
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpPed.rotation;
+        return new Vector3D(x, y, z);
+    }
+    setRotation(value) {
+        this._ccmpPed.setRotation(value);
+    }
+    get forwardVector() {
+        const { x, y, z } = this._ccmpPed.forwardVector;
+        return new Vector3D(x, y, z);
+    }
+    freezePosition(freeze) {
+        this._ccmpPed.freezePosition(freeze);
+    }
+    setCollision(collision, keepPhysics) {
+        this._ccmpPed.setCollision(collision, keepPhysics);
+    }
+    setInvincible(invincible) {
+        this._ccmpPed.setInvincible(invincible);
+    }
+    setVisible(visible) {
+        this._ccmpPed.setVisible(visible);
+    }
+    setAlpha(alpha) {
+        this._ccmpPed.setAlpha(alpha);
+    }
+    get alpha() {
+        return this._ccmpPed.alpha;
+    }
+    resetAlpha() {
+        this._ccmpPed.resetAlpha();
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this._ccmpPed.getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
+    getBoneIndexByName(boneName) {
+        return this._ccmpPed.getBoneIndexByName(boneName);
+    }
+    getWorldPositionOfBone(boneIndex) {
+        const { x, y, z } = this._ccmpPed.getWorldPositionOfBone(boneIndex);
+        return new Vector3D(x, y, z);
+    }
+    getVariable(name) {
+        void name;
+        return null;
+    }
+    getSyncedMeta(key) {
+        void key;
+        return undefined;
+    }
+    hasSyncedMeta(key) {
+        void key;
+        return false;
+    }
+    getSyncedMetaKeys() {
+        return [];
+    }
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this._ccmpPed.attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
+    }
+    detach(useDetachVelocity, collision) {
+        this._ccmpPed.detach(useDetachVelocity, collision);
+    }
+    getSpeed() {
+        return this._ccmpPed.getSpeed();
+    }
+    isPlayingAnim(dictionary, name, taskFlag) {
+        return this._ccmpPed.isPlayingAnim(dictionary, name, taskFlag);
+    }
+    setDecoration(collection, overlay) {
+        this._ccmpPed.setDecoration(collection, overlay);
+    }
+    removeDecoration(collection, overlay) {
+        this._ccmpPed.removeDecoration(collection, overlay);
+    }
+    clearDecorations() {
+        this._ccmpPed.clearDecorations();
+    }
+    setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent) {
+        this._ccmpPed.setHeadBlendData(shapeFirstId, shapeSecondId, shapeThirdId, skinFirstId, skinSecondId, skinThirdId, shapeMix, skinMix, thirdMix, isParent);
+    }
+    setFaceFeature(index, value) {
+        this._ccmpPed.setFaceFeature(index, value);
+    }
+    setHeadOverlay(overlayId, index, opacity) {
+        this._ccmpPed.setHeadOverlay(overlayId, index, opacity);
+    }
+    setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor) {
+        this._ccmpPed.setHeadOverlayColor(overlayId, colorTypeId, firstColor, secondColor);
+    }
+    setEyeColor(eyeColor) {
+        this._ccmpPed.setEyeColor(eyeColor);
+    }
+    setHairColor(colorId, highlightColorId) {
+        this._ccmpPed.setHairColor(colorId, highlightColorId);
+    }
+    setComponentVariation(componentId, drawableId, textureId, paletteId) {
+        this._ccmpPed.setComponentVariation(componentId, drawableId, textureId, paletteId);
+    }
+    setPropertyVariation(componentId, drawableId, textureId, attach) {
+        this._ccmpPed.setPropertyVariation(componentId, drawableId, textureId, attach);
+    }
+    clearProp(componentId) {
+        this._ccmpPed.clearProp(componentId);
+    }
+    getBoneCoords(boneId, offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this._ccmpPed.getBoneCoords(boneId, offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
+    clearTasks() {
+        this._ccmpPed.clearTasks();
+    }
+    taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate) {
+        this._ccmpPed.taskPlayAnim(dictionary, name, blendInSpeed, blendOutSpeed, duration, flag, playbackRate);
+    }
+    taskGoToCoordAnyMeans(x, y, z, speed, walkingStyle, drivingFlags) {
+        this._ccmpPed.taskGoToCoordAnyMeans(x, y, z, speed, walkingStyle, drivingFlags);
+    }
+    stopAnim(dictionary, name, blendOutSpeed) {
+        this._ccmpPed.stopAnim(dictionary, name, blendOutSpeed);
+    }
+    setBlockingOfNonTemporaryEvents(blocking) {
+        this._ccmpPed.setBlockingOfNonTemporaryEvents(blocking);
+    }
+}

package/dist/client/entities/ccmp/ped/CCMPPedsManager.d.ts

@@ -0,0 +1,20 @@
+import { type IPedCreateOptions, type IPedsManager } from "../../common/ped/IPedsManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPPed } from "./CCMPPed";
+export declare class CCMPPedsManager implements IPedsManager {
+    private readonly _peds;
+    private readonly _iterator;
+    create(options: IPedCreateOptions): CCMPPed;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPPed;
+    unregisterById(id: number): CCMPPed;
+    findByID(id: number): CCMPPed | null;
+    getByID(id: number): CCMPPed;
+    findByRemoteID(remoteId: number): CCMPPed | null;
+    getByRemoteID(remoteId: number): CCMPPed;
+    deleteById(id: number): CCMPPed;
+    get iterator(): IWorldObjectsIterator<CCMPPed>;
+    private _filter;
+    private _register;
+    private _pruneDestroyed;
+}

package/dist/client/entities/ccmp/ped/CCMPPedsManager.js

@@ -0,0 +1,105 @@
+import { CCMPPed } from "./CCMPPed";
+export class CCMPPedsManager {
+    constructor() {
+        this._peds = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((ped) => ped.dimension === value),
+            range2D: (center, range) => this._filter((ped) => {
+                const position = ped.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((ped) => ped.position.isInRange(center, range)),
+        };
+    }
+    create(options) {
+        const { model, position, rotation, dimension } = options;
+        const ccmpPed = ccmp.peds.create(model, position, rotation.z, { dimension });
+        if (!ccmpPed) {
+            throw new Error(`CCMPPedsManager.create: ccmp.peds.create failed for model "${model}"`);
+        }
+        return this._register(ccmpPed);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpPed of ccmp.peds.all) {
+            if (!this._peds.has(ccmpPed.id)) {
+                this._register(ccmpPed);
+            }
+        }
+    }
+    registerById(id) {
+        const existingPed = this.findByID(id);
+        if (existingPed) {
+            return existingPed;
+        }
+        const ccmpPed = ccmp.peds.getById(id);
+        if (!ccmpPed) {
+            throw new Error(`CCMPPedsManager.registerById(${id}): ped not found.`);
+        }
+        return this._register(ccmpPed);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const ped = (_a = this._peds.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (ped && !ped.isExists) {
+            this._peds.delete(id);
+            return null;
+        }
+        return ped;
+    }
+    getByID(id) {
+        const ped = this.findByID(id);
+        if (!ped) {
+            throw new Error(`CCMPPedsManager.getByID(${id}): ped not found.`);
+        }
+        return ped;
+    }
+    findByRemoteID(remoteId) {
+        return remoteId === 0 ? null : this.findByID(remoteId);
+    }
+    getByRemoteID(remoteId) {
+        const ped = this.findByRemoteID(remoteId);
+        if (!ped) {
+            throw new Error(`CCMPPedsManager.getByRemoteID(${remoteId}): ped not found.`);
+        }
+        return ped;
+    }
+    deleteById(id) {
+        const ped = this.getByID(id);
+        ped.destroy();
+        return ped;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    *_filter(predicate) {
+        for (const ped of this._peds.values()) {
+            if (!ped.isExists) {
+                this._peds.delete(ped.id);
+                continue;
+            }
+            if (predicate(ped)) {
+                yield ped;
+            }
+        }
+    }
+    _register(ccmpPed) {
+        const ped = new CCMPPed(ccmpPed, (destroyedPed) => {
+            this._peds.delete(destroyedPed.id);
+        });
+        this._peds.set(ped.id, ped);
+        return ped;
+    }
+    _pruneDestroyed() {
+        for (const ped of this._peds.values()) {
+            if (!ped.isExists) {
+                this._peds.delete(ped.id);
+            }
+        }
+    }
+}

package/dist/client/entities/ccmp/player/CCMPPlayer.d.ts

@@ -0,0 +1,112 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { type IBaseObject } from "../../common/baseObject/IBaseObject";
+import { type IPlayer } from "../../common/player/IPlayer";
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { type IVector3D } from "../../../../shared/common/utils";
+export interface ICCMPPlayerOptions {
+    /** Network id of the player (same as remoteId — CCMP exposes only one id). */
+    readonly id: number;
+    /** Human-readable name from the handshake. May be empty if not yet known. */
+    readonly name: string;
+    /** `true` if this Player represents the local user, `false` for remotes. */
+    readonly isLocal: boolean;
+}
+/**
+ * CCMP implementation of the Rock-Mod player facade.
+ *
+ * Identity and synced meta are tracked by id. Runtime entity operations are
+ * delegated to `ccmp.players.getById(id)`, whose `handle` is live for the
+ * local player and for streamed remote players. Missing remote handles degrade
+ * to safe defaults/no-ops, matching RageMP-style best-effort client behavior.
+ */
+export declare class CCMPPlayer implements IPlayer {
+    /** Глобальный set для one-time warnings, чтобы не флудить лог. */
+    private static readonly _warnedMethods;
+    private readonly _id;
+    private _name;
+    private readonly _isLocal;
+    private _isExists;
+    constructor(options: ICCMPPlayerOptions);
+    /** Помечает игрока как удалённого — вызывается из `CCMPPlayersManager`. */
+    markRemoved(): void;
+    /** Обновляет name (полезно если name приехал позже первого создания). */
+    setNameInternal(name: string): void;
+    get id(): number;
+    get remoteId(): number;
+    get type(): BaseObjectType;
+    get isExists(): boolean;
+    get handle(): number;
+    destroy(): void;
+    get position(): IVector3D;
+    get dimension(): number;
+    setPosition(value: IVector3D): void;
+    setDimension(_value: number): void;
+    setCoords(xPos: number, yPos: number, zPos: number, xAxis: boolean, yAxis: boolean, zAxis: boolean, clearArea: boolean): void;
+    get model(): number;
+    get heading(): number;
+    setHeading(heading: number): void;
+    setModel(_value: string): void;
+    get rotation(): IVector3D;
+    setRotation(value: IVector3D): void;
+    get forwardVector(): IVector3D;
+    freezePosition(freeze: boolean): void;
+    setCollision(collision: boolean, keepPhysics: boolean): void;
+    setInvincible(invincible: boolean): void;
+    setVisible(visible: boolean): void;
+    setAlpha(alpha: number): void;
+    get alpha(): number;
+    resetAlpha(): void;
+    getOffsetFromInWorldCoords(offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    getBoneIndexByName(boneName: string): number;
+    getWorldPositionOfBone(boneIndex: number): IVector3D;
+    getVariable(name: string): unknown | null;
+    getSyncedMeta(key: string): unknown | undefined;
+    hasSyncedMeta(key: string): boolean;
+    getSyncedMetaKeys(): readonly string[];
+    attachToEntity(target: IBaseObject, boneIndex: number, offset: IVector3D, rotation: IVector3D, p9: boolean, useSoftPinning: boolean, collision: boolean, isPed: boolean, vertexIndex: number, fixedRot: boolean): void;
+    detach(useDetachVelocity: boolean, collision: boolean): void;
+    getSpeed(): number;
+    isPlayingAnim(dictionary: string, name: string, taskFlag: number): boolean;
+    get name(): string;
+    get health(): number;
+    get armour(): number;
+    get isDead(): boolean;
+    get vehicle(): IVehicle | null;
+    get isVoice3DEnabled(): boolean;
+    get voiceVolume(): number;
+    get isVoiceActive(): boolean;
+    setVoice3D(_enable: boolean): void;
+    setVoiceVolume(_volume: number): void;
+    get isReloading(): boolean;
+    get weapon(): number;
+    getAmmoInClip(_weapon: number): number;
+    getWeaponAmmo(_weapon: number): number;
+    getBoneIndex(boneId: number): number;
+    setDecoration(_collection: string, _overlay: string): void;
+    removeDecoration(_collection: string, _overlay: string): void;
+    clearDecorations(): void;
+    setHeadBlendData(_shapeFirstId: number, _shapeSecondId: number, _shapeThirdId: number, _skinFirstId: number, _skinSecondId: number, _skinThirdId: number, _shapeMix: number, _skinMix: number, _thirdMix: number, _isParent: boolean): void;
+    setFaceFeature(_index: number, _value: number): void;
+    setHeadOverlay(_overlayId: number, _index: number, _opacity: number, _firstColor: number, _secondColor: number): void;
+    setHeadOverlayColor(_overlayId: number, _colorTypeId: number, _firstColor: number, _secondColor: number): void;
+    setEyeColor(_eyeColor: number): void;
+    setHairColor(_colorId: number, _highlightColorId: number): void;
+    setComponentVariation(_componentId: number, _drawableId: number, _textureId: number, _paletteId: number): void;
+    setPropertyVariation(_componentId: number, _drawableId: number, _textureId: number, _attach: boolean): void;
+    clearProp(_componentId: number): void;
+    get isLocalPlayer(): boolean;
+    taskSwapWeapon(): void;
+    taskEnterVehicle(_vehicleHandle: number, _timeout: number, _seat: number, _speed: number, _flag: number, _p6: number): void;
+    clearTasks(): void;
+    clearTasksImmediately(): void;
+    taskPlayAnim(_dictionary: string, _name: string, _blendInSpeed: number, _blendOutSpeed: number, _duration: number, _flag: number, _playbackRate: number, _lockX: boolean, _lockY: boolean, _lockZ: boolean): void;
+    stopAnim(_dictionary: string, _name: string, _blendOutSpeed: number): void;
+    setMovementClipset(_clipset: string, _speed: number): void;
+    resetMovementClipset(_blendDuration: number): void;
+    getBoneCoords(boneId: number, offsetX: number, offsetY: number, offsetZ: number): IVector3D;
+    setNoCollision(otherHandle: number, thisFrameOnly: boolean): void;
+    private _getNativePlayer;
+    private _withHandle;
+    private _withHandleVoid;
+    private _warnOnce;
+}