@ringozz/godot 4.7.2-583 → 4.7.2-592

package/README.md

@@ -50,13 +50,31 @@ await import('./app.ts'); // may now import @ringozz/godot / react-godot freely
 |---|---|
 | `@ringozz/godot` | Value types (`Vector3`, `Color`, …), global enums, heap types, utility functions, global constants, `runGodot()`, RAF polyfills |
 | `@ringozz/godot/ClassName` | Classes, one per module — e.g. `@ringozz/godot/Label`, `@ringozz/godot/Node` |
-| `@ringozz/godot/runtime` | Low-level dispatch: `_C`, `_S`, `_get`, `_set`, `_R`, `_G`, `_P`, `getGodot`, `GodotVar` |
+| `@ringozz/godot/runtime` | Low-level dispatch: `_C`, `_S`, `_R`, `_G`, `_P`, `_V`, `toValueType`, `getGodot`, `GodotVar` |
 | `@ringozz/godot/boot` | Platform boot: `getNativeModule()`; web `preloadGodot()` (awaited before importing the app; no-op on desktop) |
 | `@ringozz/godot/load` | Async resource loading: `loadResourceAsync` |
 | `@ringozz/godot/debug` | `initDebug()`, `dumpStr`, `snapshot`, `inspect`, `click`, `find`, `gc` |
 
 Class-scoped enums use bare names (import `ProcessMode` from `@ringozz/godot/Node`, not `NodeProcessMode`).
 
+### Value types
+
+Godot's built-in value types (`Vector3`, `Color`, `Transform3D`, …) are **named tuples** — labeled array aliases, not classes. Import each type module as a namespace and call its math as functions; constructors are `fromXxx` factories:
+
+```ts
+import * as v3 from '@ringozz/godot/Vector3';
+import * as basis from '@ringozz/godot/Basis';
+import type { Vector3 } from '@ringozz/godot/Vector3';
+
+const v: Vector3 = [1, 2, 3];            // flat tuple, labels in the type
+const n = v3.normalized(v);              // math API per type module
+const b = basis.fromAxisAngle([0, 1, 0], 1.57);
+```
+
+- **Shapes**: flat types are scalar-labeled (`Vector3 = [x: number, y: number, z: number]`, `Color = [r, g, b, a?]`); nested types are row-labeled tuples of the flat alias (`Transform3D = [x, y, z, origin]`, `AABB = [position, size]`). **Wrong-arity arrays fail typecheck**; `Color`'s `a` is the only optional element (alpha defaults 1).
+- **Getters/setters/props** all use the same tuple shapes — `node.position = [1, 2, 3]` reads back `[x, y, z]`; JSX props in `@ringozz/react-godot` accept them too.
+- A plain tuple stored in a **Variant-typed slot** (`setMeta`, a direct `tweenProperty` final value) becomes a generic Godot `Array` — a tuple carries no type. Wrap it with `toValueType(node, 'prop', tuple)` from `@ringozz/godot/runtime` to store the typed value.
+
 ### Async resource loading
 
 The engine loads pre-baked native resources (`.scn`, `.ctex`, …) through `ResourceLoader`. On desktop these are real files (`res://` = cwd); on web there is no filesystem, so the asset's bundled files — `.import` sidecars as text and imported products (`.scn`/`.ctex`) as emitted asset paths — are staged into Emscripten's in-memory MEMFS (transient, no IndexedDB, no persistent copy) by the generated asset modules, handing the fetched bytes straight to MEMFS via Godot's own `copyToFS` (`FS.createDataFile` with `canOwn` — zero copy, JS-heap only). On web, `.ctex` files are decoded first: the embedded PNG/WebP blobs go through the browser's `createImageBitmap` and the container is rebuilt as raw RGBA (`DATA_FORMAT_IMAGE`), so no image codec runs in wasm. The source file itself is never fetched.

package/gen/classes/ArrayOccluder3D.ts

@@ -23,7 +23,7 @@ export class ArrayOccluder3D extends Occluder3D {
      * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link setArrays} instead to avoid updating the occluder twice when it's created.
      */
     get vertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
