/**
 * Annular sector path builder with selective per-end corner rounding.
 *
 * d3-shape's `arc().cornerRadius()` rounds ALL FOUR corners of an
 * annular sector uniformly — there's no built-in per-corner control.
 * For gauges with multiple zones we want the gauge's OUTER endpoints
 * rounded (the swimlane convention applied radially) but internal zone
 * seams to stay square. This helper builds the path manually so each
 * end can be opted in independently.
 *
 * The geometry mirrors d3's algorithm: a corner circle of radius `cr`
 * is inscribed tangent to both walls (the outer/inner arc and the
 * radial line at the relevant angle). The angular setback from the
 * radial line is `asin(cr / (R ± cr))` — `R - cr` for outer corners
 * (corner centers sit `cr` inward of the outer arc), `R + cr` for
 * inner corners.
 *
 * Returned shape is an SVG path `d` attribute, equivalently consumable
 * by Path2D in canvas. Coordinates are wedge-local (centered at
 * origin); the renderer translates to `(cx, cy)`.
 *
 * Inputs use the **canvas angle convention** (0 = 3 o'clock, positive
 * clockwise) — same as `WedgeSceneNode.startAngle/endAngle`. d3-shape
 * uses 0 = 12 o'clock, so callers that pre-rotated by `+π/2` to call
 * d3-arc should NOT pre-rotate when calling this helper.
 */
export interface AnnularPathOptions {
    innerRadius: number;
    outerRadius: number;
    startAngle: number;
    endAngle: number;
    cornerRadius?: number;
    /** Round the side at startAngle (both inner + outer corners there). */
    roundStart?: boolean;
    /** Round the side at endAngle (both inner + outer corners there). */
    roundEnd?: boolean;
}
/**
 * Build the SVG path for an annular sector with per-end rounding.
 *
 * When `cornerRadius` is 0 or unset, OR neither `roundStart` nor
 * `roundEnd` is true, the result is a plain unrounded sector — same
 * shape `drawWedgeManual` would emit. When both ends are rounded with
 * a single cornerRadius value, the output matches what d3-arc would
 * produce. The novel case is mixed rounding: e.g. `roundStart: true,
 * roundEnd: false` rounds only the gauge's leading edge.
 *
 * Defensive clamps:
 *   - `cornerRadius` is clamped to `(outerRadius - innerRadius) / 2`
 *     so the corner circles can't cross the ring's centerline (which
 *     would invert the inner radial line).
 *   - If the angular sweep is too small to fit two corner radii
 *     end-to-end on the requested side, that side falls back to
 *     unrounded so the path stays well-formed.
 */
export declare function annularSectorPath(opts: AnnularPathOptions): string;
/**
 * Build the clip outline + slice paths for a gauge gradient band.
 *
 * The band is rendered as one rounded annular sector used as a clip
 * mask, with N unrounded slice sectors painted inside. Each slice
 * extends from its own start angle out to the band's full end angle,
 * so adjacent colors overpaint each other's trailing edge — eliminates
 * subpixel AA gaps between slices without an explicit overlap epsilon
 * and means the staircase reveals one color per `sliceAngle` of arc.
 *
 * Canvas and SVG renderers both consume this: canvas builds Path2D
 * objects from the strings, SVG drops them straight into `<path d="…"/>`.
 */
export interface GaugeGradientGeometryOptions {
    innerRadius: number;
    outerRadius: number;
    startAngle: number;
    endAngle: number;
    cornerRadius?: number;
    roundStart?: boolean;
    roundEnd?: boolean;
    colors: string[];
}
export interface GaugeGradientGeometry {
    clipPath: string;
    slices: {
        d: string;
        color: string;
    }[];
}
export declare function buildGaugeGradientGeometry(opts: GaugeGradientGeometryOptions): GaugeGradientGeometry;
