typegpu 0.5.3 → 0.5.5

package/{wgslTypes-VtSRoe90.d.ts → dataTypes-ts2Ccted.d.cts}

@@ -6,299 +6,7 @@ interface TgpuNamable {
     $name(label?: string | undefined): this;
 }
 
-type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-/**
- * Removes properties from record type that extend `Prop`
- */
-type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, {
-    [Key in keyof T]: T[Key] extends Prop ? never : Key;
-}[keyof T]>;
-/**
- * The opposite of Readonly<T>
- */
-type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-
-declare const vertexFormats: readonly ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
-type VertexFormat = (typeof vertexFormats)[number];
-declare const kindToDefaultFormatMap: {
-    readonly f32: "float32";
-    readonly vec2f: "float32x2";
-    readonly vec3f: "float32x3";
-    readonly vec4f: "float32x4";
-    readonly f16: "float16";
-    readonly vec2h: "float16x2";
-    readonly vec4h: "float16x4";
-    readonly u32: "uint32";
-    readonly vec2u: "uint32x2";
-    readonly vec3u: "uint32x3";
-    readonly vec4u: "uint32x4";
-    readonly i32: "sint32";
-    readonly vec2i: "sint32x2";
-    readonly vec3i: "sint32x3";
-    readonly vec4i: "sint32x4";
-};
-type KindToDefaultFormatMap = typeof kindToDefaultFormatMap;
-interface TgpuVertexAttrib<TFormat extends VertexFormat = VertexFormat> {
-    readonly format: TFormat;
-    readonly offset: number;
-}
-/**
- * All vertex attribute formats that can be interpreted as
- * an single or multi component u32 in a shader.
- * https://www.w3.org/TR/webgpu/#vertex-formats
- */
-type U32CompatibleFormats = TgpuVertexAttrib<'uint8'> | TgpuVertexAttrib<'uint8x2'> | TgpuVertexAttrib<'uint8x4'> | TgpuVertexAttrib<'uint16'> | TgpuVertexAttrib<'uint16x2'> | TgpuVertexAttrib<'uint16x4'> | TgpuVertexAttrib<'uint32'> | TgpuVertexAttrib<'uint32x2'> | TgpuVertexAttrib<'uint32x3'> | TgpuVertexAttrib<'uint32x4'>;
-/**
- * All vertex attribute formats that can be interpreted as
- * an single or multi component i32 in a shader.
- * https://www.w3.org/TR/webgpu/#vertex-formats
- */
-type I32CompatibleFormats = TgpuVertexAttrib<'sint8'> | TgpuVertexAttrib<'sint8x2'> | TgpuVertexAttrib<'sint8x4'> | TgpuVertexAttrib<'sint16'> | TgpuVertexAttrib<'sint16x2'> | TgpuVertexAttrib<'sint16x4'> | TgpuVertexAttrib<'sint32'> | TgpuVertexAttrib<'sint32x2'> | TgpuVertexAttrib<'sint32x3'> | TgpuVertexAttrib<'sint32x4'>;
-/**
- * All vertex attribute formats that can be interpreted as
- * an single or multi component f32 in a shader.
- * https://www.w3.org/TR/webgpu/#vertex-formats
- */
-type F32CompatibleFormats = TgpuVertexAttrib<'unorm8'> | TgpuVertexAttrib<'unorm8x2'> | TgpuVertexAttrib<'unorm8x4'> | TgpuVertexAttrib<'snorm8'> | TgpuVertexAttrib<'snorm8x2'> | TgpuVertexAttrib<'snorm8x4'> | TgpuVertexAttrib<'unorm16'> | TgpuVertexAttrib<'unorm16x2'> | TgpuVertexAttrib<'unorm16x4'> | TgpuVertexAttrib<'snorm16'> | TgpuVertexAttrib<'snorm16x2'> | TgpuVertexAttrib<'snorm16x4'> | TgpuVertexAttrib<'float16'> | TgpuVertexAttrib<'float16x2'> | TgpuVertexAttrib<'float16x4'> | TgpuVertexAttrib<'float32'> | TgpuVertexAttrib<'float32x2'> | TgpuVertexAttrib<'float32x3'> | TgpuVertexAttrib<'float32x4'> | TgpuVertexAttrib<'unorm10-10-10-2'> | TgpuVertexAttrib<'unorm8x4-bgra'>;
-/**
- * All vertex attribute formats that can be interpreted as
- * a single or multi component f16 in a shader. (same as f32 on the shader side)
- * https://www.w3.org/TR/webgpu/#vertex-formats
- */
-type F16CompatibleFormats = F32CompatibleFormats;
-type KindToAcceptedAttribMap = {
-    u32: U32CompatibleFormats;
-    vec2u: U32CompatibleFormats;
-    vec3u: U32CompatibleFormats;
-    vec4u: U32CompatibleFormats;
-    i32: I32CompatibleFormats;
-    vec2i: I32CompatibleFormats;
-    vec3i: I32CompatibleFormats;
-    vec4i: I32CompatibleFormats;
-    f16: F16CompatibleFormats;
-    vec2h: F16CompatibleFormats;
-    vec3h: F16CompatibleFormats;
-    vec4h: F16CompatibleFormats;
-    f32: F32CompatibleFormats;
-    vec2f: F32CompatibleFormats;
-    vec3f: F32CompatibleFormats;
-    vec4f: F32CompatibleFormats;
-};
-
-type FormatToWGSLType<T extends VertexFormat> = (typeof formatToWGSLType)[T];
-interface TgpuVertexFormatData<T extends VertexFormat> {
-    readonly '~repr': Infer<FormatToWGSLType<T>>;
-    readonly type: T;
-}
-declare const formatToWGSLType: {
-    readonly uint8: U32;
-    readonly uint8x2: Vec2u;
-    readonly uint8x4: Vec4u;
-    readonly sint8: I32;
-    readonly sint8x2: Vec2i;
-    readonly sint8x4: Vec4i;
-    readonly unorm8: F32;
-    readonly unorm8x2: Vec2f;
-    readonly unorm8x4: Vec4f;
-    readonly snorm8: F32;
-    readonly snorm8x2: Vec2f;
-    readonly snorm8x4: Vec4f;
-    readonly uint16: U32;
-    readonly uint16x2: Vec2u;
-    readonly uint16x4: Vec4u;
-    readonly sint16: I32;
-    readonly sint16x2: Vec2i;
-    readonly sint16x4: Vec4i;
-    readonly unorm16: F32;
-    readonly unorm16x2: Vec2f;
-    readonly unorm16x4: Vec4f;
-    readonly snorm16: F32;
-    readonly snorm16x2: Vec2f;
-    readonly snorm16x4: Vec4f;
-    readonly float16: F32;
-    readonly float16x2: Vec2f;
-    readonly float16x4: Vec4f;
-    readonly float32: F32;
-    readonly float32x2: Vec2f;
-    readonly float32x3: Vec3f;
-    readonly float32x4: Vec4f;
-    readonly uint32: U32;
-    readonly uint32x2: Vec2u;
-    readonly uint32x3: Vec3u;
-    readonly uint32x4: Vec4u;
-    readonly sint32: I32;
-    readonly sint32x2: Vec2i;
-    readonly sint32x3: Vec3i;
-    readonly sint32x4: Vec4i;
-    readonly 'unorm10-10-10-2': Vec4f;
-    readonly 'unorm8x4-bgra': Vec4f;
-};
-declare const packedFormats: string[];
-type uint8 = TgpuVertexFormatData<'uint8'>;
-declare const uint8: uint8;
-type uint8x2 = TgpuVertexFormatData<'uint8x2'>;
-declare const uint8x2: uint8x2;
-type uint8x4 = TgpuVertexFormatData<'uint8x4'>;
-declare const uint8x4: uint8x4;
-type sint8 = TgpuVertexFormatData<'sint8'>;
-declare const sint8: sint8;
-type sint8x2 = TgpuVertexFormatData<'sint8x2'>;
-declare const sint8x2: sint8x2;
-type sint8x4 = TgpuVertexFormatData<'sint8x4'>;
-declare const sint8x4: sint8x4;
-type unorm8 = TgpuVertexFormatData<'unorm8'>;
-declare const unorm8: unorm8;
-type unorm8x2 = TgpuVertexFormatData<'unorm8x2'>;
-declare const unorm8x2: unorm8x2;
-type unorm8x4 = TgpuVertexFormatData<'unorm8x4'>;
-declare const unorm8x4: unorm8x4;
-type snorm8 = TgpuVertexFormatData<'snorm8'>;
-declare const snorm8: snorm8;
-type snorm8x2 = TgpuVertexFormatData<'snorm8x2'>;
-declare const snorm8x2: snorm8x2;
-type snorm8x4 = TgpuVertexFormatData<'snorm8x4'>;
-declare const snorm8x4: snorm8x4;
-type uint16 = TgpuVertexFormatData<'uint16'>;
-declare const uint16: uint16;
-type uint16x2 = TgpuVertexFormatData<'uint16x2'>;
-declare const uint16x2: uint16x2;
-type uint16x4 = TgpuVertexFormatData<'uint16x4'>;
-declare const uint16x4: uint16x4;
-type sint16 = TgpuVertexFormatData<'sint16'>;
-declare const sint16: sint16;
-type sint16x2 = TgpuVertexFormatData<'sint16x2'>;
-declare const sint16x2: sint16x2;
-type sint16x4 = TgpuVertexFormatData<'sint16x4'>;
-declare const sint16x4: sint16x4;
-type unorm16 = TgpuVertexFormatData<'unorm16'>;
-declare const unorm16: unorm16;
-type unorm16x2 = TgpuVertexFormatData<'unorm16x2'>;
-declare const unorm16x2: unorm16x2;
-type unorm16x4 = TgpuVertexFormatData<'unorm16x4'>;
-declare const unorm16x4: unorm16x4;
-type snorm16 = TgpuVertexFormatData<'snorm16'>;
-declare const snorm16: snorm16;
-type snorm16x2 = TgpuVertexFormatData<'snorm16x2'>;
-declare const snorm16x2: snorm16x2;
-type snorm16x4 = TgpuVertexFormatData<'snorm16x4'>;
-declare const snorm16x4: snorm16x4;
-type float16 = TgpuVertexFormatData<'float16'>;
-declare const float16: float16;
-type float16x2 = TgpuVertexFormatData<'float16x2'>;
-declare const float16x2: float16x2;
-type float16x4 = TgpuVertexFormatData<'float16x4'>;
-declare const float16x4: float16x4;
-type float32 = TgpuVertexFormatData<'float32'>;
-declare const float32: float32;
-type float32x2 = TgpuVertexFormatData<'float32x2'>;
-declare const float32x2: float32x2;
-type float32x3 = TgpuVertexFormatData<'float32x3'>;
-declare const float32x3: float32x3;
-type float32x4 = TgpuVertexFormatData<'float32x4'>;
-declare const float32x4: float32x4;
-type uint32 = TgpuVertexFormatData<'uint32'>;
-declare const uint32: uint32;
-type uint32x2 = TgpuVertexFormatData<'uint32x2'>;
-declare const uint32x2: uint32x2;
-type uint32x3 = TgpuVertexFormatData<'uint32x3'>;
-declare const uint32x3: uint32x3;
-type uint32x4 = TgpuVertexFormatData<'uint32x4'>;
-declare const uint32x4: uint32x4;
-type sint32 = TgpuVertexFormatData<'sint32'>;
-declare const sint32: sint32;
-type sint32x2 = TgpuVertexFormatData<'sint32x2'>;
-declare const sint32x2: sint32x2;
-type sint32x3 = TgpuVertexFormatData<'sint32x3'>;
-declare const sint32x3: sint32x3;
-type sint32x4 = TgpuVertexFormatData<'sint32x4'>;
-declare const sint32x4: sint32x4;
-type unorm10_10_10_2 = TgpuVertexFormatData<'unorm10-10-10-2'>;
-declare const unorm10_10_10_2: unorm10_10_10_2;
-type unorm8x4_bgra = TgpuVertexFormatData<'unorm8x4-bgra'>;
-declare const unorm8x4_bgra: unorm8x4_bgra;
-type PackedData = uint8 | uint8x2 | uint8x4 | sint8 | sint8x2 | sint8x4 | unorm8 | unorm8x2 | unorm8x4 | snorm8 | snorm8x2 | snorm8x4 | uint16 | uint16x2 | uint16x4 | sint16 | sint16x2 | sint16x4 | unorm16 | unorm16x2 | unorm16x4 | snorm16 | snorm16x2 | snorm16x4 | float16 | float16x2 | float16x4 | float32 | float32x2 | float32x3 | float32x4 | uint32 | uint32x2 | uint32x3 | uint32x4 | sint32 | sint32x2 | sint32x3 | sint32x4 | unorm10_10_10_2 | unorm8x4_bgra;
-
-/**
- * Array schema constructed via `d.disarrayOf` function.
- *
- * Useful for defining vertex buffers.
- * Elements in the schema are not aligned in respect to their `byteAlignment`,
- * unless they are explicitly decorated with the custom align attribute
- * via `d.align` function.
- */
-interface Disarray<TElement extends BaseData = BaseData> {
-    readonly type: 'disarray';
-    readonly elementCount: number;
-    readonly elementType: TElement;
-    readonly '~repr': Infer<TElement>[];
-    readonly '~reprPartial': {
-        idx: number;
-        value: InferPartial<TElement>;
-    }[];
-}
-/**
- * Struct schema constructed via `d.unstruct` function.
- *
- * Useful for defining vertex buffers, as the standard layout restrictions do not apply.
- * Members are not aligned in respect to their `byteAlignment`,
- * unless they are explicitly decorated with the custom align attribute
- * via `d.align` function.
- */
-interface Unstruct<TProps extends Record<string, BaseData> = Record<string, BaseData>> extends TgpuNamable {
-    readonly label?: string | undefined;
-    readonly type: 'unstruct';
-    readonly propTypes: TProps;
-    readonly '~repr': Prettify<InferRecord<TProps>>;
-    readonly '~reprPartial': Prettify<Partial<InferPartialRecord<TProps>>>;
-}
-interface LooseDecorated<TInner extends BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
-    readonly type: 'loose-decorated';
-    readonly inner: TInner;
-    readonly attribs: TAttribs;
-    readonly '~repr': Infer<TInner>;
-}
-declare const looseTypeLiterals: readonly ["unstruct", "disarray", "loose-decorated", "uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
-type LooseTypeLiteral = (typeof looseTypeLiterals)[number];
-type AnyLooseData = Disarray | Unstruct | LooseDecorated | PackedData;
-declare function isLooseData(data: unknown): data is AnyLooseData;
-/**
- * Checks whether the passed in value is a disarray schema,
- * as opposed to, e.g., a regular array schema.
- *
- * Array schemas can be used to describe uniform and storage buffers,
- * whereas disarray schemas cannot. Disarrays are useful for
- * defining vertex buffers instead.
- *
- * @example
- * isDisarray(d.arrayOf(d.u32, 4)) // false
- * isDisarray(d.disarrayOf(d.u32, 4)) // true
- * isDisarray(d.vec3f) // false
- */
-declare function isDisarray<T extends Disarray>(schema: T | unknown): schema is T;
-/**
- * Checks whether passed in value is a unstruct schema,
- * as opposed to, e.g., a struct schema.
- *
- * Struct schemas can be used to describe uniform and storage buffers,
- * whereas unstruct schemas cannot. Unstructs are useful for
- * defining vertex buffers instead.
- *
- * @example
- * isUnstruct(d.struct({ a: d.u32 })) // false
- * isUnstruct(d.unstruct({ a: d.u32 })) // true
- * isUnstruct(d.vec3f) // false
- */
-declare function isUnstruct<T extends Unstruct>(schema: T | unknown): schema is T;
-declare function isLooseDecorated<T extends LooseDecorated>(value: T | unknown): value is T;
-declare function isData(value: unknown): value is AnyData;
-type AnyData = AnyWgslData | AnyLooseData;
-
+declare const $repr: unique symbol;
 /**
  * Extracts the inferred representation of a resource.
  * @example
@@ -306,12 +14,12 @@ type AnyData = AnyWgslData | AnyLooseData;
  * type B = Infer<WgslArray<F32>> // => number[]
  */
 type Infer<T> = T extends {
-    readonly '~repr': infer TRepr;
+    readonly [$repr]: infer TRepr;
 } ? TRepr : T;
 type InferPartial<T> = T extends {
     readonly '~reprPartial': infer TRepr;
 } ? TRepr : T extends {
-    readonly '~repr': infer TRepr;
+    readonly [$repr]: infer TRepr;
 } ? TRepr | undefined : T extends Record<string | number | symbol, unknown> ? InferPartialRecord<T> : T;
 type InferGPU<T> = T extends {
     readonly '~gpuRepr': infer TRepr;
@@ -326,71 +34,65 @@ type InferGPURecord<T extends Record<string | number | symbol, unknown>> = {
     [Key in keyof T]: InferGPU<T[Key]>;
 };
 type MemIdentity<T> = T extends {
-    readonly '~memIdent': infer TMemIdent extends AnyData;
+    readonly '~memIdent': infer TMemIdent;
 } ? TMemIdent : T;
 type MemIdentityRecord<T extends Record<string | number | symbol, unknown>> = {
     [Key in keyof T]: MemIdentity<T[Key]>;
 };
 
+type Default<T, TDefault> = unknown extends T ? TDefault : T extends undefined ? TDefault : T;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 /**
- * Struct schema constructed via `d.struct` function.
- *
- * Responsible for handling reading and writing struct values
- * between binary and JS representation. Takes into account
- * the `byteAlignment` requirement of its members.
+ * Removes properties from record type that extend `Prop`
  */
-interface WgslStruct<TProps extends Record<string, BaseData> = Record<string, BaseData>> extends TgpuNamable {
-    (props: InferRecord<TProps>): InferRecord<TProps>;
-    readonly type: 'struct';
-    readonly label?: string | undefined;
-    readonly propTypes: TProps;
-    /** Type-token, not available at runtime */
-    readonly '~repr': Prettify<InferRecord<TProps>>;
-    /** Type-token, not available at runtime */
-    readonly '~gpuRepr': InferGPURecord<TProps>;
-    /** Type-token, not available at runtime */
-    readonly '~memIdent': WgslStruct<MemIdentityRecord<TProps>>;
-    /** Type-token, not available at runtime */
-    readonly '~reprPartial': Prettify<Partial<InferPartialRecord<TProps>>>;
-}
-type AnyWgslStruct = WgslStruct<any>;
+type OmitProps<T extends Record<string, unknown>, Prop> = Pick<T, {
+    [Key in keyof T]: T[Key] extends Prop ? never : Key;
+}[keyof T]>;
 /**
- * Creates a struct schema that can be used to construct GPU buffers.
- * Ensures proper alignment and padding of properties (as opposed to a `d.unstruct` schema).
- * The order of members matches the passed in properties object.
- *
- * @example
- * const CircleStruct = d.struct({ radius: d.f32, pos: d.vec3f });
- *
- * @param props Record with `string` keys and `TgpuData` values,
- * each entry describing one struct member.
+ * The opposite of Readonly<T>
  */
-declare function struct<TProps extends Record<string, AnyWgslData>>(props: TProps): WgslStruct<Prettify<TProps>>;
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
 
 type DecoratedLocation<T extends BaseData> = Decorated<T, Location<number>[]>;
 interface NumberArrayView {
     readonly length: number;
     [n: number]: number;
 }
+interface BooleanArrayView {
+    readonly length: number;
+    [n: number]: boolean;
+}
 interface BaseData {
     type: string;
     /** Type-token, not available at runtime */
-    readonly '~repr': unknown;
+    readonly [$repr]: unknown;
 }
 /**
  * Represents a 64-bit integer.
  */
 interface AbstractInt {
     readonly type: 'abstractInt';
-    readonly '~repr': number;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: number;
 }
 /**
  * Represents a 64-bit IEEE 754 floating point number.
  */
 interface AbstractFloat {
     readonly type: 'abstractFloat';
-    readonly '~repr': number;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: number;
+}
+interface Void {
+    readonly type: 'void';
+    readonly [$repr]: undefined;
 }
+declare const Void: Void;
 interface Swizzle2<T2, T3, T4> {
     readonly xx: T2;
     readonly xy: T2;
@@ -736,6 +438,16 @@ interface v2u extends NumberArrayView, Swizzle2<v2u, v3u, v4u> {
     x: number;
     y: number;
 }
+/**
+ * Interface representing its WGSL vector type counterpart: `vec2<bool>`.
+ * A vector with 2 elements of type `bool`
+ */
+interface v2b extends BooleanArrayView, Swizzle2<v2b, v3b, v4b> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec2<bool>';
+    x: boolean;
+    y: boolean;
+}
 /**
  * Interface representing its WGSL vector type counterpart: vec3f or vec3<f32>.
  * A vector with 3 elements of type f32
@@ -780,6 +492,17 @@ interface v3u extends NumberArrayView, Swizzle3<v2u, v3u, v4u> {
     y: number;
     z: number;
 }
+/**
+ * Interface representing its WGSL vector type counterpart: `vec3<bool>`.
+ * A vector with 3 elements of type `bool`
+ */
+interface v3b extends BooleanArrayView, Swizzle3<v2b, v3b, v4b> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec3<bool>';
+    x: boolean;
+    y: boolean;
+    z: boolean;
+}
 /**
  * Interface representing its WGSL vector type counterpart: vec4f or vec4<f32>.
  * A vector with 4 elements of type f32
@@ -828,11 +551,28 @@ interface v4u extends NumberArrayView, Swizzle4<v2u, v3u, v4u> {
     z: number;
     w: number;
 }
-type AnyVecInstance = v2f | v2h | v2i | v2u | v3f | v3h | v3i | v3u | v4f | v4h | v4i | v4u;
-type AnyVec2Instance = v2f | v2h | v2i | v2u;
-type AnyVec3Instance = v3f | v3h | v3i | v3u;
-type AnyVec4Instance = v4f | v4h | v4i | v4u;
-type VecKind = AnyVecInstance['kind'];
+/**
+ * Interface representing its WGSL vector type counterpart: `vec4<bool>`.
+ * A vector with 4 elements of type `bool`
+ */
+interface v4b extends BooleanArrayView, Swizzle4<v2b, v3b, v4b> {
+    /** use to distinguish between vectors of the same size on the type level */
+    readonly kind: 'vec4<bool>';
+    x: boolean;
+    y: boolean;
+    z: boolean;
+    w: boolean;
+}
+type AnyFloatVecInstance = v2f | v2h | v3f | v3h | v4f | v4h;
+type AnyBooleanVecInstance = v2b | v3b | v4b;
+type AnyNumericVec2Instance = v2f | v2h | v2i | v2u;
+type AnyNumericVec3Instance = v3f | v3h | v3i | v3u;
+type AnyNumericVec4Instance = v4f | v4h | v4i | v4u;
+type AnyNumericVecInstance = AnyNumericVec2Instance | AnyNumericVec3Instance | AnyNumericVec4Instance;
+type AnyVec2Instance = v2f | v2h | v2i | v2u | v2b;
+type AnyVec3Instance = v3f | v3h | v3i | v3u | v3b;
+type AnyVec4Instance = v4f | v4h | v4i | v4u | v4b;
+type AnyVecInstance = AnyVec2Instance | AnyVec3Instance | AnyVec4Instance;
 interface matBase<TColumn> extends NumberArrayView {
     readonly columns: readonly TColumn[];
 }
@@ -892,7 +632,7 @@ type vBaseForMat<T extends AnyMatInstance> = T extends m2x2f ? v2f : T extends m
  */
 interface Bool {
     readonly type: 'bool';
-    readonly '~repr': boolean;
+    readonly [$repr]: boolean;
 }
 /**
  * 32-bit float schema representing a single WGSL f32 value.
@@ -900,7 +640,7 @@ interface Bool {
 interface F32 {
     readonly type: 'f32';
     /** Type-token, not available at runtime */
-    readonly '~repr': number;
+    readonly [$repr]: number;
     (v: number | boolean): number;
 }
 /**
@@ -909,7 +649,7 @@ interface F32 {
 interface F16 {
     readonly type: 'f16';
     /** Type-token, not available at runtime */