-    set vertices(v: PackedVector3Array | Vector3[]) { _C(this, 13308, v); }
+    set vertices(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 13308, v); }
 
     /**
      * The occluder's index position. Indices determine which points from the {@link vertices} array should be drawn, and in which order.

package/gen/classes/CPUParticles2D.ts

@@ -152,19 +152,19 @@ export class CPUParticles2D extends Node2D {
      * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionPoints(): PackedVector2Array { return _C(this, 4628) as PackedVector2Array; }
-    set emissionPoints(v: PackedVector2Array | Vector2[]) { _C(this, 11245, v); }
+    set emissionPoints(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 11245, v); }
 
     /**
      * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionNormals(): PackedVector2Array { return _C(this, 4624) as PackedVector2Array; }
-    set emissionNormals(v: PackedVector2Array | Vector2[]) { _C(this, 11241, v); }
+    set emissionNormals(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 11241, v); }
 
     /**
      * Sets the {@link Color}s to modulate particles by when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionColors(): PackedColorArray { return _C(this, 4618) as PackedColorArray; }
-    set emissionColors(v: PackedColorArray | Color[]) { _C(this, 11235, v); }
+    set emissionColors(v: PackedColorArray | (Color | number[])[]) { _C(this, 11235, v); }
 
     /**
      * The ring's inner radius if {@link emissionShape} is set to {@link EMISSION_SHAPE_RING}.

package/gen/classes/CPUParticles3D.ts

@@ -164,20 +164,20 @@ export class CPUParticles3D extends GeometryInstance3D {
      * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionPoints(): PackedVector3Array { return _C(this, 4628) as PackedVector3Array; }
-    set emissionPoints(v: PackedVector3Array | Vector3[]) { _C(this, 11245, v); }
+    set emissionPoints(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 11245, v); }
 
     /**
      * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionNormals(): PackedVector3Array { return _C(this, 4624) as PackedVector3Array; }
-    set emissionNormals(v: PackedVector3Array | Vector3[]) { _C(this, 11241, v); }
+    set emissionNormals(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 11241, v); }
 
     /**
      * Sets the {@link Color}s to modulate particles by when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      * **Note:** {@link emissionColors} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertexColorUseAsAlbedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link emissionColors} will have no visible effect.
      */
     get emissionColors(): PackedColorArray { return _C(this, 4618) as PackedColorArray; }
-    set emissionColors(v: PackedColorArray | Color[]) { _C(this, 11235, v); }
+    set emissionColors(v: PackedColorArray | (Color | number[])[]) { _C(this, 11235, v); }
 
     /**
      * The axis of the ring when using the emitter {@link EMISSION_SHAPE_RING}.

package/gen/classes/CSGPolygon3D.ts

@@ -19,7 +19,7 @@ export class CSGPolygon3D extends CSGPrimitive3D {
      * **Note:** If only 1 or 2 points are defined in {@link polygon}, no mesh will be generated.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12373, v); }
 
     /**
      * The {@link mode} used to extrude the {@link polygon}.

package/gen/classes/CollisionPolygon2D.ts

@@ -24,7 +24,7 @@ export class CollisionPolygon2D extends Node2D {
      * **Note:** The returned vertices are in the local coordinate space of the given {@link CollisionPolygon2D}.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12373, v); }
 
     /**
      * If `true`, no collisions will be detected. This property should be changed with {@link Object.setDeferred}.

package/gen/classes/CollisionPolygon3D.ts

@@ -29,7 +29,7 @@ export class CollisionPolygon3D extends Node3D {
      * Array of vertices which define the 2D polygon in the local XY plane.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12373, v); }
 
     /**
      * The collision margin for the generated {@link Shape3D}. See {@link Shape3D.margin} for more details.

package/gen/classes/ColorPalette.ts

@@ -16,7 +16,7 @@ export class ColorPalette extends Resource {
      * A {@link PackedColorArray} containing the colors in the palette.
      */
     get colors(): PackedColorArray { return _C(this, 4232) as PackedColorArray; }
-    set colors(v: PackedColorArray | Color[]) { _C(this, 10914, v); }
+    set colors(v: PackedColorArray | (Color | number[])[]) { _C(this, 10914, v); }
 
     static readonly name = _R(208, ColorPalette);
 }

package/gen/classes/ConcavePolygonShape2D.ts

