typegpu 0.3.0 → 0.3.1

package/index-CopjPGJg.d.cts

@@ -0,0 +1,749 @@
+import { D as Decorated, U as U32, r as Builtin, d as Vec4f, W as WgslArray, F as F32, l as Vec3u, B as BaseWgslData, s as Bool, b as I32, a as F16, n as WgslStruct, A as AnyWgslData, I as Infer$1, N as NativeVec2u, t as NativeVec4u, u as NativeVec2i, v as NativeVec4i, w as NativeVec2f, x as NativeVec4f, y as NativeVec3f, z as NativeVec3u, C as NativeVec3i, E as InferRecord, G as m2x2f, H as m3x3f, J as m4x4f, M as Mat2x2f, K as v2f, O as Mat3x3f, P as v3f, Q as Mat4x4f, R as v4f, S as Atomic, T as Align, X as Size, L as Location, Y as Interpolate, Z as InterpolationType, _ as PerspectiveOrLinearInterpolationType, $ as PerspectiveOrLinearInterpolatableData, a0 as FlatInterpolationType, a1 as FlatInterpolatableData, o as WgslTypeLiteral } from './vector-BSez01sn.cjs';
+
+/**
+ * Can be assigned a name. Not to be confused with
+ * being able to HAVE a name.
+ */
+interface TgpuNamable {
+    $name(label?: string | undefined): this;
+}
+
+/**
+ * Strips schema types down to their most basic forms. (native -> exotic)
+ * This is used by schema constructors to be able to ingest native schemas (created by TypeGPU), and
+ * spit out a type that matches non-native schemas as well.
+ */
+type Exotic<T> = T extends {
+    readonly '~exotic': infer TExotic;
+} ? TExotic : T;
+type ExoticArray<T> = T extends unknown[] | [] ? {
+    [Key in keyof T]: Exotic<T[Key]>;
+} : T;
+type ExoticRecord<T> = T extends Record<string | number | symbol, unknown> ? {
+    [Key in keyof T]: Exotic<T[Key]>;
+} : T;
+
+type BuiltinVertexIndex = Decorated<U32, [Builtin<'vertex_index'>]>;
+type BuiltinInstanceIndex = Decorated<U32, [Builtin<'instance_index'>]>;
+type BuiltinPosition = Decorated<Vec4f, [Builtin<'position'>]>;
+type BuiltinClipDistances = Decorated<WgslArray<U32>, [
+    Builtin<'clip_distances'>
+]>;
+type BuiltinFrontFacing = Decorated<F32, [Builtin<'front_facing'>]>;
+type BuiltinFragDepth = Decorated<F32, [Builtin<'frag_depth'>]>;
+type BuiltinSampleIndex = Decorated<U32, [Builtin<'sample_index'>]>;
+type BuiltinSampleMask = Decorated<U32, [Builtin<'sample_mask'>]>;
+type BuiltinFragment = Decorated<Vec4f, [Builtin<'fragment'>]>;
+type BuiltinLocalInvocationId = Decorated<Vec3u, [
+    Builtin<'local_invocation_id'>
+]>;
+type BuiltinLocalInvocationIndex = Decorated<U32, [
+    Builtin<'local_invocation_index'>
+]>;
+type BuiltinGlobalInvocationId = Decorated<Vec3u, [
+    Builtin<'global_invocation_id'>
+]>;
+type BuiltinWorkgroupId = Decorated<Vec3u, [Builtin<'workgroup_id'>]>;
+type BuiltinNumWorkgroups = Decorated<Vec3u, [
+    Builtin<'num_workgroups'>
+]>;
+declare const builtin: {
+    readonly vertexIndex: BuiltinVertexIndex;
+    readonly instanceIndex: BuiltinInstanceIndex;
+    readonly position: BuiltinPosition;
+    readonly clipDistances: BuiltinClipDistances;
+    readonly frontFacing: BuiltinFrontFacing;
+    readonly fragDepth: BuiltinFragDepth;
+    readonly sampleIndex: BuiltinSampleIndex;
+    readonly sampleMask: BuiltinSampleMask;
+    readonly localInvocationId: BuiltinLocalInvocationId;
+    readonly localInvocationIndex: BuiltinLocalInvocationIndex;
+    readonly globalInvocationId: BuiltinGlobalInvocationId;
+    readonly workgroupId: BuiltinWorkgroupId;
+    readonly numWorkgroups: BuiltinNumWorkgroups;
+};
+type AnyBuiltin = (typeof builtin)[keyof typeof builtin];
+type OmitBuiltins<S> = S extends AnyBuiltin ? never : S extends BaseWgslData ? S : {
+    [Key in keyof S as S[Key] extends AnyBuiltin ? never : Key]: S[Key];
+};
+
+/**
+ * A schema that represents a boolean value. (equivalent to `bool` in WGSL)
+ */
+declare const bool: Bool;
+/**
+ * Unsigned 32-bit integer schema representing a single WGSL u32 value.
+ */
+type NativeU32 = U32 & {
+    '~exotic': U32;
+} & ((v: number | boolean) => number);
+/**
+ * A schema that represents an unsigned 32-bit integer value. (equivalent to `u32` in WGSL)
+ *
+ * Can also be called to cast a value to an u32 in accordance with WGSL casting rules.
+ *
+ * @example
+ * const value = u32(3.14); // 3
+ * @example
+ * const value = u32(-1); // 4294967295
+ * @example
+ * const value = u32(-3.1); // 0
+ */
+declare const u32: NativeU32;
+/**
+ * Signed 32-bit integer schema representing a single WGSL i32 value.
+ */
+type NativeI32 = I32 & {
+    '~exotic': I32;
+} & ((v: number | boolean) => number);
+/**
+ * A schema that represents a signed 32-bit integer value. (equivalent to `i32` in WGSL)
+ *
+ * Can also be called to cast a value to an i32 in accordance with WGSL casting rules.
+ *
+ * @example
+ * const value = i32(3.14); // 3
+ * @example
+ * const value = i32(-3.9); // -3
+ * @example
+ * const value = i32(10000000000) // 1410065408
+ */
+declare const i32: NativeI32;
+/**
+ * 32-bit float schema representing a single WGSL f32 value.
+ */
+type NativeF32 = F32 & {
+    '~exotic': F32;
+} & ((v: number | boolean) => number);
+/**
+ * A schema that represents a 32-bit float value. (equivalent to `f32` in WGSL)
+ *
+ * Can also be called to cast a value to an f32.
+ *
+ * @example
+ * const value = f32(true); // 1
+ */
+declare const f32: NativeF32;
+/**
+ * 16-bit float schema representing a single WGSL f16 value.
+ */
+type NativeF16 = F16 & {
+    '~exotic': F16;
+} & ((v: number | boolean) => number);
+/**
+ * A schema that represents a 16-bit float value. (equivalent to `f16` in WGSL)
+ *
+ * Can also be called to cast a value to an f16.
+ *
+ * @example
+ * const value = f16(true); // 1
+ * @example
+ * const value = f16(21877.5); // 21872
+ */
+declare const f16: NativeF16;
+
+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];
+};
+
+/**
+ * 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 TgpuStruct<TProps extends Record<string, BaseWgslData>> extends WgslStruct<TProps>, TgpuNamable {
+    readonly '~exotic': WgslStruct<ExoticRecord<TProps>>;
+}
+/**
+ * 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.
+ */
+declare const struct: <TProps extends Record<string, AnyWgslData>>(props: TProps) => TgpuStruct<Prettify<ExoticRecord<TProps>>>;
+
+/**
+ * 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 TgpuArray<TElement extends AnyWgslData> extends WgslArray<TElement> {
+    readonly '~exotic': WgslArray<Exotic<TElement>>;
+}
+/**
+ * Creates an array schema that can be used to construct gpu buffers.
+ * Describes arrays with fixed-size length, storing elements of the same type.
+ *
+ * @example
+ * const LENGTH = 3;
+ * const array = d.arrayOf(d.u32, LENGTH);
+ *
+ * @param elementType The type of elements in the array.
+ * @param elementCount The number of elements in the array.
+ */
+declare const arrayOf: <TElement extends AnyWgslData>(elementType: TElement, elementCount: number) => TgpuArray<Exotic<TElement>>;
+
+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$1<FormatToWGSLType<T>>;
+    readonly type: T;
+}
+declare const formatToWGSLType: {
+    readonly uint8: NativeU32;
+    readonly uint8x2: NativeVec2u;
+    readonly uint8x4: NativeVec4u;
+    readonly sint8: NativeI32;
+    readonly sint8x2: NativeVec2i;
+    readonly sint8x4: NativeVec4i;
+    readonly unorm8: NativeF32;
+    readonly unorm8x2: NativeVec2f;
+    readonly unorm8x4: NativeVec4f;
+    readonly snorm8: NativeF32;
+    readonly snorm8x2: NativeVec2f;
+    readonly snorm8x4: NativeVec4f;
+    readonly uint16: NativeU32;
+    readonly uint16x2: NativeVec2u;
+    readonly uint16x4: NativeVec4u;
+    readonly sint16: NativeI32;
+    readonly sint16x2: NativeVec2i;
+    readonly sint16x4: NativeVec4i;
+    readonly unorm16: NativeF32;
+    readonly unorm16x2: NativeVec2f;
+    readonly unorm16x4: NativeVec4f;
+    readonly snorm16: NativeF32;
+    readonly snorm16x2: NativeVec2f;
+    readonly snorm16x4: NativeVec4f;
+    readonly float16: NativeF32;
+    readonly float16x2: NativeVec2f;
+    readonly float16x4: NativeVec4f;
+    readonly float32: NativeF32;
+    readonly float32x2: NativeVec2f;
+    readonly float32x3: NativeVec3f;
+    readonly float32x4: NativeVec4f;
+    readonly uint32: NativeU32;
+    readonly uint32x2: NativeVec2u;
+    readonly uint32x3: NativeVec3u;
+    readonly uint32x4: NativeVec4u;
+    readonly sint32: NativeI32;
+    readonly sint32x2: NativeVec2i;
+    readonly sint32x3: NativeVec3i;
+    readonly sint32x4: NativeVec4i;
+    readonly 'unorm10-10-10-2': NativeVec4f;
+    readonly 'unorm8x4-bgra': NativeVec4f;
+};
+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 BaseWgslData = BaseWgslData> {
+    readonly type: 'disarray';
+    readonly elementCount: number;
+    readonly elementType: TElement;
+    readonly '~repr': Infer$1<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, BaseWgslData> = Record<string, BaseWgslData>> {
+    readonly type: 'unstruct';
+    readonly propTypes: TProps;
+    readonly '~repr': InferRecord<TProps>;
+}
+interface LooseDecorated<TInner extends BaseWgslData = BaseWgslData, TAttribs extends unknown[] = unknown[]> {
+    readonly type: 'loose-decorated';
+    readonly inner: TInner;
+    readonly attribs: TAttribs;
+    readonly '~repr': Infer$1<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;
+
+/**
+ * Creates an array schema that can be used to construct vertex buffers.
+ * Describes arrays with fixed-size length, storing elements of the same type.
+ *
+ * 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.
+ *
+ * @example
+ * const disarray = d.disarrayOf(d.vec3f, 3); // packed array of vec3f
+ *
+ * @example
+ * const disarray = d.disarrayOf(d.align(16, d.vec3f), 3);
+ *
+ * @param elementType The type of elements in the array.
+ * @param count The number of elements in the array.
+ */
+declare const disarrayOf: <TElement extends AnyData>(elementType: TElement, count: number) => Disarray<Exotic<TElement>>;
+
+/**
+ * Creates a loose struct schema that can be used to construct vertex buffers.
+ * Describes structs with members of both loose and non-loose types.
+ *
+ * The order of members matches the passed in properties object.
+ * Members are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ *
+ * @example
+ * const CircleStruct = d.unstruct({ radius: d.f32, pos: d.vec3f }); // packed struct with no padding
+ *
+ * @example
+ * const CircleStruct = d.unstruct({ radius: d.f32, pos: d.align(16, d.vec3f) });
+ *
+ * @param properties Record with `string` keys and `TgpuData` or `TgpuLooseData` values,
+ * each entry describing one struct member.
+ */
+declare const unstruct: <TProps extends Record<string, BaseWgslData>>(properties: TProps) => Unstruct<ExoticRecord<TProps>>;
+
+/**
+ * Type of the `d.mat2x2f` object/function: matrix data type schema/constructor
+ */
+type NativeMat2x2f = Mat2x2f & {
+    '~exotic': Mat2x2f;
+} & ((...elements: number[]) => m2x2f) & ((...columns: v2f[]) => m2x2f) & (() => m2x2f);
+/**
+ *
+ * Schema representing mat2x2f - a matrix with 2 rows and 2 columns, with elements of type f32.
+ * Also a constructor function for this matrix type.
+ *
+ * @example
+ * const zero2x2 = mat2x2f(); // filled with zeros
+ *
+ * @example
+ * const mat = mat2x2f(0, 1, 2, 3);
+ * mat[0] // vec2f(0, 1)
+ * mat[1] // vec2f(2, 3)
+ *
+ * @example
+ * const mat = mat2x2f(
+ *  vec2f(0, 1), // column 0
+ *  vec2f(1, 2), // column 1
+ * );
+ *
+ * @example
+ * const buffer = root.createBuffer(d.mat2x2f, d.mat2x2f(0, 1, 2, 3)); // buffer holding a d.mat2x2f value, with an initial value of ((0, 1), (2, 3))
+ */
+declare const mat2x2f: NativeMat2x2f;
+/**
+ * Type of the `d.mat3x3f` object/function: matrix data type schema/constructor
+ */
+type NativeMat3x3f = Mat3x3f & {
+    '~exotic': Mat3x3f;
+} & ((...elements: number[]) => m3x3f) & ((...columns: v3f[]) => m3x3f) & (() => m3x3f);
+/**
+ *
+ * Schema representing mat3x3f - a matrix with 3 rows and 3 columns, with elements of type f32.
+ * Also a constructor function for this matrix type.
+ *
+ * @example
+ * const zero3x3 = mat3x3f(); // filled with zeros
+ *
+ * @example
+ * const mat = mat3x3f(0, 1, 2, 3, 4, 5, 6, 7, 8);
+ * mat[0] // vec3f(0, 1, 2)
+ * mat[1] // vec3f(3, 4, 5)
+ * mat[2] // vec3f(6, 7, 8)
+ *
+ * @example
+ * const mat = mat3x3f(
+ *  vec3f(0, 1, 2), // column 0
+ *  vec3f(2, 3, 4), // column 1
+ *  vec3f(5, 6, 7), // column 2
+ * );
+ *
+ * @example
+ * const buffer = root.createBuffer(d.mat3x3f, d.mat3x3f()); // buffer holding a d.mat3x3f value, with an initial value of mat3x3f filled with zeros
+ */
+declare const mat3x3f: NativeMat3x3f;
+/**
+ * Type of the `d.mat4x4f` object/function: matrix data type schema/constructor
+ */
+type NativeMat4x4f = Mat4x4f & {
+    '~exotic': Mat4x4f;
+} & ((...elements: number[]) => m4x4f) & ((...columns: v4f[]) => m4x4f) & (() => m4x4f);
+/**
+ *
+ * Schema representing mat4x4f - a matrix with 4 rows and 4 columns, with elements of type f32.
+ * Also a constructor function for this matrix type.
+ *
+ * @example
+ * const zero4x4 = mat4x4f(); // filled with zeros
+ *
+ * @example
+ * const mat = mat3x3f(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ * mat[0] // vec4f(0, 1, 2, 3)
+ * mat[1] // vec4f(4, 5, 6, 7)
+ * mat[2] // vec4f(8, 9, 10, 11)
+ * mat[3] // vec4f(12, 13, 14, 15)
+ *
+ * @example
+ * const mat = mat3x3f(
+ *  vec4f(0, 1, 2, 3),     // column 0
+ *  vec4f(4, 5, 6, 7),     // column 1
+ *  vec4f(8, 9, 10, 11),   // column 2
+ *  vec4f(12, 13, 14, 15), // column 3
+ * );
+ *
+ * @example
+ * const buffer = root.createBuffer(d.mat4x4f, d.mat4x4f()); // buffer holding a d.mat4x4f value, with an initial value of mat4x4f filled with zeros
+ */
+declare const mat4x4f: NativeMat4x4f;
+declare function matToArray(mat: m2x2f | m3x3f | m4x4f): number[];
+
+/**
+ * Marks a concrete integer scalar type schema (u32 or i32) as a WGSL atomic.
+ *
+ * @example
+ * const atomicU32 = d.atomic(d.u32);
+ * const atomicI32 = d.atomic(d.i32);
+ *
+ * @param data Underlying type schema.
+ */
+declare function atomic<TSchema extends U32 | I32>(data: TSchema): Atomic<Exotic<TSchema>>;
+
+declare const builtinNames: readonly ["vertex_index", "instance_index", "position", "clip_distances", "front_facing", "frag_depth", "sample_index", "sample_mask", "fragment", "local_invocation_id", "local_invocation_index", "global_invocation_id", "workgroup_id", "num_workgroups"];
+type BuiltinName = (typeof builtinNames)[number];
+type AnyAttribute = Align<number> | Size<number> | Location<number> | Builtin<BuiltinName> | Interpolate<InterpolationType>;
+type ExtractAttributes<T> = T extends {
+    readonly attribs: unknown[];
+} ? T['attribs'] : [];
+type Undecorate<T> = T extends {
+    readonly inner: infer TInner;
+} ? TInner : T;
+/**
+ * Decorates a data-type `TData` with an attribute `TAttrib`.
+ *
+ * - if `TData` is loose
+ *   - if `TData` is already `LooseDecorated`
+ *     - Prepend `TAttrib` to the existing attribute tuple.
+ *   - else
+ *     - Wrap `TData` with `LooseDecorated` and a single attribute `[TAttrib]`
+ * - else
+ *   - if `TData` is already `Decorated`
+ *     - Prepend `TAttrib` to the existing attribute tuple.
+ *   - else
+ *     - Wrap `TData` with `Decorated` and a single attribute `[TAttrib]`
+ */
+type Decorate<TData extends BaseWgslData, TAttrib extends AnyAttribute> = TData['type'] extends WgslTypeLiteral ? Decorated<Undecorate<TData>, [TAttrib, ...ExtractAttributes<TData>]> : TData['type'] extends LooseTypeLiteral ? LooseDecorated<Undecorate<TData>, [TAttrib, ...ExtractAttributes<TData>]> : never;
+type IsBuiltin<T> = ExtractAttributes<T>[number] extends [] ? false : ExtractAttributes<T>[number] extends Builtin<BuiltinName> ? true : false;
+type HasCustomLocation<T> = ExtractAttributes<T>[number] extends [] ? false : ExtractAttributes<T>[number] extends Location<number> ? true : false;
+/**
+ * Gives the wrapped data-type a custom byte alignment. Useful in order to
+ * fulfill uniform alignment requirements.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: u32, // takes up 4 bytes
+ *   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
+ *   b: d.align(16, u32),
+ * });
+ *
+ * @param alignment The multiple of bytes this data should align itself to.
+ * @param data The data-type to align.
+ */
+declare function align<TAlign extends number, TData extends AnyData>(alignment: TAlign, data: TData): Decorate<Exotic<TData>, Align<TAlign>>;
+/**
+ * Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: d.size(16, u32), // takes up 16 bytes, instead of 4
+ *   b: u32, // starts at byte 16, because `a` has a custom size
+ * });
+ *
+ * @param size The amount of bytes that should be reserved for this data-type.
+ * @param data The data-type to wrap.
+ */
+declare function size<TSize extends number, TData extends AnyData>(size: TSize, data: TData): Decorate<Exotic<TData>, Size<TSize>>;
+/**
+ * Assigns an explicit numeric location to a struct member or a parameter that has this type.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.u32, // has implicit location 0
+ *   b: d.location(5, d.u32),
+ *   c: d.u32, // has implicit location 6
+ * };
+ *
+ * @param location The explicit numeric location.
+ * @param data The data-type to wrap.
+ */
+declare function location<TLocation extends number, TData extends AnyData>(location: TLocation, data: TData): Decorate<Exotic<TData>, Location<TLocation>>;
+/**
+ * Specifies how user-defined vertex shader output (fragment shader input)
+ * must be interpolated.
+ *
+ * Tip: Integer outputs cannot be interpolated.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.f32, // has implicit 'perspective, center' interpolation
+ *   b: d.interpolate('linear, sample', d.f32),
+ * };
+ *
+ * @param interpolationType How data should be interpolated.
+ * @param data The data-type to wrap.
+ */
+declare function interpolate<TInterpolation extends PerspectiveOrLinearInterpolationType, TData extends PerspectiveOrLinearInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<Exotic<TData>, Interpolate<TInterpolation>>;
+/**
+ * Specifies how user-defined vertex shader output (fragment shader input)
+ * must be interpolated.
+ *
+ * Tip: Default sampling method of `flat` is `first`. Unless you specifically
+ * need deterministic behavior provided by `'flat, first'`, prefer explicit
+ * `'flat, either'` as it could be slightly faster in hardware.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.f32, // has implicit 'perspective, center' interpolation
+ *   b: d.interpolate('flat, either', d.u32), // integer outputs cannot interpolate
+ * };
+ *
+ * @param interpolationType How data should be interpolated.
+ * @param data The data-type to wrap.
+ */
+declare function interpolate<TInterpolation extends FlatInterpolationType, TData extends FlatInterpolatableData>(interpolationType: TInterpolation, data: TData): Decorate<Exotic<TData>, Interpolate<TInterpolation>>;
+declare function isBuiltin<T extends Decorated<AnyWgslData, AnyAttribute[]> | LooseDecorated<AnyLooseData, AnyAttribute[]>>(value: T | unknown): value is T;
+
+/**
+ * Returns the size (in bytes) of data represented by the `schema`.
+ */
+declare function PUBLIC_sizeOf(schema: AnyData): number;
+
+/**
+ * Returns the alignment (in bytes) of data represented by the `schema`.
+ */
+declare function PUBLIC_alignmentOf(schema: AnyData): number;
+
+/**
+ * @module typegpu/data
+ */
+
+/**
+ * Extracts the inferred representation of a resource.
+ * @example
+ * type A = Infer<F32> // => number
+ * type B = Infer<TgpuArray<F32>> // => number[]
+ */
+type Infer<T> = Infer$1<Exotic<T>>;
+
+export { type BuiltinVertexIndex as $, type AnyBuiltin as A, atomic as B, align as C, type Default as D, type Exotic as E, size as F, location as G, type HasCustomLocation as H, type IsBuiltin as I, interpolate as J, type KindToAcceptedAttribMap as K, type LooseDecorated as L, type Mutable as M, isBuiltin as N, type OmitBuiltins as O, type Prettify as P, isDisarray as Q, isUnstruct as R, isLooseDecorated as S, type TgpuNamable as T, type UnionToIntersection as U, type VertexFormat as V, isData as W, isLooseData as X, PUBLIC_sizeOf as Y, PUBLIC_alignmentOf as Z, builtin as _, type AnyAttribute as a, type BuiltinInstanceIndex as a0, type BuiltinPosition as a1, type BuiltinClipDistances as a2, type BuiltinFrontFacing as a3, type BuiltinFragDepth as a4, type BuiltinSampleIndex as a5, type BuiltinSampleMask as a6, type BuiltinFragment as a7, type BuiltinLocalInvocationId as a8, type BuiltinLocalInvocationIndex as a9, unorm16x4 as aA, snorm16 as aB, snorm16x2 as aC, snorm16x4 as aD, float16 as aE, float16x2 as aF, float16x4 as aG, float32 as aH, float32x2 as aI, float32x3 as aJ, float32x4 as aK, uint32 as aL, uint32x2 as aM, uint32x3 as aN, uint32x4 as aO, sint32 as aP, sint32x2 as aQ, sint32x3 as aR, sint32x4 as aS, unorm10_10_10_2 as aT, unorm8x4_bgra as aU, type PackedData as aV, type BuiltinGlobalInvocationId as aa, type BuiltinWorkgroupId as ab, type BuiltinNumWorkgroups as ac, type FormatToWGSLType as ad, type TgpuVertexFormatData as ae, packedFormats as af, uint8 as ag, uint8x2 as ah, uint8x4 as ai, sint8 as aj, sint8x2 as ak, sint8x4 as al, unorm8 as am, unorm8x2 as an, unorm8x4 as ao, snorm8 as ap, snorm8x2 as aq, snorm8x4 as ar, uint16 as as, uint16x2 as at, uint16x4 as au, sint16 as av, sint16x2 as aw, sint16x4 as ax, unorm16 as ay, unorm16x2 as az, type AnyData as b, type Decorate as c, type TgpuStruct as d, type Disarray as e, type Unstruct as f, type TgpuVertexAttrib as g, type KindToDefaultFormatMap as h, type OmitProps as i, type Infer as j, type ExoticArray as k, bool as l, f32 as m, f16 as n, i32 as o, type TgpuArray as p, arrayOf as q, type AnyLooseData as r, struct as s, disarrayOf as t, u32 as u, unstruct as v, mat2x2f as w, mat3x3f as x, mat4x4f as y, matToArray as z };