import { d } from './index';

/** `mx_rotl32`: rotate-left a u32 by k bits. `(x << k) | (x >> (32 - k))`. */
export declare const mxRotl32: import('typegpu').TgpuFn<(x: d.U32, k: d.I32) => d.U32>;
/** `mx_bjfinal`: final mixing of three u32 accumulators → one u32 hash. */
export declare const mxBjfinal: import('typegpu').TgpuFn<(a0: d.U32, b0: d.U32, c0: d.U32) => d.U32>;
/** `mx_hash_int` (2 ints). */
export declare const mxHashInt1: import('typegpu').TgpuFn<(x: d.I32, y: d.I32) => d.U32>;
/** `mx_hash_int` (3 ints). */
export declare const mxHashInt2: import('typegpu').TgpuFn<(x: d.I32, y: d.I32, z: d.I32) => d.U32>;
/** `mx_hash_int` (4 ints) — includes the `mx_bjmix` round (inlined; no by-ref args in TGSL). */
export declare const mxHashInt3: import('typegpu').TgpuFn<(x: d.I32, y: d.I32, z: d.I32, xx: d.I32) => d.U32>;
/** `mx_bits_to_01`: map a u32 to [0,1] by dividing by 0xffffffff. */
export declare const mxBitsTo01: import('typegpu').TgpuFn<(bits: d.U32) => d.F32>;
/** `mx_fade`: quintic smootherstep `t^3 (t (6t - 15) + 10)`. */
export declare const mxFade: import('typegpu').TgpuFn<(t: d.F32) => d.F32>;
/** `mx_gradient_float` (2D): hashed gradient dot for perlin. */
export declare const mxGradientFloat2: import('typegpu').TgpuFn<(hash: d.U32, x: d.F32, y: d.F32) => d.F32>;
/** `mx_gradient_float` (3D): hashed gradient dot for perlin. */
export declare const mxGradientFloat3: import('typegpu').TgpuFn<(hash: d.U32, x: d.F32, y: d.F32, z: d.F32) => d.F32>;
/** `mx_gradient_scale2d`: 0.6616 · v. */
export declare const mxGradientScale2d: import('typegpu').TgpuFn<(v: d.F32) => d.F32>;
/** `mx_gradient_scale3d`: 0.9820 · v. */
export declare const mxGradientScale3d: import('typegpu').TgpuFn<(v: d.F32) => d.F32>;
/** `mx_bilerp` (float). */
export declare const mxBilerp: import('typegpu').TgpuFn<(v0: d.F32, v1: d.F32, v2: d.F32, v3: d.F32, s: d.F32, t: d.F32) => d.F32>;
/** `mx_trilerp` (float). */
export declare const mxTrilerp: import('typegpu').TgpuFn<(v0: d.F32, v1: d.F32, v2: d.F32, v3: d.F32, v4: d.F32, v5: d.F32, v6: d.F32, v7: d.F32, s: d.F32, t: d.F32, r: d.F32) => d.F32>;
/** `mx_perlin_noise_float` (2D). */
export declare const mxPerlinNoiseFloat2: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** `mx_perlin_noise_float` (3D). */
export declare const mxPerlinNoiseFloat3: import('typegpu').TgpuFn<(p: d.Vec3f) => d.F32>;
/** `mx_cell_noise_vec3` (2D input). */
export declare const mxCellNoiseVec3_2d: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec3f>;
/** `mx_cell_noise_vec3` (3D input). */
export declare const mxCellNoiseVec3_3d: import('typegpu').TgpuFn<(p: d.Vec3f) => d.Vec3f>;
/** `mx_worley_distance` (2D). metric: 2=manhattan, 3=chebyshev, else squared euclidean. */
export declare const mxWorleyDistance2d: import('typegpu').TgpuFn<(p: d.Vec2f, x: d.I32, y: d.I32, xoff: d.I32, yoff: d.I32, jitter: d.F32, metric: d.I32) => d.F32>;
/** `mx_worley_distance` (3D). */
export declare const mxWorleyDistance3d: import('typegpu').TgpuFn<(p: d.Vec3f, x: d.I32, y: d.I32, z: d.I32, xoff: d.I32, yoff: d.I32, zoff: d.I32, jitter: d.F32, metric: d.I32) => d.F32>;
/** `mx_worley_noise_float` (2D). F1 nearest-cell distance; sqrt only for metric 0 (euclidean). */
export declare const mxWorleyNoiseFloat2: import('typegpu').TgpuFn<(p: d.Vec2f, jitter: d.F32, metric: d.I32) => d.F32>;
/** `mx_worley_noise_float` (3D). */
export declare const mxWorleyNoiseFloat3: import('typegpu').TgpuFn<(p: d.Vec3f, jitter: d.F32, metric: d.I32) => d.F32>;
/** `mx_noise_float(p: vec2)` with amplitude=1, pivot=0 → `mx_perlin_noise_float(p)`. */
export declare const mxNoiseFloat2: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** `mx_noise_float(p: vec3)` with amplitude=1, pivot=0 → `mx_perlin_noise_float(p)`. */
export declare const mxNoiseFloat3: import('typegpu').TgpuFn<(p: d.Vec3f) => d.F32>;
/** `mx_worley_noise_float(p: vec2, jitter)` — metric fixed to 1 (squared euclidean F1). */
export declare const mxWorleyNoiseFloat2Pub: import('typegpu').TgpuFn<(p: d.Vec2f, jitter: d.F32) => d.F32>;
/** `mx_worley_noise_float(p: vec3, jitter)` — metric fixed to 1. */
export declare const mxWorleyNoiseFloat3Pub: import('typegpu').TgpuFn<(p: d.Vec3f, jitter: d.F32) => d.F32>;
/** hash11 — float → float in [0, 1]. */
export declare const hash11: import('typegpu').TgpuFn<(p: d.F32) => d.F32>;
/** hash12 — vec2 → float in [0, 1]. */
export declare const hash12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** hash22 — vec2 → vec2 in [0, 1]². */
export declare const hash22: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec2f>;
/** hash32 — vec2 → vec3 in [0, 1]³. */
export declare const hash32: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec3f>;
/** hash13 — vec3 → float in [0, 1]. */
export declare const hash13: import('typegpu').TgpuFn<(p: d.Vec3f) => d.F32>;
/** hash33 — vec3 → vec3 in [0, 1]³. */
export declare const hash33: import('typegpu').TgpuFn<(p: d.Vec3f) => d.Vec3f>;
/** value12 — smoothstep-interpolated value noise, vec2 → [0, 1]. */
export declare const value12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** perlin12 — gradient noise, vec2 → roughly [0, 1] (×0.7 + 0.5). */
export declare const perlin12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/**
 * perlin12d — Perlin value + analytic gradient, vec2 → vec3 (value, dx, dy).
 * The gradient is used by Stone / Erosion / LiquidMetal / relief to warp / carve the field.
 */
