@nativewrappers/fivem 0.0.30 → 0.0.32

package/client/Game.js

@@ -76,7 +76,7 @@ export class Game {
      */
     static get Player() {
         const handle = PlayerId();
-        if (typeof this.cachedPlayer === 'undefined' || handle !== this.cachedPlayer.Handle) {
+        if (this.cachedPlayer === undefined || handle !== this.cachedPlayer.Handle) {
             this.cachedPlayer = new Player(handle);
         }
         return this.cachedPlayer;

package/client/Raycast.d.ts

@@ -4,7 +4,7 @@ import { Vector3 } from './utils';
 /**
  * Class that represents the result of a raycast.
  */
-export declare class RaycastResult {
+declare abstract class RaycastResult {
     /**
      * Return the entity that was hit.
      */
@@ -33,6 +33,17 @@ export declare class RaycastResult {
      * Raycast result's handle.
      */
     get Result(): number;
+    /**
+     * @returns if the shape test handle was already discarded
+     */
+    get WasDiscarded(): boolean;
+    /**
+     * NOTE: These will not be updated unless polled by `resolve` or the shape
+     * test is synchronous
+     * @returns if the raycast has been marked as ready by the engine
+     */
+    get HasResolved(): boolean;
+    protected applyShapeTestResults(): void;
     private handle;
     private hitPositionArg;
     private hitSomethingArg;
@@ -47,3 +58,14 @@ export declare class RaycastResult {
      */
     constructor(handle: number);
 }
+export declare class SynchronousRaycastResult extends RaycastResult {
+    constructor(handle: number);
+}
+export declare class AsynchronousRaycastResult extends RaycastResult {
+    /**
+     * waits until the shape test handle is valid and then sets the expected
+     * values on the RaycastResult
+     */
+    resolve(timeoutInMs?: number): Promise<void>;
+}
+export {};

package/client/Raycast.js

@@ -1,9 +1,10 @@
+import { ShapeTestStatus } from './enums/RaycastEnums';
 import { Game } from './Game';
-import { Vector3 } from './utils';
+import { Delay, Vector3 } from './utils';
 /**
  * Class that represents the result of a raycast.
  */
-export class RaycastResult {
+class RaycastResult {
     /**
      * Return the entity that was hit.
      */
@@ -46,7 +47,33 @@ export class RaycastResult {
     get Result() {
         return this.result;
     }
-    // FIXME: This only works with StartExpensiveSynchronousShapeTestLosProbe, this should have some getter you have to await afterwards for all of the data
+    /**
+     * @returns if the shape test handle was already discarded
+     */
+    get WasDiscarded() {
+        return this.result === ShapeTestStatus.Discarded;
+    }
+    /**
+     * NOTE: These will not be updated unless polled by `resolve` or the shape
+     * test is synchronous
+     * @returns if the raycast has been marked as ready by the engine
+     */
+    get HasResolved() {
+        return this.result === ShapeTestStatus.Ready;
+    }
+    applyShapeTestResults() {
+        const [result, hit, endCoords, surfaceNormal, materialHash, entityHit] = GetShapeTestResultIncludingMaterial(this.handle);
+        this.result = result;
+        if (!this.HasResolved || this.WasDiscarded)
+            return;
+        this.hitSomethingArg = hit;
+        this.hitPositionArg = Vector3.fromArray(endCoords);
+        this.surfaceNormalArg = Vector3.fromArray(surfaceNormal);
+        this.materialArg = materialHash;
+        if (entityHit !== 0) {
+            this.entityHandleArg = Game.entityFromHandle(entityHit);
+        }
+    }
     /**
      * Create a RaycastResult object that gets the results from a StartShapeTestRay()
      *
@@ -59,12 +86,31 @@ export class RaycastResult {
         this.entityHandleArg = null;
         this.surfaceNormalArg = new Vector3(0, 0, 0);
         this.materialArg = 0;
-        const [result, hit, endCoords, surfaceNormal, materialHash, entityHit] = GetShapeTestResultIncludingMaterial(this.handle);
-        this.hitSomethingArg = hit;
-        this.hitPositionArg = Vector3.fromArray(endCoords);
-        this.surfaceNormalArg = Vector3.fromArray(surfaceNormal);
-        this.materialArg = materialHash;
-        this.entityHandleArg = Game.entityFromHandle(entityHit);
-        this.result = result;
+        this.result = ShapeTestStatus.NotReady;
+    }
+}
+export class SynchronousRaycastResult extends RaycastResult {
+    constructor(handle) {
+        super(handle);
+        // if we're using a synchronous call then we want to instantly update our
+        // data, if its invalid then the caller can deal with it.
+        this.applyShapeTestResults();
+    }
+}
+export class AsynchronousRaycastResult extends RaycastResult {
+    /**
+     * waits until the shape test handle is valid and then sets the expected
+     * values on the RaycastResult
+     */
+    async resolve(timeoutInMs = 1000) {
+        const timeout = GetGameTimer() + timeoutInMs;
+        // this has to be polled every frame or the engien will mark the field shape
+        // test handle as discarded
+        while (!this.HasResolved && !this.WasDiscarded) {
+            this.applyShapeTestResults();
+            if (timeout < GetGameTimer())
+                break;
+            await Delay(0);
+        }
     }
 }

package/client/TaskSequence.js

@@ -1,4 +1,5 @@
 import { Ped } from './models/Ped';
+// TODO: Figure out why this uses 'null ped'
 export class TaskSequence {
     constructor(handle) {
         this.handle = 0;

package/client/World.d.ts

@@ -1,11 +1,11 @@
 import { Model, Prop } from './';
 import { Blip } from './Blip';
 import { Camera } from './Camera';
-import { CameraTypes, CloudHat, IntersectOptions, MarkerType, PickupType, RopeType, Weather } from './enums';
+import { CameraTypes, CloudHat, IntersectFlags, MarkerType, PickupType, RopeType, Weather } from './enums';
 import { Ped, Vehicle } from './models';
 import type { BaseEntity } from './models/BaseEntity';
 import { Pickup } from './Pickup';
-import { RaycastResult } from './Raycast';
+import { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 import { Rope } from './Rope';
 import { Color, Vector3 } from './utils';
 /**
@@ -340,24 +340,37 @@ export declare abstract class World {
      */
     static drawPoly(vertexA: Vector3, vertexB: Vector3, vertexC: Vector3, color: Color): void;
     /**
-     * Cast ("shoot") a ray in a certain direction to detect entities in the way.
+     * Cast a ray from {@param start} to {@param end}.
      *
-     * @param source Starting position of raycast.
-     * @param direction Direction to cast a ray to.
-     * @param maxDistance Max distance to cast the ray.
+     * @param start Starting position of raycast.
+     * @param end Direction to cast a ray to.
+     * @param losFlags The entity type(s) that the raycast should intersect with
+     * defaults to {@enum IntersectFlags.All}
      * @param options Possible entity types to detect.
      * @param ignoreEntity An entity to ignore (usually player's Ped).
-     * @returns RaycastResult object.
+     * @returns {@see SynchronousRaycastResult} object.
+     */
+    static expensiveRaycast(start: Vector3, end: Vector3, losFlags?: IntersectFlags, shapeTestOptions?: number, ignoreEntity?: BaseEntity): SynchronousRaycastResult;
+    /**
+     * Cast a ray from {@param start} to {@param end} and returns the first hit
+     * entity or coordinate .
+     *
+     * @param start starting position of raycast.
+     * @param end the ending position to raycast to.
+     * @param losFlags The entity type(s) that the raycast should intersect with defaults to {@enum IntersectFlags.All}
+     * @param shapeTestOptions shape test collision modifiers defaults to ignoring glass, see through, and no collided entities
+     * @param ignoreEntity An entity to ignore (usually player's Ped).
+     * @returns {@see AsynchronousRaycastResult} object that must be awaited to get its results.
      */
-    static raycast(source: Vector3, direction: Vector3, maxDistance: number, options: IntersectOptions, ignoreEntity: BaseEntity): RaycastResult;
+    static raycast(start: Vector3, end: Vector3, losFlags?: IntersectFlags, shapeTestOptions?: number, ignoreEntity?: BaseEntity): AsynchronousRaycastResult;
     /**
      * Cast a ray from the local players camera until it hits an entity
      *
      * @param maxDistance Max distance to cast the ray.
-     * @param options Possible entity types to detect.
-     * @returns RaycastResult object.
+     * @param flags Possible entity types to detect.
+     * @returns SynchronousRaycast object.
      */
-    static raycastPlayerCamera(maxDistance: number, options: IntersectOptions): RaycastResult;
+    static raycastPlayerCamera(maxDistance: number, flags: IntersectFlags): SynchronousRaycastResult;
     /**
      * Gets the closest object of this model
      */

package/client/World.js

@@ -1,14 +1,14 @@
 import { Model, Prop } from './';
 import { Blip } from './Blip';
 import { Camera } from './Camera';
-import { CameraTypes, CloudHat, Weather, } from './enums';
+import { CameraTypes, CloudHat, IntersectFlags, SHAPE_TEST_DEFAULT, Weather, } from './enums';
 import { GameplayCamera } from './GameplayCamera';
 import { VehicleHash } from './hashes';
 import { Ped, Vehicle } from './models';
 import { Pickup } from './Pickup';
-import { RaycastResult } from './Raycast';
+import { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 import { Rope } from './Rope';
-import { Maths, Vector3, Wait } from './utils';
+import { Maths, Wait } from './utils';
 /**
  * Class with common world manipulations.
  *
@@ -570,32 +570,47 @@ export class World {
     static drawPoly(vertexA, vertexB, vertexC, color) {
         DrawPoly(vertexA.x, vertexA.y, vertexA.z, vertexB.x, vertexB.y, vertexB.z, vertexC.x, vertexC.y, vertexC.z, color.r, color.g, color.b, color.a);
     }
+    // TODO: Add a raycast option for every type.
     /**
-     * Cast ("shoot") a ray in a certain direction to detect entities in the way.
+     * Cast a ray from {@param start} to {@param end}.
      *
-     * @param source Starting position of raycast.
-     * @param direction Direction to cast a ray to.
-     * @param maxDistance Max distance to cast the ray.
+     * @param start Starting position of raycast.
+     * @param end Direction to cast a ray to.
+     * @param losFlags The entity type(s) that the raycast should intersect with
+     * defaults to {@enum IntersectFlags.All}
      * @param options Possible entity types to detect.
      * @param ignoreEntity An entity to ignore (usually player's Ped).
-     * @returns RaycastResult object.
+     * @returns {@see SynchronousRaycastResult} object.
      */
-    static raycast(source, direction, maxDistance, options, ignoreEntity) {
-        const target = Vector3.add(source, Vector3.multiply(direction, maxDistance));
-        return new RaycastResult(StartExpensiveSynchronousShapeTestLosProbe(source.x, source.y, source.z, target.x, target.y, target.z, Number(options), ignoreEntity.Handle, 7));
+    static expensiveRaycast(start, end, losFlags = IntersectFlags.All, shapeTestOptions = SHAPE_TEST_DEFAULT, ignoreEntity) {
+        return new SynchronousRaycastResult(StartExpensiveSynchronousShapeTestLosProbe(start.x, start.y, start.z, end.x, end.y, end.z, losFlags, ignoreEntity?.Handle ?? 0, shapeTestOptions));
+    }
+    /**
+     * Cast a ray from {@param start} to {@param end} and returns the first hit
+     * entity or coordinate .
+     *
+     * @param start starting position of raycast.
+     * @param end the ending position to raycast to.
+     * @param losFlags The entity type(s) that the raycast should intersect with defaults to {@enum IntersectFlags.All}
+     * @param shapeTestOptions shape test collision modifiers defaults to ignoring glass, see through, and no collided entities
+     * @param ignoreEntity An entity to ignore (usually player's Ped).
+     * @returns {@see AsynchronousRaycastResult} object that must be awaited to get its results.
+     */
+    static raycast(start, end, losFlags = IntersectFlags.All, shapeTestOptions = SHAPE_TEST_DEFAULT, ignoreEntity) {
+        return new AsynchronousRaycastResult(StartShapeTestLosProbe(start.x, start.y, start.z, end.x, end.y, end.z, losFlags, ignoreEntity?.Handle ?? 0, shapeTestOptions));
     }
     /**
      * Cast a ray from the local players camera until it hits an entity
      *
      * @param maxDistance Max distance to cast the ray.
-     * @param options Possible entity types to detect.
-     * @returns RaycastResult object.
+     * @param flags Possible entity types to detect.
+     * @returns SynchronousRaycast object.
      */
-    static raycastPlayerCamera(maxDistance, options) {
+    static raycastPlayerCamera(maxDistance, flags) {
         const camera = GameplayCamera.Position;
         const direction = GameplayCamera.ForwardVector;
         const destination = direction.multiply(maxDistance).add(camera);
-        return new RaycastResult(StartExpensiveSynchronousShapeTestLosProbe(camera.x, camera.y, camera.z, destination.x, destination.y, destination.z, Number(options), PlayerPedId(), 7));
+        return new SynchronousRaycastResult(StartExpensiveSynchronousShapeTestLosProbe(camera.x, camera.y, camera.z, destination.x, destination.y, destination.z, flags, PlayerPedId(), 7));
     }
     /**
      * Gets the closest object of this model

package/client/enums/RaycastEnums.d.ts

@@ -0,0 +1,27 @@
+/**
+ * List of possible entity intersections. Used for raycasting.
+ */
+export declare enum IntersectFlags {
+    None = 0,
+    World = 1,
+    Vehicles = 2,
+    Ped = 4,
+    Ragdoll = 8,
+    Object = 16,
+    Pickup = 32,
+    River = 128,
+    Foliage = 256,
+    All = 511
+}
+export declare enum ShapeTestOptions {
+    None = 0,
+    IgnoreGlass = 1,
+    IgnoreSeeThrough = 2,
+    IgnoreNoCollision = 4
+}
+export declare enum ShapeTestStatus {
+    Discarded = 0,
+    NotReady = 1,
+    Ready = 2
+}
+export declare const SHAPE_TEST_DEFAULT: number;

package/client/enums/RaycastEnums.js

@@ -0,0 +1,30 @@
+/**
+ * List of possible entity intersections. Used for raycasting.
+ */
+export var IntersectFlags;
+(function (IntersectFlags) {
+    IntersectFlags[IntersectFlags["None"] = 0] = "None";
+    IntersectFlags[IntersectFlags["World"] = 1] = "World";
+    IntersectFlags[IntersectFlags["Vehicles"] = 2] = "Vehicles";
+    IntersectFlags[IntersectFlags["Ped"] = 4] = "Ped";
+    IntersectFlags[IntersectFlags["Ragdoll"] = 8] = "Ragdoll";
+    IntersectFlags[IntersectFlags["Object"] = 16] = "Object";
+    IntersectFlags[IntersectFlags["Pickup"] = 32] = "Pickup";
+    IntersectFlags[IntersectFlags["River"] = 128] = "River";
+    IntersectFlags[IntersectFlags["Foliage"] = 256] = "Foliage";
+    IntersectFlags[IntersectFlags["All"] = 511] = "All";
+})(IntersectFlags || (IntersectFlags = {}));
+export var ShapeTestOptions;
+(function (ShapeTestOptions) {
+    ShapeTestOptions[ShapeTestOptions["None"] = 0] = "None";
+    ShapeTestOptions[ShapeTestOptions["IgnoreGlass"] = 1] = "IgnoreGlass";
+    ShapeTestOptions[ShapeTestOptions["IgnoreSeeThrough"] = 2] = "IgnoreSeeThrough";
+    ShapeTestOptions[ShapeTestOptions["IgnoreNoCollision"] = 4] = "IgnoreNoCollision";
+})(ShapeTestOptions || (ShapeTestOptions = {}));
+export var ShapeTestStatus;
+(function (ShapeTestStatus) {
+    ShapeTestStatus[ShapeTestStatus["Discarded"] = 0] = "Discarded";
+    ShapeTestStatus[ShapeTestStatus["NotReady"] = 1] = "NotReady";
+    ShapeTestStatus[ShapeTestStatus["Ready"] = 2] = "Ready";
+})(ShapeTestStatus || (ShapeTestStatus = {}));
+export const SHAPE_TEST_DEFAULT = ShapeTestOptions.IgnoreGlass | ShapeTestOptions.IgnoreSeeThrough | ShapeTestOptions.IgnoreNoCollision;

package/client/enums/index.d.ts

@@ -20,7 +20,7 @@ export { HelmetType } from './HelmetType';
 export { HudColor } from './HudColor';
 export { HudComponent } from './HudComponent';
 export { InputMode } from './InputMode';
-export { IntersectOptions } from './IntersectOptions';
+export { IntersectFlags, ShapeTestOptions, SHAPE_TEST_DEFAULT } from './RaycastEnums';
 export { InvertAxis, InvertAxisFlags } from './InvertAxis';
 export { Language } from './Language';
 export { LeaveVehicleFlags } from './LeaveVehicleFlags';

package/client/enums/index.js

@@ -20,7 +20,7 @@ export { HelmetType } from './HelmetType';
 export { HudColor } from './HudColor';
 export { HudComponent } from './HudComponent';
 export { InputMode } from './InputMode';
-export { IntersectOptions } from './IntersectOptions';
+export { IntersectFlags, ShapeTestOptions, SHAPE_TEST_DEFAULT } from './RaycastEnums';
 export { InvertAxisFlags } from './InvertAxis';
 export { Language } from './Language';
 export { LeaveVehicleFlags } from './LeaveVehicleFlags';

package/client/index.d.ts

@@ -10,7 +10,7 @@ export { GameplayCamera } from './GameplayCamera';
 export { ParticleEffect } from './ParticleEffect';
 export { ParticleEffectAsset } from './ParticleEffectAsset';
 export { Pickup } from './Pickup';
-export { RaycastResult } from './Raycast';
+export { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 export { RelationshipGroup } from './RelationshipGroup';
 export { Tasks } from './Tasks';
 export { TaskSequence } from './TaskSequence';

package/client/index.js

@@ -10,7 +10,7 @@ export { GameplayCamera } from './GameplayCamera';
 export { ParticleEffect } from './ParticleEffect';
 export { ParticleEffectAsset } from './ParticleEffectAsset';
 export { Pickup } from './Pickup';
-export { RaycastResult } from './Raycast';
+export { AsynchronousRaycastResult, SynchronousRaycastResult } from './Raycast';
 export { RelationshipGroup } from './RelationshipGroup';
 export { Tasks } from './Tasks';
 export { TaskSequence } from './TaskSequence';

package/client/models/BaseEntity.d.ts

@@ -132,19 +132,11 @@ export declare class BaseEntity {
     isNearEntity(entity: BaseEntity, bounds: Vector3): boolean;
     isTouching(entity: BaseEntity): boolean;
     isTouchingModel(model: Model): boolean;
-    /**
-      * @deprecated use [[getAbsolutePositionOffset]]
-      */
-    getOffsetPosition(offset: Vector3): Vector3;
     /**
      * @param offset: the amount to offset from the entity
      * @returns the offset position from the entity in world coords
      */
-    getAbsolutePositionOffset(offset: Vector3): Vector3;
-    /**
-     * @deprecated use [[getRelativePositionOffset]] instead
-     */
-    getPositionOffset(worldCoords: Vector3): Vector3;
+    getAbsolutePositionOffset(worldCoords: Vector3): Vector3;
     /**
       * @example
       * ```typescript
@@ -161,7 +153,15 @@ export declare class BaseEntity {
       * @param worldCoords: the offset given the world coords
       * @returns the offset position from the entity in relative coords
       */
-    getRelativePositionOffset(worldCoords: Vector3): Vector3;
+    getRelativePositionOffset(offset: Vector3): Vector3;
+    /**
+     * @deprecated use [[getAbsolutePositionOffset]] instead
+     */
+    getPositionOffset(worldCoords: Vector3): Vector3;
+    /**
+      * @deprecated use [[getRelativePositionOffset]]
+      */
+    getOffsetPosition(offset: Vector3): Vector3;
     attachTo(entity: BaseEntity, position: Vector3, rotation: Vector3, collisions?: boolean, unk9?: boolean, useSoftPinning?: boolean, rotationOrder?: number): void;
     attachToBone(entityBone: EntityBone, position: Vector3, rotation: Vector3, collisions?: boolean, unk9?: boolean, useSoftPinning?: boolean, rotationOrder?: number): void;
     detach(): void;

package/client/models/BaseEntity.js

@@ -362,24 +362,12 @@ export class BaseEntity {
     isTouchingModel(model) {
         return IsEntityTouchingModel(this.handle, model.Hash);
     }
-    /**
-      * @deprecated use [[getAbsolutePositionOffset]]
-      */
-    getOffsetPosition(offset) {
-        return Vector3.fromArray(GetOffsetFromEntityInWorldCoords(this.handle, offset.x, offset.y, offset.z));
-    }
     /**
      * @param offset: the amount to offset from the entity
      * @returns the offset position from the entity in world coords
      */
-    getAbsolutePositionOffset(offset) {
-        return Vector3.fromArray(GetOffsetFromEntityInWorldCoords(this.handle, offset.x, offset.y, offset.z));
-    }
-    /**
-     * @deprecated use [[getRelativePositionOffset]] instead
-     */
-    getPositionOffset(worldCoords) {
-        return this.getRelativePositionOffset(worldCoords);
+    getAbsolutePositionOffset(worldCoords) {
+        return Vector3.fromArray(GetOffsetFromEntityGivenWorldCoords(this.handle, worldCoords.x, worldCoords.y, worldCoords.z));
     }
     // TODO: Better example
     /**
@@ -398,8 +386,20 @@ export class BaseEntity {
       * @param worldCoords: the offset given the world coords
       * @returns the offset position from the entity in relative coords
       */
-    getRelativePositionOffset(worldCoords) {
-        return Vector3.fromArray(GetOffsetFromEntityGivenWorldCoords(this.handle, worldCoords.x, worldCoords.y, worldCoords.z));
+    getRelativePositionOffset(offset) {
+        return Vector3.fromArray(GetOffsetFromEntityInWorldCoords(this.handle, offset.x, offset.y, offset.z));
+    }
+    /**
+     * @deprecated use [[getAbsolutePositionOffset]] instead
+     */
+    getPositionOffset(worldCoords) {
+        return this.getAbsolutePositionOffset(worldCoords);
+    }
+    /**
+      * @deprecated use [[getRelativePositionOffset]]
+      */
+    getOffsetPosition(offset) {
+        return this.getRelativePositionOffset(offset);
     }
     attachTo(entity, position, rotation, collisions = false, unk9 = true, useSoftPinning = true, rotationOrder = 1) {
         if (this.handle == entity.Handle) {

package/client/models/EntityBoneCollection.d.ts

@@ -2,8 +2,6 @@ import { EntityBone } from './';
 import type { BaseEntity } from './BaseEntity';
 export declare class EntityBoneCollection {
     protected readonly owner: BaseEntity;
-    private readonly _collection;
-    private _currentIndex;
     constructor(owner: BaseEntity);
     hasBone(name: string): boolean;
     getBone(boneIndex?: number, boneName?: string): EntityBone;

package/client/models/EntityBoneCollection.js

@@ -1,7 +1,6 @@
 import { EntityBone } from './';
 export class EntityBoneCollection {
     constructor(owner) {
-        this._currentIndex = -1;
         this.owner = owner;
     }
     hasBone(name) {

package/client/models/Ped.d.ts

@@ -9,11 +9,11 @@ import { BaseEntity } from './BaseEntity';
 export declare class Ped extends BaseEntity {
     static exists(ped: Ped): boolean;
     static fromHandle(handle: number): Ped | null;
-    static fromNetworkId(networkId: number, errorOnInvalid?: boolean): Ped | null;
+    static fromNetworkId(networkId: number): Ped | null;
     protected type: ClassTypes;
-    private pedBones;
-    private weapons;
-    private readonly speechModifierNames;
+    private pedBones?;
+    private weapons?;
+    private static readonly speechModifierNames;
     private tasks;
     constructor(handle: number);
     get Player(): Player;
@@ -107,7 +107,7 @@ export declare class Ped extends BaseEntity {
     set DrivingStyle(style: DrivingStyle);
     set IsDrunk(isDrunk: boolean);
     set MotionBlur(value: boolean);
-    get Task(): Tasks | undefined;
+    get Task(): Tasks;
     get DeathCause(): number;
     get TaskSequenceProgress(): number;
     set BlockPermanentEvents(block: boolean);
@@ -157,7 +157,7 @@ export declare class Ped extends BaseEntity {
     setConfigFlag(flagId: number, value: boolean): void;
     resetConfigFlag(flagId: number): void;
     clone(): Ped;
-    exists(ped?: Ped): boolean;
+    exists(): boolean;
     isFacingPed(ped: Ped, angle?: number): boolean;
     setComponentVariation(componentId: number, drawableId: number, textureId: number, paletteId?: number): void;
     setRandomComponentVariation(): void;

package/client/models/Ped.js

@@ -12,54 +12,15 @@ export class Ped extends BaseEntity {
     static fromHandle(handle) {
         return new Ped(handle);
     }
-    static fromNetworkId(networkId, errorOnInvalid = false) {
-        if (errorOnInvalid && NetworkDoesEntityExistWithNetworkId(networkId)) {
-            throw new Error(`Entity with ${networkId} doesn't exist`);
+    static fromNetworkId(networkId) {
+        if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+            return null;
         }
         return new Ped(NetworkGetEntityFromNetworkId(networkId));
     }
     constructor(handle) {
         super(handle);
         this.type = ClassTypes.Ped;
-        this.speechModifierNames = [
-            'SPEECH_PARAMS_STANDARD',
-            'SPEECH_PARAMS_ALLOW_REPEAT',
-            'SPEECH_PARAMS_BEAT',
-            'SPEECH_PARAMS_FORCE',
-            'SPEECH_PARAMS_FORCE_FRONTEND',
-            'SPEECH_PARAMS_FORCE_NO_REPEAT_FRONTEND',
-            'SPEECH_PARAMS_FORCE_NORMAL',
-            'SPEECH_PARAMS_FORCE_NORMAL_CLEAR',
-            'SPEECH_PARAMS_FORCE_NORMAL_CRITICAL',
-            'SPEECH_PARAMS_FORCE_SHOUTED',
-            'SPEECH_PARAMS_FORCE_SHOUTED_CLEAR',
-            'SPEECH_PARAMS_FORCE_SHOUTED_CRITICAL',
-            'SPEECH_PARAMS_FORCE_PRELOAD_ONLY',
-            'SPEECH_PARAMS_MEGAPHONE',
-            'SPEECH_PARAMS_HELI',
-            'SPEECH_PARAMS_FORCE_MEGAPHONE',
-            'SPEECH_PARAMS_FORCE_HELI',
-            'SPEECH_PARAMS_INTERRUPT',
-            'SPEECH_PARAMS_INTERRUPT_SHOUTED',
-            'SPEECH_PARAMS_INTERRUPT_SHOUTED_CLEAR',
-            'SPEECH_PARAMS_INTERRUPT_SHOUTED_CRITICAL',
-            'SPEECH_PARAMS_INTERRUPT_NO_FORCE',
-            'SPEECH_PARAMS_INTERRUPT_FRONTEND',
-            'SPEECH_PARAMS_INTERRUPT_NO_FORCE_FRONTEND',
-            'SPEECH_PARAMS_ADD_BLIP',
-            'SPEECH_PARAMS_ADD_BLIP_ALLOW_REPEAT',
-            'SPEECH_PARAMS_ADD_BLIP_FORCE',
-            'SPEECH_PARAMS_ADD_BLIP_SHOUTED',
-            'SPEECH_PARAMS_ADD_BLIP_SHOUTED_FORCE',
-            'SPEECH_PARAMS_ADD_BLIP_INTERRUPT',
-            'SPEECH_PARAMS_ADD_BLIP_INTERRUPT_FORCE',
-            'SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED',
-            'SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED_CLEAR',
-            'SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED_CRITICAL',
-            'SPEECH_PARAMS_SHOUTED',
-            'SPEECH_PARAMS_SHOUTED_CLEAR',
-            'SPEECH_PARAMS_SHOUTED_CRITICAL',
-        ];
     }
     get Player() {
         return new Player(NetworkGetPlayerIndexFromPed(this.handle));
@@ -441,12 +402,12 @@ export class Ped extends BaseEntity {
         RemovePedFromGroup(this.handle);
     }
     playAmbientSpeed(speechName, voiceName = '', modifier = SpeechModifier.Standard) {
-        if (Number(modifier) >= 0 && Number(modifier) < this.speechModifierNames.length) {
+        if (Number(modifier) >= 0 && Number(modifier) < Ped.speechModifierNames.length) {
             if (voiceName === '') {
-                PlayAmbientSpeech1(this.handle, speechName, this.speechModifierNames[Number(modifier)]);
+                PlayAmbientSpeech1(this.handle, speechName, Ped.speechModifierNames[Number(modifier)]);
             }
             else {
-                PlayAmbientSpeechWithVoice(this.handle, speechName, voiceName, this.speechModifierNames[Number(modifier)], false);
+                PlayAmbientSpeechWithVoice(this.handle, speechName, voiceName, Ped.speechModifierNames[Number(modifier)], false);
             }
         }
         else {
@@ -533,11 +494,8 @@ export class Ped extends BaseEntity {
     clone() {
         return new Ped(ClonePed(this.handle, false, false, false));
     }
-    exists(ped) {
-        if (!ped) {
-            return super.exists() && GetEntityType(this.handle) === 1;
-        }
-        return ped?.exists() ?? false;
+    exists() {
+        return super.exists() && GetEntityType(this.handle) === 1;
     }
     isFacingPed(ped, angle = 25.0) {
         return IsPedFacingPed(this.handle, ped.Handle, angle);
@@ -683,3 +641,42 @@ export class Ped extends BaseEntity {
         return HasPedHeadBlendFinished(this.handle);
     }
 }
+Ped.speechModifierNames = [
+    'SPEECH_PARAMS_STANDARD',
+    'SPEECH_PARAMS_ALLOW_REPEAT',
+    'SPEECH_PARAMS_BEAT',
+    'SPEECH_PARAMS_FORCE',
+    'SPEECH_PARAMS_FORCE_FRONTEND',
+    'SPEECH_PARAMS_FORCE_NO_REPEAT_FRONTEND',
+    'SPEECH_PARAMS_FORCE_NORMAL',
+    'SPEECH_PARAMS_FORCE_NORMAL_CLEAR',
+    'SPEECH_PARAMS_FORCE_NORMAL_CRITICAL',
+    'SPEECH_PARAMS_FORCE_SHOUTED',
+    'SPEECH_PARAMS_FORCE_SHOUTED_CLEAR',
+    'SPEECH_PARAMS_FORCE_SHOUTED_CRITICAL',
+    'SPEECH_PARAMS_FORCE_PRELOAD_ONLY',
+    'SPEECH_PARAMS_MEGAPHONE',
+    'SPEECH_PARAMS_HELI',
+    'SPEECH_PARAMS_FORCE_MEGAPHONE',
+    'SPEECH_PARAMS_FORCE_HELI',
+    'SPEECH_PARAMS_INTERRUPT',
+    'SPEECH_PARAMS_INTERRUPT_SHOUTED',
+    'SPEECH_PARAMS_INTERRUPT_SHOUTED_CLEAR',
+    'SPEECH_PARAMS_INTERRUPT_SHOUTED_CRITICAL',
+    'SPEECH_PARAMS_INTERRUPT_NO_FORCE',
+    'SPEECH_PARAMS_INTERRUPT_FRONTEND',
+    'SPEECH_PARAMS_INTERRUPT_NO_FORCE_FRONTEND',
+    'SPEECH_PARAMS_ADD_BLIP',
+    'SPEECH_PARAMS_ADD_BLIP_ALLOW_REPEAT',
+    'SPEECH_PARAMS_ADD_BLIP_FORCE',
+    'SPEECH_PARAMS_ADD_BLIP_SHOUTED',
+    'SPEECH_PARAMS_ADD_BLIP_SHOUTED_FORCE',
+    'SPEECH_PARAMS_ADD_BLIP_INTERRUPT',
+    'SPEECH_PARAMS_ADD_BLIP_INTERRUPT_FORCE',
+    'SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED',
+    'SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED_CLEAR',
+    'SPEECH_PARAMS_FORCE_PRELOAD_ONLY_SHOUTED_CRITICAL',
+    'SPEECH_PARAMS_SHOUTED',
+    'SPEECH_PARAMS_SHOUTED_CLEAR',
+    'SPEECH_PARAMS_SHOUTED_CRITICAL',
+];

package/client/models/Player.d.ts

@@ -3,7 +3,7 @@ import { StateBagChangeHandler } from '../cfx';
 import { BaseEntity, Ped } from './';
 export declare class Player {
     private handle;
-    private ped;
+    private ped?;
     private pvp;
     private stateBagCookies;
     private source;

package/client/models/Prop.d.ts

@@ -3,7 +3,7 @@ import { BaseEntity } from './BaseEntity';
 export declare class Prop extends BaseEntity {
     static exists(prop: Prop): boolean;
     static fromHandle(handle: number): Prop | null;
-    static fromNetworkId(networkId: number, errorOnInvalid?: boolean): Prop | null;
+    static fromNetworkId(networkId: number): Prop | null;
     protected type: ClassTypes;
     constructor(handle: number);
     exists(): boolean;

package/client/models/Prop.js

@@ -7,9 +7,9 @@ export class Prop extends BaseEntity {
     static fromHandle(handle) {
         return new Prop(handle);
     }
-    static fromNetworkId(networkId, errorOnInvalid = false) {
-        if (errorOnInvalid && NetworkDoesEntityExistWithNetworkId(networkId)) {
-            throw new Error(`Entity with ${networkId} doesn't exist`);
+    static fromNetworkId(networkId) {
+        if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+            return null;
         }
         return new Prop(NetworkGetEntityFromNetworkId(networkId));
     }

package/client/models/Vehicle.d.ts

@@ -11,10 +11,10 @@ export declare class Vehicle extends BaseEntity {
     static exists(vehicle: Vehicle): boolean;
     static fromHandle(handle: number): Vehicle | null;
     static fromNetworkId(networkId: number): Vehicle | null;
-    private _doors;
-    private _mods;
-    private _wheels;
-    private _windows;
+    private _doors?;
+    private _mods?;
+    private _wheels?;
+    private _windows?;
     protected type: ClassTypes;
     constructor(handle: number);
     exists(): boolean;

package/client/models/VehicleModCollection.d.ts

@@ -16,7 +16,7 @@ export declare class VehicleModCollection {
     set WheelType(type: VehicleWheelType);
     installModKit(): void;
     get Livery(): number | undefined;
-    set Livery(value: number | undefined);
+    set Livery(value: number);
     get LiveryCount(): number;
     get WindowTint(): VehicleWindowTint;
     set WindowTint(tint: VehicleWindowTint);

package/client/models/VehicleModCollection.js

@@ -44,6 +44,7 @@ export class VehicleModCollection {
     installModKit() {
         SetVehicleModKit(this._owner.Handle, 0);
     }
+    // TODO: This should return always return a  number
     get Livery() {
         const modCount = this.getMod(VehicleModType.Livery)?.ModCount;
         if (modCount !== undefined && modCount > 0) {
@@ -52,8 +53,6 @@ export class VehicleModCollection {
         return GetVehicleLivery(this._owner.Handle);
     }
     set Livery(value) {
-        if (value === undefined)
-            return;
         const mod = this.getMod(VehicleModType.Livery);
         if (mod !== undefined && mod.ModCount > 0) {
             mod.Index = value;

package/client/models/VehicleWindowCollection.d.ts

@@ -5,8 +5,8 @@ export declare class VehicleWindowCollection {
     private _owner;
     private readonly _vehicleWindows;
     constructor(owner: Vehicle);
-    getWindow(index: VehicleWindowIndex): VehicleWindow | undefined;
-    getAllWindows(): (VehicleWindow | null | undefined)[];
+    getWindow(index: VehicleWindowIndex): VehicleWindow;
+    getAllWindows(): (VehicleWindow | null)[];
     get AreAllWindowsIntact(): boolean;
     rollDownAllWindows(): void;
     rollUpAllWindows(): void;

package/client/models/VehicleWindowCollection.js

@@ -6,10 +6,13 @@ export class VehicleWindowCollection {
         this._owner = owner;
     }
     getWindow(index) {
-        if (!this._vehicleWindows.has(index)) {
-            this._vehicleWindows.set(index, new VehicleWindow(this._owner, index));
+        let window = this._vehicleWindows.get(index);
+        if (!window) {
+            const vehicleWindow = new VehicleWindow(this._owner, index);
+            this._vehicleWindows.set(index, vehicleWindow);
+            return vehicleWindow;
         }
-        return this._vehicleWindows.get(index);
+        return window;
     }
     getAllWindows() {
         return Object.keys(VehicleWindowIndex)
@@ -37,8 +40,6 @@ export class VehicleWindowCollection {
         });
     }
     hasWindow(window) {
-        if (this._owner.Bones === undefined)
-            return false;
         switch (window) {
             case VehicleWindowIndex.FrontLeftWindow:
                 return this._owner.Bones.hasBone('window_lf');

package/client/ui/menu/Menu.d.ts

@@ -9,8 +9,8 @@ export declare class Menu {
     static screenResolution: Size;
     readonly id: string;
     visible: boolean;
-    parentMenu: Menu | undefined;
-    parentItem: UIMenuItem | undefined;
+    parentMenu?: Menu;
+    parentItem?: UIMenuItem;
     items: UIMenuItem[];
     children: Map<string, Menu>;
     readonly menuOpen: LiteEvent;

package/client/ui/menu/items/UIMenuItem.d.ts

@@ -18,7 +18,7 @@ export declare class UIMenuItem {
     selected: boolean;
     hovered: boolean;
     offset: Point;
-    parent: Menu | undefined;
+    parent?: Menu;
     readonly activated: LiteEvent;
     readonly panelActivated: LiteEvent;
     protected supportsDescription: boolean;

package/client/ui/menu/items/panels/AbstractUIMenuPanel.d.ts

@@ -3,9 +3,9 @@ import { Rectangle, Sprite } from '../../../';
 import { Menu } from '../../';
 export declare abstract class AbstractUIMenuPanel {
     readonly id: string;
-    protected parentItem: UIMenuItem | undefined;
+    protected parentItem?: UIMenuItem;
     protected enabled: boolean;
-    protected readonly background: Sprite | Rectangle | undefined;
+    protected readonly background?: Sprite | Rectangle;
     get ParentMenu(): Menu | undefined;
     get ParentItem(): UIMenuItem | undefined;
     set ParentItem(value: UIMenuItem | undefined);

package/client/ui/menu/items/panels/AbstractUIMenuPanel.js

@@ -10,7 +10,7 @@ export class AbstractUIMenuPanel {
         return this.parentItem ? this.parentItem.parent : undefined;
     }
     get ParentItem() {
-        return this.parentItem ?? undefined;
+        return this.parentItem;
     }
     set ParentItem(value) {
         this.parentItem = value;

package/client/ui/menu/items/panels/UIMenuGridPanel.d.ts

@@ -7,10 +7,10 @@ export declare class UIMenuGridPanel extends AbstractUIMenuPanel {
     private _pressed;
     private _lockXAxis;
     private _lockYAxis;
-    private _topText;
-    private _leftText;
-    private _rightText;
-    private _bottomText;
+    private _topText?;
+    private _leftText?;
+    private _rightText?;
+    private _bottomText?;
     private _lastCirclePosition;
     private readonly _grid;
     private readonly _circle;

package/common/utils/Vector.d.ts

@@ -55,9 +55,6 @@ export declare class Vector {
     y: number;
     z?: number | undefined;
     w?: number | undefined;
-    /**
-     * The type identifier for vectors.
-     */
     type: ClassTypes;
     protected static create(x: number, y?: number): Vector2;
     protected static create(x: number, y?: number, z?: number): Vector3;
@@ -144,6 +141,35 @@ export declare class Vector {
      * @returns A new vector with divided components.
      */
     static divide<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Performs an operation between a vector and either another vector or scalar value converting the vector into absolute values.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
+    private static operateAbsolute;
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
+    static subtractAbsolute<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
+    static multiplyAbsolute<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
+    static divideAbsolute<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
     /**
      * Calculates the dot product of two vectors.
      * @param a - The first vector.
@@ -246,6 +272,18 @@ export declare class Vector {
      * @see Vector.divide
      */
     divide(v: VectorLike | number): this;
+    /**
+     * @see Vector.subtractAbsolute
+     */
+    subtractAbsolute(v: VectorLike): this;
+    /**
+     * @see Vector.multiply
+     */
+    multiplyAbsolute(v: VectorLike | number): this;
+    /**
+     * @see Vector.divide
+     */
+    divideAbsolute(v: VectorLike | number): this;
     /**
      * Converts the vector to an array of its components.
      */
@@ -296,6 +334,10 @@ export declare class Vector3 extends Vector implements Vec3 {
      * @see Vector.crossProduct
      */
     crossProduct(v: Vec3 | Vec4): Vec3 | Vec4;
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2(): Vector2;
 }
 /**
  * Represents a 4-dimensional vector.
@@ -325,5 +367,13 @@ export declare class Vector4 extends Vector {
      * @see Vector.crossProduct
      */
     crossProduct(v: Vec3 | Vec4): Vec3 | Vec4;
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2(): Vector2;
+    /**
+      * @returns the x and y values as Vec3
+      */
+    toVec3(): Vector3;
 }
 export {};

package/common/utils/Vector.js

@@ -145,6 +145,51 @@ export class Vector {
     static divide(a, b) {
         return this.operate(a, b, (x, y) => x / y);
     }
+    /**
+     * Performs an operation between a vector and either another vector or scalar value converting the vector into absolute values.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
+    static operateAbsolute(a, b, operator) {
+        let { x, y, z, w } = a;
+        const isNumber = typeof b === 'number';
+        x = operator(Math.abs(x), isNumber ? b : Math.abs(b.x ?? 0));
+        y = operator(Math.abs(y), isNumber ? b : Math.abs(b.y ?? 0));
+        if (z)
+            z = operator(Math.abs(z), isNumber ? b : Math.abs(b.z ?? 0));
+        if (w)
+            w = operator(Math.abs(w), isNumber ? b : Math.abs(b.w ?? 0));
+        return this.create(x, y, z, w);
+    }
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
+    static subtractAbsolute(a, b) {
+        return this.operateAbsolute(a, b, (x, y) => x - y);
+    }
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
+    static multiplyAbsolute(a, b) {
+        return this.operateAbsolute(a, b, (x, y) => x * y);
+    }
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
+    static divideAbsolute(a, b) {
+        return this.operateAbsolute(a, b, (x, y) => x / y);
+    }
     /**
      * Calculates the dot product of two vectors.
      * @param a - The first vector.
@@ -244,9 +289,8 @@ export class Vector {
         this.y = y;
         this.z = z;
         this.w = w;
-        /**
-         * The type identifier for vectors.
-         */
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST
         this.type = ClassTypes.Vector2;
     }
     *[Symbol.iterator]() {
@@ -333,6 +377,24 @@ export class Vector {
     divide(v) {
         return Vector.divide(this, v);
     }
+    /**
+     * @see Vector.subtractAbsolute
+     */
+    subtractAbsolute(v) {
+        return Vector.subtractAbsolute(this, v);
+    }
+    /**
+     * @see Vector.multiply
+     */
+    multiplyAbsolute(v) {
+        return Vector.multiplyAbsolute(this, v);
+    }
+    /**
+     * @see Vector.divide
+     */
+    divideAbsolute(v) {
+        return Vector.divideAbsolute(this, v);
+    }
     /**
      * Converts the vector to an array of its components.
      */
@@ -371,6 +433,8 @@ export class Vector2 extends Vector {
      */
     constructor(x, y = x) {
         super(2, x, y);
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST, CHANGING IT WILL BREAK STUFF
         this.type = ClassTypes.Vector2;
     }
 }
@@ -387,6 +451,8 @@ export class Vector3 extends Vector {
      */
     constructor(x, y = x, z = y) {
         super(3, x, y, z);
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST, CHANGING IT WILL BREAK STUFF
         this.type = ClassTypes.Vector3;
         this.z = z;
     }
@@ -402,6 +468,12 @@ export class Vector3 extends Vector {
     crossProduct(v) {
         return Vector.crossProduct(this, v);
     }
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2() {
+        return new Vector2(this.x, this.y);
+    }
 }
 Vector3.Zero = new Vector3(0, 0, 0);
 /**
@@ -417,6 +489,8 @@ export class Vector4 extends Vector {
      */
     constructor(x, y = x, z = y, w = z) {
         super(4, x, y, z, w);
+        // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+        // TO EXIST, CHANGING IT WILL BREAK STUFF
         this.type = ClassTypes.Vector4;
         this.z = z;
         this.w = w;
@@ -439,5 +513,17 @@ export class Vector4 extends Vector {
     crossProduct(v) {
         return Vector.crossProduct(this, v);
     }
+    /**
+      * @returns the x and y values as Vec2
+      */
+    toVec2() {
+        return new Vector2(this.x, this.y);
+    }
+    /**
+      * @returns the x and y values as Vec3
+      */
+    toVec3() {
+        return new Vector3(this.x, this.y, this.z);
+    }
 }
 Vector4.Zero = new Vector4(0, 0, 0, 0);

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "publishConfig": {
     "directory": "lib"
   },

package/client/enums/IntersectOptions.d.ts

@@ -1,15 +0,0 @@
-/**
- * List of possible entity intersections. Used for raycasting.
- */
-export declare enum IntersectOptions {
-    Everything = -1,
-    None = 0,
-    World = 1,
-    Vehicles = 2,
-    PedsSimpleCollision = 4,
-    Peds = 8,
-    Objects = 16,
-    Water = 32,
-    Unk3 = 128,
-    Foliage = 256
-}

package/client/enums/IntersectOptions.js

@@ -1,16 +0,0 @@
-/**
- * List of possible entity intersections. Used for raycasting.
- */
-export var IntersectOptions;
-(function (IntersectOptions) {
-    IntersectOptions[IntersectOptions["Everything"] = -1] = "Everything";
-    IntersectOptions[IntersectOptions["None"] = 0] = "None";
-    IntersectOptions[IntersectOptions["World"] = 1] = "World";
-    IntersectOptions[IntersectOptions["Vehicles"] = 2] = "Vehicles";
-    IntersectOptions[IntersectOptions["PedsSimpleCollision"] = 4] = "PedsSimpleCollision";
-    IntersectOptions[IntersectOptions["Peds"] = 8] = "Peds";
-    IntersectOptions[IntersectOptions["Objects"] = 16] = "Objects";
-    IntersectOptions[IntersectOptions["Water"] = 32] = "Water";
-    IntersectOptions[IntersectOptions["Unk3"] = 128] = "Unk3";
-    IntersectOptions[IntersectOptions["Foliage"] = 256] = "Foliage";
-})(IntersectOptions || (IntersectOptions = {}));