rock-mod 0.20.0 → 0.22.0

package/dist/client/entities/ccmp/vehicle/CCMPVehicle.js

@@ -0,0 +1,392 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+const notImplemented = (memberName) => {
+    throw new Error(`CCMPVehicle.${memberName}: not implemented`);
+};
+export class CCMPVehicle {
+    constructor(_ccmpVehicle, _onDestroy = () => { }) {
+        this._ccmpVehicle = _ccmpVehicle;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpVehicle.id;
+    }
+    get remoteId() {
+        return this._ccmpVehicle.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Vehicle;
+    }
+    get isExists() {
+        var _a;
+        if (this._destroyed)
+            return false;
+        if (this._ccmpVehicle.isRemote) {
+            return this._getRemoteVehicleExists();
+        }
+        return !this._destroyed && ((_a = this._ccmpVehicle.isExists) !== null && _a !== void 0 ? _a : this._ccmpVehicle.isAlive);
+    }
+    get handle() {
+        const handle = Number(this._ccmpVehicle.handle);
+        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpVehicle.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpVehicle.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpVehicle.dimension;
+    }
+    setPosition(_value) {
+        notImplemented("setPosition");
+    }
+    setDimension(_value) {
+        notImplemented("setDimension");
+    }
+    setCoords(_xPos, _yPos, _zPos, _xAxis, _yAxis, _zAxis, _clearArea) {
+        notImplemented("setCoords");
+    }
+    get model() {
+        return this._ccmpVehicle.model;
+    }
+    get heading() {
+        return this._ccmpVehicle.heading;
+    }
+    setHeading(_heading) {
+        notImplemented("setHeading");
+    }
+    setModel(_value) {
+        notImplemented("setModel");
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpVehicle.rotation;
+        return new Vector3D(x, y, z);
+    }
+    get forwardVector() {
+        const headingRad = (this.heading * Math.PI) / 180;
+        return new Vector3D(-Math.sin(headingRad), Math.cos(headingRad), 0);
+    }
+    setRotation(_value) {
+        notImplemented("setRotation");
+    }
+    freezePosition(_freeze) {
+        notImplemented("freezePosition");
+    }
+    setCollision(_collision, _keepPhysics) {
+        notImplemented("setCollision");
+    }
+    setInvincible(_invincible) {
+        notImplemented("setInvincible");
+    }
+    setVisible(_visible) {
+        notImplemented("setVisible");
+    }
+    setAlpha(alpha) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.setEntityAlpha(handle, alpha, false);
+        });
+    }
+    get alpha() {
+        return this._withHandle(255, (handle) => ccmp.natives.entity.getEntityAlpha(handle));
+    }
+    resetAlpha() {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.entity.resetEntityAlpha(handle);
+        });
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        return this._withHandle(this._getOffsetFromCachedTransform(offsetX, offsetY, offsetZ), (handle) => {
+            const { x, y, z } = ccmp.natives.entity.getOffsetFromEntityInWorldCoords(handle, offsetX, offsetY, offsetZ);
+            return new Vector3D(x, y, z);
+        });
+    }
+    getBoneIndexByName(boneName) {
+        return this._withHandle(-1, (handle) => ccmp.natives.entity.getEntityBoneIndexByName(handle, boneName));
+    }
+    getWorldPositionOfBone(boneIndex) {
+        return this._withHandle(this.position, (handle) => {
+            const { x, y, z } = ccmp.natives.entity.getWorldPositionOfEntityBone(handle, boneIndex);
+            return new Vector3D(x, y, z);
+        });
+    }
+    getVariable(name) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, name);
+        return value === undefined ? null : value;
+    }
+    getSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Vehicle, remoteId);
+    }
+    attachToEntity(_target, _boneIndex, _offset, _rotation, _p9, _useSoftPinning, _collision, _isPed, _vertexIndex, _fixedRot) {
+        notImplemented("attachToEntity");
+    }
+    detach(_useDetachVelocity, _collision) {
+        notImplemented("detach");
+    }
+    getSpeed() {
+        return notImplemented("getSpeed");
+    }
+    isPlayingAnim(_dictionary, _name, _taskFlag) {
+        return notImplemented("isPlayingAnim");
+    }
+    get bodyHealth() {
+        return notImplemented("bodyHealth");
+    }
+    get engineHealth() {
+        return notImplemented("engineHealth");
+    }
+    get numberPlate() {
+        var _a;
+        return (_a = this._ccmpVehicle.numberPlate) !== null && _a !== void 0 ? _a : this._ccmpVehicle.numberPlateText;
+    }
+    get isDead() {
+        return !this.isExists;
+    }
+    setBodyHealth(_value) {
+        notImplemented("setBodyHealth");
+    }
+    setEngineHealth(_value) {
+        notImplemented("setEngineHealth");
+    }
+    setNumberPlate(_value) {
+        notImplemented("setNumberPlate");
+    }
+    explode() {
+        notImplemented("explode");
+    }
+    getPedInSeat(seat) {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getPedInVehicleSeat(handle, seat, false));
+    }
+    setUndriveable(_toggle) {
+        notImplemented("setUndriveable");
+    }
+    get maxNumberOfPassengers() {
+        return notImplemented("maxNumberOfPassengers");
+    }
+    get gear() {
+        return notImplemented("gear");
+    }
+    get speed() {
+        return notImplemented("speed");
+    }
+    get isEngineRunning() {
+        return notImplemented("isEngineRunning");
+    }
+    setEngineOn(_toggle, _instantly, _otherwise) {
+        notImplemented("setEngineOn");
+    }
+    get lightsState() {
+        return notImplemented("lightsState");
+    }
+    get isLocked() {
+        return notImplemented("isLocked");
+    }
+    setIsLocked(_value) {
+        notImplemented("setIsLocked");
+    }
+    setCustomPrimaryColour(color) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleCustomPrimaryColour(handle, color.r, color.g, color.b);
+        });
+    }
+    setCustomSecondaryColour(color) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleCustomSecondaryColour(handle, color.r, color.g, color.b);
+        });
+    }
+    get customPrimaryColour() {
+        return this._withHandle({ r: 0, g: 0, b: 0 }, (handle) => ccmp.natives.vehicle.getVehicleCustomPrimaryColour(handle));
+    }
+    get customSecondaryColour() {
+        return this._withHandle({ r: 0, g: 0, b: 0 }, (handle) => ccmp.natives.vehicle.getVehicleCustomSecondaryColour(handle));
+    }
+    setMod(modType, modIndex) {
+        this._withHandleVoid((handle) => {
+            this._setModKit(handle);
+            ccmp.natives.vehicle.setVehicleMod(handle, modType, modIndex, false);
+        });
+    }
+    getMod(modType) {
+        return this._withHandle(-1, (handle) => ccmp.natives.vehicle.getVehicleMod(handle, modType));
+    }
+    getNumMods(modType) {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getNumVehicleMods(handle, modType));
+    }
+    setNeonLightEnabled(index, toggle) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleNeonEnabled(handle, index, toggle);
+        });
+    }
+    setNeonLightsColour(color) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleNeonColour(handle, color.r, color.g, color.b);
+        });
+    }
+    setWindowTint(tintType) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleWindowTint(handle, tintType);
+        });
+    }
+    get windowTint() {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getVehicleWindowTint(handle));
+    }
+    setWheelType(wheelType) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleWheelType(handle, wheelType);
+        });
+    }
+    get wheelType() {
+        return this._withHandle(0, (handle) => ccmp.natives.vehicle.getVehicleWheelType(handle));
+    }
+    setNumberPlateTextIndex(_index) {
+        notImplemented("setNumberPlateTextIndex");
+    }
+    get numberPlateTextIndex() {
+        return notImplemented("numberPlateTextIndex");
+    }
+    setDoorOpen(_doorIndex, _loose, _openInstantly) {
+        notImplemented("setDoorOpen");
+    }
+    setDoorShut(_doorIndex, _instantly) {
+        notImplemented("setDoorShut");
+    }
+    setHandling(_field, _value) {
+        notImplemented("setHandling");
+    }
+    getHandling(_field) {
+        return notImplemented("getHandling");
+    }
+    setEnginePowerMultiplier(_value) {
+        notImplemented("setEnginePowerMultiplier");
+    }
+    setEngineTorqueMultiplier(_value) {
+        notImplemented("setEngineTorqueMultiplier");
+    }
+    modifyTopSpeed(_value) {
+        notImplemented("modifyTopSpeed");
+    }
+    setCheatPowerIncrease(_value) {
+        notImplemented("setCheatPowerIncrease");
+    }
+    toggleMod(modType, toggle) {
+        this._withHandleVoid((handle) => {
+            this._setModKit(handle);
+            ccmp.natives.vehicle.toggleVehicleMod(handle, modType, toggle);
+        });
+    }
+    setTyreSmokeColor(r, g, b) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleTyreSmokeColor(handle, r, g, b);
+        });
+    }
+    setModColor1(paintType, color, p3) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleModColor1(handle, paintType, color, p3);
+        });
+    }
+    setExtraColours(_pearlescentColor, _wheelColor) {
+        notImplemented("setExtraColours");
+    }
+    setHeadlightColor(colorIndex) {
+        this._withHandleVoid((handle) => {
+            ccmp.natives.vehicle.setVehicleXenonLightColorIndex(handle, colorIndex);
+        });
+    }
+    setDashboardColor(colorIndex) {
+        this._withHandleVoid((handle) => {
+            var _a;
+            const vehicleNatives = ccmp.natives.vehicle;
+            const setDashboardColor = (_a = vehicleNatives.setVehicleDashboardColor) !== null && _a !== void 0 ? _a : vehicleNatives.setVehicleDashboardColour;
+            if (!setDashboardColor)
+                return;
+            setDashboardColor(handle, colorIndex);
+        });
+    }
+    setInteriorColor(colorIndex) {
+        this._withHandleVoid((handle) => {
+            var _a;
+            const vehicleNatives = ccmp.natives.vehicle;
+            const setInteriorColor = (_a = vehicleNatives.setVehicleInteriorColor) !== null && _a !== void 0 ? _a : vehicleNatives.setVehicleInteriorColour;
+            if (!setInteriorColor)
+                return;
+            setInteriorColor(handle, colorIndex);
+        });
+    }
+    getMaxBraking() {
+        return notImplemented("getMaxBraking");
+    }
+    getAcceleration() {
+        return notImplemented("getAcceleration");
+    }
+    getMaxTraction() {
+        return notImplemented("getMaxTraction");
+    }
+    getModelMaxSpeed() {
+        return notImplemented("getModelMaxSpeed");
+    }
+    _withHandle(fallback, callback) {
+        const handle = this.handle;
+        if (!handle) {
+            return fallback;
+        }
+        return callback(handle);
+    }
+    _withHandleVoid(callback) {
+        const handle = this.handle;
+        if (!handle) {
+            return;
+        }
+        callback(handle);
+    }
+    _setModKit(handle) {
+        ccmp.natives.vehicle.setVehicleModKit(handle, 0);
+    }
+    _getRemoteVehicleExists() {
+        var _a;
+        try {
+            return (_a = this._ccmpVehicle.isExists) !== null && _a !== void 0 ? _a : true;
+        }
+        catch (_b) {
+            return true;
+        }
+    }
+    _getOffsetFromCachedTransform(offsetX, offsetY, offsetZ) {
+        const position = this.position;
+        const headingRad = (this.heading * Math.PI) / 180;
+        const rightX = Math.cos(headingRad);
+        const rightY = Math.sin(headingRad);
+        const forwardX = -Math.sin(headingRad);
+        const forwardY = Math.cos(headingRad);
+        return new Vector3D(position.x + rightX * offsetX + forwardX * offsetY, position.y + rightY * offsetX + forwardY * offsetY, position.z + offsetZ);
+    }
+}

