import { d } from '../../gpu/kit/index';

/** Double heartbeat: two staggered sine spikes (the paper's beat()). */
export declare const heartbeatPulse: import('typegpu').TgpuFn<(animTime: d.F32) => d.F32>;
/**
 * The luminous band + smoke over a shape's distance field. Returns `vec2(border, angle01)`:
 *   border  — the band mask around the silhouette (hard ring at softness 0, wide gradient at 1),
 *             with the noisy smoke already added and the whole thing clamped to [0,1]
 *   angle01 — polar angle of the fragment around the shape centre, in turns
 * `beat` is the caller-computed heartbeatPulse(animTime), shared with orbitSpotsAccum.
 */
export declare const edgeGlowBand: import('typegpu').TgpuFn<(fieldRaw: d.F32, sdfUV: d.Vec2f, viewport: d.Vec2f, scale: d.F32, thickness: d.F32, softness: d.F32, smokeSize: d.F32, smokeAmt: d.F32, animTime: d.F32, pulse: d.F32, beat: d.F32) => d.Vec2f>;
/**
 * Sector accumulation for ONE color's orbiting spots. Up to 5 spots orbit the band with
 * hash-decorrelated speeds, directions, phases and sizes; each spot is an angular window ×
 * breathing mask × border × intensity. Returns `vec2(overSector, addSector)`: the
 * Porter-Duff-accumulated coverage (blend path) and the raw additive sum (bloom path). Spots
 * are runtime-gated by `spotsF`. `beat` is the caller-computed heartbeatPulse(animTime) — the
 * caller evaluates it ONCE per pixel and shares it across every per-color unrolled call.
 */
export declare const orbitSpotsAccum: import('typegpu').TgpuFn<(angle01: d.F32, border: d.F32, animTime: d.F32, beat: d.F32, spotsF: d.F32, spotSize: d.F32, pulse: d.F32, intensity: d.F32, softness: d.F32, seed: d.F32, colorIdxF: d.F32) => d.Vec2f>;
export declare const EdgeGlowAccum: d.WgslStruct<{
    rgb: d.Vec3f;
    w: d.F32;
    ba: d.F32;
    ac: d.Vec3f;
    aa: d.F32;
}>;
export declare const edgeGlowAccumZero: import('typegpu').TgpuFn<() => d.WgslStruct<{
    rgb: d.Vec3f;
    w: d.F32;
    ba: d.F32;
    ac: d.Vec3f;
    aa: d.F32;
}>>;
export declare function edgeGlowAccumColorFor(mode: number): import('typegpu').TgpuFn<(st: d.WgslStruct<{
    rgb: d.Vec3f;
    w: d.F32;
    ba: d.F32;
    ac: d.Vec3f;
    aa: d.F32;
}>, color: d.Vec4f, sectors: d.Vec2f) => d.WgslStruct<{
    rgb: d.Vec3f;
    w: d.F32;
    ba: d.F32;
    ac: d.Vec3f;
    aa: d.F32;
}>>;
/** One color from the packed stops uniform (positions ignored — the stops are a color LIST).
 *  Copied component-wise: TypeGPU forbids returning references to fn arguments. */
export declare const colorAtIndex: import('typegpu').TgpuFn<(colors: d.WgslArray<d.Vec4f>, idx: d.F32) => d.Vec4f>;
/**
 * Final composite — the `bloom = 4·bloom` blend/add extrapolation, over a TRANSPARENT
 * background. The blend path premultiplies the space-blended color by its coverage. Returns
 * STRAIGHT rgba.
 */
export declare const edgeGlowCompose: import('typegpu').TgpuFn<(st: d.WgslStruct<{
    rgb: d.Vec3f;
    w: d.F32;
    ba: d.F32;
    ac: d.Vec3f;
    aa: d.F32;
}>, bloom: d.F32) => d.Vec4f>;
//# sourceMappingURL=edgeGlow.d.ts.map