import { T as TagGroup, D as DgmoError, a as PaletteColors, C as CompactViewState } from './tag-groups-DrHT2tEc.js';

/** A POI / route-stop position: gazetteer name (+ optional ISO scope) or coords. */
type PoiPos = {
    readonly kind: 'coords';
    readonly lat: number;
    readonly lon: number;
} | {
    readonly kind: 'name';
    readonly name: string;
    readonly scope?: string;
};
/** One-shot directives (§24B.2/.7). Values are raw strings unless typed.
 *
 *  COSMETIC DEFAULTS ARE ON. Every basemap feature renders by default; the only
 *  control is a bare `no-*` opt-out flag that sets the matching `noXxx` boolean.
 *  Absent (undefined) = feature ON — so render gates test `!== true`, never
 *  `=== true`. There are NO positive opt-in cosmetic flags (§24B.2). */
interface MapDirectives {
    /** Legend label for the region value ramp (`region-heat <label>`). */
    regionMetric?: string;
    /** Recognized color NAME for the choropleth ramp HIGH endpoint, peeled off the
     *  `region-heat` trailing token (§24B.3). Defaults to red when absent. */
    regionMetricColor?: string;
    /** Recognized color NAME for the choropleth ramp LOW endpoint (the second,
     *  left-of-two trailing colors on `region-heat`, §24B.3). Absent ⇒ the low
     *  end is the implied floored neutral (today's single-colour behaviour). */
    regionMetricLowColor?: string;
    /** Legend label for the POI value (marker size) channel (`poi-size`). */
    poiMetric?: string;
    /** Legend label for the edge/leg value (thickness) channel (`flow-width`). */
    flowMetric?: string;
    /** Default ISO scope for bare-name resolution (§24B.8): a 3166-1 country
     *  (`locale US`) or 3166-2 subdivision (`locale US-GA`). The country part
     *  biases ambiguous bare cities to that nation; the subdivision part further
     *  prefers that state. Inferred from content; explicit only to steer a guess. */
    locale?: string;
    activeTag?: string;
    caption?: string;
    /** `no-title` — suppress the title banner (the subtitle/caption, if any, still
     *  render). Mirrors the `no-title` directive across the other chart types. */
    noTitle?: boolean;
    /** `no-legend` — suppress the legend (default-on). */
    noLegend?: boolean;
    /** `no-coastline` — suppress the faint nautical-chart water-lines along
     *  coasts/shorelines (default-on; geometry derived from drawn region paths). */
    noCoastline?: boolean;
    /** `no-relief` — suppress mountain-range relief hachures. Relief is default-on
     *  but auto-gated to dataless reference maps at continent/world zoom (§24B.2). */
    noRelief?: boolean;
    /** `no-context-labels` — suppress the orientation backdrop (water-body names +
     *  unreferenced notable country names), distinct from `region-labels`. */
    noContextLabels?: boolean;
    /** `no-region-labels` — suppress region labels (default-on, full→abbrev→hide). */
    noRegionLabels?: boolean;
    /** `no-region-heat-value` — suppress the metric VALUE shown under each data region's
     *  name on a `region-heat` choropleth (default-on). The region NAME still
     *  renders (governed by `no-region-labels`); only the numeric value line goes. */
    noRegionValue?: boolean;
    /** `no-poi-labels` — suppress POI labels (default-on, collision-managed auto). */
    noPoiLabels?: boolean;
    /** `no-colorize` — force the plain green-land reference dress even when regions
     *  are referenced (regions are auto-coloured by default; §24B colorize). A
     *  no-op under data — the basemap is already gray there. */
    noColorize?: boolean;
    /** `no-cities` — suppress the subtle gazetteer city dots scattered across the
     *  basemap for geographic orientation (default-on; population-ranked, spacing-
     *  thinned so density adapts to zoom). Explicit POIs always draw regardless. */
    noCities?: boolean;
    /** `no-cluster-pois` — never collapse coincident POI markers into a count badge
     *  (clustering/spiderfy is default-on in the interactive preview). With this set
     *  the markers always render fanned out with their legs — the same as a static
     *  export — so a dense map reads the same on screen as on paper. No-op for
     *  export (already always expanded). */
    noClusterPois?: boolean;
    /** `hours 9-17` — availability window for the clock channel (open/closed status
     *  dot), evaluated per pin in its own zone. Raw string; parsed at resolve.
     *  Activation is the per-POI `clock` flag (BL-122), not a header directive. */
    clockHours?: string;
    /** `days mon-fri` — working days for the clock channel window (default mon-fri
     *  when `hours` is set). Raw string; parsed at resolve. */
    clockDays?: string;
}
/** A region-fill: a subdivision name with an optional score and/or tag values
 *  (§24B.3/.4 — BOTH may be present; bivariate seam). */
