@tileflow/core 0.1.0-alpha.21 → 0.1.0-alpha.22

package/dist/map-BHL_0Mkx.d.ts

@@ -0,0 +1,1145 @@
+import { j as TileflowSymbolStyle, u as TileflowAreaStyle, S as TileflowLineStackStyle, i as TileflowLineStyle, g as TileflowExtrusionStyle, e as TileflowBackgroundStyle, h as TileflowFillStyle, Z as TileflowMarkerSymbolStyle, f as TileflowCircleStyle, b3 as TileflowThemeColorValue, b6 as TileflowThemeNumberValue, aV as TileflowTerrainHillshadeStyle, aU as TileflowTerrainEncoding, b4 as TileflowThemeFontValue, b5 as TileflowThemeImageValue, bR as TileflowTypographyStyle, L as TileflowLight, bS as ResolvedTileflowTypography, n as TileflowLabelsModuleConfig, p as TileflowPoiModuleConfig, l as TileflowRoadsModuleConfig, a7 as TileflowProjection, aP as TileflowTerrain, ba as TileflowViewConfig, M as MapLibreStyle, be as ValidationResult } from './manifest-B5GKVMFE.js';
+import * as zod from 'zod';
+import { T as TileflowCaptureScene } from './capture-scene-BK_0J2oR.js';
+
+type TileflowAddressesModuleOptions = {
+    /** Styling for OpenMapTiles point house-number labels. */
+    labels?: TileflowSymbolStyle;
+};
+type TileflowAddressesModuleConfig = TileflowAddressesModuleOptions & {
+    type: 'addresses';
+};
+declare function addresses(options?: TileflowAddressesModuleOptions): TileflowAddressesModuleConfig;
+
+type TileflowAerowaysModuleOptions = {
+    area?: TileflowAreaStyle;
+    runway?: TileflowLineStackStyle;
+    runwayRef?: TileflowSymbolStyle;
+    taxiway?: TileflowLineStackStyle;
+};
+type TileflowAerowaysModuleConfig = TileflowAerowaysModuleOptions & {
+    type: 'aeroways';
+};
+declare function aeroways(options?: TileflowAerowaysModuleOptions): TileflowAerowaysModuleConfig;
+
+type TileflowBoundariesModuleOptions = {
+    admin2?: TileflowLineStyle;
+    admin4?: TileflowLineStyle;
+    disputed?: TileflowLineStyle;
+    maritime?: TileflowLineStyle;
+};
+type TileflowBoundariesModuleConfig = TileflowBoundariesModuleOptions & {
+    type: 'boundaries';
+};
+declare function boundaries(options?: TileflowBoundariesModuleOptions): TileflowBoundariesModuleConfig;
+
+type TileflowBuildingMode = '3d' | 'flat';
+type TileflowBuildingsModuleOptions = {
+    businessCorridor?: TileflowAreaStyle;
+    extrusion?: TileflowExtrusionStyle;
+    flat?: TileflowAreaStyle;
+    mode?: TileflowBuildingMode;
+};
+type TileflowBuildingsModuleConfig = TileflowBuildingsModuleOptions & {
+    type: 'buildings';
+};
+declare function buildings(options?: TileflowBuildingsModuleOptions): TileflowBuildingsModuleConfig;
+
+type TileflowLanduseClass = 'cemetery' | 'civic' | 'commercial' | 'education' | 'government' | 'industrial' | 'medical' | 'military' | 'parking' | 'railway' | 'recreation' | 'residential';
+type TileflowLandcoverClass = 'farmland' | 'flowerbed' | 'grass' | 'ice' | 'meadow' | 'protected' | 'recreationGround' | 'rock' | 'sand' | 'scrub' | 'urbanPark' | 'villageGreen' | 'wetland' | 'wood';
+type TileflowLandModuleOptions = {
+    background?: TileflowBackgroundStyle;
+    globalLandcover?: TileflowFillStyle;
+    landcover?: Partial<Record<TileflowLandcoverClass, TileflowAreaStyle>>;
+    landuse?: Partial<Record<TileflowLanduseClass, TileflowAreaStyle>>;
+};
+type TileflowLandModuleConfig = TileflowLandModuleOptions & {
+    type: 'land';
+};
+declare function land(options?: TileflowLandModuleOptions): TileflowLandModuleConfig;
+
+declare const tileflowLandformClasses: readonly ["peak", "volcano", "saddle", "ridge", "cliff", "arete"];
+type TileflowLandformClass = (typeof tileflowLandformClasses)[number];
+type TileflowLandformsModuleOptions = {
+    classes?: Partial<Record<TileflowLandformClass, TileflowSymbolStyle>>;
+    /** Append source elevation in metres when the feature provides it. */
+    elevation?: boolean;
+};
+type TileflowLandformsModuleConfig = TileflowLandformsModuleOptions & {
+    type: 'landforms';
+};
+declare function landforms(options?: TileflowLandformsModuleOptions): TileflowLandformsModuleConfig;
+
+/** Labels anchored inside polygon features; point-feature labels remain on their feature style. */
+type TileflowNauticalAreaLabelStyles = {
+    coverage?: TileflowSymbolStyle;
+    hazards?: TileflowSymbolStyle;
+    navigationAreas?: TileflowSymbolStyle;
+    reefs?: TileflowSymbolStyle;
+    wrecks?: TileflowSymbolStyle;
+};
+type TileflowNauticalModuleOptions = {
+    aids?: TileflowMarkerSymbolStyle;
+    coverage?: TileflowAreaStyle;
+    hazardAreas?: TileflowAreaStyle;
+    hazards?: TileflowMarkerSymbolStyle;
+    labels?: TileflowNauticalAreaLabelStyles;
+    lighthouses?: TileflowMarkerSymbolStyle;
+    lights?: TileflowMarkerSymbolStyle;
+    navigationAreas?: TileflowAreaStyle;
+    reefs?: TileflowAreaStyle;
+    soundings?: TileflowMarkerSymbolStyle;
+    wreckAreas?: TileflowAreaStyle;
+    wrecks?: TileflowMarkerSymbolStyle;
+};
+type TileflowNauticalModuleConfig = TileflowNauticalModuleOptions & {
+    type: 'nautical';
+};
+/** Style the semantic objects published by the `nautical-v1` sidecar. */
+declare function nautical(options?: TileflowNauticalModuleOptions): TileflowNauticalModuleConfig;
+
+/** Compiler-only state produced by semantic module operations during map resolution. */
+type TileflowResolvedModuleConfig<TModule extends {
+    type: string;
+}> = TModule & {
+    readonly enabled?: boolean;
+};
+
+type TileflowTransitModuleOptions = {
+    cableway?: TileflowLineStyle;
+    ferry?: TileflowLineStyle;
+    rail?: TileflowTransitRailStyle;
+    railHatching?: TileflowTransitRailStyle;
+    serviceRail?: TileflowTransitRailStyle;
+};
+type TileflowTransitRailStyle = {
+    bridge?: TileflowLineStyle;
+    surface?: TileflowLineStyle;
+    tunnel?: TileflowLineStyle;
+};
+type TileflowTransitModuleConfig = TileflowTransitModuleOptions & {
+    type: 'transit';
+};
+declare function transit(options?: TileflowTransitModuleOptions): TileflowTransitModuleConfig;
+
+type TileflowVegetationMode = '3d' | 'flat';
+type TileflowVegetationThreeDimensionalStyle = {
+    barkColor?: TileflowThemeColorValue;
+    broadleafColors?: readonly TileflowThemeColorValue[];
+    coniferColors?: readonly TileflowThemeColorValue[];
+    crownScale?: TileflowThemeNumberValue;
+    heightScale?: TileflowThemeNumberValue;
+};
+type TileflowVegetationModuleOptions = {
+    flat?: TileflowCircleStyle;
+    minZoom?: number;
+    mode?: TileflowVegetationMode;
+    threeDimensional?: TileflowVegetationThreeDimensionalStyle;
+};
+type TileflowVegetationModuleConfig = TileflowVegetationModuleOptions & {
+    type: 'vegetation';
+};
+declare function vegetation(options?: TileflowVegetationModuleOptions): TileflowVegetationModuleConfig;
+
+type TileflowWaterwayClass = 'canal' | 'other' | 'river' | 'stream';
+type TileflowWaterModuleOptions = {
+    bathymetry?: TileflowFillStyle;
+    /** Opt-in approximate contours traced from discrete bathymetry polygon band edges. */
+    bathymetryContours?: TileflowLineStyle;
+    /** Opt-in labels for bathymetry polygon band floors, not measured survey soundings. */
+    bathymetryLabels?: TileflowSymbolStyle;
+    bodies?: TileflowAreaStyle;
+    intermittent?: {
+        bodies?: TileflowAreaStyle;
+        waterways?: TileflowLineStyle;
+    };
+    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
+};
+type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
+    type: 'water';
+};
+declare function water(options?: TileflowWaterModuleOptions): TileflowWaterModuleConfig;
+
+declare const tileflowWorldGeneration: "v1";
+/** Mutable discovery selector. The server resolves it once to an immutable release in TileJSON. */
+declare const tileflowWorldTileJsonUrl: "https://api.tileflow.dev/tiles/world/tiles.json";
+
+declare const tileflowPrimarySourceId = "tileflow";
+declare const openMapTilesContractVersion = 1;
+type ParkLayerSemantics = 'mixed' | 'protected-only';
+type OpenMapTilesLayerBindings = {
+    aerodromeLabel: string;
+    aeroway: string;
+    boundary: string;
+    building: string;
+    /** Required low-zoom GEBCO extension in the Tileflow World V1 schema. */
+    bathymetry?: string;
+    /** Optional derived commercial-activity polygons rendered below buildings. */
+    businessCorridor?: string;
+    /** Optional generated circle centers used for detailed roundabout rendering. */
+    circularFeature?: string;
+    /** Optional low-zoom global land-cover extension. Defaults to `globallandcover`. */
+    globalLandcover?: string;
+    houseNumber: string;
+    landcover: string;
+    landuse: string;
+    mountainPeak: string;
+    park: string;
+    place: string;
+    poi: string;
+    road: string;
+    roadName: string;
+    /** Optional generalized low-zoom route-shield points. Required by Tileflow World V1. */
+    roadShield?: string;
+    /** Optional detailed pedestrian-surface polygons. */
+    sidewalk?: string;
+    /** Optional point features such as pedestrian crossings. */
+    streetFurniture?: string;
+    /** Optional individual-tree point extension used by the vegetation module. */
+    tree?: string;
+    water: string;
+    waterName: string;
+    waterway: string;
+};
+type OpenMapTilesFieldBindings = {
+    access: string;
+    activityScore: string;
+    adminLevel: string;
+    bicycle: string;
+    /** GEBCO depth-band upper boundary in metres. */
+    bathymetryMinDepth?: string;
+    /** Stable shallow-to-deep ordering for GEBCO bands. */
+    bathymetrySortKey?: string;
+    brunnel: string;
+    buildingKind: string;
+    buildingTone: string;
+    capital: string;
+    /** Roundabout geometry kind in the optional circular-feature layer. */
+    circularKind?: string;
+    /** Precomputed roundabout radius in pixels at zoom 15. */
+    circularRadiusAtZoom15?: string;
+    /** Extra precomputed clearance on road approaches to a circular road at zoom 15. */
+    circularClearanceExtraAtZoom15?: string;
+    /** Roundabout radius in metres. */
+    circularRadiusMeters?: string;
+    /** Roundabout inner radius in metres. */
+    circularInnerRadiusMeters?: string;
+    /** Roundabout outer radius in metres. */
+    circularOuterRadiusMeters?: string;
+    class: string;
+    /** Crossing control classification on street-furniture points. */
+    crossing: string;
+    circumference: string;
+    classificationConfidence: string;
+    confidence: string;
+    diameterCrown: string;
+    disputed: string;
+    /** Direction in degrees for oriented street-furniture symbols. */
+    direction?: string;
+    elevation: string;
+    elevationFeet: string;
+    expressway: string;
+    foot: string;
+    height: string;
+    hide3d: string;
+    hasBusiness: string;
+    /** Whether a building footprint owns separately materialized building parts. */
+    hasParts?: string;
+    horse: string;
+    houseNumber: string;
+    /** Optional sparse 1–4 semantic and locally normalized urban-importance tier. */
+    importanceTier?: string;
+    iata: string;
+    icao: string;
+    indoor: string;
+    intermittent: string;
+    genus: string;
+    layer: string;
+    leafCycle: string;
+    leafType: string;
+    level: string;
+    maritime: string;
+    /** Physical crossing-marking classification on street-furniture points. */
+    markings: string;
+    minHeight: string;
+    minZoom: string;
+    mtbScale: string;
+    name: string;
+    nameEnglish: string;
+    nameLatin: string;
+    network: string;
+    official: string;
+    oneway: string;
+    /** Canonical editorial POI category. Never aliases OpenMapTiles `class`. */
+    poiCategory: string;
+    /** Per-zoom POI density tier from 0 (most selective) through 5. */
+    poiFilterRank: string;
+    /** Producer-selected POI icon key. */
+    poiIcon: string;
+    /** Physical-size tier from 0 (largest) through 16 (point-sized). */
+    poiSizeRank: string;
+    /** Canonical specific POI type. Never aliases OpenMapTiles `subclass`. */
+    poiType: string;
+    ramp: string;
+    rank: string;
+    ref: string;
+    refLength: string;
+    renderHeight: string;
+    renderMinZoom: string;
+    renderMinHeight: string;
+    /** Optional producer-normalized route-shield family. Required by Tileflow World V1. */
+    shieldKind?: string;
+    /** Optional merged line length used to bound detailed route-shield repetition. */
+    shieldLineLengthMeters?: string;
+    /** Optional producer-normalized route network identifier. */
+    shieldNetwork?: string;
+    /** Optional producer-normalized route-shield collision rank. */
+    shieldRank?: string;
+    /** Optional producer-normalized route-shield text. */
+    shieldText?: string;
+    /** Optional producer-normalized route-shield ink role. Required by Tileflow World V1. */
+    shieldTextColor?: string;
+    service: string;
+    species: string;
+    speciesWikidata: string;
+    subclass: string;
+    surface: string;
+    toll: string;
+};
+type OpenMapTilesSchemaOptions = {
+    capabilities?: {
+        businessCorridor?: boolean;
+        bathymetry?: boolean;
+        globalLandcover?: boolean;
+        tree?: boolean;
+    };
+    fields?: Partial<OpenMapTilesFieldBindings>;
+    layers?: Partial<OpenMapTilesLayerBindings>;
+    semantics?: {
+        /** Whether the bound park layer mixes ordinary parks with protected areas. */
+        parkLayer?: ParkLayerSemantics;
+    };
+};
+type OpenMapTilesSchema = {
+    type: 'openmaptiles';
+    contractVersion: typeof openMapTilesContractVersion;
+    fields: OpenMapTilesFieldBindings;
+    layers: OpenMapTilesLayerBindings;
+    semantics: {
+        parkLayer: ParkLayerSemantics;
+    };
+};
+type TileflowWorldV1Schema = Omit<OpenMapTilesSchema, 'fields' | 'layers'> & {
+    fields: OpenMapTilesFieldBindings & {
+        bathymetryMinDepth: string;
+        bathymetrySortKey: string;
+        circularClearanceExtraAtZoom15: string;
+        circularInnerRadiusMeters: string;
+        circularKind: string;
+        circularOuterRadiusMeters: string;
+        circularRadiusAtZoom15: string;
+        circularRadiusMeters: string;
+        direction: string;
+        hasParts: string;
+        shieldKind: string;
+        shieldLineLengthMeters: string;
+        shieldNetwork: string;
+        shieldRank: string;
+        shieldText: string;
+        shieldTextColor: string;
+    };
+    layers: OpenMapTilesLayerBindings & {
+        bathymetry: string;
+        circularFeature: string;
+        globalLandcover: string;
+        sidewalk: string;
+        streetFurniture: string;
+        roadShield: string;
+    };
+};
+type TileflowWorldReleaseReference = Readonly<{
+    descriptorSha256: string;
+    releaseId: string;
+}>;
+type TileflowWorldSelection = Readonly<{
+    kind: 'current';
+    product: 'world-v1';
+}> | Readonly<{
+    kind: 'release';
+    product: 'world-v1';
+    release: TileflowWorldReleaseReference;
+}>;
+type TileflowWorldData = {
+    generation: typeof tileflowWorldGeneration;
+    selection: TileflowWorldSelection;
+    type: 'tileflow-world';
+};
+type VectorTilesDataCommon = {
+    type: 'vector-tiles';
+    attribution: string;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+};
+type VectorTilesData = VectorTilesDataCommon & ({
+    bounds?: never;
+    maxzoom?: never;
+    minzoom?: never;
+    tiles?: never;
+    url: string;
+} | {
+    bounds?: [number, number, number, number];
+    maxzoom?: number;
+    minzoom?: number;
+    tiles: [string, ...string[]];
+    url?: never;
+});
+type TileflowDataConfig = TileflowWorldData | VectorTilesData;
+type TileflowDataIdentity = {
+    bindings?: {
+        fields: OpenMapTilesFieldBindings;
+        layers: OpenMapTilesLayerBindings;
+    };
+    capabilities?: {
+        businessCorridor: boolean;
+        bathymetry: boolean;
+        globalLandcover: boolean;
+        tree: boolean;
+    };
+    generation?: typeof tileflowWorldGeneration;
+    kind: TileflowDataConfig['type'];
+    /** External fixture identity. */
+    revision?: string;
+    schema: OpenMapTilesSchema['type'];
+    schemaVersion: number;
+    semantics: OpenMapTilesSchema['semantics'];
+    sourceId: typeof tileflowPrimarySourceId;
+    url?: string;
+    worldSelection?: TileflowWorldSelection;
+};
+type ResolvedTileflowData = {
+    attribution: string;
+    bounds?: [number, number, number, number];
+    generation?: typeof tileflowWorldGeneration;
+    identity: TileflowDataIdentity;
+    kind: TileflowDataConfig['type'];
+    maxzoom?: number;
+    minzoom?: number;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+    sourceId: typeof tileflowPrimarySourceId;
+    tiles?: string[];
+    url?: string;
+};
+declare function openMapTiles(options?: OpenMapTilesSchemaOptions): OpenMapTilesSchema;
+/** OpenMapTiles plus the required typed extensions emitted by Tileflow World V1. */
+declare function tileflowWorldV1Schema(options?: OpenMapTilesSchemaOptions): TileflowWorldV1Schema;
+declare function validateTileflowWorldV1Tilejson(tilejson: {
+    vector_layers?: readonly unknown[];
+} | null | undefined, schema?: TileflowWorldV1Schema): string[];
+declare function tileflowWorld(options?: {
+    release?: TileflowWorldReleaseReference;
+}): TileflowWorldData;
+declare function vectorTiles(options: {
+    attribution: string;
+    bounds?: [number, number, number, number];
+    maxzoom?: number;
+    minzoom?: number;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+    tiles?: readonly [string, ...string[]];
+    url?: string;
+}): VectorTilesData;
+declare function resolveTileflowData(data: TileflowDataConfig | undefined, options?: {
+    apiBaseUrl?: string;
+}): ResolvedTileflowData;
+declare function isCanonicalOpenMapTilesSchema(schema: OpenMapTilesSchema): boolean;
+
+declare const tileflowBathymetrySourceId: "tileflow-bathymetry";
+declare const tileflowBathymetryDemSourceId: "tileflow-bathymetry-dem";
+declare const tileflowNauticalSourceId: "tileflow-nautical";
+declare const tileflowBathymetryV1Schema: Readonly<{
+    fields: Readonly<{
+        minDepth: "min_depth";
+        sortKey: "sort_key";
+    }>;
+    layer: "bathymetry";
+    layers: Readonly<{
+        bands: "bathymetry";
+        contours: "bathymetry_contour";
+        coverage: "bathymetry_coverage";
+        landforms: "seafloor_landform";
+        waterNames: "water_name";
+    }>;
+    optionalLayers: readonly ["contours", "coverage", "landforms", "waterNames"];
+    product: "bathymetry-v1";
+    requiredLayers: readonly ["bands"];
+    schemaVersion: 1;
+    sources: Readonly<{
+        dem: Readonly<{
+            encoding: "terrarium";
+            sourceId: "tileflow-bathymetry-dem";
+            tileSize: 512;
+        }>;
+        vector: Readonly<{
+            sourceId: "tileflow-bathymetry";
+        }>;
+    }>;
+}>;
+declare const tileflowNauticalV1Schema: Readonly<{
+    fields: Readonly<{
+        cell: "cell";
+        character: "character";
+        class: "class";
+        color: "color";
+        coverage: "coverage";
+        depth: "depth";
+        direction: "direction";
+        edition: "edition";
+        licence: "licence";
+        name: "name";
+        provider: "provider";
+        provenance: "provenance";
+        quality: "quality";
+        rangeNm: "range_nm";
+        scale: "scale";
+        subclass: "subclass";
+        update: "update";
+    }>;
+    geometryTypes: Readonly<{
+        aids: readonly ["Point"];
+        coverage: readonly ["Polygon"];
+        hazards: readonly ["Point", "Polygon"];
+        lights: readonly ["Point"];
+        navigationAreas: readonly ["Polygon"];
+        reefs: readonly ["Polygon"];
+        soundings: readonly ["Point"];
+        wrecks: readonly ["Point", "Polygon"];
+    }>;
+    layers: Readonly<{
+        aids: "aid";
+        coverage: "coverage";
+        hazards: "hazard";
+        lights: "light";
+        navigationAreas: "navigation_area";
+        reefs: "reef";
+        soundings: "sounding";
+        wrecks: "wreck";
+    }>;
+    product: "nautical-v1";
+    schemaVersion: 1;
+}>;
+type TileflowMarineMode = 'none' | 'bathymetry' | 'nautical' | 'chart';
+/** One schema-compatible vector TileJSON source used by a marine sidecar. */
+type TileflowMarineSourceConfig = {
+    attribution?: string;
+    sourceId?: string;
+    url?: string;
+};
+type TileflowBathymetryDisplay = 'bands' | 'relief' | 'hybrid';
+/**
+ * Styling and physical-source overrides for the optional Bathymetry DEM.
+ * Terrarium and 512 px tiles are the hosted defaults; advanced compatible sources may override
+ * either. `opacity` applies to both the continuous color relief and the hillshade tint.
+ */
+type TileflowBathymetryReliefConfig = TileflowTerrainHillshadeStyle & {
+    attribution?: string;
+    encoding?: TileflowTerrainEncoding;
+    illuminationAltitude?: TileflowThemeNumberValue;
+    multidirectional?: boolean;
+    opacity?: TileflowThemeNumberValue;
+    sourceId?: string;
+    tileSize?: 256 | 512;
+    url?: string;
+};
+/** One logical Bathymetry product backed by vector bands and, when requested, a DEM. */
+type TileflowBathymetryConfig = TileflowMarineSourceConfig & {
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display?: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: false | TileflowBathymetryReliefConfig;
+    type: 'bathymetry';
+};
+type TileflowBathymetryOptions = Omit<TileflowBathymetryConfig, 'type'>;
+/** Configure Bathymetry as one product while loading only the physical sources its display needs. */
+declare function bathymetry(options?: TileflowBathymetryOptions): TileflowBathymetryConfig;
+/**
+ * Advanced marine selection. An omitted member selects Tileflow's current product; `false`
+ * disables only that member. Therefore `{}` is equivalent to `"chart"`.
+ */
+type TileflowMarineConfig = {
+    bathymetry?: false | TileflowBathymetryConfig | TileflowMarineSourceConfig;
+    nautical?: false | TileflowMarineSourceConfig;
+};
+type TileflowMarine = TileflowMarineMode | TileflowMarineConfig;
+type TileflowMarineSourceIdentity = Readonly<{
+    kind: 'tileflow-bathymetry' | 'tileflow-nautical';
+    product: 'bathymetry-v1' | 'nautical-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    url: string;
+}>;
+type TileflowBathymetryDemSourceIdentity = Readonly<{
+    encoding: TileflowTerrainEncoding;
+    kind: 'tileflow-bathymetry-dem';
+    product: 'bathymetry-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    tileSize: 256 | 512;
+    url: string;
+}>;
+type ResolvedMarineSource = Readonly<{
+    identity: TileflowMarineSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        type: 'vector';
+        url: string;
+    }>;
+    sourceId: string;
+}>;
+type ResolvedBathymetryRelief = Readonly<{
+    identity: TileflowBathymetryDemSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        encoding: TileflowTerrainEncoding;
+        tileSize: 256 | 512;
+        type: 'raster-dem';
+        url: string;
+    }>;
+    sourceId: string;
+    style: TileflowBathymetryReliefConfig;
+}>;
+type ResolvedBathymetry = Readonly<{
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: ResolvedBathymetryRelief;
+    vector?: ResolvedMarineSource;
+}>;
+type ResolvedMarine = Readonly<{
+    bathymetry?: ResolvedBathymetry;
+    nautical?: ResolvedMarineSource;
+}>;
+/** Resolve the optional marine sidecars without fetching their TileJSON documents. */
+declare function resolveMarine(marine: TileflowMarine | undefined, apiBaseUrl?: string): ResolvedMarine | undefined;
+
+type TileflowVisualValueCategory = 'color' | 'font' | 'image' | 'number';
+/** Return the semantic theme category for one visual property, or undefined for structure/data. */
+declare function classifyTileflowVisualProperty(property: string, value?: unknown): TileflowVisualValueCategory | undefined;
+
+type TileflowThemeColorScheme = 'dark' | 'light';
+type TileflowThemeName = string;
+declare const tileflowThemeLimits: Readonly<{
+    readonly maxThemes: 64;
+}>;
+type TileflowThemeTokens = {
+    color: Readonly<Record<string, TileflowThemeColorValue>>;
+    font: Readonly<Record<string, TileflowThemeFontValue>>;
+    image: Readonly<Record<string, TileflowThemeImageValue>>;
+    number: Readonly<Record<string, TileflowThemeNumberValue>>;
+};
+type TileflowThemeTypographyStyle = {
+    fallbacks?: readonly TileflowThemeFontValue[];
+    font?: TileflowThemeFontValue;
+    letterSpacing?: TileflowThemeNumberValue;
+    transform?: TileflowTypographyStyle['transform'];
+};
+type TileflowThemeTypography = TileflowThemeTypographyStyle & {
+    places?: TileflowThemeTypographyStyle;
+    poi?: TileflowThemeTypographyStyle;
+    roads?: TileflowThemeTypographyStyle;
+    water?: TileflowThemeTypographyStyle;
+};
+type TileflowThemeLighting = {
+    anchor?: 'map' | 'viewport';
+    color?: TileflowThemeColorValue;
+    intensity?: TileflowThemeNumberValue;
+    position?: readonly [
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue
+    ];
+};
+/** A complete, inheritance-free appearance document. */
+type TileflowTheme = {
+    colorScheme: TileflowThemeColorScheme;
+    id: string;
+    lighting: TileflowThemeLighting;
+    tokens: TileflowThemeTokens;
+    typography: TileflowThemeTypography;
+    version: number;
+};
+type TileflowThemeTokenOverrides = {
+    [TCategory in keyof TileflowThemeTokens]?: Readonly<Partial<TileflowThemeTokens[TCategory]>>;
+};
+/** Input accepted by defineTheme. The returned theme is always fully materialized. */
+type TileflowThemeDefinition = Pick<TileflowTheme, 'colorScheme' | 'id' | 'version'> & {
+    lighting?: TileflowThemeLighting;
+    tokens?: TileflowThemeTokenOverrides;
+    typography?: TileflowThemeTypography;
+};
+type ResolvedTileflowThemeTokens = {
+    color: Readonly<Record<string, string>>;
+    font: Readonly<Record<string, string>>;
+    image: Readonly<Record<string, string>>;
+    number: Readonly<Record<string, number>>;
+};
+type ResolvedTileflowTheme = Omit<TileflowTheme, 'lighting' | 'tokens' | 'typography'> & {
+    lighting: TileflowLight;
+    tokens: ResolvedTileflowThemeTokens;
+    typography: ResolvedTileflowTypography;
+};
+type TileflowResolvedThemeSelection = {
+    name: TileflowThemeName;
+    theme: TileflowTheme;
+};
+type TileflowThemeAuditScope = 'module' | 'terrain' | 'value';
+type TileflowThemeAuditContext = {
+    owner?: string;
+    scope: TileflowThemeAuditScope;
+    target?: string;
+};
+type TileflowThemeAuditDiagnostic = {
+    category: TileflowVisualValueCategory;
+    code: 'THEME_IMPLICIT_FIXED';
+    message: string;
+    owner?: string;
+    path: string;
+    phase: 'theme-audit';
+    scope: TileflowThemeAuditScope;
+    severity: 'error' | 'warning';
+    suggestion: string;
+    target?: string;
+    value: number | string;
+};
+/** A deterministic, machine-readable failure for blocking theme-audit diagnostics. */
+declare class TileflowThemeAuditError extends Error {
+    readonly diagnostics: readonly TileflowThemeAuditDiagnostic[];
+    constructor(diagnostics: readonly TileflowThemeAuditDiagnostic[]);
+}
+declare function defineTheme(definition: TileflowThemeDefinition): TileflowTheme;
+declare function defineTheme(base: TileflowTheme, definition: TileflowThemeDefinition): TileflowTheme;
+declare function resolveTileflowTheme(theme: TileflowTheme): ResolvedTileflowTheme;
+/** Resolve every theme node in modules, terrain, zoom values and expression arrays. */
+declare function resolveThemeValues<T>(value: T, theme: TileflowTheme, path?: string): T;
+/** Select an explicit theme or the map's deterministic default. Browser "system" is external. */
+declare function resolveThemeSelection(map: {
+    defaultTheme: string;
+    themes: Readonly<Record<string, TileflowTheme>>;
+}, requested?: string): TileflowResolvedThemeSelection;
+/** Find visual literals whose permanence is otherwise invisible to an agent. */
+declare function auditTileflowThemeValues(value: unknown, path?: string, context?: TileflowThemeAuditContext): TileflowThemeAuditDiagnostic[];
+/** Audit every appearance-bearing branch of a resolved map. */
+declare function auditTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): TileflowThemeAuditDiagnostic[];
+/** Fail closed when a map contains implicit chromatic, font, or image literals. */
+declare function assertTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): void;
+
+type TileflowLayerDomain = TileflowSemanticModuleName | 'terrain';
+
+declare const tileflowLayerSlots: readonly ["background", "land", "terrain", "hydro", "building-areas", "transport-areas", "transport-tunnel-shadow", "transport-tunnel-casing", "transport-tunnel-fill", "transport-pedestrian-areas", "aeroways", "transport-surface-shadow", "transport-surface-casing", "transport-surface-fill", "transport-bridge-shadow", "transport-bridge-casing", "transport-bridge-fill", "transport-symbols", "boundaries", "buildings", "vegetation", "symbols"];
+type TileflowLayerSlot = (typeof tileflowLayerSlots)[number];
+
+type TileflowSemanticModules = {
+    addresses?: TileflowAddressesModuleConfig;
+    aeroways?: TileflowAerowaysModuleConfig;
+    boundaries?: TileflowBoundariesModuleConfig;
+    buildings?: TileflowBuildingsModuleConfig;
+    labels?: TileflowLabelsModuleConfig;
+    land?: TileflowLandModuleConfig;
+    landforms?: TileflowLandformsModuleConfig;
+    nautical?: TileflowNauticalModuleConfig;
+    poi?: TileflowPoiModuleConfig;
+    roads?: TileflowRoadsModuleConfig;
+    transit?: TileflowTransitModuleConfig;
+    vegetation?: TileflowVegetationModuleConfig;
+    water?: TileflowWaterModuleConfig;
+};
+type TileflowSemanticModuleName = keyof TileflowSemanticModules;
+type TileflowResolvedSemanticModuleOverrides = {
+    readonly [TName in TileflowSemanticModuleName]?: TileflowResolvedModuleConfig<NonNullable<TileflowSemanticModules[TName]>>;
+};
+
+declare const tileflowOverlayPlacements: readonly ["above-water", "below-roads", "above-roads", "above-buildings", "below-labels", "above-labels"];
+declare const tileflowHostedSourceLimit: 16;
+type TileflowOverlayPlacement = (typeof tileflowOverlayPlacements)[number];
+type TileflowHostedTilesetType = 'raster' | 'vector';
+type TileflowHostedTilesetSource = Readonly<{
+    attribution: string;
+    kind: 'hosted-tileset';
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type: TileflowHostedTilesetType;
+}>;
+type TileflowMapLibreOverlayLayer = Readonly<Record<string, unknown> & {
+    id: string;
+    source?: never;
+    type: string;
+}>;
+type TileflowMapLibreOverlay = Readonly<{
+    kind: 'maplibre-overlay';
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}>;
+type TileflowRemoveOperation = Readonly<{
+    op: 'remove';
+}>;
+type TileflowHostedSourceCollection = Readonly<Record<string, TileflowHostedTilesetSource | TileflowRemoveOperation>>;
+type TileflowOverlayCollection = Readonly<Record<string, TileflowMapLibreOverlay | TileflowRemoveOperation>>;
+/** Bind one logical Team tileset to an explicit account-free local PMTiles archive. */
+declare function hostedTileset(options: {
+    attribution: string;
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type?: TileflowHostedTilesetType;
+}): TileflowHostedTilesetSource;
+/** Group one or more ordinary MapLibre layers around one named Tileflow source. */
+declare function maplibreOverlay(options: {
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}): TileflowMapLibreOverlay;
+/** Remove one inherited keyed source or overlay. */
+declare function remove(): TileflowRemoveOperation;
+declare function isSafeLocalPmtilesPath(value: unknown): value is string;
+
+/** A directory resolved relative to the selected executable tileflow.config.ts. */
+type TileflowLocalDirectory = `./${string}` | `../${string}`;
+declare const tileflowLocalDirectoryMaximumLength = 512;
+declare const tileflowLocalDirectoryMessage = "Expected a canonical relative directory beginning with ./ or ../; only leading .. segments are allowed and segments must be non-empty, without backslashes or controls";
+/** Exact portable syntax shared by config validation and Node filesystem resolution. */
+declare function isTileflowLocalDirectory(value: unknown): value is TileflowLocalDirectory;
+/**
+ * A package-owned asset directory. Applications normally import one of these
+ * descriptors from the package that owns the assets instead of constructing it.
+ */
+type TileflowPackageDirectory = Readonly<{
+    kind: 'package-directory';
+    package: string;
+    path: string;
+}>;
+/** One icon directory in the ordered map icon search path. */
+type TileflowIconDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/** One font directory in the ordered map font search path. */
+type TileflowFontDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/**
+ * An explicit MapLibre glyph provider. `fontStacks` lists the exact comma-joined request keys
+ * produced by each compiled `text-font` array. The map owns the URL; World never supplies fonts.
+ */
+type TileflowGlyphs = Readonly<{
+    fontStacks: readonly string[];
+    kind: 'url';
+    url: string;
+}>;
+
+declare const tileflowResetBrand: unique symbol;
+/** Serializable sentinel that removes one inherited override during `refine()`. */
+type TileflowReset = Readonly<{
+    readonly $tileflow: 'reset';
+    readonly [tileflowResetBrand]: true;
+}>;
+type TileflowPatchValue<TValue> = TileflowReset | (TValue extends readonly unknown[] ? TValue : TValue extends object ? TileflowNestedPatch<TValue> : TValue);
+type TileflowNestedPatch<TValue extends object> = {
+    readonly [TKey in keyof TValue]?: TileflowPatchValue<TValue[TKey]>;
+};
+/**
+ * A recursive semantic patch. Records merge; arrays and scalar values replace.
+ * Module ownership and compiler visibility are immutable only at the patch root;
+ * nested domain options named `type` or `enabled` retain their ordinary meaning.
+ */
+type TileflowModulePatch<TModule extends object> = {
+    readonly [TKey in Exclude<keyof TModule, 'enabled' | 'type'>]?: TileflowPatchValue<TModule[TKey]>;
+};
+type TileflowRefineOperation<TPatch extends object = object> = Readonly<{
+    readonly op: 'refine';
+    readonly patches: readonly TPatch[];
+}>;
+type TileflowDisableOperation = Readonly<{
+    readonly op: 'disable';
+}>;
+type TileflowModuleOperation<TModule extends object> = TileflowDisableOperation | TileflowRefineOperation<TileflowModulePatch<TModule>>;
+type TileflowAuthoringModules = {
+    readonly [TName in keyof TileflowSemanticModules]?: NonNullable<TileflowSemanticModules[TName]> | TileflowModuleOperation<NonNullable<TileflowSemanticModules[TName]>>;
+};
+/** Deeply refine an inherited module; arrays and scalar values replace atomically. */
+declare function refine<const TPatch extends object>(...patches: readonly [TPatch, ...TPatch[]]): TileflowRefineOperation<TPatch>;
+/** Disable a complete semantic module while retaining an explicit compiler decision. */
+declare function disable(): TileflowDisableOperation;
+/** Remove an inherited override so the domain registry can supply its semantic default. */
+declare function reset(): TileflowReset;
+
+/** Portable, filesystem-safe identity shared by maps and their leaf-owned scenes. */
+declare const tileflowMapIdSchema: zod.ZodString;
+/** Identity is always owned by the map being resolved and never inherited. */
+type TileflowMapIdentity = {
+    id: string;
+    name?: string;
+    /** Editorial version of this map. */
+    version: number;
+};
+/** A capture scene owned by one singular map; its map id is implicit. */
+type TileflowMapScene = Omit<TileflowCaptureScene, 'map'>;
+/** Tooling metadata belongs to the leaf definition and is never inherited. */
+type TileflowMapTooling = {
+    scenes?: Record<string, TileflowMapScene>;
+};
+type TileflowMapTextAssets = {
+    fonts?: never;
+    glyphs?: never;
+} | {
+    fonts: readonly TileflowFontDirectory[];
+    glyphs?: never;
+} | {
+    fonts?: never;
+    glyphs: TileflowGlyphs;
+};
+/** Cartographic fields supported by the V1 semantic compiler. */
+type TileflowMapDesign = TileflowMapTextAssets & {
+    data?: TileflowDataConfig;
+    /** Name used whenever a concrete theme is not explicitly requested. */
+    defaultTheme?: TileflowThemeName;
+    /** Ordered icon directories. Omission inherits; declaration replaces; [] means no icons. */
+    icons?: readonly TileflowIconDirectory[];
+    /** Independent Bathymetry and Nautical products composed by the compiler. */
+    marine?: TileflowMarine;
+    /** Semantic domains, expressed directly or with explicit refine/disable operations. */
+    modules?: TileflowAuthoringModules;
+    /** Keyed MapLibre overlay units. Omission inherits; entries replace atomically. */
+    overlays?: TileflowOverlayCollection;
+    projection?: TileflowProjection;
+    /** Keyed logical hosted sources. Omission inherits; entries replace atomically. */
+    sources?: TileflowHostedSourceCollection;
+    /** Browser color-scheme mapping. Runtime resolves "system" to one of these concrete names. */
+    systemThemes?: {
+        dark: TileflowThemeName;
+        light: TileflowThemeName;
+    };
+    terrain?: TileflowTerrain;
+    /** Complete named appearances. Omission inherits; declaration replaces the collection. */
+    themes?: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+    view?: TileflowViewConfig;
+};
+/** Complete semantic map at the base of a lineage. The compiler is implicit. */
+type TileflowStandaloneMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type TileflowDerivedMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    extends: TileflowMap;
+};
+/** Executable authoring definition using the one implicit semantic compiler. */
+type TileflowMap = TileflowDerivedMap | TileflowStandaloneMap;
+type ResolvedTileflowMapDesign<TDesign extends TileflowMapDesign = TileflowMapDesign> = TDesign extends TileflowMapDesign ? Omit<TDesign, 'defaultTheme' | 'modules' | 'overlays' | 'sources' | 'themes'> : never;
+/** A standalone map definition with inheritance removed. */
+type ResolvedTileflowMap = Omit<TileflowMapIdentity, 'name'> & ResolvedTileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    modules?: TileflowResolvedSemanticModuleOverrides;
+    name: string;
+    overlays?: Readonly<Record<string, TileflowMapLibreOverlay>>;
+    sources?: Readonly<Record<string, TileflowHostedTilesetSource>>;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type ResolveMapOptions = {
+    /** Maximum number of map definitions in a lineage, including its standalone base. */
+    maxDepth?: number;
+};
+
+type TileflowDataFieldType = 'Boolean' | 'Number' | 'String';
+type TileflowDataFieldRequirement = Readonly<{
+    name: string;
+    type?: TileflowDataFieldType;
+}>;
+type TileflowDataLayerRequirement = Readonly<{
+    fields: readonly TileflowDataFieldRequirement[];
+    id: string;
+}>;
+type TileflowDataRequirementsV1 = Readonly<{
+    complete: boolean;
+    dynamicAccesses: readonly string[];
+    schemaVersion: 1;
+    sourceId: string;
+    sourceLayers: readonly TileflowDataLayerRequirement[];
+}>;
+/** Per-source requirements for styles that compose independent vector and DEM products. */
+type TileflowSourceRequirementsV1 = Readonly<{
+    rasterDemSources?: Readonly<Record<string, TileflowRasterDemSourceRequirementV1>>;
+    schemaVersion: 1;
+    sources: Readonly<Record<string, TileflowDataRequirementsV1>>;
+}>;
+type TileflowRasterDemSourceRequirementV1 = Readonly<{
+    encoding: 'mapbox' | 'terrarium';
+    sourceId: string;
+    tileSize: 256 | 512;
+    type: 'raster-dem';
+}>;
+type TileflowObservedDataContractV1 = Readonly<{
+    sourceLayers: readonly Readonly<{
+        fields: readonly Readonly<{
+            name: string;
+            type: TileflowDataFieldType;
+        }>[];
+        id: string;
+    }>[];
+}>;
+type TileflowDataCompatibilityIssue = Readonly<{
+    code: 'dynamic-field-access' | 'field-missing' | 'field-type-mismatch' | 'source-layer-missing';
+    field?: string;
+    message: string;
+    sourceLayer?: string;
+}>;
+/**
+ * Infer the effective data surface from finalized MapLibre layers. Disabled modules contribute no
+ * requirements, and fields hidden by map inheritance never reach this compiler output.
+ */
+declare function inferTileflowDataRequirements(style: MapLibreStyle, options?: {
+    additional?: readonly TileflowDataLayerRequirement[];
+    sourceId?: string;
+}): TileflowDataRequirementsV1;
+/**
+ * Infer the V1 layer/field contract for every referenced vector source and the physical contract
+ * for each included raster DEM. The singular helper remains unchanged for World-only consumers.
+ */
+declare function inferTileflowSourceRequirements(style: MapLibreStyle): TileflowSourceRequirementsV1;
+/** Compare inferred use with producer-observed layers and fields; no editorial allowlist exists. */
+declare function validateTileflowDataCompatibility(requirements: TileflowDataRequirementsV1, contract: TileflowObservedDataContractV1): readonly TileflowDataCompatibilityIssue[];
+
+/** Version of the opt-in, read-only physical-output inspection sidecar. */
+declare const tileflowStyleInspectionSchemaVersion: 1;
+type TileflowStyleInspectionRenderOperation = {
+    readonly kind: 'pass' | 'refinement';
+    readonly owner: TileflowLayerDomain;
+    readonly target: string;
+};
+/** One semantic contribution represented by a compiled physical style layer. */
+type TileflowStyleInspectionContribution = {
+    readonly owner: TileflowLayerDomain;
+    readonly slot: TileflowLayerSlot;
+    readonly target: string;
+    /** Ordered semantic render operations represented by this contribution. */
+    readonly operations: readonly TileflowStyleInspectionRenderOperation[];
+};
+type TileflowStyleInspectionLayer = {
+    /** Opaque physical output identity for diagnostics; never a public authoring target. */
+    readonly id: string;
+    readonly index: number;
+    readonly type: string;
+    /** Multiple entries are expected when the physical planner combines semantic layers. */
+    readonly contributions: readonly TileflowStyleInspectionContribution[];
+};
+/**
+ * Opt-in, read-only cartographic provenance for diagnostics and build tooling.
+ * Physical IDs are output observations, not stable or addressable authoring APIs.
+ * This object is never embedded in Style JSON.
+ */
+type TileflowStyleInspection = {
+    readonly schemaVersion: typeof tileflowStyleInspectionSchemaVersion;
+    readonly map: string;
+    readonly theme: string;
+    readonly layers: readonly TileflowStyleInspectionLayer[];
+};
+type TileflowInspectedStyle = {
+    readonly style: MapLibreStyle;
+    readonly inspection: TileflowStyleInspection;
+};
+
+declare const tileflowCompilationReportSchemaVersion: 1;
+declare const tileflowCompilationPhases: readonly ["assembly", "assets", "config-validation", "data", "domain-ir", "domains", "finalization", "input", "lowering", "physical-planner", "render-stack", "theme", "theme-audit", "validation"];
+declare const tileflowCompilationPlannerStages: readonly ["domain-ir", "assembly", "render-stack", "physical-planner", "lowering"];
+type TileflowCompilationPhase = (typeof tileflowCompilationPhases)[number];
+type TileflowCompilationPlannerStage = (typeof tileflowCompilationPlannerStages)[number];
+type TileflowCompilationDiagnostic = Readonly<{
+    code: string;
+    domain?: TileflowSemanticModuleName;
+    message: string;
+    path?: string;
+    phase: TileflowCompilationPhase;
+    severity: 'error' | 'warning';
+    suggestion?: string;
+    target?: string;
+}>;
+type TileflowCompilationDomainReport = Readonly<{
+    contributionCount: number;
+    name: TileflowSemanticModuleName;
+    renderOperationCount: number;
+    status: 'emitted' | 'suppressed';
+    suppressionReason?: 'disabled' | 'no-contributions';
+    targets: readonly string[];
+}>;
+type TileflowCompilationPlannerDecision = Readonly<{
+    candidateCount?: number;
+    inputCount: number;
+    outputCount: number;
+    selectedCount?: number;
+    stage: TileflowCompilationPlannerStage;
+}>;
+type TileflowCompilationReport = Readonly<{
+    domains: readonly TileflowCompilationDomainReport[];
+    map: string;
+    planner: readonly TileflowCompilationPlannerDecision[];
+    /** Opt-in read-only physical diagnostics; its IDs are not addressable authoring targets. */
+    provenance?: TileflowStyleInspection;
+    requirements?: TileflowSourceRequirementsV1;
+    schemaVersion: typeof tileflowCompilationReportSchemaVersion;
+    targets: readonly string[];
+    theme?: string;
+}>;
+type TileflowCompilationSuccess = Readonly<{
+    diagnostics: readonly TileflowCompilationDiagnostic[];
+    ok: true;
+    report: TileflowCompilationReport;
+    style: MapLibreStyle;
+}>;
+type TileflowCompilationFailure = Readonly<{
+    diagnostics: readonly TileflowCompilationDiagnostic[];
+    ok: false;
+    report: TileflowCompilationReport;
+    style?: never;
+}>;
+type TileflowCompilationResult = TileflowCompilationFailure | TileflowCompilationSuccess;
+declare function isTileflowCompilationPhase(value: unknown): value is TileflowCompilationPhase;
+
+type TileflowPreparedMapAssets = {
+    icons?: {
+        ids: readonly string[];
+        sprite: string;
+    };
+};
+type TileflowSemanticCompileOptions = {
+    apiBaseUrl?: string;
+    /** Resolved authoring identity. Internal build orchestration supplies this. */
+    map?: {
+        id: string;
+        lineage?: readonly string[];
+        version: number;
+    };
+    /** Build-owned assets prepared from the authoring directories. */
+    preparedAssets?: TileflowPreparedMapAssets;
+    /** Concrete named theme. Omission deterministically selects map.defaultTheme. */
+    theme?: string;
+};
+type TileflowSemanticCompilationOptions = TileflowSemanticCompileOptions & {
+    /** Include opt-in read-only physical diagnostics; emitted IDs are not authoring targets. */
+    inspection?: boolean;
+};
+
+type TileflowStyleOptions = TileflowSemanticCompileOptions;
+type TileflowCompilationOptions = TileflowSemanticCompilationOptions;
+declare function createStyle(config: TileflowMap, options?: TileflowStyleOptions): MapLibreStyle;
+/** Resolve and compile one map without throwing, returning deterministic compiler diagnostics. */
+declare function createStyleResult(config: TileflowMap, options?: TileflowCompilationOptions): TileflowCompilationResult;
+declare function collectMapLineage(map: TileflowMap): string[];
+/** Resolve and validate one public authoring map before asset preparation or compilation. */
+declare function parseTileflowMap(map: TileflowMap): ResolvedTileflowMap;
+/** Validate one singular authoring map, including its complete extends lineage. */
+declare function validateTileflowMap(input: unknown): ValidationResult;
+
+export { type TileflowBoundariesModuleOptions as $, type TileflowSemanticModuleName as A, tileflowHostedSourceLimit as B, tileflowOverlayPlacements as C, type OpenMapTilesSchema as D, type OpenMapTilesSchemaOptions as E, type ResolvedBathymetry as F, type ResolvedBathymetryRelief as G, type ResolvedMarine as H, type ResolvedMarineSource as I, type ResolvedTileflowData as J, type ResolvedTileflowTheme as K, type ResolvedTileflowThemeTokens as L, type TileflowAddressesModuleConfig as M, type TileflowAddressesModuleOptions as N, type OpenMapTilesFieldBindings as O, type ParkLayerSemantics as P, type TileflowAerowaysModuleConfig as Q, type ResolvedTileflowMap as R, type TileflowAerowaysModuleOptions as S, type TileflowDataRequirementsV1 as T, type TileflowAuthoringModules as U, type TileflowBathymetryConfig as V, type TileflowBathymetryDemSourceIdentity as W, type TileflowBathymetryDisplay as X, type TileflowBathymetryOptions as Y, type TileflowBathymetryReliefConfig as Z, type TileflowBoundariesModuleConfig as _, type TileflowSourceRequirementsV1 as a, type TileflowThemeLighting as a$, type TileflowBuildingMode as a0, type TileflowBuildingsModuleConfig as a1, type TileflowBuildingsModuleOptions as a2, type TileflowCompilationDiagnostic as a3, type TileflowCompilationDomainReport as a4, type TileflowCompilationFailure as a5, type TileflowCompilationOptions as a6, type TileflowCompilationPhase as a7, type TileflowCompilationPlannerDecision as a8, type TileflowCompilationPlannerStage as a9, type TileflowMarine as aA, type TileflowMarineConfig as aB, type TileflowMarineMode as aC, type TileflowMarineSourceConfig as aD, type TileflowMarineSourceIdentity as aE, type TileflowModuleOperation as aF, type TileflowModulePatch as aG, type TileflowNauticalAreaLabelStyles as aH, type TileflowNauticalModuleConfig as aI, type TileflowNauticalModuleOptions as aJ, type TileflowOverlayCollection as aK, type TileflowOverlayPlacement as aL, type TileflowPackageDirectory as aM, type TileflowRasterDemSourceRequirementV1 as aN, type TileflowRefineOperation as aO, type TileflowRemoveOperation as aP, type TileflowReset as aQ, type TileflowResolvedThemeSelection as aR, type TileflowSemanticModules as aS, type TileflowStandaloneMap as aT, type TileflowTheme as aU, type TileflowThemeAuditContext as aV, type TileflowThemeAuditDiagnostic as aW, TileflowThemeAuditError as aX, type TileflowThemeAuditScope as aY, type TileflowThemeColorScheme as aZ, type TileflowThemeDefinition as a_, type TileflowCompilationReport as aa, type TileflowCompilationResult as ab, type TileflowCompilationSuccess as ac, type TileflowDataConfig as ad, type TileflowDataIdentity as ae, type TileflowDerivedMap as af, type TileflowDisableOperation as ag, type TileflowFontDirectory as ah, type TileflowGlyphs as ai, type TileflowHostedSourceCollection as aj, type TileflowHostedTilesetSource as ak, type TileflowHostedTilesetType as al, type TileflowIconDirectory as am, type TileflowLandModuleConfig as an, type TileflowLandModuleOptions as ao, type TileflowLandcoverClass as ap, type TileflowLandformClass as aq, type TileflowLandformsModuleConfig as ar, type TileflowLandformsModuleOptions as as, type TileflowLanduseClass as at, type TileflowLocalDirectory as au, type TileflowMapDesign as av, type TileflowMapIdentity as aw, type TileflowMapLibreOverlay as ax, type TileflowMapLibreOverlayLayer as ay, type TileflowMapTooling as az, type TileflowMap as b, tileflowThemeLimits as b$, type TileflowThemeName as b0, type TileflowThemeTokens as b1, type TileflowThemeTypography as b2, type TileflowThemeTypographyStyle as b3, type TileflowTransitModuleConfig as b4, type TileflowTransitModuleOptions as b5, type TileflowTransitRailStyle as b6, type TileflowVegetationMode as b7, type TileflowVegetationModuleConfig as b8, type TileflowVegetationModuleOptions as b9, isTileflowCompilationPhase as bA, isTileflowLocalDirectory as bB, land as bC, landforms as bD, maplibreOverlay as bE, nautical as bF, openMapTiles as bG, openMapTilesContractVersion as bH, parseTileflowMap as bI, refine as bJ, remove as bK, reset as bL, resolveMarine as bM, resolveThemeSelection as bN, resolveThemeValues as bO, resolveTileflowData as bP, resolveTileflowTheme as bQ, tileflowBathymetryDemSourceId as bR, tileflowBathymetrySourceId as bS, tileflowBathymetryV1Schema as bT, tileflowLandformClasses as bU, tileflowLocalDirectoryMaximumLength as bV, tileflowLocalDirectoryMessage as bW, tileflowMapIdSchema as bX, tileflowNauticalSourceId as bY, tileflowNauticalV1Schema as bZ, tileflowPrimarySourceId as b_, type TileflowVegetationThreeDimensionalStyle as ba, type TileflowVisualValueCategory as bb, type TileflowWaterModuleConfig as bc, type TileflowWaterModuleOptions as bd, type TileflowWaterwayClass as be, type TileflowWorldData as bf, type TileflowWorldReleaseReference as bg, type TileflowWorldSelection as bh, type TileflowWorldV1Schema as bi, type VectorTilesData as bj, addresses as bk, aeroways as bl, assertTileflowMapThemeValues as bm, auditTileflowMapThemeValues as bn, auditTileflowThemeValues as bo, bathymetry as bp, boundaries as bq, buildings as br, classifyTileflowVisualProperty as bs, createStyle as bt, createStyleResult as bu, defineTheme as bv, disable as bw, hostedTileset as bx, isCanonicalOpenMapTilesSchema as by, isSafeLocalPmtilesPath as bz, type TileflowStyleOptions as c, tileflowWorld as c0, tileflowWorldGeneration as c1, tileflowWorldTileJsonUrl as c2, tileflowWorldV1Schema as c3, transit as c4, validateTileflowMap as c5, validateTileflowWorldV1Tilejson as c6, vectorTiles as c7, vegetation as c8, water as c9, type TileflowInspectedStyle as d, type TileflowPreparedMapAssets as e, type TileflowDataCompatibilityIssue as f, type TileflowDataFieldRequirement as g, type TileflowDataFieldType as h, type TileflowDataLayerRequirement as i, type TileflowObservedDataContractV1 as j, type TileflowStyleInspection as k, type TileflowStyleInspectionContribution as l, type TileflowStyleInspectionLayer as m, type TileflowStyleInspectionRenderOperation as n, collectMapLineage as o, inferTileflowDataRequirements as p, inferTileflowSourceRequirements as q, type TileflowMapScene as r, type ResolveMapOptions as s, tileflowStyleInspectionSchemaVersion as t, type TileflowLayerDomain as u, validateTileflowDataCompatibility as v, type OpenMapTilesLayerBindings as w, tileflowCompilationPhases as x, tileflowCompilationPlannerStages as y, tileflowCompilationReportSchemaVersion as z };