-    readonly '~repr': number;
+    readonly [$repr]: number;
     (v: number | boolean): number;
 }
 /**
@@ -918,7 +658,7 @@ interface F16 {
 interface I32 {
     readonly type: 'i32';
     /** Type-token, not available at runtime */
-    readonly '~repr': number;
+    readonly [$repr]: number;
     readonly '~memIdent': I32 | Atomic<I32> | DecoratedLocation<I32>;
     (v: number | boolean): number;
 }
@@ -928,7 +668,7 @@ interface I32 {
 interface U32 {
     readonly type: 'u32';
     /** Type-token, not available at runtime */
-    readonly '~repr': number;
+    readonly [$repr]: number;
     readonly '~memIdent': U32 | Atomic<U32> | DecoratedLocation<U32>;
     (v: number | boolean): number;
 }
@@ -938,11 +678,11 @@ interface U32 {
 interface Vec2f {
     readonly type: 'vec2f';
     /** Type-token, not available at runtime */
-    readonly '~repr': v2f;
+    readonly [$repr]: v2f;
     (x: number, y: number): v2f;
     (xy: number): v2f;
     (): v2f;
-    (v: AnyVec2Instance): v2f;
+    (v: AnyNumericVec2Instance): v2f;
 }
 /**
  * Type of the `d.vec2h` object/function: vector data type schema/constructor
@@ -950,11 +690,11 @@ interface Vec2f {
 interface Vec2h {
     readonly type: 'vec2h';
     /** Type-token, not available at runtime */
-    readonly '~repr': v2h;
+    readonly [$repr]: v2h;
     (x: number, y: number): v2h;
     (xy: number): v2h;
     (): v2h;
-    (v: AnyVec2Instance): v2h;
+    (v: AnyNumericVec2Instance): v2h;
 }
 /**
  * Type of the `d.vec2i` object/function: vector data type schema/constructor
@@ -962,11 +702,11 @@ interface Vec2h {
 interface Vec2i {
     readonly type: 'vec2i';
     /** Type-token, not available at runtime */
-    readonly '~repr': v2i;
+    readonly [$repr]: v2i;
     (x: number, y: number): v2i;
     (xy: number): v2i;
     (): v2i;
-    (v: AnyVec2Instance): v2i;
+    (v: AnyNumericVec2Instance): v2i;
 }
 /**
  * Type of the `d.vec2u` object/function: vector data type schema/constructor
@@ -974,11 +714,24 @@ interface Vec2i {
 interface Vec2u {
     readonly type: 'vec2u';
     /** Type-token, not available at runtime */
