rock-mod 0.21.0 → 0.23.0

package/dist/client/entities/ccmp/object/CCMPObject.js

@@ -0,0 +1,149 @@
+import { BaseObjectType } from "../../../../shared/entities";
+import { Vector3D } from "../../../../shared/common/utils";
+export class CCMPObject {
+    constructor(_ccmpObject, _onDestroy = () => { }) {
+        this._ccmpObject = _ccmpObject;
+        this._onDestroy = _onDestroy;
+        this._destroyed = false;
+    }
+    get id() {
+        return this._ccmpObject.id;
+    }
+    get remoteId() {
+        return this._ccmpObject.remoteId;
+    }
+    get type() {
+        return BaseObjectType.Object;
+    }
+    get isExists() {
+        return !this._destroyed && this._ccmpObject.isExists;
+    }
+    get handle() {
+        return this._normalizeHandle(this._ccmpObject.handle);
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._ccmpObject.destroy();
+        this._onDestroy(this);
+    }
+    get position() {
+        const { x, y, z } = this._ccmpObject.position;
+        return new Vector3D(x, y, z);
+    }
+    get dimension() {
+        return this._ccmpObject.dimension;
+    }
+    setPosition(value) {
+        this._ccmpObject.setPosition(value);
+    }
+    setDimension(value) {
+        this._ccmpObject.setDimension(value);
+    }
+    setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea) {
+        this._ccmpObject.setCoords(xPos, yPos, zPos, xAxis, yAxis, zAxis, clearArea);
+    }
+    get model() {
+        return this._ccmpObject.model;
+    }
+    get heading() {
+        return this._ccmpObject.heading;
+    }
+    setHeading(heading) {
+        this._ccmpObject.setHeading(heading);
+    }
+    setModel(value) {
+        this._ccmpObject.setModel(value);
+    }
+    get rotation() {
+        const { x, y, z } = this._ccmpObject.rotation;
+        return new Vector3D(x, y, z);
+    }
+    get forwardVector() {
+        const { x, y, z } = this._ccmpObject.forwardVector;
+        return new Vector3D(x, y, z);
+    }
+    setRotation(value) {
+        this._ccmpObject.setRotation(value);
+    }
+    freezePosition(freeze) {
+        this._ccmpObject.freezePosition(freeze);
+    }
+    setCollision(collision, keepPhysics) {
+        this._ccmpObject.setCollision(collision, keepPhysics);
+    }
+    setInvincible(invincible) {
+        this._ccmpObject.setInvincible(invincible);
+    }
+    setVisible(visible) {
+        this._ccmpObject.setVisible(visible);
+    }
+    setAlpha(alpha) {
+        this._ccmpObject.setAlpha(alpha);
+    }
+    get alpha() {
+        return this._ccmpObject.alpha;
+    }
+    resetAlpha() {
+        this._ccmpObject.resetAlpha();
+    }
+    getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ) {
+        const { x, y, z } = this._ccmpObject.getOffsetFromInWorldCoords(offsetX, offsetY, offsetZ);
+        return new Vector3D(x, y, z);
+    }
+    getBoneIndexByName(boneName) {
+        return this._ccmpObject.getBoneIndexByName(boneName);
+    }
+    getWorldPositionOfBone(boneIndex) {
+        const { x, y, z } = this._ccmpObject.getWorldPositionOfBone(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.Object, 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.Object, remoteId, key);
+    }
+    hasSyncedMeta(key) {
+        const remoteId = this.remoteId;
+        if (remoteId === null)
+            return false;
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Object, remoteId, key);
+    }
+    getSyncedMetaKeys() {
+        const remoteId = this.remoteId;
+        if (remoteId === null)
+            return [];
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Object, remoteId);
+    }
+    attachTo(entity, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this._ccmpObject.attachTo(entity, boneIndex, xPos, yPos, zPos, xRot, yRot, zRot, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
+    }
+    isAttachedTo(entity) {
+        return this._ccmpObject.isAttachedTo(entity);
+    }
+    attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
+        this._ccmpObject.attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot);
+    }
+    detach(useDetachVelocity, collision) {
+        this._ccmpObject.detach(useDetachVelocity, collision);
+    }
+    getSpeed() {
+        return this._ccmpObject.getSpeed();
+    }
+    isPlayingAnim(dictionary, name, taskFlag) {
+        return this._ccmpObject.isPlayingAnim(dictionary, name, taskFlag);
+    }
+    _normalizeHandle(value) {
+        const handle = Number(value);
+        return Number.isFinite(handle) && handle > 0 ? Math.trunc(handle) : 0;
+    }
+}

