import { Expr } from '../../gpu/contract';
import { FilterParams } from '../../gpu/scaffolds/pointwiseFilter';
import { PointwiseEffect } from '../types';
import { ArgSpec } from '../invoke';
import { PropRef } from '../values';

/**
 * A coverage coordinate: a per-pixel scalar in [0,1] ordering when each pixel is wiped
 * (0 = goes first, 1 = goes last). Produced by the {@link coverage} namespace; refined by the
 * modifier methods, each of which returns a new coverage.
 */
export declare class Coverage {
    readonly build: (params: FilterParams) => Expr;
    constructor(build: (params: FilterParams) => Expr);
    /**
     * Fold the coordinate about its midpoint: 0 on the center line, 1 at both ends — one sweeping
     * front becomes two fronts opening outward (barn doors).
     */
    folded(): Coverage;
    /**
     * Tile the coordinate into `count` repeats, each tile crossing the same front in lockstep
     * (venetian blinds).
     */
    tiled(count: ArgSpec): Coverage;
    /**
     * Quantize the coordinate into `count` bands that vanish whole, one after another in
     * coordinate order (ring pops over a radial coverage). Chain `.shuffled()` to randomize the
     * band order instead.
     */
    bands(count: ArgSpec): BandedCoverage;
}
/** A banded coverage — bands vanish in coordinate order, or in stable random order via {@link BandedCoverage.shuffled}. */
export declare class BandedCoverage extends Coverage {
    constructor(base: Coverage, count: ArgSpec);
    private readonly base;
    private readonly count;
    /**
     * Give each band a stable random coverage (a hash of its index, no time dependence) so the
     * bands vanish in a frozen shuffled order (random bars).
     */
    shuffled(): Coverage;
}
/**
 * The cell-grid coverage family: the frame diced into square-ish cells `size` wide (as a fraction
 * of frame width, height aspect-corrected). Not a coverage by itself — pick how the cells order
 * their pixels: {@link diamond}, {@link checker}, or {@link shuffled}.
 */
export declare class CellCoverage {
    private readonly size;
    constructor(size: ArgSpec);
    /** Each pixel's coverage is its diamond distance from the cell center — a lattice of growing diamonds. */
    diamond(): Coverage;
    /** Cells vanish in the staggered checkerboard order: even-parity cells sweep corner-to-corner first, odd-parity second. */
    checker(): Coverage;
    /** Each cell gets a stable random coverage (a hash of its index, no time dependence) — blocks dissolve in a frozen random order. */
    shuffled(): Coverage;
}
/** The sweep direction of an angular coverage — a structural choice, baked into the compiled shader. */
export type AngularDirection = 'cw' | 'ccw' | 'both';
/** The coverage coordinate producers — one per family. All read the frame's own UV and aspect. */
export declare const coverage: {
    /**
     * 0→1 along `angleDeg` (degrees, 0 = left to right), aspect corrected so a diagonal reads as
     * a true angle and both extremes of the frame are reached exactly.
     */
    directional(angleDeg: ArgSpec): Coverage;
    /**
     * Distance from `center` (a position prop), normalized by the distance to the FARTHEST corner
     * so coverage 1 is reached at every pixel however off-center the origin is.
     */
    radial(center: ArgSpec): Coverage;
    /**
     * Clock-sweep fraction around `center`, measured from `startDeg`. `direction` is STRUCTURAL —
     * a compile-time string prop (bind with `p()`) or a literal `'cw' | 'ccw' | 'both'`, baked
     * into the compiled shader as a mode literal ('both' opens two wedges meeting on the far side).
     */
    angular(center: ArgSpec, startDeg: ArgSpec, direction: PropRef | AngularDirection): Coverage;
    /**
     * The frame diced into square-ish cells `size` wide (as a fraction of frame width). Pick the
     * per-cell ordering: `.diamond()`, `.checker()`, or `.shuffled()`.
     */
    cells(size: ArgSpec): CellCoverage;
    /**
     * An organic noise field (a stable 3-octave fbm, no time dependence) — the classic film
     * dissolve. `scale` sets the blob frequency; `seed` shifts the pattern.
     */
    noise(scale: ArgSpec, seed: ArgSpec): Coverage;
};
/** The reveal noun's slots: what orders the pixels, and the shared wipe timing. */
export interface RevealSlots {
    /** The coverage coordinate — which pixels go first. */
    coverage: Coverage;
    /** How far the wipe has travelled (0 = fully visible, 1 = fully wiped away). */
    progress: ArgSpec;
    /** Softness of the wipe front (the progress window a pixel crosses). */
    feather: ArgSpec;
    /** Reverse the coverage ordering (a boolean prop; flips the coordinate, not the progress). */
    invert: ArgSpec;
}
/**
 * Wipe the child away along a coverage coordinate: pixels vanish in coverage order as `progress`
 * grows, crossing a ±`feather` soft front remapped so both progress extremes clear completely.
 * Scales the straight-alpha child's alpha with RGB preserved — pointwise, no render-to-texture.
 */
export declare function reveal(slots: RevealSlots): PointwiseEffect;
//# sourceMappingURL=reveal.d.ts.map