-    readonly '~repr': v2u;
+    readonly [$repr]: v2u;
     (x: number, y: number): v2u;
     (xy: number): v2u;
     (): v2u;
-    (v: AnyVec2Instance): v2u;
+    (v: AnyNumericVec2Instance): v2u;
+}
+/**
+ * Type of the `d.vec2b` object/function: vector data type schema/constructor
+ * Cannot be used inside buffers as it is not host-shareable.
+ */
+interface Vec2b {
+    readonly type: 'vec2<bool>';
+    /** Type-token, not available at runtime */
+    readonly [$repr]: v2b;
+    (x: boolean, y: boolean): v2b;
+    (xy: boolean): v2b;
+    (): v2b;
+    (v: v2b): v2b;
 }
 /**
  * Type of the `d.vec3f` object/function: vector data type schema/constructor
@@ -986,13 +739,13 @@ interface Vec2u {
 interface Vec3f {
     readonly type: 'vec3f';
     /** Type-token, not available at runtime */
-    readonly '~repr': v3f;
+    readonly [$repr]: v3f;
     (x: number, y: number, z: number): v3f;
     (xyz: number): v3f;
     (): v3f;
-    (v: AnyVec3Instance): v3f;
-    (v0: AnyVec2Instance, z: number): v3f;
-    (x: number, v0: AnyVec2Instance): v3f;
+    (v: AnyNumericVec3Instance): v3f;
+    (v0: AnyNumericVec2Instance, z: number): v3f;
+    (x: number, v0: AnyNumericVec2Instance): v3f;
 }
 /**
  * Type of the `d.vec3h` object/function: vector data type schema/constructor
@@ -1000,13 +753,13 @@ interface Vec3f {
 interface Vec3h {
     readonly type: 'vec3h';
     /** Type-token, not available at runtime */
