typegpu 0.3.0 → 0.3.1

package/vector-BSez01sn.d.ts

@@ -0,0 +1,961 @@
+/**
+ * Extracts the inferred representation of a resource.
+ * @example
+ * type A = Infer<F32> // => number
+ * type B = Infer<TgpuArray<F32>> // => number[]
+ */
+type Infer<T> = T extends {
+    readonly '~repr': infer TRepr;
+} ? TRepr : T;
+type InferRecord<T extends Record<string | number | symbol, unknown>> = {
+    [Key in keyof T]: Infer<T[Key]>;
+};
+
+interface NumberArrayView {
+    readonly length: number;
+    [n: number]: number;
+}
+interface BaseWgslData {
+    type: string;
+    /** Type-token, not available at runtime */
+    readonly '~repr': unknown;
+}
+interface Swizzle2<T2, T3, T4> {
+    readonly xx: T2;
+    readonly xy: T2;
+    readonly yx: T2;
+    readonly yy: T2;
+    readonly xxx: T3;
+    readonly xxy: T3;
+    readonly xyx: T3;
+    readonly xyy: T3;
+    readonly yxx: T3;
+    readonly yxy: T3;
+    readonly yyx: T3;
+    readonly yyy: T3;
+    readonly xxxx: T4;
+    readonly xxxy: T4;
+    readonly xxyx: T4;
+    readonly xxyy: T4;
+    readonly xyxx: T4;
+    readonly xyxy: T4;
+    readonly xyyx: T4;
+    readonly xyyy: T4;
+    readonly yxxx: T4;
+    readonly yxxy: T4;
+    readonly yxyx: T4;
+    readonly yxyy: T4;
+    readonly yyxx: T4;
+    readonly yyxy: T4;
+    readonly yyyx: T4;
+    readonly yyyy: T4;
+}
+interface Swizzle3<T2, T3, T4> extends Swizzle2<T2, T3, T4> {
+    readonly xz: T2;
+    readonly yz: T2;
+    readonly zx: T2;
+    readonly zy: T2;
+    readonly zz: T2;
+    readonly xxz: T3;
+    readonly xyz: T3;
+    readonly xzx: T3;
+    readonly xzy: T3;
+    readonly xzz: T3;
+    readonly yxz: T3;
+    readonly yyz: T3;
+    readonly yzx: T3;
+    readonly yzy: T3;
+    readonly yzz: T3;
+    readonly zxx: T3;
+    readonly zxy: T3;
+    readonly zxz: T3;
+    readonly zyx: T3;
+    readonly zyy: T3;
+    readonly zyz: T3;
+    readonly zzx: T3;
+    readonly zzy: T3;
+    readonly zzz: T3;
+    readonly xxxz: T4;
+    readonly xxyz: T4;
+    readonly xxzx: T4;
+    readonly xxzy: T4;
+    readonly xxzz: T4;
+    readonly xyxz: T4;
+    readonly xyyz: T4;
+    readonly xyzx: T4;
+    readonly xyzy: T4;
+    readonly xyzz: T4;
+    readonly xzxx: T4;
+    readonly xzxy: T4;
+    readonly xzxz: T4;
+    readonly xzyx: T4;
+    readonly xzyy: T4;
+    readonly xzyz: T4;
+    readonly xzzx: T4;
+    readonly xzzy: T4;
+    readonly xzzz: T4;
+    readonly yxxz: T4;
+    readonly yxyz: T4;
+    readonly yxzx: T4;
+    readonly yxzy: T4;
+    readonly yxzz: T4;
+    readonly yyxz: T4;
+    readonly yyyz: T4;
+    readonly yyzx: T4;
+    readonly yyzy: T4;
+    readonly yyzz: T4;
+    readonly yzxx: T4;
+    readonly yzxy: T4;
+    readonly yzxz: T4;
+    readonly yzyx: T4;
+    readonly yzyy: T4;
+    readonly yzyz: T4;
+    readonly yzzx: T4;
+    readonly yzzy: T4;
+    readonly yzzz: T4;
+    readonly zxxx: T4;
+    readonly zxxy: T4;
+    readonly zxxz: T4;
+    readonly zxyx: T4;
+    readonly zxyy: T4;
+    readonly zxyz: T4;
+    readonly zxzx: T4;
+    readonly zxzy: T4;
+    readonly zxzz: T4;
+    readonly zyxx: T4;
+    readonly zyxy: T4;
+    readonly zyxz: T4;
+    readonly zyyx: T4;
+    readonly zyyy: T4;
+    readonly zyyz: T4;
+    readonly zyzx: T4;
+    readonly zyzy: T4;
+    readonly zyzz: T4;
+    readonly zzxx: T4;
+    readonly zzxy: T4;
+    readonly zzxz: T4;
+    readonly zzyx: T4;
+    readonly zzyy: T4;
+    readonly zzyz: T4;
+    readonly zzzx: T4;
+    readonly zzzy: T4;
+    readonly zzzz: T4;
+}
+interface Swizzle4<T2, T3, T4> extends Swizzle3<T2, T3, T4> {
+    readonly yw: T2;
+    readonly zw: T2;
+    readonly wx: T2;
+    readonly wy: T2;
+    readonly wz: T2;
+    readonly ww: T2;
+    readonly xxw: T3;
+    readonly xyw: T3;
+    readonly xzw: T3;
+    readonly xwx: T3;
+    readonly xwy: T3;
+    readonly xwz: T3;
+    readonly xww: T3;
+    readonly yxw: T3;
+    readonly yyw: T3;
+    readonly yzw: T3;
+    readonly ywx: T3;
+    readonly ywy: T3;
+    readonly ywz: T3;
+    readonly yww: T3;
+    readonly zxw: T3;
+    readonly zyw: T3;
+    readonly zzw: T3;
+    readonly zwx: T3;
+    readonly zwy: T3;
+    readonly zwz: T3;
+    readonly zww: T3;
+    readonly wxx: T3;
+    readonly wxz: T3;
+    readonly wxy: T3;
+    readonly wyy: T3;
+    readonly wyz: T3;
+    readonly wzz: T3;
+    readonly wwx: T3;
+    readonly wwy: T3;
+    readonly wwz: T3;
+    readonly www: T3;
+    readonly xxxw: T4;
+    readonly xxyw: T4;
+    readonly xxzw: T4;
+    readonly xxwx: T4;
+    readonly xxwy: T4;
+    readonly xxwz: T4;
+    readonly xxww: T4;
+    readonly xyxw: T4;
+    readonly xyyw: T4;
+    readonly xyzw: T4;
+    readonly xywx: T4;
+    readonly xywy: T4;
+    readonly xywz: T4;
+    readonly xyww: T4;
+    readonly xzxw: T4;
+    readonly xzyw: T4;
+    readonly xzzw: T4;
+    readonly xzwx: T4;
+    readonly xzwy: T4;
+    readonly xzwz: T4;
+    readonly xzww: T4;
+    readonly xwxx: T4;
+    readonly xwxy: T4;
+    readonly xwxz: T4;
+    readonly xwyy: T4;
+    readonly xwyz: T4;
+    readonly xwzz: T4;
+    readonly xwwx: T4;
+    readonly xwwy: T4;
+    readonly xwwz: T4;
+    readonly xwww: T4;
+    readonly yxxw: T4;
+    readonly yxyw: T4;
+    readonly yxzw: T4;
+    readonly yxwx: T4;
+    readonly yxwy: T4;
+    readonly yxwz: T4;
+    readonly yxww: T4;
+    readonly yyxw: T4;
+    readonly yyyw: T4;
+    readonly yyzw: T4;
+    readonly yywx: T4;
+    readonly yywy: T4;
+    readonly yywz: T4;
+    readonly yyww: T4;
+    readonly yzxw: T4;
+    readonly yzyw: T4;
+    readonly yzzw: T4;
+    readonly yzwx: T4;
+    readonly yzwy: T4;
+    readonly yzwz: T4;
+    readonly yzww: T4;
+    readonly ywxx: T4;
+    readonly ywxy: T4;
+    readonly ywxz: T4;
+    readonly ywxw: T4;
+    readonly ywyy: T4;
+    readonly ywyz: T4;
+    readonly ywzz: T4;
+    readonly ywwx: T4;
+    readonly ywwy: T4;
+    readonly ywwz: T4;
+    readonly ywww: T4;
+    readonly zxxw: T4;
+    readonly zxyw: T4;
+    readonly zxzw: T4;
+    readonly zxwx: T4;
+    readonly zxwy: T4;
+    readonly zxwz: T4;
+    readonly zxww: T4;
+    readonly zyxw: T4;
+    readonly zyyw: T4;
+    readonly zyzw: T4;
+    readonly zywx: T4;
+    readonly zywy: T4;
+    readonly zywz: T4;
+    readonly zyww: T4;
+    readonly zzxw: T4;
+    readonly zzyw: T4;
+    readonly zzzw: T4;
+    readonly zzwx: T4;
+    readonly zzwy: T4;
+    readonly zzwz: T4;
+    readonly zzww: T4;
+    readonly zwxx: T4;
+    readonly zwxy: T4;
+    readonly zwxz: T4;
+    readonly zwxw: T4;
+    readonly zwyy: T4;
+    readonly zwyz: T4;
+    readonly zwzz: T4;
+    readonly zwwx: T4;
+    readonly zwwy: T4;
+    readonly zwwz: T4;
+    readonly zwww: T4;
+    readonly wxxx: T4;
+    readonly wxxy: T4;
+    readonly wxxz: T4;
+    readonly wxxw: T4;
+    readonly wxyx: T4;
+    readonly wxyy: T4;
+    readonly wxyz: T4;
+    readonly wxyw: T4;
+    readonly wxzx: T4;
+    readonly wxzy: T4;
+    readonly wxzz: T4;
+    readonly wxzw: T4;
+    readonly wxwx: T4;
+    readonly wxwy: T4;
+    readonly wxwz: T4;
+    readonly wxww: T4;
+    readonly wyxx: T4;
+    readonly wyxy: T4;
+    readonly wyxz: T4;
+    readonly wyxw: T4;
+    readonly wyyy: T4;
+    readonly wyyz: T4;
+    readonly wyzw: T4;
+    readonly wywx: T4;
+    readonly wywy: T4;
+    readonly wywz: T4;
+    readonly wyww: T4;
+    readonly wzxx: T4;
+    readonly wzxy: T4;
+    readonly wzxz: T4;
+    readonly wzxw: T4;
+    readonly wzyy: T4;
+    readonly wzyz: T4;
+    readonly wzzy: T4;
+    readonly wzzw: T4;
+    readonly wzwx: T4;
+    readonly wzwy: T4;
+    readonly wzwz: T4;
+    readonly wzww: T4;
+    readonly wwxx: T4;
+    readonly wwxy: T4;
+    readonly wwxz: T4;
+    readonly wwxw: T4;
+    readonly wwyy: T4;
+    readonly wwyz: T4;
+    readonly wwzz: T4;
+    readonly wwwx: T4;
+    readonly wwwy: T4;
+    readonly wwwz: T4;
+    readonly wwww: T4;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec2f or vec2<f32>.
+ * A vector with 2 elements of type f32
+ */
+interface v2f extends NumberArrayView, Swizzle2<v2f, v3f, v4f> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec2f';
+    x: number;
+    y: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec2h or vec2<f16>.
+ * A vector with 2 elements of type f16
+ */
+interface v2h extends NumberArrayView, Swizzle2<v2h, v3h, v4h> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec2h';
+    x: number;
+    y: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec2i or vec2<i32>.
+ * A vector with 2 elements of type i32
+ */
+interface v2i extends NumberArrayView, Swizzle2<v2i, v3i, v4i> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec2i';
+    x: number;
+    y: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec2u or vec2<u32>.
+ * A vector with 2 elements of type u32
+ */
+interface v2u extends NumberArrayView, Swizzle2<v2u, v3u, v4u> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec2u';
+    x: number;
+    y: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec3f or vec3<f32>.
+ * A vector with 3 elements of type f32
+ */
+interface v3f extends NumberArrayView, Swizzle3<v2f, v3f, v4f> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec3f';
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec3h or vec3<f16>.
+ * A vector with 3 elements of type f16
+ */
+interface v3h extends NumberArrayView, Swizzle3<v2h, v3h, v4h> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec3h';
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec3i or vec3<i32>.
+ * A vector with 3 elements of type i32
+ */
+interface v3i extends NumberArrayView, Swizzle3<v2i, v3i, v4i> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec3i';
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec3u or vec3<u32>.
+ * A vector with 3 elements of type u32
+ */
+interface v3u extends NumberArrayView, Swizzle3<v2u, v3u, v4u> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec3u';
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec4f or vec4<f32>.
+ * A vector with 4 elements of type f32
+ */
+interface v4f extends NumberArrayView, Swizzle4<v2f, v3f, v4f> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec4f';
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec4h or vec4<f16>.
+ * A vector with 4 elements of type f16
+ */
+interface v4h extends NumberArrayView, Swizzle4<v2h, v3h, v4h> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec4h';
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec4i or vec4<i32>.
+ * A vector with 4 elements of type i32
+ */
+interface v4i extends NumberArrayView, Swizzle4<v2i, v3i, v4i> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec4i';
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/**
+ * Interface representing its WGSL vector type counterpart: vec4u or vec4<u32>.
+ * A vector with 4 elements of type u32
+ */
+interface v4u extends NumberArrayView, Swizzle4<v2u, v3u, v4u> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec4u';
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+type AnyVecInstance = v2f | v2h | v2i | v2u | v3f | v3h | v3i | v3u | v4f | v4h | v4i | v4u;
+interface matBase<TColumn> extends NumberArrayView {
+    readonly columns: readonly TColumn[];
+}
+/**
+ * Interface representing its WGSL matrix type counterpart: mat2x2
+ * A matrix with 2 rows and 2 columns, with elements of type `TColumn`
+ */
+interface mat2x2<TColumn> extends matBase<TColumn> {
+    readonly length: 4;
+    readonly kind: string;
+    [n: number]: number;
+}
+/**
+ * Interface representing its WGSL matrix type counterpart: mat2x2f or mat2x2<f32>
+ * A matrix with 2 rows and 2 columns, with elements of type d.f32
+ */
+interface m2x2f extends mat2x2<v2f> {
+    readonly kind: 'mat2x2f';
+}
+/**
+ * Interface representing its WGSL matrix type counterpart: mat3x3
+ * A matrix with 3 rows and 3 columns, with elements of type `TColumn`
+ */
+interface mat3x3<TColumn> extends matBase<TColumn> {
+    readonly length: 12;
+    readonly kind: string;
+    [n: number]: number;
+}
+/**
+ * Interface representing its WGSL matrix type counterpart: mat3x3f or mat3x3<f32>
+ * A matrix with 3 rows and 3 columns, with elements of type d.f32
+ */
+interface m3x3f extends mat3x3<v3f> {
+    readonly kind: 'mat3x3f';
+}
+/**
+ * Interface representing its WGSL matrix type counterpart: mat4x4
+ * A matrix with 4 rows and 4 columns, with elements of type `TColumn`
+ */
+interface mat4x4<TColumn> extends matBase<TColumn> {
+    readonly length: 16;
+    readonly kind: string;
+    [n: number]: number;
+}
+/**
+ * Interface representing its WGSL matrix type counterpart: mat4x4f or mat4x4<f32>
+ * A matrix with 4 rows and 4 columns, with elements of type d.f32
+ */
+interface m4x4f extends mat4x4<v4f> {
+    readonly kind: 'mat4x4f';
+}
+type AnyMatInstance = m2x2f | m3x3f | m4x4f;
+/**
+ * Boolean schema representing a single WGSL bool value.
+ * Cannot be used inside buffers as it is not host-shareable.
+ */
+interface Bool {
+    readonly type: 'bool';
+    readonly '~repr': boolean;
+}
+interface F32 {
+    readonly type: 'f32';
+    /** Type-token, not available at runtime */
+    readonly '~repr': number;
+}
+interface F16 {
+    readonly type: 'f16';
+    /** Type-token, not available at runtime */
+    readonly '~repr': number;
+}
+interface I32 {
+    readonly type: 'i32';
+    /** Type-token, not available at runtime */
+    readonly '~repr': number;
+}
+interface U32 {
+    readonly type: 'u32';
+    /** Type-token, not available at runtime */
+    readonly '~repr': number;
+}
+interface Vec2f {
+    readonly type: 'vec2f';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v2f;
+}
+interface Vec2h {
+    readonly type: 'vec2h';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v2h;
+}
+interface Vec2i {
+    readonly type: 'vec2i';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v2i;
+}
+interface Vec2u {
+    readonly type: 'vec2u';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v2u;
+}
+interface Vec3f {
+    readonly type: 'vec3f';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v3f;
+}
+interface Vec3h {
+    readonly type: 'vec3h';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v3h;
+}
+interface Vec3i {
+    readonly type: 'vec3i';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v3i;
+}
+interface Vec3u {
+    readonly type: 'vec3u';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v3u;
+}
+interface Vec4f {
+    readonly type: 'vec4f';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v4f;
+}
+interface Vec4h {
+    readonly type: 'vec4h';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v4h;
+}
+interface Vec4i {
+    readonly type: 'vec4i';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v4i;
+}
+interface Vec4u {
+    readonly type: 'vec4u';
+    /** Type-token, not available at runtime */
+    readonly '~repr': v4u;
+}
+interface Mat2x2f {
+    readonly type: 'mat2x2f';
+    /** Type-token, not available at runtime */
+    readonly '~repr': m2x2f;
+}
+interface Mat3x3f {
+    readonly type: 'mat3x3f';
+    /** Type-token, not available at runtime */
+    readonly '~repr': m3x3f;
+}
+interface Mat4x4f {
+    readonly type: 'mat4x4f';
+    /** Type-token, not available at runtime */
+    readonly '~repr': m4x4f;
+}
+interface WgslStruct<TProps extends Record<string, BaseWgslData> = Record<string, BaseWgslData>> {
+    readonly type: 'struct';
+    readonly label?: string | undefined;
+    readonly propTypes: TProps;
+    /** Type-token, not available at runtime */
+    readonly '~repr': InferRecord<TProps>;
+}
+interface WgslArray<TElement = BaseWgslData> {
+    readonly type: 'array';
+    readonly elementCount: number;
+    readonly elementType: TElement;
+    /** Type-token, not available at runtime */
+    readonly '~repr': Infer<TElement>[];
+}
+/**
+ * Schema representing the `atomic<...>` WGSL data type.
+ */
+interface Atomic<TInner extends U32 | I32 = U32 | I32> {
+    readonly type: 'atomic';
+    readonly inner: TInner;
+    /** Type-token, not available at runtime */
+    readonly '~repr': Infer<TInner>;
+}
+interface Align<T extends number> {
+    readonly type: '@align';
+    readonly value: T;
+}
+interface Size<T extends number> {
+    readonly type: '@size';
+    readonly value: T;
+}
+interface Location<T extends number> {
+    readonly type: '@location';
+    readonly value: T;
+}
+type PerspectiveOrLinearInterpolationType = `${'perspective' | 'linear'}${'' | ', center' | ', centroid' | ', sample'}`;
+type FlatInterpolationType = `flat${'' | ', first' | ', either'}`;
+type InterpolationType = PerspectiveOrLinearInterpolationType | FlatInterpolationType;
+interface Interpolate<T extends InterpolationType> {
+    readonly type: '@interpolate';
+    readonly value: T;
+}
+interface Builtin<T extends string> {
+    readonly type: '@builtin';
+    readonly value: T;
+}
+interface Decorated<TInner extends BaseWgslData = BaseWgslData, TAttribs extends unknown[] = unknown[]> {
+    readonly type: 'decorated';
+    readonly inner: TInner;
+    readonly attribs: TAttribs;
+    /** Type-token, not available at runtime */
+    readonly '~repr': Infer<TInner>;
+}
+declare const wgslTypeLiterals: readonly ["bool", "f32", "f16", "i32", "u32", "vec2f", "vec2h", "vec2i", "vec2u", "vec3f", "vec3h", "vec3i", "vec3u", "vec4f", "vec4h", "vec4i", "vec4u", "mat2x2f", "mat3x3f", "mat4x4f", "struct", "array", "atomic", "decorated"];
+type WgslTypeLiteral = (typeof wgslTypeLiterals)[number];
+type PerspectiveOrLinearInterpolatableData = F32 | F16 | Vec2f | Vec2h | Vec3f | Vec3h | Vec4f | Vec4h;
+type FlatInterpolatableData = PerspectiveOrLinearInterpolatableData | I32 | U32 | Vec2i | Vec2u | Vec3i | Vec3u | Vec4i | Vec4u;
+type AnyWgslData = Bool | F32 | F16 | I32 | U32 | Vec2f | Vec2h | Vec2i | Vec2u | Vec3f | Vec3h | Vec3i | Vec3u | Vec4f | Vec4h | Vec4i | Vec4u | Mat2x2f | Mat3x3f | Mat4x4f | WgslStruct | WgslArray | Atomic | Decorated;
+declare function isWgslData(value: unknown): value is AnyWgslData;
+/**
+ * Checks whether passed in value is an array schema,
+ * as opposed to, e.g., a disarray schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas disarray schemas cannot.
+ *
+ * @example
+ * isWgslArray(d.arrayOf(d.u32, 4)) // true
+ * isWgslArray(d.disarray(d.u32, 4)) // false
+ * isWgslArray(d.vec3f) // false
+ */
+declare function isWgslArray<T extends WgslArray>(schema: T | unknown): schema is T;
+/**
+ * Checks whether passed in value is a struct schema,
+ * as opposed to, e.g., an unstruct schema.
+ *
+ * Struct schemas can be used to describe uniform and storage buffers,
+ * whereas unstruct schemas cannot.
+ *
+ * @example
+ * isWgslStruct(d.struct({ a: d.u32 })) // true
+ * isWgslStruct(d.unstruct({ a: d.u32 })) // false
+ * isWgslStruct(d.vec3f) // false
+ */
+declare function isWgslStruct<T extends WgslStruct>(schema: T | unknown): schema is T;
+/**
+ * Checks whether the passed in value is an atomic schema.
+ *
+ * @example
+ * isAtomic(d.atomic(d.u32)) // true
+ * isAtomic(d.u32) // false
+ */
+declare function isAtomic<T extends Atomic<U32 | I32>>(schema: T | unknown): schema is T;
+declare function isAlignAttrib<T extends Align<number>>(value: unknown | T): value is T;
+declare function isSizeAttrib<T extends Size<number>>(value: unknown | T): value is T;
+declare function isLocationAttrib<T extends Location<number>>(value: unknown | T): value is T;
+declare function isInterpolateAttrib<T extends Interpolate<InterpolationType>>(value: unknown | T): value is T;
+declare function isBuiltinAttrib<T extends Builtin<string>>(value: unknown | T): value is T;
+declare function isDecorated<T extends Decorated>(value: unknown | T): value is T;
+
+/**
+ * Type encompassing all available kinds of vector.
+ */
+type VecKind = 'vec2f' | 'vec2i' | 'vec2u' | 'vec2h' | 'vec3f' | 'vec3i' | 'vec3u' | 'vec3h' | 'vec4f' | 'vec4i' | 'vec4u' | 'vec4h';
+/**
+ * Type of the `d.vec2f` object/function: vector data type schema/constructor
+ */
+type NativeVec2f = Vec2f & {
+    '~exotic': Vec2f;
+} & ((x: number, y: number) => v2f) & ((xy: number) => v2f) & (() => v2f);
+/**
+ *
+ * Schema representing vec2f - a vector with 2 elements of type f32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2f(); // (0.0, 0.0)
+ * const vector = d.vec2f(1); // (1.0, 1.0)
+ * const vector = d.vec2f(0.5, 0.1); // (0.5, 0.1)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2f, d.vec2f(0, 1)); // buffer holding a d.vec2f value, with an initial value of vec2f(0, 1);
+ */
+declare const vec2f: NativeVec2f;
+/**
+ * Type of the `d.vec2h` object/function: vector data type schema/constructor
+ */
+type NativeVec2h = Vec2h & {
+    '~exotic': Vec2h;
+} & ((x: number, y: number) => v2h) & ((xy: number) => v2h) & (() => v2h);
+/**
+ *
+ * Schema representing vec2h - a vector with 2 elements of type f16.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2h(); // (0.0, 0.0)
+ * const vector = d.vec2h(1); // (1.0, 1.0)
+ * const vector = d.vec2h(0.5, 0.1); // (0.5, 0.1)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2h, d.vec2h(0, 1)); // buffer holding a d.vec2h value, with an initial value of vec2h(0, 1);
+ */
+declare const vec2h: NativeVec2h;
+/**
+ * Type of the `d.vec2i` object/function: vector data type schema/constructor
+ */
+type NativeVec2i = Vec2i & {
+    '~exotic': Vec2i;
+} & ((x: number, y: number) => v2i) & ((xy: number) => v2i) & (() => v2i);
+/**
+ *
+ * Schema representing vec2i - a vector with 2 elements of type i32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2i(); // (0, 0)
+ * const vector = d.vec2i(1); // (1, 1)
+ * const vector = d.vec2i(-1, 1); // (-1, 1)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2i, d.vec2i(0, 1)); // buffer holding a d.vec2i value, with an initial value of vec2i(0, 1);
+ */
+declare const vec2i: NativeVec2i;
+/**
+ * Type of the `d.vec2u` object/function: vector data type schema/constructor
+ */
+type NativeVec2u = Vec2u & {
+    '~exotic': Vec2u;
+} & ((x: number, y: number) => v2u) & ((xy: number) => v2u) & (() => v2u);
+/**
+ *
+ * Schema representing vec2u - a vector with 2 elements of type u32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec2u(); // (0, 0)
+ * const vector = d.vec2u(1); // (1, 1)
+ * const vector = d.vec2u(1, 2); // (1, 2)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec2u, d.vec2u(0, 1)); // buffer holding a d.vec2u value, with an initial value of vec2u(0, 1);
+ */
+declare const vec2u: NativeVec2u;
+/**
+ * Type of the `d.vec3f` object/function: vector data type schema/constructor
+ */
+type NativeVec3f = Vec3f & {
+    '~exotic': Vec3f;
+} & ((x: number, y: number, z: number) => v3f) & ((xyz: number) => v3f) & (() => v3f);
+/**
+ *
+ * Schema representing vec3f - a vector with 3 elements of type f32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3f(); // (0.0, 0.0, 0.0)
+ * const vector = d.vec3f(1); // (1.0, 1.0, 1.0)
+ * const vector = d.vec3f(1, 2, 3.5); // (1.0, 2.0, 3.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3f, d.vec3f(0, 1, 2)); // buffer holding a d.vec3f value, with an initial value of vec3f(0, 1, 2);
+ */
+declare const vec3f: NativeVec3f;
+/**
+ * Type of the `d.vec3h` object/function: vector data type schema/constructor
+ */
+type NativeVec3h = Vec3h & {
+    '~exotic': Vec3h;
+} & ((x: number, y: number, z: number) => v3h) & ((xyz: number) => v3h) & (() => v3h);
+/**
+ *
+ * Schema representing vec3h - a vector with 3 elements of type f16.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3h(); // (0.0, 0.0, 0.0)
+ * const vector = d.vec3h(1); // (1.0, 1.0, 1.0)
+ * const vector = d.vec3h(1, 2, 3.5); // (1.0, 2.0, 3.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3h, d.vec3h(0, 1, 2)); // buffer holding a d.vec3h value, with an initial value of vec3h(0, 1, 2);
+ */
+declare const vec3h: NativeVec3h;
+/**
+ * Type of the `d.vec3i` object/function: vector data type schema/constructor
+ */
+type NativeVec3i = Vec3i & {
+    '~exotic': Vec3i;
+} & ((x: number, y: number, z: number) => v3i) & ((xyz: number) => v3i) & (() => v3i);
+/**
+ *
+ * Schema representing vec3i - a vector with 3 elements of type i32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3i(); // (0, 0, 0)
+ * const vector = d.vec3i(1); // (1, 1, 1)
+ * const vector = d.vec3i(1, 2, -3); // (1, 2, -3)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3i, d.vec3i(0, 1, 2)); // buffer holding a d.vec3i value, with an initial value of vec3i(0, 1, 2);
+ */
+declare const vec3i: NativeVec3i;
+/**
+ * Type of the `d.vec3u` object/function: vector data type schema/constructor
+ */
+type NativeVec3u = Vec3u & {
+    '~exotic': Vec3u;
+} & ((x: number, y: number, z: number) => v3u) & ((xyz: number) => v3u) & (() => v3u);
+/**
+ *
+ * Schema representing vec3u - a vector with 3 elements of type u32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec3u(); // (0, 0, 0)
+ * const vector = d.vec3u(1); // (1, 1, 1)
+ * const vector = d.vec3u(1, 2, 3); // (1, 2, 3)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec3u, d.vec3u(0, 1, 2)); // buffer holding a d.vec3u value, with an initial value of vec3u(0, 1, 2);
+ */
+declare const vec3u: NativeVec3u;
+/**
+ * Type of the `d.vec4f` object/function: vector data type schema/constructor
+ */
+type NativeVec4f = Vec4f & {
+    '~exotic': Vec4f;
+} & ((x: number, y: number, z: number, w: number) => v4f) & ((xyzw: number) => v4f) & (() => v4f);
+/**
+ *
+ * Schema representing vec4f - a vector with 4 elements of type f32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4f(); // (0.0, 0.0, 0.0, 0.0)
+ * const vector = d.vec4f(1); // (1.0, 1.0, 1.0, 1.0)
+ * const vector = d.vec4f(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4f, d.vec4f(0, 1, 2, 3)); // buffer holding a d.vec4f value, with an initial value of vec4f(0, 1, 2, 3);
+ */
+declare const vec4f: NativeVec4f;
+/**
+ * Type of the `d.vec4h` object/function: vector data type schema/constructor
+ */
+type NativeVec4h = Vec4h & {
+    '~exotic': Vec4h;
+} & ((x: number, y: number, z: number, w: number) => v4h) & ((xyzw: number) => v4h) & (() => v4h);
+/**
+ *
+ * Schema representing vec4h - a vector with 4 elements of type f16.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4h(); // (0.0, 0.0, 0.0, 0.0)
+ * const vector = d.vec4h(1); // (1.0, 1.0, 1.0, 1.0)
+ * const vector = d.vec4h(1, 2, 3, 4.5); // (1.0, 2.0, 3.0, 4.5)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4h, d.vec4h(0, 1, 2, 3)); // buffer holding a d.vec4h value, with an initial value of vec4h(0, 1, 2, 3);
+ */
+declare const vec4h: NativeVec4h;
+/**
+ * Type of the `d.vec4i` object/function: vector data type schema/constructor
+ */
+type NativeVec4i = Vec4i & {
+    '~exotic': Vec4i;
+} & ((x: number, y: number, z: number, w: number) => v4i) & ((xyzw: number) => v4i) & (() => v4i);
+/**
+ *
+ * Schema representing vec4i - a vector with 4 elements of type i32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4i(); // (0, 0, 0, 0)
+ * const vector = d.vec4i(1); // (1, 1, 1, 1)
+ * const vector = d.vec4i(1, 2, 3, -4); // (1, 2, 3, -4)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4i, d.vec4i(0, 1, 2, 3)); // buffer holding a d.vec4i value, with an initial value of vec4i(0, 1, 2, 3);
+ */
+declare const vec4i: NativeVec4i;
+/**
+ * Type of the `d.vec4u` object/function: vector data type schema/constructor
+ */
+type NativeVec4u = Vec4u & {
+    '~exotic': Vec4u;
+} & ((x: number, y: number, z: number, w: number) => v4u) & ((xyzw: number) => v4u) & (() => v4u);
+/**
+ *
+ * Schema representing vec4u - a vector with 4 elements of type u32.
+ * Also a constructor function for this vector value.
+ *
+ * @example
+ * const vector = d.vec4u(); // (0, 0, 0, 0)
+ * const vector = d.vec4u(1); // (1, 1, 1, 1)
+ * const vector = d.vec4u(1, 2, 3, 4); // (1, 2, 3, 4)
+ *
+ * @example
+ * const buffer = root.createBuffer(d.vec4u, d.vec4u(0, 1, 2, 3)); // buffer holding a d.vec4u value, with an initial value of vec4u(0, 1, 2, 3);
+ */
+declare const vec4u: NativeVec4u;
+
+export { type PerspectiveOrLinearInterpolatableData as $, type AnyWgslData as A, type BaseWgslData as B, type NativeVec3i as C, type Decorated as D, type InferRecord as E, type F32 as F, type m2x2f as G, type m3x3f as H, type Infer as I, type m4x4f as J, type v2f as K, type Location as L, type Mat2x2f as M, type NativeVec2u as N, type Mat3x3f as O, type v3f as P, type Mat4x4f as Q, type v4f as R, type Atomic as S, type Align as T, type U32 as U, type Vec2f as V, type WgslArray as W, type Size as X, type Interpolate as Y, type InterpolationType as Z, type PerspectiveOrLinearInterpolationType as _, type F16 as a, type FlatInterpolationType as a0, type FlatInterpolatableData as a1, isWgslData as a2, isWgslArray as a3, isWgslStruct as a4, isAtomic as a5, isDecorated as a6, isAlignAttrib as a7, isBuiltinAttrib as a8, isLocationAttrib as a9, isInterpolateAttrib as aa, isSizeAttrib as ab, type v2i as ac, type v2u as ad, type v3i as ae, type v3u as af, type v4i as ag, type v4u as ah, vec2f as ai, vec2h as aj, vec2i as ak, vec2u as al, vec3f as am, vec3h as an, vec3i as ao, vec3u as ap, vec4f as aq, vec4h as ar, vec4i as as, vec4u as at, type VecKind as au, type I32 as b, type Vec3f as c, type Vec4f as d, type Vec2h as e, type Vec3h as f, type Vec4h as g, type Vec2i as h, type Vec3i as i, type Vec4i as j, type Vec2u as k, type Vec3u as l, type Vec4u as m, type WgslStruct as n, type WgslTypeLiteral as o, type AnyVecInstance as p, type AnyMatInstance as q, type Builtin as r, type Bool as s, type NativeVec4u as t, type NativeVec2i as u, type NativeVec4i as v, type NativeVec2f as w, type NativeVec4f as x, type NativeVec3f as y, type NativeVec3u as z };