@@ -20,7 +20,7 @@ export class ConcavePolygonShape2D extends Shape2D {
      * The array of points that make up the {@link ConcavePolygonShape2D}'s line segments. The array (of length divisible by two) is naturally divided into pairs (one pair for each segment); each pair consists of the starting point of a segment and the endpoint of a segment.
      */
     get segments(): PackedVector2Array { return _C(this, 6318) as PackedVector2Array; }
-    set segments(v: PackedVector2Array | Vector2[]) { _C(this, 12683, v); }
+    set segments(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12683, v); }
 
     static readonly name = _R(220, ConcavePolygonShape2D);
 }

package/gen/classes/ConcavePolygonShape3D.ts

@@ -17,7 +17,7 @@ export class ConcavePolygonShape3D extends Shape3D {
     constructor(name = 221) { super(name); }
 
     get data(): PackedVector3Array { return _C(this, 4736) as PackedVector3Array; }
-    set data(v: PackedVector3Array | Vector3[]) { _C(this, 11352, v); }
+    set data(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 11352, v); }
 
     /**
      * If set to `true`, collisions occur on both sides of the concave shape faces. Otherwise they occur only along the face normals.

package/gen/classes/ConvexPolygonShape2D.ts

@@ -25,7 +25,7 @@ export class ConvexPolygonShape2D extends Shape2D {
      * **Warning:** Only set this property to a list of points that actually form a convex hull. Use {@link setPointCloud} to generate the convex hull of an arbitrary set of points.
      */
     get points(): PackedVector2Array { return _C(this, 5958) as PackedVector2Array; }
-    set points(v: PackedVector2Array | Vector2[]) { _C(this, 12369, v); }
+    set points(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12369, v); }
 
     static readonly name = _R(228, ConvexPolygonShape2D);
 }

package/gen/classes/ConvexPolygonShape3D.ts

@@ -19,7 +19,7 @@ export class ConvexPolygonShape3D extends Shape3D {
      * The list of 3D points forming the convex polygon shape.
      */
     get points(): PackedVector3Array { return _C(this, 5958) as PackedVector3Array; }
-    set points(v: PackedVector3Array | Vector3[]) { _C(this, 12369, v); }
+    set points(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 12369, v); }
 
     static readonly name = _R(229, ConvexPolygonShape3D);
 }

package/gen/classes/FontVariation.ts

@@ -117,7 +117,7 @@ export class FontVariation extends Font {
      * An array of colors to override predefined palette. Use `Color(0, 0, 0, 0)`, to keep predefined palette color at specific position.
      */
     get paletteCustomColors(): PackedColorArray { return _C(this, 5797) as PackedColorArray; }
-    set paletteCustomColors(v: PackedColorArray | Color[]) { _C(this, 12238, v); }
+    set paletteCustomColors(v: PackedColorArray | (Color | number[])[]) { _C(this, 12238, v); }
 
     static readonly name = _R(274, FontVariation);
 }

package/gen/classes/Gradient.ts

@@ -84,7 +84,7 @@ export class Gradient extends Resource {
      * **Note:** Setting this property updates all colors at once. To update any color individually use {@link setColor}.
      */
     get colors(): PackedColorArray { return _C(this, 4232) as PackedColorArray; }
-    set colors(v: PackedColorArray | Color[]) { _C(this, 10914, v); }
+    set colors(v: PackedColorArray | (Color | number[])[]) { _C(this, 10914, v); }
 
     static readonly name = _R(314, Gradient);
 }

package/gen/classes/Line2D.ts

@@ -52,7 +52,7 @@ export class Line2D extends Node2D {
      * The points of the polyline, interpreted in local 2D coordinates. Segments are drawn between the adjacent points in this array.
      */
     get points(): PackedVector2Array { return _C(this, 5958) as PackedVector2Array; }
-    set points(v: PackedVector2Array | Vector2[]) { _C(this, 12369, v); }
+    set points(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12369, v); }
 
     /**
      * If `true` and the polyline has more than 2 points, the last point and the first one will be connected by a segment.

package/gen/classes/MultiMesh.ts

@@ -138,25 +138,25 @@ export class MultiMesh extends Resource {
      * Array containing each {@link Transform3D} value used by all instances of this mesh, as a {@link PackedVector3Array}. Each transform is divided into 4 {@link Vector3} values corresponding to the transforms' `x`, `y`, `z`, and `origin`.
      */
     get transformArray(): PackedVector3Array { return _C(this, 1014) as PackedVector3Array; }