-    readonly '~repr': v3h;
+    readonly [$repr]: v3h;
     (x: number, y: number, z: number): v3h;
     (xyz: number): v3h;
     (): v3h;
-    (v: AnyVec3Instance): v3h;
-    (v0: AnyVec2Instance, z: number): v3h;
-    (x: number, v0: AnyVec2Instance): v3h;
+    (v: AnyNumericVec3Instance): v3h;
+    (v0: AnyNumericVec2Instance, z: number): v3h;
+    (x: number, v0: AnyNumericVec2Instance): v3h;
 }
 /**
  * Type of the `d.vec3i` object/function: vector data type schema/constructor
@@ -1014,13 +767,13 @@ interface Vec3h {
 interface Vec3i {
     readonly type: 'vec3i';
     /** Type-token, not available at runtime */
-    readonly '~repr': v3i;
+    readonly [$repr]: v3i;
     (x: number, y: number, z: number): v3i;
     (xyz: number): v3i;
     (): v3i;
-    (v: AnyVec3Instance): v3i;
-    (v0: AnyVec2Instance, z: number): v3i;
-    (x: number, v0: AnyVec2Instance): v3i;
+    (v: AnyNumericVec3Instance): v3i;
+    (v0: AnyNumericVec2Instance, z: number): v3i;
+    (x: number, v0: AnyNumericVec2Instance): v3i;
 }
 /**
  * Type of the `d.vec3u` object/function: vector data type schema/constructor
@@ -1028,13 +781,28 @@ interface Vec3i {
 interface Vec3u {
     readonly type: 'vec3u';
     /** Type-token, not available at runtime */
-    readonly '~repr': v3u;
+    readonly [$repr]: v3u;
     (x: number, y: number, z: number): v3u;
     (xyz: number): v3u;
     (): v3u;
-    (v: AnyVec3Instance): v3u;
-    (v0: AnyVec2Instance, z: number): v3u;
-    (x: number, v0: AnyVec2Instance): v3u;
+    (v: AnyNumericVec3Instance): v3u;
+    (v0: AnyNumericVec2Instance, z: number): v3u;
+    (x: number, v0: AnyNumericVec2Instance): v3u;
+}
+/**
+ * Type of the `d.vec3b` object/function: vector data type schema/constructor
+ * Cannot be used inside buffers as it is not host-shareable.
+ */
+interface Vec3b {
+    readonly type: 'vec3<bool>';
+    /** Type-token, not available at runtime */
+    readonly [$repr]: v3b;
+    (x: boolean, y: boolean, z: boolean): v3b;
+    (xyz: boolean): v3b;
+    (): v3b;
+    (v: v3b): v3b;
+    (v0: v2b, z: boolean): v3b;
+    (x: boolean, v0: v2b): v3b;
 }
 /**
  * Type of the `d.vec4f` object/function: vector data type schema/constructor
@@ -1042,17 +810,17 @@ interface Vec3u {
 interface Vec4f {
     readonly type: 'vec4f';
     /** Type-token, not available at runtime */
-    readonly '~repr': v4f;
+    readonly [$repr]: v4f;
     (x: number, y: number, z: number, w: number): v4f;
     (xyzw: number): v4f;
     (): v4f;
-    (v: AnyVec4Instance): v4f;
-    (v0: AnyVec3Instance, w: number): v4f;
-    (x: number, v0: AnyVec3Instance): v4f;
-    (v0: AnyVec2Instance, v1: AnyVec2Instance): v4f;
-    (v0: AnyVec2Instance, z: number, w: number): v4f;
-    (x: number, v0: AnyVec2Instance, z: number): v4f;
-    (x: number, y: number, v0: AnyVec2Instance): v4f;
+    (v: AnyNumericVec4Instance): v4f;
+    (v0: AnyNumericVec3Instance, w: number): v4f;
+    (x: number, v0: AnyNumericVec3Instance): v4f;
+    (v0: AnyNumericVec2Instance, v1: AnyNumericVec2Instance): v4f;
+    (v0: AnyNumericVec2Instance, z: number, w: number): v4f;
+    (x: number, v0: AnyNumericVec2Instance, z: number): v4f;
+    (x: number, y: number, v0: AnyNumericVec2Instance): v4f;
 }
 /**
  * Type of the `d.vec4h` object/function: vector data type schema/constructor
@@ -1060,17 +828,17 @@ interface Vec4f {
 interface Vec4h {
     readonly type: 'vec4h';
     /** Type-token, not available at runtime */
-    readonly '~repr': v4h;
+    readonly [$repr]: v4h;
     (x: number, y: number, z: number, w: number): v4h;
     (xyzw: number): v4h;
     (): v4h;
-    (v: AnyVec4Instance): v4h;
-    (v0: AnyVec3Instance, w: number): v4h;
-    (x: number, v0: AnyVec3Instance): v4h;
-    (v0: AnyVec2Instance, v1: AnyVec2Instance): v4h;
-    (v0: AnyVec2Instance, z: number, w: number): v4h;
-    (x: number, v0: AnyVec2Instance, z: number): v4h;
-    (x: number, y: number, v0: AnyVec2Instance): v4h;
+    (v: AnyNumericVec4Instance): v4h;
+    (v0: AnyNumericVec3Instance, w: number): v4h;
+    (x: number, v0: AnyNumericVec3Instance): v4h;
+    (v0: AnyNumericVec2Instance, v1: AnyNumericVec2Instance): v4h;
+    (v0: AnyNumericVec2Instance, z: number, w: number): v4h;
+    (x: number, v0: AnyNumericVec2Instance, z: number): v4h;
+    (x: number, y: number, v0: AnyNumericVec2Instance): v4h;
 }
 /**
  * Type of the `d.vec4i` object/function: vector data type schema/constructor
@@ -1078,17 +846,17 @@ interface Vec4h {
 interface Vec4i {
     readonly type: 'vec4i';
     /** Type-token, not available at runtime */
-    readonly '~repr': v4i;
+    readonly [$repr]: v4i;
     (x: number, y: number, z: number, w: number): v4i;
     (xyzw: number): v4i;
     (): v4i;