interface MapRegion {
    readonly name: string;
    /** Optional trailing ISO scope qualifier (§24B.8) — a 3166-1 country code
     *  (`Georgia US` → US context) or 3166-2 subdivision (`Georgia US-GA`).
     *  Forces the country-vs-state interpretation and silences the ambiguity warning. */
    readonly scope?: string;
    /** Numeric value → choropleth shade (§24B.3). Lifted out of `meta`. */
    readonly value?: number;
    /** §1.5 trailing-token color NAME → flat categorical override fill (§24B.4);
     *  painted regardless of the active colouring dimension, no legend entry. */
    readonly color?: string;
    /** Tag values keyed by lowercased tag GROUP name (alias is resolved away). */
    readonly tags: Readonly<Record<string, string>>;
    /** Any remaining reserved keys captured verbatim (`label`/`style`/…). */
    readonly meta: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
/** A point of interest (§24B.5). `meta` holds the numeric `value` (→ marker
 *  size) and `style` verbatim; `label` is lifted out. */
interface MapPoi {
    readonly pos: PoiPos;
    readonly alias?: string;
    readonly label?: string;
    /** §1.5 trailing-token color NAME → flat marker fill (§24B.5); wins over a
     *  tag color and the default orange. */
    readonly color?: string;
    /** BL-122 — a `clock` control on this POI line: render a live local-time card
     *  above the marker. Bare (`poi Denver clock`) derives the zone from the place;
     *  valued (`clock: Europe/Oslo`, held in `meta.clock`) names the zone, for
     *  bare-coord pins or to override a city. */
    readonly clock?: boolean;
    readonly tags: Readonly<Record<string, string>>;
    readonly meta: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
/** One leg of a route (§24B.6): an edge from the previous stop to `dest`. Reuses
 *  the indented edge arrow idiom (same as sitemap) — in-arrow text = leg label,
 *  `width:` = leg thickness, the arrow glyph = shape (`-…->` straight, `~…~>`
 *  arc). A tag on the leg line colours the LINE (§24B.6); `label:`/`as` still
 *  name the DESTINATION stop. The arrow is required — a bare destination errors. */
interface MapRouteLeg {
    readonly label?: string;
    readonly style: 'straight' | 'arc';
    readonly value?: string;
    readonly dest: PoiPos;
    readonly destAlias?: string;
    readonly destLabel?: string;
    /** Tag(s) on the leg line → colour the LINE itself. To categorise a STOP,
     *  tag its own `poi` line. */
    readonly tags: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
/** An ordered, auto-numbered route (§24B.6): `route <origin>` + a sequence of
 *  indented arrow legs, each continuing from the previous stop. Leg shape is
 *  per-leg (the arrow glyph) — there is no header-level shape option. Repeat the
 *  origin as a leg's destination to close a loop. */
interface MapRoute {
    readonly origin: PoiPos;
    readonly originAlias?: string;
    readonly originLabel?: string;
    readonly originValue?: string;
    readonly originTags: Readonly<Record<string, string>>;
    readonly legs: readonly MapRouteLeg[];
    readonly lineNumber: number;
}
/** A connector (§24B.6). Endpoints are RAW identifier strings (name or alias);
 *  binding to POIs/regions is the resolver's job. Token = arrowhead iff it ends
 *  in `>`, arc iff it starts with `~`: `->` straight, `~>` arc, `--`/`-label-`
 *  undirected straight, `~~`/`~label~` undirected arc. */
interface MapEdge {
    readonly from: string;
    readonly to: string;
    readonly label?: string;
    readonly directed: boolean;
    readonly style: 'straight' | 'arc';
    readonly meta: Readonly<Record<string, string>>;
    /** Tag(s) on the edge line → colour the LINE itself (§24B.6). */
    readonly tags: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
interface ParsedMap {
    readonly title: string | null;
    readonly titleLineNumber: number | null;
    readonly directives: MapDirectives;
    readonly tagGroups: readonly TagGroup[];
    readonly regions: readonly MapRegion[];
    readonly pois: readonly MapPoi[];
    readonly routes: readonly MapRoute[];
    readonly edges: readonly MapEdge[];
    readonly options: Readonly<Record<string, string>>;
    readonly diagnostics: readonly DgmoError[];
    readonly error: string | null;
}
/** Legend descriptor for a rendered map (a layout-stage output, re-exported from
 *  `layout.ts`). It lives here so the `legend-band` helper can consume it without
 *  importing `layout` — `layout` already value-imports `mapLegendBand`, so the
 *  reverse type import would form a layout↔legend-band cycle. */
interface MapLayoutLegend {
    readonly tagGroups: ReadonlyArray<{
        name: string;
        entries: ReadonlyArray<{
            value: string;
            color: string;
        }>;
    }>;
    readonly activeGroup: string | null;
    readonly ramp?: {
        metric?: string;
        min: number;
        max: number;
        /** Resolved hex of the LOW (t=0) endpoint — the explicit low colour, or the
         *  floored neutral the single-colour fills blend up from. */
        low: string;
        /** Resolved hex of the HIGH (t=1) endpoint (the named ramp hue). */
        high: string;
    };
}

/** A TopoJSON topology (world-coarse/world-detail keyed by ISO 3166-1 alpha-2;
 *  us-states keyed by ISO 3166-2). Geometry feature `id` is the ISO code;
 *  `properties.name` is the display string. Kept loose to avoid a topojson dep. */
interface BoundaryTopology {
    type: 'Topology';
    objects: Record<string, {
        type: string;
        geometries: BoundaryGeometry[];
    }>;
    arcs: number[][][];
    transform?: {
        scale: [number, number];
        translate: [number, number];
    };
    bbox?: number[];
}
interface BoundaryGeometry {
    type: string;
    /** ISO code: alpha-2 (countries) or 3166-2 `US-XX` (states). */
    id: string;
    properties: {
        name: string;
    };
    arcs?: unknown;
}
/**
 * A gazetteer city entry: `[lat, lon, iso, pop, name, sub?]`.
 * - `lat`/`lon` — rounded to 3 decimals.
 * - `iso` — ISO 3166-1 alpha-2 country code.
 * - `pop` — population.
 * - `name` — canonical display name (case/accents preserved).
 * - `sub` — ISO 3166-2 subdivision (US cities only in v1, e.g. `US-OR`); absent otherwise.
 */
type GazetteerEntry = [
    lat: number,
    lon: number,
    iso: string,
    pop: number,
    name: string,
    sub?: string
];
interface Gazetteer {
    /** Every city, stored once. `byName`/`alt` reference cities by array index
     *  (normalized — no tuple duplication; geonameid is a build-time-only linker). */
    cities: GazetteerEntry[];
    /** Folded (NFD, diacritic-stripped, lowercased) name → indices into `cities`.
     *  Always an array; length > 1 for same-named cities (Portland US-OR / US-ME). */
    byName: Record<string, number[]>;
    /** Folded alias → index into `cities`. Never collides with a `byName` key. */
    alt: Record<string, number>;
    /** BL-122 clock-on-map: distinct IANA zone ids (sorted), referenced by `tz`. */
    zones?: string[];
    /** BL-122: IANA zone per city, parallel to `cities` — `tz[i]` indexes `zones`
     *  (−1 when a city had no GeoNames match). Lets `poi Denver clock` derive its
     *  local time without the author restating the zone. */
    tz?: number[];
}
/**
 * IATA-coded airport index (a SEPARATE optional asset — `airports.json`; ADR-1).
 * Lets memorized airport codes resolve to coordinates through the resolver's
 * existing fold→lookup path (`poi JFK`, `route JFK -> LAX`) — no parser change.
 *
 * - `airports` — `GazetteerEntry` tuples `[lat, lon, iso, 0, name]`. `pop` is
 *   always 0 (OurAirports has no enplanement column); `name` is the full airport
 *   name, used for COMPLETION DISPLAY only — airports resolve by IATA code, never
 *   by name. Coords are rounded to 2 decimals (~1km; sub-pixel at map scale).
 * - `airportIata` — folded 3-letter IATA code → index into `airports`. Consulted
 *   LAST in resolution (after city `byName` + `alt`), so a real city always wins
 *   a shared token (ADR-2). Airports never enter `cities[]`, so the city-scatter
 *   and reverse-geocode layers never see them.
 */
interface AirportData {
    readonly airports: GazetteerEntry[];
    readonly airportIata: Record<string, number>;
}
/** Water-feature class (Natural Earth `featurecla`, rivers/reefs excluded). */
type WaterKind = 'ocean' | 'sea' | 'gulf' | 'bay' | 'strait' | 'channel' | 'sound';
/**
 * A water-body label entry: `[lat, lon, name, tier, kind, alt?]`.
 * - `lat`/`lon` — label anchor (Natural Earth inner point), rounded to 3 decimals.
 * - `name` — full display name (no abbreviation exists for water bodies).
 * - `tier` — Natural Earth `scalerank` (0 = most prominent → orientation priority).
 * - `kind` — feature class (drives styling/priority bucketing).
 * - `alt` — optional extra anchor points `[lat, lon][]`; the layout picks the
 *   one nearest the viewport center (Decision 5 multi-anchor seam). Absent today.
 */
type WaterBodyEntry = [
    lat: number,
    lon: number,
    name: string,
    tier: number,
    kind: WaterKind,
    alt?: ReadonlyArray<readonly [number, number]>
];
interface WaterBodies {
    /** Deterministically ordered (tier, then name). Generated from Natural Earth
     *  marine polys by scripts/build-map-data.mjs into `water-bodies.json`. */
    readonly entries: readonly WaterBodyEntry[];
}
/** A fill-able region (country or US state) — the display name + its ISO id +
 *  layer. Powers region-name autocomplete (completion-only; the renderer derives
 *  names from the topology directly). Extracted from the topologies by
 *  scripts/build-map-data.mjs into `region-names.json`. */
interface RegionName {
    /** Display name (original casing), e.g. `California` / `Germany`. */
    readonly name: string;
    /** ISO 3166-1 alpha-2 (country) or 3166-2 `US-XX` (state). */
    readonly iso: string;
    readonly layer: 'country' | 'us-state';
}
interface RegionNames {
    /** Deterministically ordered (layer, then name). */
    readonly regions: readonly RegionName[];
}

/** The four static assets, injected into the pure resolver (DI). */
interface MapData {
    worldCoarse: BoundaryTopology;
    worldDetail: BoundaryTopology;
    usStates: BoundaryTopology;
    /** Major lakes (Natural Earth 110m) drawn as water over land — e.g. the Great
     *  Lakes. Optional so hand-built test fixtures need not supply it. */
    lakes?: BoundaryTopology;
    /** Major river centerlines (Natural Earth 110m) drawn as thin water lines over
     *  land — e.g. the Amazon, Nile, Mississippi. Optional, like `lakes`. */
    rivers?: BoundaryTopology;
    /** Notable mountain-range polygons (Natural Earth 50m geography regions) drawn
     *  as a subtle gradient relief cue over base land when the `relief` directive
     *  is on — e.g. the Rockies, Andes, Himalayas. Optional, like `lakes`. */
    mountainRanges?: BoundaryTopology;
    /** North-America-clipped 10m country land, used as crisp neighbour context
     *  under the albers-usa US view so Canada/Mexico match the 10m states instead
     *  of the coarser world tiers. Optional, like `lakes`. */
    naLand?: BoundaryTopology;
    /** North-America-clipped 10m major lakes (Great Lakes etc.), used in place of
     *  the coarse `lakes` under the albers-usa US view. Optional. */
    naLakes?: BoundaryTopology;
    /** Water-body orientation labels (Natural Earth marine polys) drawn when the
     *  `context-labels` directive is on — oceans/seas/gulfs/bays/etc. Optional, so
     *  hand-built test fixtures and older bundles need not supply it. */
    waterBodies?: WaterBodies;
    /** IATA-coded airports (`airports.json`) — lets `poi JFK` / `route JFK -> LAX`
     *  resolve. Optional so hand-built fixtures and older DI bundles need not supply
     *  it; the resolver guards `data.airports?.…` everywhere. */
    airports?: AirportData;
    gazetteer: Gazetteer;
}
type ProjectionFamily = 'equal-earth' | 'natural-earth' | 'equirectangular' | 'albers-usa' | 'conic-equal-area' | 'mercator';
/** Which geometry layers the renderer draws. */
interface Basemaps {
    /** World country tier: coarse (world-scale) | detail (regional/zoom). */
    world: 'coarse' | 'detail';
    /** Loaded subdivision layers (v1: only 'us-states'). */
    subdivisions: Array<'us-states'>;
}
interface ResolvedRegion {
    /** ISO code: alpha-2 (country) or 3166-2 `US-XX` (state) — the geometry id. */
    readonly iso: string;
    readonly name: string;
    readonly layer: 'country' | 'us-state';
    readonly value?: number;
    /** §1.5 trailing-token color NAME → flat override fill (§24B.4). */
    readonly color?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly meta: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
interface ResolvedPoi {
    /** Folded registry id (alias|name folded, or `@lat,lon` for coord POIs). */
    readonly id: string;
    /** Display name (original casing): the city/place name, alias, or endpoint
     *  string. The on-map label falls back to this when `label` is absent (the
     *  folded `id` is for binding, not display). */
    readonly name?: string;
    readonly lat: number;
    readonly lon: number;
    readonly label?: string;
    /** §1.5 trailing-token color NAME → flat marker fill (§24B.5). */
    readonly color?: string;
    readonly tags: Readonly<Record<string, string>>;
    readonly meta: Readonly<Record<string, string>>;
    readonly lineNumber: number;
    /** True when created from an undeclared edge/route endpoint (§24B.10). */
    readonly implicit?: boolean;
    /** BL-122 clock channel: the resolved IANA zone id (`Asia/Tokyo`) or a canonical
     *  fixed-offset label (`UTC+9`) for this pin, from an explicit `tz:` meta (or a
     *  gazetteer `tz` once built). Absent ⇒ no time card. Set only when the map's
     *  `clock` directive is on and `tz:` validated; a malformed `tz:` warns + omits. */
    readonly tz?: string;
    /** BL-122: minutes-east-of-UTC when `tz` is a FIXED offset (from `tz: UTC+9`),
     *  so the renderer bakes `data-dgmo-clock-fixed-offset` and the ticker skips DST.
     *  Absent for real IANA zones. */
    readonly tzFixedOffsetMin?: number;
}
interface ResolvedEdge {
    readonly fromId: string;
    readonly toId: string;
    readonly label?: string;
    readonly directed: boolean;
    readonly style: 'straight' | 'arc';
    readonly meta: Readonly<Record<string, string>>;
    /** Tag(s) on the edge line → colour the LINE (§24B.6). */
    readonly tags: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
interface ResolvedRouteLeg {
    readonly fromId: string;
    readonly toId: string;
    readonly label?: string;
    readonly style: 'straight' | 'arc';
    readonly value?: string;
    /** Tag(s) on the leg line → colour the LINE (§24B.6). */
    readonly tags: Readonly<Record<string, string>>;
    readonly lineNumber: number;
}
interface ResolvedRoute {
    /** Ordered UNIQUE stop ids (for numbering + the origin marker). A loop-closing
     *  leg whose destination is an earlier stop adds a leg but no duplicate stop. */
    readonly stopIds: readonly string[];
    readonly legs: readonly ResolvedRouteLeg[];
    readonly lineNumber: number;
}
/** Geographic bounding box `[[west, south], [east, north]]` in degrees.
 *
 *  WRAP CONVENTION (#12): for an antimeridian-crossing extent the resolver keeps
 *  `west` in [−180, 180] and returns `east` UNWRAPPED in (180, 540] (i.e.
 *  `east = west + span`, span ≤ 360). So `east > 180` signals a dateline-crossing
 *  extent; the renderer (step 4) must mod `east` back into [−180, 180] (or shift
 *  the projection's center) rather than assume `east ≤ 180`. `south`/`north` are
 *  always plain degrees in [−90, 90]. */
type GeoExtent = [[number, number], [number, number]];
interface ResolvedMap {
    readonly title: string | null;
    /** DEAD — the `subtitle` directive was removed (2026-06-02 defaults-on review).
     *  Never populated; the renderer's subtitle branch is now unreachable. Left for
     *  a later cleanup pass. */
    readonly subtitle?: string;
    readonly caption?: string;
    readonly tagGroups: readonly TagGroup[];
    readonly directives: MapDirectives;
    readonly basemaps: Basemaps;
    readonly regions: readonly ResolvedRegion[];
    readonly pois: readonly ResolvedPoi[];
    readonly edges: readonly ResolvedEdge[];
    readonly routes: readonly ResolvedRoute[];
    readonly extent: GeoExtent;
    readonly projection: ProjectionFamily;
    /** POI-only region framing: the region(s) that CONTAIN the POIs — us-state ids
     *  (`US-CA`) or country isos (`FR`). The frame is snapped to the union of their
     *  bboxes, and the layout labels them prominently (vs. muted neighbours). Empty
     *  for non-POI-only maps or when POIs fall outside every polygon. Optional so
     *  older/foreign ResolvedMap literals need not supply it. */
    readonly poiFrameContainers?: readonly string[];
    readonly diagnostics: readonly DgmoError[];
    readonly error: string | null;
}

/**
 * How a host supplies map basemap assets: the data itself, or a loader that
 * returns it. Declared here (rather than accepting only `MapData`) so a Node
 * host can hand over `loadMapData` without paying to read eleven JSON files on
 * a render that turns out not to be a map — the loader is called only inside
 * the map branch.
 */
type MapDataSource = MapData | (() => Promise<MapData>);
/**
 * Renders a D3 chart to an SVG string for export.
 * Creates a detached DOM element, renders into it, extracts the SVG, then cleans up.
 */
type RenderForExportOptions = {
    c4Level?: 'context' | 'containers' | 'components' | 'deployment';
    c4System?: string;
    c4Container?: string;
    tagGroup?: string;
    exportMode?: boolean;
    mapData?: MapDataSource;
    mapAspect?: number;
    onMapResolverDiagnostics?: (diagnostics: readonly DgmoError[]) => void;
    /**
     * Canvas to draw onto, in px. Defaults to EXPORT_WIDTH x EXPORT_HEIGHT.
     *
     * Every chart used to render onto a fixed 1200x800 sheet, so a caller who
     * fitted the result to a narrow column got its ASPECT too — a one-line goal
     * meter arrived 800px tall with the bar as a sliver in the middle. Callers
     * that know the shape they need can now say so; omitting these keeps the
     * previous canvas exactly.
     */
    width?: number;
    height?: number;
};
declare function renderForExport(content: string, theme: 'light' | 'dark' | 'transparent', palette?: PaletteColors, viewState?: CompactViewState, options?: RenderForExportOptions): Promise<string>;

export { type AirportData as A, type BoundaryTopology as B, type Gazetteer as G, type MapDataSource as M, type ParsedMap as P, type RegionName as R, type GazetteerEntry as a, type MapData as b, type RegionNames as c, type ResolvedMap as d, type MapLayoutLegend as e, type GeoExtent as f, type MapDirectives as g, type MapEdge as h, type MapPoi as i, type MapRegion as j, type MapRoute as k, type PoiPos as l, type ProjectionFamily as m, type ResolvedEdge as n, type ResolvedPoi as o, type ResolvedRegion as p, type ResolvedRoute as q, renderForExport as r };