-    set transformArray(v: PackedVector3Array | Vector3[]) { _C(this, 1045, v); }
+    set transformArray(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 1045, v); }
 
     /**
      * Array containing each {@link Transform2D} value used by all instances of this mesh, as a {@link PackedVector2Array}. Each transform is divided into 3 {@link Vector2} values corresponding to the transforms' `x`, `y`, and `origin`.
      */
     get transform2dArray(): PackedVector2Array { return _C(this, 1013) as PackedVector2Array; }
-    set transform2dArray(v: PackedVector2Array | Vector2[]) { _C(this, 1044, v); }
+    set transform2dArray(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 1044, v); }
 
     /**
      * Array containing each {@link Color} used by all instances of this mesh.
      */
     get colorArray(): PackedColorArray { return _C(this, 997) as PackedColorArray; }
-    set colorArray(v: PackedColorArray | Color[]) { _C(this, 1023, v); }
+    set colorArray(v: PackedColorArray | (Color | number[])[]) { _C(this, 1023, v); }
 
     /**
      * Array containing each custom data value used by all instances of this mesh, as a {@link PackedColorArray}.
      */
     get customDataArray(): PackedColorArray { return _C(this, 999) as PackedColorArray; }
-    set customDataArray(v: PackedColorArray | Color[]) { _C(this, 1025, v); }
+    set customDataArray(v: PackedColorArray | (Color | number[])[]) { _C(this, 1025, v); }
 
     /**
      * Choose whether to use an interpolation method that favors speed or quality.

package/gen/classes/NavigationMesh.ts

@@ -55,7 +55,7 @@ export class NavigationMesh extends Resource {
     clear(): void { _C(this, 2232); }
 
     get vertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
-    set vertices(v: PackedVector3Array | Vector3[]) { _C(this, 13308, v); }
+    set vertices(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 13308, v); }
 
     get polygons(): GodotArray { return _C(this, 1009) as GodotArray; }
     set polygons(v: GodotArray | unknown[]) { _C(this, 1037, v); }

package/gen/classes/NavigationObstacle2D.ts

@@ -49,7 +49,7 @@ export class NavigationObstacle2D extends Node2D {
      * The outline vertices of the obstacle. If the vertices are winded in clockwise order agents will be pushed in by the obstacle, else they will be pushed out. Outlines can not be crossed or overlap. Should the vertices using obstacle be warped to a new position agent's can not predict this movement and may get trapped inside the obstacle.
      */
     get vertices(): PackedVector2Array { return _C(this, 7068) as PackedVector2Array; }
-    set vertices(v: PackedVector2Array | Vector2[]) { _C(this, 13308, v); }
+    set vertices(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 13308, v); }
 
     /**
      * If enabled and parsed in a navigation mesh baking process the obstacle will discard source geometry inside its {@link vertices} defined shape.

package/gen/classes/NavigationObstacle3D.ts

@@ -55,7 +55,7 @@ export class NavigationObstacle3D extends Node3D {
      * The outline vertices of the obstacle. If the vertices are winded in clockwise order agents will be pushed in by the obstacle, else they will be pushed out. Outlines can not be crossed or overlap. Should the vertices using obstacle be warped to a new position agent's can not predict this movement and may get trapped inside the obstacle.
      */
     get vertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
-    set vertices(v: PackedVector3Array | Vector3[]) { _C(this, 13308, v); }
+    set vertices(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 13308, v); }
 
     /**
      * If enabled and parsed in a navigation mesh baking process the obstacle will discard source geometry inside its {@link vertices} and {@link height} defined shape.

package/gen/classes/NavigationPathQueryResult2D.ts

@@ -21,7 +21,7 @@ export class NavigationPathQueryResult2D extends RefCounted {
      * The resulting path array from the navigation query. All path array positions are in global coordinates. Without customized query parameters this is the same path as returned by {@link NavigationServer2D.mapGetPath}.
      */
     get path(): PackedVector2Array { return _C(this, 5840) as PackedVector2Array; }