-    (v: AnyVec4Instance): v4i;
-    (v0: AnyVec3Instance, w: number): v4i;
-    (x: number, v0: AnyVec3Instance): v4i;
-    (v0: AnyVec2Instance, v1: AnyVec2Instance): v4i;
-    (v0: AnyVec2Instance, z: number, w: number): v4i;
-    (x: number, v0: AnyVec2Instance, z: number): v4i;
-    (x: number, y: number, v0: AnyVec2Instance): v4i;
+    (v: AnyNumericVec4Instance): v4i;
+    (v0: AnyNumericVec3Instance, w: number): v4i;
+    (x: number, v0: AnyNumericVec3Instance): v4i;
+    (v0: AnyNumericVec2Instance, v1: AnyNumericVec2Instance): v4i;
+    (v0: AnyNumericVec2Instance, z: number, w: number): v4i;
+    (x: number, v0: AnyNumericVec2Instance, z: number): v4i;
+    (x: number, y: number, v0: AnyNumericVec2Instance): v4i;
 }
 /**
  * Type of the `d.vec4u` object/function: vector data type schema/constructor
@@ -1096,17 +864,36 @@ interface Vec4i {
 interface Vec4u {
     readonly type: 'vec4u';
     /** Type-token, not available at runtime */
-    readonly '~repr': v4u;
+    readonly [$repr]: v4u;
     (x: number, y: number, z: number, w: number): v4u;
     (xyzw: number): v4u;
     (): v4u;
-    (v: AnyVec4Instance): v4u;
-    (v0: AnyVec3Instance, w: number): v4u;
-    (x: number, v0: AnyVec3Instance): v4u;
-    (v0: AnyVec2Instance, v1: AnyVec2Instance): v4u;
-    (v0: AnyVec2Instance, z: number, w: number): v4u;
-    (x: number, v0: AnyVec2Instance, z: number): v4u;
-    (x: number, y: number, v0: AnyVec2Instance): v4u;
+    (v: AnyNumericVec4Instance): v4u;
+    (v0: AnyNumericVec3Instance, w: number): v4u;
+    (x: number, v0: AnyNumericVec3Instance): v4u;
+    (v0: AnyNumericVec2Instance, v1: AnyNumericVec2Instance): v4u;
+    (v0: AnyNumericVec2Instance, z: number, w: number): v4u;
+    (x: number, v0: AnyNumericVec2Instance, z: number): v4u;
+    (x: number, y: number, v0: AnyNumericVec2Instance): v4u;
+}
+/**
+ * Type of the `d.vec4b` object/function: vector data type schema/constructor
+ * Cannot be used inside buffers as it is not host-shareable.
+ */
+interface Vec4b {
+    readonly type: 'vec4<bool>';
+    /** Type-token, not available at runtime */
+    readonly [$repr]: v4b;
+    (x: boolean, y: boolean, z: boolean, w: boolean): v4b;
+    (xyzw: boolean): v4b;
+    (): v4b;
+    (v: v4b): v4b;
+    (v0: v3b, w: boolean): v4b;
+    (x: boolean, v0: v3b): v4b;
+    (v0: v2b, v1: v2b): v4b;
+    (v0: v2b, z: boolean, w: boolean): v4b;
+    (x: boolean, v0: v2b, z: boolean): v4b;
+    (x: boolean, y: boolean, v0: v2b): v4b;
 }
 /**
  * Type of the `d.mat2x2f` object/function: matrix data type schema/constructor
@@ -1114,7 +901,7 @@ interface Vec4u {
 interface Mat2x2f {
     readonly type: 'mat2x2f';
     /** Type-token, not available at runtime */
-    readonly '~repr': m2x2f;
+    readonly [$repr]: m2x2f;
     (...elements: number[]): m2x2f;
     (...columns: v2f[]): m2x2f;
     (): m2x2f;
