@mafiahub/types 0.1.7 → 0.1.9

package/core/color.d.ts

@@ -1,55 +1,53 @@
-declare namespace Core {
-    /**
-     * RGBA color. Components are stored as floats in [0, 1] range.
-     * Use `Color.fromRGB()` to construct from 0-255 values.
-     */
-    class Color {
-        /** Create a color from normalized components; alpha defaults to 1. */
-        constructor(r: number, g: number, b: number, a?: number);
+/**
+ * RGBA color. Components are stored as floats in [0, 1] range.
+ * Use `Color.fromRGB()` to construct from 0-255 values.
+ */
+declare class Color {
+    /** Create a color from normalized components; alpha defaults to 1. */
+    constructor(r: number, g: number, b: number, a?: number);
 
-        /** Mutable normalized red component. */
-        r: number;
-        /** Mutable normalized green component. */
-        g: number;
-        /** Mutable normalized blue component. */
-        b: number;
-        /** Mutable normalized alpha component. */
-        a: number;
+    /** Mutable normalized red component. */
+    r: number;
+    /** Mutable normalized green component. */
+    g: number;
+    /** Mutable normalized blue component. */
+    b: number;
+    /** Mutable normalized alpha component. */
+    a: number;
 
-        /** Interpolate every component toward `target`, mutating this color. */
-        lerp(target: Color, t: number): this;
-        /** Replace normalized components; alpha defaults to 1 when omitted. */
-        set(r: number, g: number, b: number, a?: number): this;
-        /** Create an independent copy. */
-        clone(): Color;
-        /** Return uppercase `#RRGGBB`, or `#RRGGBBAA` when alpha is requested. */
-        toHex(includeAlpha?: boolean): string;
-        /** Format as `Color(r, g, b, a)` for logging. */
-        toString(): string;
-        /** Convert to a plain normalized component object for `JSON.stringify`. */
-        toJSON(): { r: number; g: number; b: number; a: number };
+    /** Interpolate every component toward `target`, mutating this color. */
+    lerp(target: Color, t: number): this;
+    /** Replace normalized components; alpha defaults to 1 when omitted. */
+    set(r: number, g: number, b: number, a?: number): this;
+    /** Create an independent copy. */
+    clone(): Color;
+    /** Return uppercase `#RRGGBB`, or `#RRGGBBAA` when alpha is requested. */
+    toHex(includeAlpha?: boolean): string;
+    /** Format as `Color(r, g, b, a)` for logging. */
+    toString(): string;
+    /** Convert to a plain normalized component object for `JSON.stringify`. */
+    toJSON(): { r: number; g: number; b: number; a: number };
 
-        /** Parse `#RGB`, `#RGBA`, `#RRGGBB`, or `#RRGGBBAA`; invalid input returns opaque white. */
-        static fromHex(hex: string): Color;
-        /** Construct from 0-255 component values; alpha defaults to 255. */
-        static fromRGB(r: number, g: number, b: number, a?: number): Color;
-        /** Create opaque white. */
-        static white(): Color;
-        /** Create opaque black. */
-        static black(): Color;
-        /** Create opaque red. */
-        static red(): Color;
-        /** Create opaque green. */
-        static green(): Color;
-        /** Create opaque blue. */
-        static blue(): Color;
-        /** Create opaque yellow. */
-        static yellow(): Color;
-        /** Create opaque cyan. */
-        static cyan(): Color;
-        /** Create opaque magenta. */
-        static magenta(): Color;
-        /** Create fully transparent black. */
-        static transparent(): Color;
-    }
+    /** Parse `#RGB`, `#RGBA`, `#RRGGBB`, or `#RRGGBBAA`; invalid input returns opaque white. */
+    static fromHex(hex: string): Color;
+    /** Construct from 0-255 component values; alpha defaults to 255. */
+    static fromRGB(r: number, g: number, b: number, a?: number): Color;
+    /** Create opaque white. */
+    static white(): Color;
+    /** Create opaque black. */
+    static black(): Color;
+    /** Create opaque red. */
+    static red(): Color;
+    /** Create opaque green. */
+    static green(): Color;
+    /** Create opaque blue. */
+    static blue(): Color;
+    /** Create opaque yellow. */
+    static yellow(): Color;
+    /** Create opaque cyan. */
+    static cyan(): Color;
+    /** Create opaque magenta. */
+    static magenta(): Color;
+    /** Create fully transparent black. */
+    static transparent(): Color;
 }

package/core/events.d.ts

@@ -1,70 +1,68 @@
-declare namespace Core {
+/**
+ * Global event bus with async support.
+ *
+ * Reserved events (framework-only, cannot be emitted from JS):
+ * `resourceStart`, `resourceStop`, `resourceError`,
+ * `playerConnect`, `playerDisconnect`, `playerSpawn`,
+ * `serverStart`, `serverStop`
+ */
+declare const Events: {
     /**
-     * Global event bus with async support.
-     *
-     * Reserved events (framework-only, cannot be emitted from JS):
-     * `resourceStart`, `resourceStop`, `resourceError`,
-     * `playerConnect`, `playerDisconnect`, `playerSpawn`,
-     * `serverStart`, `serverStop`
+     * Register a persistent listener owned by the calling resource.
+     * @param eventName Case-sensitive shared event name.
+     * @param handler Callback invoked with the emitted arguments; asynchronous results are awaited by emitters.
+     * @returns An unsubscribe function.
      */
-    const Events: {
-        /**
-         * Register a persistent listener owned by the calling resource.
-         * @param eventName Case-sensitive shared event name.
-         * @param handler Callback invoked with the emitted arguments; asynchronous results are awaited by emitters.
-         * @returns An unsubscribe function.
-         */
-        on(eventName: string, handler: (...args: any[]) => void): () => void;
+    on(eventName: string, handler: (...args: any[]) => void): () => void;
 
-        /**
-         * Register a listener removed before its first invocation.
-         * @param eventName Case-sensitive shared event name.
-         * @param handler Resource-owned callback invoked once.
-         */
-        once(eventName: string, handler: (...args: any[]) => void): void;
+    /**
+     * Register a listener removed before its first invocation.
+     * @param eventName Case-sensitive shared event name.
+     * @param handler Resource-owned callback invoked once.
+     */
+    once(eventName: string, handler: (...args: any[]) => void): void;
 
-        /**
-         * Remove a matching listener owned by the calling resource.
-         * @param eventName Case-sensitive shared event name.
-         * @param handler Exact function passed to `on` or `once`.
-         */
-        off(eventName: string, handler: (...args: any[]) => void): void;
+    /**
+     * Remove a matching listener owned by the calling resource.
+     * @param eventName Case-sensitive shared event name.
+     * @param handler Exact function passed to `on` or `once`.
+     */
+    off(eventName: string, handler: (...args: any[]) => void): void;
 
-        /**
-         * Emit an event globally. Reserved events cannot be emitted.
-         * Resolves when all handlers complete; rejects with
-         * `AggregateError` if any handler fails.
-         * @param eventName Shared event name; framework-reserved names cannot be emitted by scripts.
-         * @param args Arguments delivered to every matching handler.
-         */
-        emit(eventName: string, ...args: any[]): Promise<void>;
+    /**
+     * Emit an event globally. Reserved events cannot be emitted.
+     * Resolves when all handlers complete; rejects with
+     * `AggregateError` if any handler fails.
+     * @param eventName Shared event name; framework-reserved names cannot be emitted by scripts.
+     * @param args Arguments delivered to every matching handler.
+     */
+    emit(eventName: string, ...args: any[]): Promise<void>;
 
-        /**
-         * Emit an event targeting listeners owned by one resource.
-         * @param resourceName Destination running resource.
-         * @param eventName Shared event name.
-         * @param args Arguments delivered to matching destination handlers.
-         */
-        emitTo(resourceName: string, eventName: string, ...args: any[]): Promise<void>;
+    /**
+     * Emit an event targeting listeners owned by one resource.
+     * @param resourceName Destination running resource.
+     * @param eventName Shared event name.
+     * @param args Arguments delivered to matching destination handlers.
+     */
+    emitTo(resourceName: string, eventName: string, ...args: any[]): Promise<void>;
 
-        /**
-         * Register a listener in the calling resource's private event namespace.
-         * @param eventName Private event name.
-         * @param handler Callback invoked only by the same resource's `emitLocal` calls.
-         */
-        onLocal(eventName: string, handler: (...args: any[]) => void): void;
+    /**
+     * Register a listener in the calling resource's private event namespace.
+     * @param eventName Private event name.
+     * @param handler Callback invoked only by the same resource's `emitLocal` calls.
+     */
+    onLocal(eventName: string, handler: (...args: any[]) => void): void;
 
-        /**
-         * Emit within the calling resource's private event namespace.
-         * @param eventName Private event name.
-         * @param args Arguments delivered to local handlers.
-         */
-        emitLocal(eventName: string, ...args: any[]): Promise<void>;
+    /**
+     * Emit within the calling resource's private event namespace.
+     * @param eventName Private event name.
+     * @param args Arguments delivered to local handlers.
+     */
+    emitLocal(eventName: string, ...args: any[]): Promise<void>;
 
-        /**
-         * Count persistent and one-shot listeners across resources.
-         * @param eventName Shared event name to inspect.
-         */
-        listenerCount(eventName: string): number;
-    };
-}
+    /**
+     * Count persistent and one-shot listeners across resources.
+     * @param eventName Shared event name to inspect.
+     */
+    listenerCount(eventName: string): number;
+};

package/core/quaternion.d.ts

@@ -1,48 +1,46 @@
-declare namespace Core {
-    /** Mutable quaternion used to compose and apply three-dimensional rotations. */
-    class Quaternion {
-        /** Create a quaternion in scalar-first `(w, x, y, z)` order. */
-        constructor(w: number, x: number, y: number, z: number);
+/** Mutable quaternion used to compose and apply three-dimensional rotations. */
+declare class Quaternion {
+    /** Create a quaternion in scalar-first `(w, x, y, z)` order. */
+    constructor(w: number, x: number, y: number, z: number);
 
-        /** Mutable scalar component. */
-        w: number;
-        /** Mutable X imaginary component. */
-        x: number;
-        /** Mutable Y imaginary component. */
-        y: number;
-        /** Mutable Z imaginary component. */
-        z: number;
+    /** Mutable scalar component. */
+    w: number;
+    /** Mutable X imaginary component. */
+    x: number;
+    /** Mutable Y imaginary component. */
+    y: number;
+    /** Mutable Z imaginary component. */
+    z: number;
 
-        /** Compose this rotation with `other`, mutating this quaternion. */
-        multiply(other: Quaternion): this;
-        /** Normalize this quaternion in place. */
-        normalize(): this;
-        /** Spherically interpolate toward `target`; `t=0` keeps this rotation and `t=1` reaches it. */
-        slerp(target: Quaternion, t: number): this;
-        /** Return a new conjugated quaternion without modifying this one. */
-        conjugate(): Quaternion;
-        /** Return a new inverse rotation without modifying this quaternion. */
-        inverse(): Quaternion;
-        /** Compute the scalar quaternion dot product. */
-        dot(other: Quaternion): number;
-        /** Apply this rotation and return a new rotated vector. */
-        rotateVector(v: Vector3): Vector3;
-        /** Euler angles in radians (x=pitch, y=yaw, z=roll). */
-        toEuler(): Vector3;
-        /** Replace every component and return this quaternion for chaining. */
-        set(w: number, x: number, y: number, z: number): this;
-        /** Create an independent copy. */
-        clone(): Quaternion;
-        /** Format as `Quaternion(w, x, y, z)` for logging. */
-        toString(): string;
-        /** Convert to a plain component object for `JSON.stringify`. */
-        toJSON(): { w: number; x: number; y: number; z: number };
+    /** Compose this rotation with `other`, mutating this quaternion. */
+    multiply(other: Quaternion): this;
+    /** Normalize this quaternion in place. */
+    normalize(): this;
+    /** Spherically interpolate toward `target`; `t=0` keeps this rotation and `t=1` reaches it. */
+    slerp(target: Quaternion, t: number): this;
+    /** Return a new conjugated quaternion without modifying this one. */
+    conjugate(): Quaternion;
+    /** Return a new inverse rotation without modifying this quaternion. */
+    inverse(): Quaternion;
+    /** Compute the scalar quaternion dot product. */
+    dot(other: Quaternion): number;
+    /** Apply this rotation and return a new rotated vector. */
+    rotateVector(v: Vector3): Vector3;
+    /** Euler angles in radians (x=pitch, y=yaw, z=roll). */
+    toEuler(): Vector3;
+    /** Replace every component and return this quaternion for chaining. */
+    set(w: number, x: number, y: number, z: number): this;
+    /** Create an independent copy. */
+    clone(): Quaternion;
+    /** Format as `Quaternion(w, x, y, z)` for logging. */
+    toString(): string;
+    /** Convert to a plain component object for `JSON.stringify`. */
+    toJSON(): { w: number; x: number; y: number; z: number };
 
-        /** Create the identity rotation `Quaternion(1, 0, 0, 0)`. */
-        static identity(): Quaternion;
-        /** From euler angles in radians. */
-        static fromEuler(pitch: number, yaw: number, roll: number): Quaternion;
-        /** Create a rotation of `angle` radians around an axis normalized internally. */
-        static fromAxisAngle(axis: Vector3, angle: number): Quaternion;
-    }
+    /** Create the identity rotation `Quaternion(1, 0, 0, 0)`. */
+    static identity(): Quaternion;
+    /** From euler angles in radians. */
+    static fromEuler(pitch: number, yaw: number, roll: number): Quaternion;
+    /** Create a rotation of `angle` radians around an axis normalized internally. */
+    static fromAxisAngle(axis: Vector3, angle: number): Quaternion;
 }

package/core/vector2.d.ts

@@ -1,45 +1,43 @@
-declare namespace Core {
-    class Vector2 {
-        /** Create a vector from its X and Y components. */
-        constructor(x: number, y: number);
+declare class Vector2 {
+    /** Create a vector from its X and Y components. */
+    constructor(x: number, y: number);
 
-        /** Mutable X component. */
-        x: number;
-        /** Mutable Y component. */
-        y: number;
-        /** Euclidean magnitude of this vector. */
-        readonly length: number;
-        /** Squared magnitude, avoiding a square-root calculation. */
-        readonly lengthSquared: number;
+    /** Mutable X component. */
+    x: number;
+    /** Mutable Y component. */
+    y: number;
+    /** Euclidean magnitude of this vector. */
+    readonly length: number;
+    /** Squared magnitude, avoiding a square-root calculation. */
+    readonly lengthSquared: number;
 
-        /** Add another vector component-wise, mutating this vector. */
-        add(other: Vector2): this;
-        /** Subtract another vector component-wise, mutating this vector. */
-        sub(other: Vector2): this;
-        /** Multiply both components by a scalar, mutating this vector. */
-        mul(scalar: number): this;
-        /** Divide both components by a non-zero scalar, mutating this vector. */
-        div(scalar: number): this;
-        /** Normalize this vector in place; a zero vector remains unchanged. */
-        normalize(): this;
-        /** Compute the scalar dot product without changing either vector. */
-        dot(other: Vector2): number;
-        /** Compute Euclidean distance to another vector. */
-        distance(other: Vector2): number;
-        /** Interpolate toward `target`; `t=0` keeps this value and `t=1` reaches the target. */
-        lerp(target: Vector2, t: number): this;
-        /** Replace both components and return this vector for chaining. */
-        set(x: number, y: number): this;
-        /** Create an independent copy. */
-        clone(): Vector2;
-        /** Format as `Vector2(x, y)` for logging. */
-        toString(): string;
-        /** Convert to a plain component object for `JSON.stringify`. */
-        toJSON(): { x: number; y: number };
+    /** Add another vector component-wise, mutating this vector. */
+    add(other: Vector2): this;
+    /** Subtract another vector component-wise, mutating this vector. */
+    sub(other: Vector2): this;
+    /** Multiply both components by a scalar, mutating this vector. */
+    mul(scalar: number): this;
+    /** Divide both components by a non-zero scalar, mutating this vector. */
+    div(scalar: number): this;
+    /** Normalize this vector in place; a zero vector remains unchanged. */
+    normalize(): this;
+    /** Compute the scalar dot product without changing either vector. */
+    dot(other: Vector2): number;
+    /** Compute Euclidean distance to another vector. */
+    distance(other: Vector2): number;
+    /** Interpolate toward `target`; `t=0` keeps this value and `t=1` reaches the target. */
+    lerp(target: Vector2, t: number): this;
+    /** Replace both components and return this vector for chaining. */
+    set(x: number, y: number): this;
+    /** Create an independent copy. */
+    clone(): Vector2;
+    /** Format as `Vector2(x, y)` for logging. */
+    toString(): string;
+    /** Convert to a plain component object for `JSON.stringify`. */
+    toJSON(): { x: number; y: number };
 
-        /** Create `Vector2(0, 0)`. */
-        static zero(): Vector2;
-        /** Create `Vector2(1, 1)`. */
-        static one(): Vector2;
-    }
+    /** Create `Vector2(0, 0)`. */
+    static zero(): Vector2;
+    /** Create `Vector2(1, 1)`. */
+    static one(): Vector2;
 }

package/core/vector3.d.ts

@@ -1,55 +1,53 @@
-declare namespace Core {
-    class Vector3 {
-        /** Create a vector from its X, Y, and Z components. */
-        constructor(x: number, y: number, z: number);
+declare class Vector3 {
+    /** Create a vector from its X, Y, and Z components. */
+    constructor(x: number, y: number, z: number);
 
-        /** Mutable X component. */
-        x: number;
-        /** Mutable Y component. */
-        y: number;
-        /** Mutable Z component. */
-        z: number;
-        /** Euclidean magnitude of this vector. */
-        readonly length: number;
-        /** Squared magnitude, avoiding a square-root calculation. */
-        readonly lengthSquared: number;
+    /** Mutable X component. */
+    x: number;
+    /** Mutable Y component. */
+    y: number;
+    /** Mutable Z component. */
+    z: number;
+    /** Euclidean magnitude of this vector. */
+    readonly length: number;
+    /** Squared magnitude, avoiding a square-root calculation. */
+    readonly lengthSquared: number;
 
-        /** Add another vector component-wise, mutating this vector. */
-        add(other: Vector3): this;
-        /** Subtract another vector component-wise, mutating this vector. */
-        sub(other: Vector3): this;
-        /** Multiply every component by a scalar, mutating this vector. */
-        mul(scalar: number): this;
-        /** Divide every component by a non-zero scalar, mutating this vector. */
-        div(scalar: number): this;
-        /** Normalize this vector in place; a zero vector remains unchanged. */
-        normalize(): this;
-        /** Compute the scalar dot product without changing either vector. */
-        dot(other: Vector3): number;
-        /** Replace this vector with its cross product against `other`. */
-        cross(other: Vector3): this;
-        /** Compute Euclidean distance to another vector. */
-        distance(other: Vector3): number;
-        /** Interpolate toward `target`; `t=0` keeps this value and `t=1` reaches the target. */
-        lerp(target: Vector3, t: number): this;
-        /** Replace all components and return this vector for chaining. */
-        set(x: number, y: number, z: number): this;
-        /** Create an independent copy. */
-        clone(): Vector3;
-        /** Format as `Vector3(x, y, z)` for logging. */
-        toString(): string;
-        /** Convert to a plain component object for `JSON.stringify`. */
-        toJSON(): { x: number; y: number; z: number };
+    /** Add another vector component-wise, mutating this vector. */
+    add(other: Vector3): this;
+    /** Subtract another vector component-wise, mutating this vector. */
+    sub(other: Vector3): this;
+    /** Multiply every component by a scalar, mutating this vector. */
+    mul(scalar: number): this;
+    /** Divide every component by a non-zero scalar, mutating this vector. */
+    div(scalar: number): this;
+    /** Normalize this vector in place; a zero vector remains unchanged. */
+    normalize(): this;
+    /** Compute the scalar dot product without changing either vector. */
+    dot(other: Vector3): number;
+    /** Replace this vector with its cross product against `other`. */
+    cross(other: Vector3): this;
+    /** Compute Euclidean distance to another vector. */
+    distance(other: Vector3): number;
+    /** Interpolate toward `target`; `t=0` keeps this value and `t=1` reaches the target. */
+    lerp(target: Vector3, t: number): this;
+    /** Replace all components and return this vector for chaining. */
+    set(x: number, y: number, z: number): this;
+    /** Create an independent copy. */
+    clone(): Vector3;
+    /** Format as `Vector3(x, y, z)` for logging. */
+    toString(): string;
+    /** Convert to a plain component object for `JSON.stringify`. */
+    toJSON(): { x: number; y: number; z: number };
 
-        /** Create `Vector3(0, 0, 0)`. */
-        static zero(): Vector3;
-        /** Create `Vector3(1, 1, 1)`. */
-        static one(): Vector3;
-        /** Create the framework's positive-Y unit direction. */
-        static up(): Vector3;
-        /** Create the framework's positive-Z unit direction. */
-        static forward(): Vector3;
-        /** Create the framework's positive-X unit direction. */
-        static right(): Vector3;
-    }
+    /** Create `Vector3(0, 0, 0)`. */
+    static zero(): Vector3;
+    /** Create `Vector3(1, 1, 1)`. */
+    static one(): Vector3;
+    /** Create the framework's positive-Y unit direction. */
+    static up(): Vector3;
+    /** Create the framework's positive-Z unit direction. */
+    static forward(): Vector3;
+    /** Create the framework's positive-X unit direction. */
+    static right(): Vector3;
 }

package/core/vector4.d.ts

@@ -1,49 +1,47 @@
-declare namespace Core {
-    class Vector4 {
-        /** Create a vector from its X, Y, Z, and W components. */
-        constructor(x: number, y: number, z: number, w: number);
+declare class Vector4 {
+    /** Create a vector from its X, Y, Z, and W components. */
+    constructor(x: number, y: number, z: number, w: number);
 
-        /** Mutable X component. */
-        x: number;
-        /** Mutable Y component. */
-        y: number;
-        /** Mutable Z component. */
-        z: number;
-        /** Mutable W component. */
-        w: number;
-        /** Euclidean magnitude of this vector. */
-        readonly length: number;
-        /** Squared magnitude, avoiding a square-root calculation. */
-        readonly lengthSquared: number;
+    /** Mutable X component. */
+    x: number;
+    /** Mutable Y component. */
+    y: number;
+    /** Mutable Z component. */
+    z: number;
+    /** Mutable W component. */
+    w: number;
+    /** Euclidean magnitude of this vector. */
+    readonly length: number;
+    /** Squared magnitude, avoiding a square-root calculation. */
+    readonly lengthSquared: number;
 
-        /** Add another vector component-wise, mutating this vector. */
-        add(other: Vector4): this;
-        /** Subtract another vector component-wise, mutating this vector. */
-        sub(other: Vector4): this;
-        /** Multiply every component by a scalar, mutating this vector. */
-        mul(scalar: number): this;
-        /** Divide every component by a non-zero scalar, mutating this vector. */
-        div(scalar: number): this;
-        /** Normalize this vector in place; a zero vector remains unchanged. */
-        normalize(): this;
-        /** Compute the scalar dot product without changing either vector. */
-        dot(other: Vector4): number;
-        /** Compute Euclidean distance to another vector. */
-        distance(other: Vector4): number;
-        /** Interpolate toward `target`; `t=0` keeps this value and `t=1` reaches the target. */
-        lerp(target: Vector4, t: number): this;
-        /** Replace all components and return this vector for chaining. */
-        set(x: number, y: number, z: number, w: number): this;
-        /** Create an independent copy. */
-        clone(): Vector4;
-        /** Format as `Vector4(x, y, z, w)` for logging. */
-        toString(): string;
-        /** Convert to a plain component object for `JSON.stringify`. */
-        toJSON(): { x: number; y: number; z: number; w: number };
+    /** Add another vector component-wise, mutating this vector. */
+    add(other: Vector4): this;
+    /** Subtract another vector component-wise, mutating this vector. */
+    sub(other: Vector4): this;
+    /** Multiply every component by a scalar, mutating this vector. */
+    mul(scalar: number): this;
+    /** Divide every component by a non-zero scalar, mutating this vector. */
+    div(scalar: number): this;
+    /** Normalize this vector in place; a zero vector remains unchanged. */
+    normalize(): this;
+    /** Compute the scalar dot product without changing either vector. */
+    dot(other: Vector4): number;
+    /** Compute Euclidean distance to another vector. */
+    distance(other: Vector4): number;
+    /** Interpolate toward `target`; `t=0` keeps this value and `t=1` reaches the target. */
+    lerp(target: Vector4, t: number): this;
+    /** Replace all components and return this vector for chaining. */
+    set(x: number, y: number, z: number, w: number): this;
+    /** Create an independent copy. */
+    clone(): Vector4;
+    /** Format as `Vector4(x, y, z, w)` for logging. */
+    toString(): string;
+    /** Convert to a plain component object for `JSON.stringify`. */
+    toJSON(): { x: number; y: number; z: number; w: number };
 
-        /** Create `Vector4(0, 0, 0, 0)`. */
-        static zero(): Vector4;
-        /** Create `Vector4(1, 1, 1, 1)`. */
-        static one(): Vector4;
-    }
+    /** Create `Vector4(0, 0, 0, 0)`. */
+    static zero(): Vector4;
+    /** Create `Vector4(1, 1, 1, 1)`. */
+    static one(): Vector4;
 }

package/framework/key.d.ts

@@ -17,6 +17,9 @@
  * - Numpad `numpad0`–`numpad9` (aliases `num0`–`num9`)
  * - Mouse `mouse1` (left) `mouse2` (right) `mouse3` (middle) `mouse4` `mouse5`
  *
+ * Letters and digits identify physical positions on a US keyboard. Use
+ * `getLabel` to show the corresponding label in the player's current layout.
+ *
  * @example
  * // Toggle a HUD on key-down:
  * Key.bind("f6", "down", () => toggleHud());
@@ -52,4 +55,17 @@ declare const Key: {
      * game window is in the background (same gate as bind dispatch).
      */
     isDown(key: string): boolean;
+
+    /**
+     * Display label for a physical key using the current keyboard layout.
+     * For example, `getLabel("y")` returns `"Z"` on German QWERTZ.
+     * Works while menus/web views own input and without registering a binding.
+     * Query again when refreshing a prompt so layout changes are reflected.
+     * Labels are display text; keep using the original key name for bindings.
+     * @returns Uppercase printable text, or an English name such as `"Enter"`
+     *   or `"Mouse 1"`. Falls back to the uppercase canonical key name if the
+     *   layout cannot translate it. Ignores held modifiers and Caps Lock.
+     * @throws If the key is unknown or the argument is not a string.
+     */
+    getLabel(key: string): string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mafiahub/types",
-    "version": "0.1.7",
+    "version": "0.1.9",
     "description": "TypeScript type definitions for the MafiaHub Framework scripting API",
     "types": "index.d.ts",
     "files": [