-    set path(v: PackedVector2Array | Vector2[]) { _C(this, 12271, v); }
+    set path(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12271, v); }
 
     /**
      * The type of navigation primitive (region or link) that each point of the path goes through.

package/gen/classes/NavigationPathQueryResult3D.ts

@@ -21,7 +21,7 @@ export class NavigationPathQueryResult3D extends RefCounted {
      * The resulting path array from the navigation query. All path array positions are in global coordinates. Without customized query parameters this is the same path as returned by {@link NavigationServer3D.mapGetPath}.
      */
     get path(): PackedVector3Array { return _C(this, 5840) as PackedVector3Array; }
-    set path(v: PackedVector3Array | Vector3[]) { _C(this, 12271, v); }
+    set path(v: PackedVector3Array | (Vector3 | number[])[]) { _C(this, 12271, v); }
 
     /**
      * The type of navigation primitive (region or link) that each point of the path goes through.

package/gen/classes/NavigationPolygon.ts

@@ -122,7 +122,7 @@ export class NavigationPolygon extends Resource {
     clear(): void { _C(this, 2232); }
 
     get vertices(): PackedVector2Array { return _C(this, 7068) as PackedVector2Array; }
-    set vertices(v: PackedVector2Array | Vector2[]) { _C(this, 13308, v); }
+    set vertices(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 13308, v); }
 
     get polygons(): GodotArray { return _C(this, 1009) as GodotArray; }
     set polygons(v: GodotArray | unknown[]) { _C(this, 1037, v); }

package/gen/classes/OccluderPolygon2D.ts

@@ -28,7 +28,7 @@ export class OccluderPolygon2D extends Resource {
      * A {@link Vector2} array with the index for polygon's vertices positions.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12373, v); }
 
     static readonly name = _R(467, OccluderPolygon2D);
 }

package/gen/classes/Polygon2D.ts

@@ -117,19 +117,19 @@ export class Polygon2D extends Node2D {
      * The polygon's list of vertices. The final point will be connected to the first.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12373, v); }
 
     /**
      * Texture coordinates for each vertex of the polygon. There should be one UV value per polygon vertex. If there are fewer, undefined vertices will use `Vector2(0, 0)`.
      */
     get uv(): PackedVector2Array { return _C(this, 7002) as PackedVector2Array; }
-    set uv(v: PackedVector2Array | Vector2[]) { _C(this, 13251, v); }
+    set uv(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 13251, v); }
 
     /**
      * Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use {@link color}.
      */
     get vertexColors(): PackedColorArray { return _C(this, 7050) as PackedColorArray; }
-    set vertexColors(v: PackedColorArray | Color[]) { _C(this, 13291, v); }
+    set vertexColors(v: PackedColorArray | (Color | number[])[]) { _C(this, 13291, v); }
 
     /**
      * The list of polygons, in case more than one is being represented. Every individual polygon is stored as a {@link PackedInt32Array} where each {@link int} is an index to a point in {@link polygon}. If empty, this property will be ignored, and the resulting single polygon will be composed of all points in {@link polygon}, using the order they are stored in.

package/gen/classes/PolygonOccluder3D.ts

@@ -18,7 +18,7 @@ export class PolygonOccluder3D extends Occluder3D {
      * The polygon must *not* have intersecting lines. Otherwise, triangulation will fail (with an error message printed).
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12373, v); }
 
     static readonly name = _R(601, PolygonOccluder3D);
 }

package/gen/classes/Window.ts

@@ -542,7 +542,7 @@ export class Window extends Viewport {
      * **Note:** This property is implemented on Linux (X11), macOS and Windows.
      */
     get mousePassthroughPolygon(): PackedVector2Array { return _C(this, 5590) as PackedVector2Array; }
-    set mousePassthroughPolygon(v: PackedVector2Array | Vector2[]) { _C(this, 12096, v); }
+    set mousePassthroughPolygon(v: PackedVector2Array | (Vector2 | number[])[]) { _C(this, 12096, v); }
 
     /**
      * If `true`, the window is visible.

package/gen/index.ts

@@ -6,6 +6,3 @@ export * from './global-enums.ts';
 export * from './heap-types/index.ts';
 export * from './utility-functions.ts';
 export * from './global-constants.ts';
-
-type VT = typeof import('./value-types/index.ts');
-export type ValueTypes = InstanceType<{ [K in keyof VT]: VT[K] extends new (...args: never) => unknown ? VT[K] : never }[keyof VT]>;