import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactNode } from 'react';

type Palette = {
    a: [number, number, number];
    b: [number, number, number];
    c: [number, number, number];
    d: [number, number, number];
};
declare const PALETTES: {
    prism: Palette;
    berry: Palette;
    lagoon: Palette;
    citrus: Palette;
    azure: Palette;
    ember: Palette;
};
type PaletteName = keyof typeof PALETTES;

type Direction = 'ltr' | 'rtl' | 'ttb' | 'btt';
type ShaderController = {
    canvas: HTMLCanvasElement;
    setProgress: (p: number) => void;
    setAlpha: (a: number) => void;
    setPalette: (p: Palette) => void;
    setBandTight: (b: number) => void;
    setDirection: (d: Direction) => void;
    setWaveAmount: (v: number) => void;
    setRippleAmount: (v: number) => void;
    setWaveSpeed: (v: number) => void;
    setBrightness: (v: number) => void;
    setSwellAmount: (v: number) => void;
    getProgress: () => number;
    getAlpha: () => number;
    destroy: () => void;
};

declare const EASINGS: {
    linear: (p: number) => number;
    easeOutQuart: (p: number) => number;
    easeOutCubic: (p: number) => number;
    easeInCubic: (p: number) => number;
    easeInOutCubic: (p: number) => number;
    easeOutExpo: (p: number) => number;
    easeInOutQuint: (p: number) => number;
    snap: Easing;
    ease: Easing;
    back: Easing;
};
type EasingName = keyof typeof EASINGS;

type Easing = (p: number) => number;
type SweepOptions = {
    /** ms for the band to traverse. Default 1100. */
    sweepMs?: number;
    /** ms for the post-traversal fade-out. Default 700. */
    outroMs?: number;
    /** 0..1, when in the sweep to fire `onMidpoint` (i.e. swap pages). Default 0.56. */
    midpoint?: number;
    palette?: PaletteName | Palette;
    bandTight?: number;
    direction?: Direction;
    easing?: EasingName | Easing;
    /** Caps the band's peak alpha. 0..1.5, default 1. Useful for dimming. */
    peakAlpha?: number;
    /** 0..2, opt-in edge displacement. 0 = straight default, 1 = organic, 2 = strong. */
    waveAmount?: number;
    /** 0..2, vertical ripple texture intensity. 0 = smooth, 1 = default. */
    rippleAmount?: number;
    /** 0..3, multiplies all time-based shader motion. 1 = default. */
    waveSpeed?: number;
    /** 0..1.5, multiplies the band's RGB. Lower it on dark backgrounds so the
     *  iridescent colours don't read as harsh whites. 1 = default. */
    brightness?: number;
    /** 0..1, depth/iridescent swell on top of the flat band. 0 = legacy flat
     *  stripe, 1 = full crest highlight + Fresnel rim. Default left to the
     *  shader controller (0.55). */
    swellAmount?: number;
    /** Called once the band has reached `midpoint`. Use this to navigate / swap content. */
    onMidpoint?: () => void | Promise<void>;
    /** Called when the full animation (incl. outro) finishes. */
    onComplete?: () => void;
};
type SweepHandle = {
    /** Resolves when the band reaches the configured midpoint. */
    midpoint: Promise<void>;
    /** Resolves when the outro fade finishes. */
    done: Promise<void>;
    /**
     * Cancel mid-flight. Stops the animation loop but leaves the shader's
     * current alpha/progress untouched so a following sweep can continue
     * from where this one was.
     */
    cancel: () => void;
};

/** A factory matching `createShader`'s signature. Lets callers swap in a
 *  different shader controller implementation (e.g. `createMeshShader`)
 *  without rewriting the provider. */
type ShaderFactory = (opts: {
    canvas: HTMLCanvasElement;
    palette?: Palette;
    bandTight?: number;
    direction?: Direction;
}) => ShaderController | null;
type GlimmDefaults = Omit<SweepOptions, 'onMidpoint' | 'onComplete'> & {
    /** 'instant' skips the sweep, 'sweep' plays anyway. Default 'instant'. */
    reducedMotion?: 'instant' | 'sweep';
    /** z-index of the canvas overlay. Default 9999. */
    zIndex?: number;
    /** Optional override for the shader controller factory. Defaults to the
     *  fullscreen-quad `createShader`; pass `createMeshShader` (or any other
     *  ShaderFactory) to use a different sweep look in this subtree. */
    shaderFactory?: ShaderFactory;
    /** Fires once when the underlying shader controller is created. Lets
     *  callers grab a ref to the controller for live tuning (e.g. piping
     *  idea-playground flags into a MeshShaderController). */
    onController?: (ctrl: ShaderController) => void;
};
type SweepFn = (
/** A function that triggers your navigation (router.push, etc.). Awaited inside the sweep. */
navigate: () => void | Promise<void>, 
/** Per-call overrides (merged over provider defaults). */
options?: SweepOptions) => SweepHandle;
type Ctx = {
    sweep: SweepFn;
    defaults: GlimmDefaults;
};
declare function useGlimm(): Ctx;
declare function GlimmProvider({ children, ...defaults }: GlimmDefaults & {
    children: ReactNode;
}): react_jsx_runtime.JSX.Element;

export { type Direction, EASINGS, type EasingName, type GlimmDefaults, GlimmProvider, PALETTES, type Palette, type PaletteName, type SweepFn, type SweepHandle, type SweepOptions, useGlimm };