export declare const perlin12d: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec3f>;
/** perm — vec4 helper for value13 (Quilez-style permutation). Pure float. */
export declare const perm4: import('typegpu').TgpuFn<(x: d.Vec4f) => d.Vec4f>;
/** value13 — 3D value noise, vec3 → [0, 1]. Pure float (no bitcast). */
export declare const value13: import('typegpu').TgpuFn<(p: d.Vec3f) => d.F32>;
/** perlin13 — 3D gradient noise, vec3 → roughly [0, 1]. */
export declare const perlin13: import('typegpu').TgpuFn<(p: d.Vec3f) => d.F32>;
/**
 * gabor12 — bilinearly-blended oriented sine grains, vec2 → [-1, 1]. `freq` is the in-cell wave
 * frequency (default 8); `phase` shifts the waves along their per-cell orientation.
 */
export declare const gabor12: import('typegpu').TgpuFn<(p: d.Vec2f, freq: d.F32, phase: d.F32) => d.F32>;
/** curl22 — divergence-free flow field, vec2 → vec2. */
export declare const curl22: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec2f>;
/**
 * curl22z — curl field that evolves in place along a third (time) axis, vec2 → vec2. Same as
 * curl22 but from 3D Perlin so animating `z` morphs the flow rather than sliding it.
 */
export declare const curl22z: import('typegpu').TgpuFn<(p: d.Vec2f, z: d.F32) => d.Vec2f>;
/**
 * wavelet12 — rotating banded wavelets, vec2 → roughly [-1, 1]. `phase` animates the bands;
 * `scale` is the per-octave frequency ratio. Pure float (fract-based hash, no bitcast).
 */
export declare const wavelet12: import('typegpu').TgpuFn<(p: d.Vec2f, phase: d.F32, scale: d.F32) => d.F32>;
/** blue12 — pixel-space blue noise, vec2(floored pixel coords) → ~[0, 1]. */
export declare const blue12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** hilbertBlue12 — vec2(floored pixel coords) → [0, 1] ordered blue noise. */
export declare const hilbertBlue12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** scratches12 — overlaid hairline scratches, vec2 → [0, ~12] (typically used with clamp). */
export declare const scratches12: import('typegpu').TgpuFn<(uv: d.Vec2f, time: d.F32, thickness: d.F32) => d.F32>;
/** fractal Perlin sum, vec2 → [0, 1]. */
export declare const fbmPerlin: import('typegpu').TgpuFn<(p: d.Vec2f, octaves: d.I32) => d.F32>;
/** stone12 — derivative-warped fractal noise, vec2 → [0, 1]. */
export declare const stone12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** wool12 — interwoven fibres, vec2 → [0, ~1]. */
export declare const wool12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.F32>;
/** erosion12 — hydraulic-erosion-style ridges, vec2 → vec3 (height in .x). */
export declare const erosion12: import('typegpu').TgpuFn<(p: d.Vec2f) => d.Vec3f>;
/** paper12 — fibrous paper grain, vec2 → roughly [0.4, 1]. `octaves` defaults to 10. */
export declare const paper12: import('typegpu').TgpuFn<(p: d.Vec2f, octaves: d.I32) => d.F32>;
//# sourceMappingURL=noise.d.ts.map