@@ -1125,7 +912,7 @@ interface Mat2x2f {
 interface Mat3x3f {
     readonly type: 'mat3x3f';
     /** Type-token, not available at runtime */
-    readonly '~repr': m3x3f;
+    readonly [$repr]: m3x3f;
     (...elements: number[]): m3x3f;
     (...columns: v3f[]): m3x3f;
     (): m3x3f;
@@ -1136,145 +923,460 @@ interface Mat3x3f {
 interface Mat4x4f {
     readonly type: 'mat4x4f';
     /** Type-token, not available at runtime */
-    readonly '~repr': m4x4f;
+    readonly [$repr]: m4x4f;
     (...elements: number[]): m4x4f;
     (...columns: v4f[]): m4x4f;
     (): m4x4f;
 }
 /**
- * Array schema constructed via `d.arrayOf` function.
+ * Array schema constructed via `d.arrayOf` function.
+ *
+ * Responsible for handling reading and writing array values
+ * between binary and JS representation. Takes into account
+ * the `byteAlignment` requirement of its elementType.
+ */
+interface WgslArray<TElement extends BaseData = BaseData> {
+    readonly type: 'array';
+    readonly elementCount: number;
+    readonly elementType: TElement;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TElement>[];
+    readonly '~gpuRepr': InferGPU<TElement>[];
+    readonly '~reprPartial': {
+        idx: number;
+        value: InferPartial<TElement>;
+    }[];
+    readonly '~memIdent': WgslArray<MemIdentity<TElement>>;
+}
+declare const $structTag: unique symbol;
+/**
+ * Struct schema constructed via `d.struct` function.
+ *
+ * Responsible for handling reading and writing struct values
+ * between binary and JS representation. Takes into account
+ * the `byteAlignment` requirement of its members.
+ */
+interface WgslStruct<TProps extends Record<string, BaseData> = Record<string, BaseData>> extends TgpuNamable {
+    (props: Prettify<InferRecord<TProps>>): Prettify<InferRecord<TProps>>;
+    /** @deprecated */
+    readonly type: 'struct';
+    readonly label?: string | undefined;
+    readonly propTypes: TProps;
+    readonly [$structTag]: true;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Prettify<InferRecord<TProps>>;
+    /** Type-token, not available at runtime */
+    readonly '~gpuRepr': Prettify<InferGPURecord<TProps>>;
+    /** Type-token, not available at runtime */
+    readonly '~memIdent': WgslStruct<Prettify<MemIdentityRecord<TProps>>>;
+    /** Type-token, not available at runtime */
+    readonly '~reprPartial': Prettify<Partial<InferPartialRecord<TProps>>>;
+}
+type AnyWgslStruct = WgslStruct<any>;
+type AddressSpace = 'uniform' | 'storage' | 'workgroup' | 'private' | 'function' | 'handle';
+type Access = 'read' | 'write' | 'read-write';
+interface Ptr<TAddr extends AddressSpace = AddressSpace, TInner extends BaseData = BaseData, // can also be sampler or texture (╯'□')╯︵ ┻━┻
+TAccess extends Access = Access> {
+    readonly type: 'ptr';
+    readonly inner: TInner;
+    readonly addressSpace: TAddr;
+    readonly access: TAccess;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TInner>;
+}
+/**
+ * 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>;
+    readonly '~gpuRepr': TInner extends U32 ? atomicU32 : atomicI32;
+    readonly '~memIdent': MemIdentity<TInner>;
+}
+interface atomicU32 {
+    type: 'atomicU32';
+}
+interface atomicI32 {
+    type: 'atomicI32';
+}
+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 BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
+    readonly type: 'decorated';
+    readonly inner: TInner;
+    readonly attribs: TAttribs;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TInner>;
+    readonly '~gpuRepr': InferGPU<TInner>;
+    readonly '~reprPartial': InferPartial<TInner>;
+    readonly '~memIdent': TAttribs extends Location<number>[] ? MemIdentity<TInner> | Decorated<MemIdentity<TInner>, TAttribs> : Decorated<MemIdentity<TInner>, TAttribs>;
+}
+declare const wgslTypeLiterals: readonly ["bool", "f32", "f16", "i32", "u32", "vec2f", "vec2h", "vec2i", "vec2u", "vec2<bool>", "vec3f", "vec3h", "vec3i", "vec3u", "vec3<bool>", "vec4f", "vec4h", "vec4i", "vec4u", "vec4<bool>", "mat2x2f", "mat3x3f", "mat4x4f", "struct", "array", "ptr", "atomic", "decorated", "abstractInt", "abstractFloat", "void"];
+type WgslTypeLiteral = (typeof wgslTypeLiterals)[number];
+type PerspectiveOrLinearInterpolatableBaseType = F32 | F16 | Vec2f | Vec2h | Vec3f | Vec3h | Vec4f | Vec4h;
+type PerspectiveOrLinearInterpolatableData = PerspectiveOrLinearInterpolatableBaseType | Decorated<PerspectiveOrLinearInterpolatableBaseType>;
+type FlatInterpolatableAdditionalBaseType = I32 | U32 | Vec2i | Vec2u | Vec3i | Vec3u | Vec4i | Vec4u;
+type FlatInterpolatableData = PerspectiveOrLinearInterpolatableData | FlatInterpolatableAdditionalBaseType | Decorated<FlatInterpolatableAdditionalBaseType>;
+type ScalarData = Bool | F32 | F16 | I32 | U32 | AbstractInt | AbstractFloat;
+type AnyWgslData = Bool | F32 | F16 | I32 | U32 | Vec2f | Vec2h | Vec2i | Vec2u | Vec2b | Vec3f | Vec3h | Vec3i | Vec3u | Vec3b | Vec4f | Vec4h | Vec4i | Vec4u | Vec4b | Mat2x2f | Mat3x3f | Mat4x4f | AnyWgslStruct | WgslArray | Ptr | Atomic | Decorated | AbstractInt | AbstractFloat | Void;
+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 passed in value is a pointer ('function' scope) schema.
+ *
+ * @example
+ * isPtrFn(d.ptrFn(d.f32)) // true
+ * isPtrFn(d.f32) // false
+ */
+declare function isPtr<T extends Ptr>(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;
+
+declare const $internal: unique symbol;
+
+declare const vertexFormats: readonly ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
+type VertexFormat = (typeof vertexFormats)[number];
+declare const kindToDefaultFormatMap: {
+    readonly f32: "float32";
+    readonly vec2f: "float32x2";
+    readonly vec3f: "float32x3";
+    readonly vec4f: "float32x4";
+    readonly f16: "float16";
+    readonly vec2h: "float16x2";
+    readonly vec4h: "float16x4";
+    readonly u32: "uint32";
+    readonly vec2u: "uint32x2";
+    readonly vec3u: "uint32x3";
+    readonly vec4u: "uint32x4";
+    readonly i32: "sint32";
+    readonly vec2i: "sint32x2";
+    readonly vec3i: "sint32x3";
+    readonly vec4i: "sint32x4";
+};
+type KindToDefaultFormatMap = typeof kindToDefaultFormatMap;
+interface TgpuVertexAttrib<TFormat extends VertexFormat = VertexFormat> {
+    readonly format: TFormat;
+    readonly offset: number;
+}
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component u32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type U32CompatibleFormats = TgpuVertexAttrib<'uint8'> | TgpuVertexAttrib<'uint8x2'> | TgpuVertexAttrib<'uint8x4'> | TgpuVertexAttrib<'uint16'> | TgpuVertexAttrib<'uint16x2'> | TgpuVertexAttrib<'uint16x4'> | TgpuVertexAttrib<'uint32'> | TgpuVertexAttrib<'uint32x2'> | TgpuVertexAttrib<'uint32x3'> | TgpuVertexAttrib<'uint32x4'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component i32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type I32CompatibleFormats = TgpuVertexAttrib<'sint8'> | TgpuVertexAttrib<'sint8x2'> | TgpuVertexAttrib<'sint8x4'> | TgpuVertexAttrib<'sint16'> | TgpuVertexAttrib<'sint16x2'> | TgpuVertexAttrib<'sint16x4'> | TgpuVertexAttrib<'sint32'> | TgpuVertexAttrib<'sint32x2'> | TgpuVertexAttrib<'sint32x3'> | TgpuVertexAttrib<'sint32x4'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * an single or multi component f32 in a shader.
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type F32CompatibleFormats = TgpuVertexAttrib<'unorm8'> | TgpuVertexAttrib<'unorm8x2'> | TgpuVertexAttrib<'unorm8x4'> | TgpuVertexAttrib<'snorm8'> | TgpuVertexAttrib<'snorm8x2'> | TgpuVertexAttrib<'snorm8x4'> | TgpuVertexAttrib<'unorm16'> | TgpuVertexAttrib<'unorm16x2'> | TgpuVertexAttrib<'unorm16x4'> | TgpuVertexAttrib<'snorm16'> | TgpuVertexAttrib<'snorm16x2'> | TgpuVertexAttrib<'snorm16x4'> | TgpuVertexAttrib<'float16'> | TgpuVertexAttrib<'float16x2'> | TgpuVertexAttrib<'float16x4'> | TgpuVertexAttrib<'float32'> | TgpuVertexAttrib<'float32x2'> | TgpuVertexAttrib<'float32x3'> | TgpuVertexAttrib<'float32x4'> | TgpuVertexAttrib<'unorm10-10-10-2'> | TgpuVertexAttrib<'unorm8x4-bgra'>;
+/**
+ * All vertex attribute formats that can be interpreted as
+ * a single or multi component f16 in a shader. (same as f32 on the shader side)
+ * https://www.w3.org/TR/webgpu/#vertex-formats
+ */
+type F16CompatibleFormats = F32CompatibleFormats;
+type KindToAcceptedAttribMap = {
+    u32: U32CompatibleFormats;
+    vec2u: U32CompatibleFormats;
+    vec3u: U32CompatibleFormats;
+    vec4u: U32CompatibleFormats;
+    i32: I32CompatibleFormats;
+    vec2i: I32CompatibleFormats;
+    vec3i: I32CompatibleFormats;
+    vec4i: I32CompatibleFormats;
+    f16: F16CompatibleFormats;
+    vec2h: F16CompatibleFormats;
+    vec3h: F16CompatibleFormats;
+    vec4h: F16CompatibleFormats;
+    f32: F32CompatibleFormats;
+    vec2f: F32CompatibleFormats;
+    vec3f: F32CompatibleFormats;
+    vec4f: F32CompatibleFormats;
+};
+
+type FormatToWGSLType<T extends VertexFormat> = (typeof formatToWGSLType)[T];
+interface TgpuVertexFormatData<T extends VertexFormat> {
+    readonly type: T;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<FormatToWGSLType<T>>;
+}
+declare const formatToWGSLType: {
+    readonly uint8: U32;
+    readonly uint8x2: Vec2u;
+    readonly uint8x4: Vec4u;
+    readonly sint8: I32;
+    readonly sint8x2: Vec2i;
+    readonly sint8x4: Vec4i;
+    readonly unorm8: F32;
+    readonly unorm8x2: Vec2f;
+    readonly unorm8x4: Vec4f;
+    readonly snorm8: F32;
+    readonly snorm8x2: Vec2f;
+    readonly snorm8x4: Vec4f;
+    readonly uint16: U32;
+    readonly uint16x2: Vec2u;
+    readonly uint16x4: Vec4u;
+    readonly sint16: I32;
+    readonly sint16x2: Vec2i;
+    readonly sint16x4: Vec4i;
+    readonly unorm16: F32;
+    readonly unorm16x2: Vec2f;
+    readonly unorm16x4: Vec4f;
+    readonly snorm16: F32;
+    readonly snorm16x2: Vec2f;
+    readonly snorm16x4: Vec4f;
+    readonly float16: F32;
+    readonly float16x2: Vec2f;
+    readonly float16x4: Vec4f;
+    readonly float32: F32;
+    readonly float32x2: Vec2f;
+    readonly float32x3: Vec3f;
+    readonly float32x4: Vec4f;
+    readonly uint32: U32;
+    readonly uint32x2: Vec2u;
+    readonly uint32x3: Vec3u;
+    readonly uint32x4: Vec4u;
+    readonly sint32: I32;
+    readonly sint32x2: Vec2i;
+    readonly sint32x3: Vec3i;
+    readonly sint32x4: Vec4i;
+    readonly 'unorm10-10-10-2': Vec4f;
+    readonly 'unorm8x4-bgra': Vec4f;
+};
+declare const packedFormats: string[];
+type uint8 = TgpuVertexFormatData<'uint8'>;
+declare const uint8: uint8;
+type uint8x2 = TgpuVertexFormatData<'uint8x2'>;
+declare const uint8x2: uint8x2;
+type uint8x4 = TgpuVertexFormatData<'uint8x4'>;
+declare const uint8x4: uint8x4;
+type sint8 = TgpuVertexFormatData<'sint8'>;
+declare const sint8: sint8;
+type sint8x2 = TgpuVertexFormatData<'sint8x2'>;
+declare const sint8x2: sint8x2;
+type sint8x4 = TgpuVertexFormatData<'sint8x4'>;
+declare const sint8x4: sint8x4;
+type unorm8 = TgpuVertexFormatData<'unorm8'>;
+declare const unorm8: unorm8;
+type unorm8x2 = TgpuVertexFormatData<'unorm8x2'>;
+declare const unorm8x2: unorm8x2;
+type unorm8x4 = TgpuVertexFormatData<'unorm8x4'>;
+declare const unorm8x4: unorm8x4;
+type snorm8 = TgpuVertexFormatData<'snorm8'>;
+declare const snorm8: snorm8;
+type snorm8x2 = TgpuVertexFormatData<'snorm8x2'>;
+declare const snorm8x2: snorm8x2;
+type snorm8x4 = TgpuVertexFormatData<'snorm8x4'>;
+declare const snorm8x4: snorm8x4;
+type uint16 = TgpuVertexFormatData<'uint16'>;
+declare const uint16: uint16;
+type uint16x2 = TgpuVertexFormatData<'uint16x2'>;
+declare const uint16x2: uint16x2;
+type uint16x4 = TgpuVertexFormatData<'uint16x4'>;
+declare const uint16x4: uint16x4;
+type sint16 = TgpuVertexFormatData<'sint16'>;
+declare const sint16: sint16;
+type sint16x2 = TgpuVertexFormatData<'sint16x2'>;
+declare const sint16x2: sint16x2;
+type sint16x4 = TgpuVertexFormatData<'sint16x4'>;
+declare const sint16x4: sint16x4;
+type unorm16 = TgpuVertexFormatData<'unorm16'>;
+declare const unorm16: unorm16;
+type unorm16x2 = TgpuVertexFormatData<'unorm16x2'>;
+declare const unorm16x2: unorm16x2;
+type unorm16x4 = TgpuVertexFormatData<'unorm16x4'>;
+declare const unorm16x4: unorm16x4;
+type snorm16 = TgpuVertexFormatData<'snorm16'>;
+declare const snorm16: snorm16;
+type snorm16x2 = TgpuVertexFormatData<'snorm16x2'>;
+declare const snorm16x2: snorm16x2;
+type snorm16x4 = TgpuVertexFormatData<'snorm16x4'>;
+declare const snorm16x4: snorm16x4;
+type float16 = TgpuVertexFormatData<'float16'>;
+declare const float16: float16;
+type float16x2 = TgpuVertexFormatData<'float16x2'>;
+declare const float16x2: float16x2;
+type float16x4 = TgpuVertexFormatData<'float16x4'>;
+declare const float16x4: float16x4;
+type float32 = TgpuVertexFormatData<'float32'>;
+declare const float32: float32;
+type float32x2 = TgpuVertexFormatData<'float32x2'>;
+declare const float32x2: float32x2;
+type float32x3 = TgpuVertexFormatData<'float32x3'>;
+declare const float32x3: float32x3;
+type float32x4 = TgpuVertexFormatData<'float32x4'>;
+declare const float32x4: float32x4;
+type uint32 = TgpuVertexFormatData<'uint32'>;
+declare const uint32: uint32;
+type uint32x2 = TgpuVertexFormatData<'uint32x2'>;
+declare const uint32x2: uint32x2;
+type uint32x3 = TgpuVertexFormatData<'uint32x3'>;
+declare const uint32x3: uint32x3;
+type uint32x4 = TgpuVertexFormatData<'uint32x4'>;
+declare const uint32x4: uint32x4;
+type sint32 = TgpuVertexFormatData<'sint32'>;
+declare const sint32: sint32;
+type sint32x2 = TgpuVertexFormatData<'sint32x2'>;
+declare const sint32x2: sint32x2;
+type sint32x3 = TgpuVertexFormatData<'sint32x3'>;
+declare const sint32x3: sint32x3;
+type sint32x4 = TgpuVertexFormatData<'sint32x4'>;
+declare const sint32x4: sint32x4;
+type unorm10_10_10_2 = TgpuVertexFormatData<'unorm10-10-10-2'>;
+declare const unorm10_10_10_2: unorm10_10_10_2;
+type unorm8x4_bgra = TgpuVertexFormatData<'unorm8x4-bgra'>;
+declare const unorm8x4_bgra: unorm8x4_bgra;
+type PackedData = uint8 | uint8x2 | uint8x4 | sint8 | sint8x2 | sint8x4 | unorm8 | unorm8x2 | unorm8x4 | snorm8 | snorm8x2 | snorm8x4 | uint16 | uint16x2 | uint16x4 | sint16 | sint16x2 | sint16x4 | unorm16 | unorm16x2 | unorm16x4 | snorm16 | snorm16x2 | snorm16x4 | float16 | float16x2 | float16x4 | float32 | float32x2 | float32x3 | float32x4 | uint32 | uint32x2 | uint32x3 | uint32x4 | sint32 | sint32x2 | sint32x3 | sint32x4 | unorm10_10_10_2 | unorm8x4_bgra;
+
+type TgpuDualFn<TImpl extends (...args: unknown[]) => unknown> = TImpl & {
+    [$internal]: {
+        implementation: TImpl | string;
+    };
+};
+/**
+ * Array schema constructed via `d.disarrayOf` function.
  *
- * Responsible for handling reading and writing array values
- * between binary and JS representation. Takes into account
- * the `byteAlignment` requirement of its elementType.
+ * Useful for defining vertex buffers.
+ * Elements in the schema are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
  */
-interface WgslArray<TElement extends BaseData = BaseData> {
-    readonly type: 'array';
+interface Disarray<TElement extends BaseData = BaseData> {
+    readonly type: 'disarray';
     readonly elementCount: number;
     readonly elementType: TElement;
-    /** Type-token, not available at runtime */
-    readonly '~repr': Infer<TElement>[];
-    readonly '~gpuRepr': InferGPU<TElement>[];
+    readonly [$repr]: Infer<TElement>[];
     readonly '~reprPartial': {
         idx: number;
         value: InferPartial<TElement>;
     }[];
-    readonly '~memIdent': WgslArray<MemIdentity<TElement>>;
-}
-type AddressSpace = 'uniform' | 'storage' | 'workgroup' | 'private' | 'function' | 'handle';
-type Access = 'read' | 'write' | 'read-write';
-interface Ptr<TAddr extends AddressSpace = AddressSpace, TInner extends BaseData = BaseData, // can also be sampler or texture (╯'□')╯︵ ┻━┻
-TAccess extends Access = Access> {
-    readonly type: 'ptr';
-    readonly inner: TInner;
-    readonly addressSpace: TAddr;
-    readonly access: TAccess;
-    /** Type-token, not available at runtime */
-    readonly '~repr': Infer<TInner>;
 }
 /**
- * Schema representing the `atomic<...>` WGSL data type.
+ * Struct schema constructed via `d.unstruct` function.
+ *
+ * Useful for defining vertex buffers, as the standard layout restrictions do not apply.
+ * Members are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
  */
-interface Atomic<TInner extends U32 | I32 = U32 | I32> {
-    readonly type: 'atomic';
-    readonly inner: TInner;
-    /** Type-token, not available at runtime */
-    readonly '~repr': Infer<TInner>;
-    readonly '~gpuRepr': TInner extends U32 ? atomicU32 : atomicI32;
-    readonly '~memIdent': MemIdentity<TInner>;
-}
-interface atomicU32 {
-    type: 'atomicU32';
-}
-interface atomicI32 {
-    type: 'atomicI32';
-}
-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 Unstruct<TProps extends Record<string, BaseData> = Record<string, BaseData>> extends TgpuNamable {
+    (props: Prettify<InferRecord<TProps>>): Prettify<InferRecord<TProps>>;
+    readonly label?: string | undefined;
+    readonly type: 'unstruct';
+    readonly propTypes: TProps;
+    readonly [$repr]: Prettify<InferRecord<TProps>>;
+    readonly '~gpuRepr': Prettify<InferGPURecord<TProps>>;
+    readonly '~memIdent': Unstruct<Prettify<MemIdentityRecord<TProps>>>;
+    readonly '~reprPartial': Prettify<Partial<InferPartialRecord<TProps>>>;
 }
-interface Decorated<TInner extends BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
-    readonly type: 'decorated';
+type AnyUnstruct = Unstruct<any>;
+interface LooseDecorated<TInner extends BaseData = BaseData, TAttribs extends unknown[] = unknown[]> {
+    readonly type: 'loose-decorated';
     readonly inner: TInner;
     readonly attribs: TAttribs;
-    /** Type-token, not available at runtime */
-    readonly '~repr': Infer<TInner>;
-    readonly '~gpuRepr': InferGPU<TInner>;
-    readonly '~reprPartial': InferPartial<TInner>;
-    readonly '~memIdent': TAttribs extends Location<number>[] ? MemIdentity<TInner> | Decorated<MemIdentity<TInner>, TAttribs> : Decorated<MemIdentity<TInner>, TAttribs>;
+    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", "ptr", "atomic", "decorated", "abstractInt", "abstractFloat"];
-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 | AnyWgslStruct | WgslArray | Ptr | Atomic | Decorated | AbstractInt | AbstractFloat;
-declare function isWgslData(value: unknown): value is AnyWgslData;
+declare const looseTypeLiterals: readonly ["unstruct", "disarray", "loose-decorated", "uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
+type LooseTypeLiteral = (typeof looseTypeLiterals)[number];
+type AnyLooseData = Disarray | AnyUnstruct | LooseDecorated | PackedData;
+declare function isLooseData(data: unknown): data is AnyLooseData;
 /**
- * Checks whether passed in value is an array schema,
- * as opposed to, e.g., a disarray schema.
+ * Checks whether the passed in value is a disarray schema,
+ * as opposed to, e.g., a regular array schema.
  *
  * Array schemas can be used to describe uniform and storage buffers,
- * whereas disarray schemas cannot.
+ * whereas disarray schemas cannot. Disarrays are useful for
+ * defining vertex buffers instead.
  *
  * @example
- * isWgslArray(d.arrayOf(d.u32, 4)) // true
- * isWgslArray(d.disarray(d.u32, 4)) // false
- * isWgslArray(d.vec3f) // false
+ * isDisarray(d.arrayOf(d.u32, 4)) // false
+ * isDisarray(d.disarrayOf(d.u32, 4)) // true
+ * isDisarray(d.vec3f) // false
  */
-declare function isWgslArray<T extends WgslArray>(schema: T | unknown): schema is T;
+declare function isDisarray<T extends Disarray>(schema: T | unknown): schema is T;
 /**
- * Checks whether passed in value is a struct schema,
- * as opposed to, e.g., an unstruct schema.
+ * Checks whether passed in value is a unstruct schema,
+ * as opposed to, e.g., a struct 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 passed in value is a pointer ('function' scope) schema.
- *
- * @example
- * isPtrFn(d.ptrFn(d.f32)) // true
- * isPtrFn(d.f32) // false
- */
-declare function isPtr<T extends Ptr>(schema: T | unknown): schema is T;
-/**
- * Checks whether the passed in value is an atomic schema.
+ * whereas unstruct schemas cannot. Unstructs are useful for
+ * defining vertex buffers instead.
  *
  * @example
- * isAtomic(d.atomic(d.u32)) // true
- * isAtomic(d.u32) // false
+ * isUnstruct(d.struct({ a: d.u32 })) // false
+ * isUnstruct(d.unstruct({ a: d.u32 })) // true
+ * isUnstruct(d.vec3f) // 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;
+declare function isUnstruct<T extends Unstruct>(schema: T | unknown): schema is T;
+declare function isLooseDecorated<T extends LooseDecorated>(value: T | unknown): value is T;
+declare function isData(value: unknown): value is AnyData;
+type AnyData = AnyWgslData | AnyLooseData;
 
-export { type Atomic as $, type AnyWgslData as A, type BaseData as B, type InferGPU as C, type Decorated as D, type AbstractInt as E, type F32 as F, type AbstractFloat as G, type AnyVecInstance as H, type Infer as I, type AnyMatInstance as J, type KindToDefaultFormatMap as K, type Location as L, type Mutable as M, type Bool as N, type OmitProps as O, type Prettify as P, type Ptr as Q, type Mat2x2f as R, type Mat3x3f as S, type TgpuNamable as T, type U32 as U, type Vec2f as V, type WgslStruct as W, type Mat4x4f as X, type m2x2f as Y, type m3x3f as Z, type m4x4f as _, type F16 as a, float32 as a$, isWgslData as a0, isWgslArray as a1, isWgslStruct as a2, isPtr as a3, isAtomic as a4, isDecorated as a5, isAlignAttrib as a6, isBuiltinAttrib as a7, isLocationAttrib as a8, isInterpolateAttrib as a9, uint8 as aA, uint8x2 as aB, uint8x4 as aC, sint8 as aD, sint8x2 as aE, sint8x4 as aF, unorm8 as aG, unorm8x2 as aH, unorm8x4 as aI, snorm8 as aJ, snorm8x2 as aK, snorm8x4 as aL, uint16 as aM, uint16x2 as aN, uint16x4 as aO, sint16 as aP, sint16x2 as aQ, sint16x4 as aR, unorm16 as aS, unorm16x2 as aT, unorm16x4 as aU, snorm16 as aV, snorm16x2 as aW, snorm16x4 as aX, float16 as aY, float16x2 as aZ, float16x4 as a_, isSizeAttrib as aa, type Size as ab, type Align as ac, type Builtin as ad, type Interpolate as ae, type v2f as af, type v2i as ag, type v2u as ah, type v3f as ai, type v3i as aj, type v3u as ak, type v4f as al, type v4i as am, type v4u as an, struct as ao, type LooseDecorated as ap, type AnyLooseData as aq, isDisarray as ar, isUnstruct as as, isLooseDecorated as at, isData as au, isLooseData as av, type FormatToWGSLType as aw, type TgpuVertexFormatData as ax, formatToWGSLType as ay, packedFormats as az, type I32 as b, float32x2 as b0, float32x3 as b1, float32x4 as b2, uint32 as b3, uint32x2 as b4, uint32x3 as b5, uint32x4 as b6, sint32 as b7, sint32x2 as b8, sint32x3 as b9, sint32x4 as ba, unorm10_10_10_2 as bb, unorm8x4_bgra as bc, type PackedData as bd, type InterpolationType as be, type LooseTypeLiteral as bf, type PerspectiveOrLinearInterpolationType as bg, type PerspectiveOrLinearInterpolatableData as bh, type FlatInterpolationType as bi, type FlatInterpolatableData as bj, type VecKind as bk, type vBaseForMat as bl, type v2h as bm, type v3h as bn, type v4h as bo, type atomicI32 as bp, type atomicU32 as bq, 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 AnyWgslStruct as n, type Default as o, type UnionToIntersection as p, type WgslArray as q, type Disarray as r, type Unstruct as s, type VertexFormat as t, type TgpuVertexAttrib as u, type KindToAcceptedAttribMap as v, type AnyData as w, type WgslTypeLiteral as x, type InferPartial as y, type MemIdentity as z };
+export { $internal as $, type AnyWgslData as A, type BaseData as B, type Default as C, type Decorated as D, type InferGPU as E, type F32 as F, type AnyVecInstance as G, type AnyMatInstance as H, type Infer as I, type Bool as J, type KindToDefaultFormatMap as K, type Location as L, type Mutable as M, type Ptr as N, type OmitProps as O, type Prettify as P, type Vec2b as Q, type Vec3b as R, type Vec4b as S, type TgpuNamable as T, type U32 as U, type Vec2f as V, type WgslStruct as W, type Unstruct as X, type Mat2x2f as Y, type Mat3x3f as Z, type Mat4x4f as _, type F16 as a, float16 as a$, type m2x2f as a0, type m3x3f as a1, type m4x4f as a2, type Atomic as a3, isWgslData as a4, isWgslArray as a5, isWgslStruct as a6, isPtr as a7, isAtomic as a8, isDecorated as a9, type TgpuVertexFormatData as aA, formatToWGSLType as aB, packedFormats as aC, uint8 as aD, uint8x2 as aE, uint8x4 as aF, sint8 as aG, sint8x2 as aH, sint8x4 as aI, unorm8 as aJ, unorm8x2 as aK, unorm8x4 as aL, snorm8 as aM, snorm8x2 as aN, snorm8x4 as aO, uint16 as aP, uint16x2 as aQ, uint16x4 as aR, sint16 as aS, sint16x2 as aT, sint16x4 as aU, unorm16 as aV, unorm16x2 as aW, unorm16x4 as aX, snorm16 as aY, snorm16x2 as aZ, snorm16x4 as a_, isAlignAttrib as aa, isBuiltinAttrib as ab, isLocationAttrib as ac, isInterpolateAttrib as ad, isSizeAttrib as ae, type Size as af, type Align as ag, type Builtin as ah, type Interpolate as ai, type v2f as aj, type v2i as ak, type v2u as al, type v3f as am, type v3i as an, type v3u as ao, type v4f as ap, type v4i as aq, type v4u as ar, type LooseDecorated as as, type AnyLooseData as at, isDisarray as au, isUnstruct as av, isLooseDecorated as aw, isData as ax, isLooseData as ay, type FormatToWGSLType as az, type I32 as b, float16x2 as b0, float16x4 as b1, float32 as b2, float32x2 as b3, float32x3 as b4, float32x4 as b5, uint32 as b6, uint32x2 as b7, uint32x3 as b8, uint32x4 as b9, type atomicU32 as bA, sint32 as ba, sint32x2 as bb, sint32x3 as bc, sint32x4 as bd, unorm10_10_10_2 as be, unorm8x4_bgra as bf, type PackedData as bg, type InterpolationType as bh, type LooseTypeLiteral as bi, type PerspectiveOrLinearInterpolationType as bj, type PerspectiveOrLinearInterpolatableData as bk, type FlatInterpolationType as bl, type FlatInterpolatableData as bm, type TgpuDualFn as bn, type AnyNumericVecInstance as bo, type vBaseForMat as bp, type AnyFloatVecInstance as bq, type v3h as br, type AnyVec2Instance as bs, type v2b as bt, type AnyVec3Instance as bu, type v3b as bv, type v4b as bw, type AnyBooleanVecInstance as bx, type ScalarData as by, type atomicI32 as bz, 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 AnyWgslStruct as n, $repr as o, type WgslArray as p, type Disarray as q, type AnyUnstruct as r, type VertexFormat as s, type TgpuVertexAttrib as t, type KindToAcceptedAttribMap as u, type AnyData as v, type WgslTypeLiteral as w, type UnionToIntersection as x, type InferPartial as y, type MemIdentity as z };