package/dist/client/entities/ccmp/object/CCMPObjectsManager.d.ts

@@ -0,0 +1,27 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
+import { type IObjectCreateOptions, type IObjectsManager } from "../../common/object/IObjectsManager";
+import { type IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { CCMPObject } from "./CCMPObject";
+export declare class CCMPObjectsManager implements IObjectsManager {
+    private readonly _events;
+    private readonly _objects;
+    private readonly _objectsByRemoteId;
+    private readonly _iterator;
+    constructor(_events: CCMPEventsManager);
+    create(options: IObjectCreateOptions): CCMPObject;
+    syncWithMpPool(): void;
+    registerById(id: number): CCMPObject;
+    unregisterById(id: number): CCMPObject;
+    findByID(id: number): CCMPObject | null;
+    getByID(id: number): CCMPObject;
+    findByRemoteID(remoteId: number): CCMPObject | null;
+    getByRemoteID(remoteId: number): CCMPObject;
+    deleteById(id: number): CCMPObject;
+    get iterator(): IWorldObjectsIterator<CCMPObject>;
+    private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerLifecycleEvents;
+    private _filter;
+    private _pruneDestroyed;
+}

package/dist/client/entities/ccmp/object/CCMPObjectsManager.js

@@ -0,0 +1,177 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
+import { CCMPObject } from "./CCMPObject";
+export class CCMPObjectsManager {
+    constructor(_events) {
+        this._events = _events;
+        this._objects = new Map();
+        this._objectsByRemoteId = new Map();
+        this._iterator = {
+            all: () => this._filter(() => true),
+            dimension: (value) => this._filter((object) => object.dimension === value),
+            range2D: (center, range) => this._filter((object) => {
+                const position = object.position;
+                const squaredDistance = (position.x - center.x) ** 2 + (position.y - center.y) ** 2;
+                return squaredDistance <= range * range;
+            }),
+            range3D: (center, range) => this._filter((object) => object.position.isInRange(center, range)),
+        };
+        this._registerLifecycleEvents();
+        this.syncWithMpPool();
+    }
+    create(options) {
+        const ccmpObject = ccmp.objects.create(options.model, options.position, options.rotation, {
+            dimension: options.dimension,
+            alpha: options.alpha,
+        });
+        if (!ccmpObject) {
+            throw new Error(`CCMPObjectsManager.create: ccmp.objects.create failed for model "${options.model}"`);
+        }
+        return this._register(ccmpObject);
+    }
+    syncWithMpPool() {
+        this._pruneDestroyed();
+        for (const ccmpObject of ccmp.objects.all) {
+            this._register(ccmpObject);
+        }
+    }
+    registerById(id) {
+        const existingObject = this.findByID(id);
+        if (existingObject) {
+            return existingObject;
+        }
+        const ccmpObject = ccmp.objects.getById(id);
+        if (!ccmpObject) {
+            throw new Error(`CCMPObjectsManager.registerById(${id}): object not found.`);
+        }
+        return this._register(ccmpObject);
+    }
+    unregisterById(id) {
+        return this.deleteById(id);
+    }
+    findByID(id) {
+        var _a;
+        const object = (_a = this._objects.get(id)) !== null && _a !== void 0 ? _a : null;
+        if (object && !object.isExists) {
+            this._unregister(object);
+        }
+        else if (object) {
+            return object;
+        }
+        const ccmpObject = ccmp.objects.getById(id);
+        if (!ccmpObject) {
+            return null;
+        }
+        return this._register(ccmpObject);
+    }
+    getByID(id) {
+        const object = this.findByID(id);
+        if (!object) {
+            throw new Error(`CCMPObjectsManager.getByID(${id}): object not found.`);
+        }
+        return object;
+    }
+    findByRemoteID(remoteId) {
+        var _a;
+        const object = (_a = this._objectsByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (object && !object.isExists) {
+            this._unregister(object);
+        }
+        else if (object) {
+            return object;
+        }
+        const ccmpObject = ccmp.objects.getByRemoteId(remoteId);
+        if (!ccmpObject) {
+            return null;
+        }
+        return this._register(ccmpObject);
+    }
+    getByRemoteID(remoteId) {
+        const object = this.findByRemoteID(remoteId);
+        if (!object) {
+            throw new Error(`CCMPObjectsManager.getByRemoteID(${remoteId}): object not found.`);
+        }
+        return object;
+    }
+    deleteById(id) {
+        const object = this.getByID(id);
+        object.destroy();
+        return object;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    _register(ccmpObject) {
+        const existingObject = this._findRegistered(ccmpObject);
+        if (existingObject && existingObject.isExists) {
+            return existingObject;
+        }
+        if (existingObject) {
+            this._unregister(existingObject);
+        }
+        const object = new CCMPObject(ccmpObject, (destroyedObject) => {
+            this._unregister(destroyedObject);
+        });
+        this._objects.set(object.id, object);
+        if (object.remoteId !== null) {
+            this._objectsByRemoteId.set(object.remoteId, object);
+        }
+        return object;
+    }
+    _unregister(object) {
+        this._objects.delete(object.id);
+        if (object.remoteId !== null) {
+            this._objectsByRemoteId.delete(object.remoteId);
+        }
+    }
+    _findRegistered(ccmpObject) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpObject.remoteId === null ? null : ((_a = this._objectsByRemoteId.get(ccmpObject.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._objects.get(ccmpObject.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerLifecycleEvents() {
+        ccmp.on("objectCreated", (ccmpObject) => {
+            if (!ccmpObject)
+                return;
+            const object = this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityCreated, object);
+        });
+        ccmp.on("objectDestroyed", (ccmpObject) => {
+            var _a;
+            if (!ccmpObject)
+                return;
+            const object = (_a = this._findRegistered(ccmpObject)) !== null && _a !== void 0 ? _a : this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityDestroyed, object);
+            this._unregister(object);
+        });
+        ccmp.on("objectStreamIn", (ccmpObject) => {
+            if (!ccmpObject)
+                return;
+            const object = this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamIn, object);
+        });
+        ccmp.on("objectStreamOut", (ccmpObject) => {
+            var _a;
+            if (!ccmpObject)
+                return;
+            const object = (_a = this._findRegistered(ccmpObject)) !== null && _a !== void 0 ? _a : this._register(ccmpObject);
+            this._events.emitInternal(ClientInternalEventName.EntityStreamOut, object);
+        });
+    }
+    *_filter(predicate) {
+        for (const object of this._objects.values()) {
+            if (!object.isExists) {
+                this._unregister(object);
+                continue;
+            }
+            if (predicate(object)) {
+                yield object;
+            }
+        }
+    }
+    _pruneDestroyed() {
+        for (const object of this._objects.values()) {
+            if (!object.isExists) {
+                this._unregister(object);
+            }
+        }
+    }
+}

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

@@ -9,7 +9,7 @@ export declare class CCMPPed implements IPed {
     private _destroyed;
     constructor(_ccmpPed: CcmpPed, _onDestroy?: (ped: CCMPPed) => void);
     get id(): number;
-    get remoteId(): number;
+    get remoteId(): number | null;
     get type(): BaseObjectType;
     get isExists(): boolean;
     get handle(): number;

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

@@ -101,19 +101,33 @@ export class CCMPPed {
         return new Vector3D(x, y, z);
     }
     getVariable(name) {
-        void name;
-        return null;
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return null;
+        }
+        const value = ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Ped, remoteId, name);
+        return value === undefined ? null : value;
     }
     getSyncedMeta(key) {
-        void key;
-        return undefined;
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return undefined;
+        }
+        return ccmp.entities.getStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Ped, remoteId, key);
     }
     hasSyncedMeta(key) {
-        void key;
-        return false;
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return false;
+        }
+        return ccmp.entities.hasStreamSyncedMeta(ccmp.entities.ENTITY_TYPE.Ped, remoteId, key);
     }
     getSyncedMetaKeys() {
-        return [];
+        const remoteId = this.remoteId;
+        if (remoteId === null) {
+            return [];
+        }
+        return ccmp.entities.getStreamSyncedMetaKeys(ccmp.entities.ENTITY_TYPE.Ped, remoteId);
     }
     attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot) {
         this._ccmpPed.attachToEntity(target, boneIndex, offset, rotation, p9, useSoftPinning, collision, isPed, vertexIndex, fixedRot);

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

@@ -1,9 +1,13 @@
+import { type CCMPEventsManager } from "../../../net/ccmp/events/CCMPEventsManager";
 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 _events;
     private readonly _peds;
+    private readonly _pedsByRemoteId;
     private readonly _iterator;
+    constructor(_events: CCMPEventsManager);
     create(options: IPedCreateOptions): CCMPPed;
     syncWithMpPool(): void;
     registerById(id: number): CCMPPed;
@@ -16,5 +20,8 @@ export declare class CCMPPedsManager implements IPedsManager {
     get iterator(): IWorldObjectsIterator<CCMPPed>;
     private _filter;
     private _register;
+    private _unregister;
+    private _findRegistered;
+    private _registerStreamEvents;
     private _pruneDestroyed;
 }

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

@@ -1,7 +1,10 @@
+import { ClientInternalEventName } from "../../../net/common/events/types";
 import { CCMPPed } from "./CCMPPed";
 export class CCMPPedsManager {
-    constructor() {
+    constructor(_events) {
+        this._events = _events;
         this._peds = new Map();
+        this._pedsByRemoteId = new Map();
         this._iterator = {
             all: () => this._filter(() => true),
             dimension: (value) => this._filter((ped) => ped.dimension === value),
@@ -12,6 +15,8 @@ export class CCMPPedsManager {
             }),
             range3D: (center, range) => this._filter((ped) => ped.position.isInRange(center, range)),
         };
+        this._registerStreamEvents();
+        this.syncWithMpPool();
     }
     create(options) {
         const { model, position, rotation, dimension } = options;
@@ -24,9 +29,7 @@ export class CCMPPedsManager {
     syncWithMpPool() {
         this._pruneDestroyed();
         for (const ccmpPed of ccmp.peds.all) {
-            if (!this._peds.has(ccmpPed.id)) {
-                this._register(ccmpPed);
-            }
+            this._register(ccmpPed);
         }
     }
     registerById(id) {
@@ -47,10 +50,16 @@ export class CCMPPedsManager {
         var _a;
         const ped = (_a = this._peds.get(id)) !== null && _a !== void 0 ? _a : null;
         if (ped && !ped.isExists) {
-            this._peds.delete(id);
+            this._unregister(ped);
+        }
+        else if (ped) {
+            return ped;
+        }
+        const ccmpPed = ccmp.peds.getById(id);
+        if (!ccmpPed) {
             return null;
         }
-        return ped;
+        return this._register(ccmpPed);
     }
     getByID(id) {
         const ped = this.findByID(id);
@@ -60,7 +69,19 @@ export class CCMPPedsManager {
         return ped;
     }
     findByRemoteID(remoteId) {
-        return remoteId === 0 ? null : this.findByID(remoteId);
+        var _a;
+        const ped = (_a = this._pedsByRemoteId.get(remoteId)) !== null && _a !== void 0 ? _a : null;
+        if (ped && !ped.isExists) {
+            this._unregister(ped);
+        }
+        else if (ped) {
+            return ped;
+        }
+        const ccmpPed = ccmp.peds.getByRemoteId(remoteId);
+        if (!ccmpPed) {
+            return null;
+        }
+        return this._register(ccmpPed);
     }
     getByRemoteID(remoteId) {
         const ped = this.findByRemoteID(remoteId);
@@ -80,7 +101,7 @@ export class CCMPPedsManager {
     *_filter(predicate) {
         for (const ped of this._peds.values()) {
             if (!ped.isExists) {
-                this._peds.delete(ped.id);
+                this._unregister(ped);
                 continue;
             }
             if (predicate(ped)) {
@@ -89,16 +110,67 @@ export class CCMPPedsManager {
         }
     }
     _register(ccmpPed) {
+        const existingPed = this._findRegistered(ccmpPed);
+        if (existingPed && existingPed.isExists) {
+            return existingPed;
+        }
+        if (existingPed) {
+            this._unregister(existingPed);
+        }
         const ped = new CCMPPed(ccmpPed, (destroyedPed) => {
-            this._peds.delete(destroyedPed.id);
+            this._unregister(destroyedPed);
         });
         this._peds.set(ped.id, ped);
+        if (ped.remoteId !== null) {
+            this._pedsByRemoteId.set(ped.remoteId, ped);
+        }
         return ped;
     }
+    _unregister(ped) {
+        this._peds.delete(ped.id);
+        if (ped.remoteId !== null) {
+            this._pedsByRemoteId.delete(ped.remoteId);
+        }
+    }
+    _findRegistered(ccmpPed) {
+        var _a, _b, _c;
+        return ((_c = (_b = (ccmpPed.remoteId === null ? null : ((_a = this._pedsByRemoteId.get(ccmpPed.remoteId)) !== null && _a !== void 0 ? _a : null))) !== null && _b !== void 0 ? _b : this._peds.get(ccmpPed.id)) !== null && _c !== void 0 ? _c : null);
+    }
+    _registerStreamEvents() {
+        ccmp.on("pedCreated", (ccmpPed) => {
+            if (ccmpPed) {
+                const ped = this._register(ccmpPed);
+                this._events.emitInternal(ClientInternalEventName.EntityCreated, ped);
+            }
+        });
+        ccmp.on("pedDestroyed", (ccmpPed) => {
+            var _a;
+            if (ccmpPed) {
+                const ped = (_a = this._findRegistered(ccmpPed)) !== null && _a !== void 0 ? _a : this._register(ccmpPed);
+                this._events.emitInternal(ClientInternalEventName.EntityDestroyed, ped);
+                this._unregister(ped);
+            }
+        });
+        ccmp.on("pedStreamIn", (ccmpPed) => {
+            if (ccmpPed) {
+                const ped = this._register(ccmpPed);
+                this._events.emitInternal(ClientInternalEventName.EntityStreamIn, ped);
+            }
+        });
+        ccmp.on("pedStreamOut", (ccmpPed) => {
+            var _a;
+            if (ccmpPed) {
+                const ped = (_a = this._findRegistered(ccmpPed)) !== null && _a !== void 0 ? _a : this._register(ccmpPed);
+                if (ped) {
+                    this._events.emitInternal(ClientInternalEventName.EntityStreamOut, ped);
+                }
+            }
+        });
+    }
     _pruneDestroyed() {
         for (const ped of this._peds.values()) {
             if (!ped.isExists) {
-                this._peds.delete(ped.id);
+                this._unregister(ped);
             }
         }
     }

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

@@ -45,7 +45,7 @@ export declare class CCMPPlayer implements IPlayer {
     get model(): number;
     get heading(): number;
     setHeading(heading: number): void;
-    setModel(_value: string): void;
+    setModel(value: string): void;
     get rotation(): IVector3D;
     setRotation(value: IVector3D): void;
     get forwardVector(): IVector3D;
@@ -82,31 +82,29 @@ export declare class CCMPPlayer implements IPlayer {
     getAmmoInClip(_weapon: number): number;
     getWeaponAmmo(_weapon: number): number;
     getBoneIndex(boneId: number): number;
-    setDecoration(_collection: string, _overlay: string): void;
-    removeDecoration(_collection: string, _overlay: string): void;
+    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;
+    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;
+    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;
+    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;
 }