package/dist/client/entities/ccmp/vehicle/CCMPVehiclesManager.d.ts

@@ -0,0 +1,27 @@
+import { type IVehicle } from "../../common/vehicle/IVehicle";
+import { type IVehicleCreateOptions, type IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+export declare class CCMPVehiclesManager implements IVehiclesManager {
+    private readonly _vehicles;
+    private readonly _vehiclesByRemoteId;
+    private readonly _iterator;
+    constructor();
+    create(options: IVehicleCreateOptions): IVehicle;
+    getDisplayNameFromVehicleModel(modelHash: number): string;
+    syncWithMpPool(): void;
+    registerById(id: number): IVehicle;
+    unregisterById(id: number): IVehicle;
+    findByID(id: number): IVehicle | null;
+    getByID(id: number): IVehicle;
+    findByRemoteID(remoteId: number): IVehicle | null;
+    getByRemoteID(remoteId: number): IVehicle;
+    deleteById(id: number): IVehicle;
+    get iterator(): IWorldObjectsIterator<IVehicle>;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerLifecycleEvents;
+    private _filter;
+    private _pruneDestroyed;
+    private _getNativeVehiclesApi;
+}

package/dist/client/entities/ccmp/vehicle/CCMPVehiclesManager.js

@@ -0,0 +1,183 @@
+/// <reference types="@classic-mp/types/client" />
+import { RockMod } from "../../../RockMod";
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPVehicle } from "./CCMPVehicle";
+export class CCMPVehiclesManager {
+    constructor() {
+        this._vehicles = new Map();
+        this._vehiclesByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((vehicle) => vehicle.dimension === value),
+            range2D: (center, range) => this._filter((vehicle) => {
+                const position = vehicle.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((vehicle) => vehicle.position.isInRange(center, range)),
+        };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
+    }
+    create(options) {
+        var _a;
+        const ccmpVehicle = (_a = this._getNativeVehiclesApi()) === null || _a === void 0 ? void 0 : _a.create(options.model, options.position, options.rotation, {
+            dimension: options.dimension,
+            engine: options.engine,
+            locked: options.locked,
+        });
+        if (!ccmpVehicle) {
+            throw new Error(`CCMPVehiclesManager.create: ccmp.vehicles.create failed for model "${options.model}"`);
+        }
+        return this._register(ccmpVehicle);
+    }
+    getDisplayNameFromVehicleModel(modelHash) {
+        return ccmp.natives.vehicle.getDisplayNameFromVehicleModel(modelHash);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        const ccmpVehicles = this._getNativeVehiclesApi();
+        if (!ccmpVehicles)
+            return;
+        for (const ccmpVehicle of ccmpVehicles.all) {
+            this._register(ccmpVehicle);
+        }
+    }
+    registerById(id) {
+        var _a, _b;
+        const existingVehicle = this.findByID(id);
+        if (existingVehicle)
+            return existingVehicle;
+        const ccmpVehicle = (_b = (_a = this._getNativeVehiclesApi()) === null || _a === void 0 ? void 0 : _a.getById(id)) !== null && _b !== void 0 ? _b : null;
+        if (!ccmpVehicle) {
+            throw new Error(`CCMPVehiclesManager.registerById(${id}): vehicle not found.`);
+        }
+        return this._register(ccmpVehicle);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a, _b, _c;
+        const vehicle = (_a = this._vehicles.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (vehicle && vehicle.isExists)
+            return vehicle;
+        if (vehicle)
+            this._unregister(vehicle);
+        const ccmpVehicle = (_c = (_b = this._getNativeVehiclesApi()) === null || _b === void 0 ? void 0 : _b.getById(id)) !== null && _c !== void 0 ? _c : null;
+        if (!ccmpVehicle)
+            return null;
+        return this._register(ccmpVehicle);
+    }
+    getByID(id) {
+        const vehicle = this.findByID(id);
+        if (!vehicle) {
+            throw new Error(`CCMPVehiclesManager.getByID(${id}): vehicle not found.`);
+        }
+        return vehicle;
+    }
+    findByRemoteID(remoteId) {
+        var _a, _b, _c;
+        const vehicle = (_a = this._vehiclesByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (vehicle && vehicle.isExists)
+            return vehicle;
+        if (vehicle)
+            this._unregister(vehicle);
+        const ccmpVehicle = (_c = (_b = this._getNativeVehiclesApi()) === null || _b === void 0 ? void 0 : _b.getByRemoteId(remoteId)) !== null && _c !== void 0 ? _c : null;
+        if (!ccmpVehicle)
+            return null;
+        return this._register(ccmpVehicle);
+    }
+    getByRemoteID(remoteId) {
+        const vehicle = this.findByRemoteID(remoteId);
+        if (!vehicle) {
+            throw new Error(`CCMPVehiclesManager.getByRemoteID(${remoteId}): vehicle not found.`);
+        }
+        return vehicle;
+    }
+    deleteById(id) {
+        const vehicle = this.getByID(id);
+        vehicle.destroy();
+        return vehicle;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    _register(ccmpVehicle) {
+        const existingVehicle = this._findRegistered(ccmpVehicle);
+        if (existingVehicle && existingVehicle.isExists)
+            return existingVehicle;
+        if (existingVehicle)
+            this._unregister(existingVehicle);
+        const vehicle = new CCMPVehicle(ccmpVehicle, (destroyedVehicle) => {
+            this._unregister(destroyedVehicle);
+        });
+        this._vehicles.set(vehicle.id, vehicle);
+        if (vehicle.remoteId !== null) {
+            this._vehiclesByRemoteId.set(vehicle.remoteId, vehicle);
+        }
+        return vehicle;
+    }
+    _unregister(vehicle) {
+        this._vehicles.delete(vehicle.id);
+        if (vehicle.remoteId !== null) {
+            this._vehiclesByRemoteId.delete(vehicle.remoteId);
+        }
+    }
+    _findRegistered(ccmpVehicle) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpVehicle.remoteId === null ? null : ((_a = this._vehiclesByRemoteId.get(ccmpVehicle.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._vehicles.get(ccmpVehicle.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        const eventsApi = ccmp;
+        eventsApi.on("vehicleCreated", (ccmpVehicle) => {
+            if (!ccmpVehicle)
+                return;
+            const vehicle = this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityCreated, vehicle);
+        });
+        eventsApi.on("vehicleDestroyed", (ccmpVehicle) => {
+            var _a;
+            if (!ccmpVehicle)
+                return;
+            const vehicle = (_a = this._findRegistered(ccmpVehicle)) !== null && _a !== void 0 ? _a : this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityDestroyed, vehicle);
+            this._unregister(vehicle);
+        });
+        eventsApi.on("vehicleStreamIn", (ccmpVehicle) => {
+            if (!ccmpVehicle)
+                return;
+            const vehicle = this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityStreamIn, vehicle);
+        });
+        eventsApi.on("vehicleStreamOut", (ccmpVehicle) => {
+            var _a;
+            if (!ccmpVehicle)
+                return;
+            const vehicle = (_a = this._findRegistered(ccmpVehicle)) !== null && _a !== void 0 ? _a : this._register(ccmpVehicle);
+            RockMod.instance.net.events.emitInternal(ClientInternalEventName.EntityStreamOut, vehicle);
+        });
+    }
+    *_filter(predicate) {
+        for (const vehicle of this._vehicles.values()) {
+            if (!vehicle.isExists) {
+                this._unregister(vehicle);
+                continue;
+            }
+            if (predicate(vehicle)) {
+                yield vehicle;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const vehicle of this._vehicles.values()) {
+            if (!vehicle.isExists) {
+                this._unregister(vehicle);
+            }
+        }
+    }
+    _getNativeVehiclesApi() {
+        var _a;
+        return (_a = ccmp.vehicles) !== null && _a !== void 0 ? _a : null;
+    }
+}

package/dist/client/entities/common/baseObject/IBaseObject.d.ts

@@ -5,7 +5,8 @@ export interface IBaseObjectOptions {
 }
 export interface IBaseObject {
     get id(): number;
-    get remoteId(): number;
+    /** Server/network id for remote objects; null for client-only objects. */
+    get remoteId(): number | null;
     get type(): BaseObjectType;
     get isExists(): boolean;
     get handle(): number;

package/dist/client/entities/common/entity/IEntity.d.ts

@@ -22,6 +22,9 @@ export interface IEntity extends IWorldObject {
     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;

package/dist/client/entities/ragemp/entity/RageEntity.d.ts

@@ -24,8 +24,15 @@ export declare abstract class RageEntity<T extends EntityMp> extends RageWorldOb
     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;
+    private _getNativeRotation;
+    private _getEntityRotationProperty;
+    private _hasValidHandle;
+    private _isVectorLike;
 }