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

package/dist/manifest-B5GKVMFE.d.ts

@@ -0,0 +1,757 @@
+import { z } from 'zod';
+
+declare const expressionBrand: unique symbol;
+declare const themeValueBrand: unique symbol;
+declare const zoomBrand: unique symbol;
+declare const tileflowThemeTokenCategories: readonly ["color", "font", "image", "number"];
+type TileflowThemeTokenCategory = (typeof tileflowThemeTokenCategories)[number];
+type TileflowThemeTokenPrimitive = {
+    color: string;
+    font: string;
+    image: string;
+    number: number;
+};
+/** A JSON-safe semantic reference. The category is carried at runtime as well as in its type. */
+type TileflowThemeTokenReference<TCategory extends TileflowThemeTokenCategory = TileflowThemeTokenCategory> = {
+    readonly category: TCategory;
+    readonly kind: 'theme-token';
+    readonly token: string;
+    readonly [themeValueBrand]: TileflowThemeTokenPrimitive[TCategory];
+};
+/** An explicit opt-out from theme substitution. A reason is mandatory for auditability. */
+type TileflowFixedValue<T> = {
+    readonly kind: 'theme-fixed';
+    readonly reason: string;
+    readonly value: T;
+    readonly [themeValueBrand]: T;
+};
+type TileflowThemeColorMix = {
+    readonly amount: TileflowThemeNumberValue;
+    readonly from: TileflowThemeColorValue;
+    readonly kind: 'theme-color';
+    readonly operation: 'mix';
+    readonly space: 'oklch';
+    readonly to: TileflowThemeColorValue;
+    readonly [themeValueBrand]: string;
+};
+type TileflowThemeColorAlpha = {
+    readonly color: TileflowThemeColorValue;
+    readonly kind: 'theme-color';
+    readonly opacity: TileflowThemeNumberValue;
+    readonly operation: 'alpha';
+    readonly [themeValueBrand]: string;
+};
+type TileflowThemeColorOperation = TileflowThemeColorAlpha | TileflowThemeColorMix;
+type TileflowThemeNumberValue = number | TileflowFixedValue<number> | TileflowThemeTokenReference<'number'>;
+type TileflowThemeColorValue = string | TileflowFixedValue<string> | TileflowThemeColorOperation | TileflowThemeTokenReference<'color'>;
+type TileflowThemeFontValue = string | TileflowFixedValue<string> | TileflowThemeTokenReference<'font'>;
+type TileflowThemeImageValue = string | TileflowFixedValue<string> | TileflowThemeTokenReference<'image'>;
+type TileflowThemeValue<T> = T | TileflowFixedValue<T> | (T extends number ? TileflowThemeTokenReference<'number'> : T extends string ? TileflowThemeTokenReference<'color' | 'font' | 'image'> | TileflowThemeColorOperation : never);
+declare const token: {
+    color(name: string): TileflowThemeTokenReference<"color">;
+    font(name: string): TileflowThemeTokenReference<"font">;
+    image(name: string): TileflowThemeTokenReference<"image">;
+    number(name: string): TileflowThemeTokenReference<"number">;
+};
+declare function fixed<T>(value: T, options: {
+    reason: string;
+}): TileflowFixedValue<T>;
+declare const color: {
+    alpha(value: TileflowThemeColorValue, opacity: TileflowThemeNumberValue): TileflowThemeColorAlpha;
+    mix(from: TileflowThemeColorValue, to: TileflowThemeColorValue, options: {
+        amount: TileflowThemeNumberValue;
+        space?: "oklch";
+    }): TileflowThemeColorMix;
+};
+type TileflowExpression<T> = {
+    readonly kind: 'expression';
+    readonly value: readonly unknown[];
+    /** Opaque result type. Only Tileflow's closed `expr.*` builders expose this brand publicly. */
+    readonly [expressionBrand]: T;
+};
+type TileflowZoomInterpolation = 'linear' | 'exponential';
+type TileflowZoomValueCommon<T> = {
+    readonly kind: 'zoom';
+    readonly stops: readonly (readonly [number, T])[];
+    readonly [zoomBrand]?: T;
+};
+type TileflowZoomValue<T> = TileflowZoomValueCommon<T> & ({
+    readonly base: number;
+    readonly interpolation: 'exponential';
+} | {
+    readonly base?: never;
+    readonly interpolation: 'linear' | 'step';
+});
+type TileflowStyleValue<T> = TileflowExpression<T> | TileflowThemeValue<T> | TileflowZoomValue<TileflowThemeValue<T>>;
+declare const zoom: {
+    exponential<T>(base: number, stops: readonly (readonly [number, T])[]): TileflowZoomValue<T>;
+    linear<T>(stops: readonly (readonly [number, T])[]): TileflowZoomValue<T>;
+    step<T>(stops: readonly (readonly [number, T])[]): TileflowZoomValue<T>;
+};
+
+/** A color literal, semantic color token, color operation, expression, or zoom ramp. */
+type TileflowColorStyleValue = TileflowExpression<string> | TileflowThemeColorValue | TileflowZoomValue<TileflowThemeColorValue>;
+/** An image name, semantic image token, expression, or zoom ramp. */
+type TileflowImageStyleValue = TileflowExpression<string> | TileflowThemeImageValue | TileflowZoomValue<TileflowThemeImageValue>;
+/** A number, semantic number token, expression, or zoom ramp. */
+type TileflowNumberStyleValue = TileflowExpression<number> | TileflowThemeNumberValue | TileflowZoomValue<TileflowThemeNumberValue>;
+/** A visual numeric array whose components may be themed, or whose full shape is fixed. */
+type TileflowThemeNumberArrayValue = readonly TileflowThemeNumberValue[] | TileflowFixedValue<readonly number[]>;
+/** A visual numeric array, expression, or zoom ramp with explicit theme intent. */
+type TileflowNumberArrayStyleValue = TileflowExpression<readonly number[]> | TileflowThemeNumberArrayValue | TileflowZoomValue<TileflowThemeNumberArrayValue>;
+/** A two-dimensional visual offset with category-safe numeric components. */
+type TileflowNumberOffsetStyleValue = readonly [TileflowThemeNumberValue, TileflowThemeNumberValue] | TileflowFixedValue<readonly number[]> | TileflowExpression<readonly number[]> | TileflowZoomValue<readonly [TileflowThemeNumberValue, TileflowThemeNumberValue] | TileflowFixedValue<readonly number[]>>;
+/** Top, right, bottom, and left visual insets with category-safe numeric components. */
+type TileflowNumberInsetsStyleValue = readonly [
+    TileflowThemeNumberValue,
+    TileflowThemeNumberValue,
+    TileflowThemeNumberValue,
+    TileflowThemeNumberValue
+] | TileflowFixedValue<readonly [number, number, number, number]> | TileflowExpression<readonly number[]> | TileflowZoomValue<readonly [
+    TileflowThemeNumberValue,
+    TileflowThemeNumberValue,
+    TileflowThemeNumberValue,
+    TileflowThemeNumberValue
+] | TileflowFixedValue<readonly [number, number, number, number]>>;
+/** A structural value that does not participate in semantic theme-token substitution. */
+type TileflowStructuralStyleValue<T> = T | TileflowExpression<T> | TileflowZoomValue<T>;
+/** Structural text, including expressions and zoom-dependent literal strings. */
+type TileflowStringStyleValue = TileflowStructuralStyleValue<string>;
+type TileflowLineCap = 'butt' | 'round' | 'square';
+type TileflowLineJoin = 'bevel' | 'miter' | 'round';
+type TileflowSymbolPlacement = 'line' | 'line-center' | 'point';
+type TileflowSymbolZOrder = 'auto' | 'source' | 'viewport-y';
+type TileflowPriorityOrder = 'higher-first' | 'lower-first';
+type TileflowTextAnchor = 'bottom' | 'bottom-left' | 'bottom-right' | 'center' | 'left' | 'right' | 'top' | 'top-left' | 'top-right';
+type TileflowTextJustify = 'auto' | 'center' | 'left' | 'right';
+type TileflowIconAnchor = TileflowTextAnchor;
+type TileflowAlignment = 'auto' | 'map' | 'viewport';
+type TileflowIconTextFit = 'both' | 'height' | 'none' | 'width';
+/** Visibility and zoom bounds shared by every visual primitive. */
+type TileflowLayerRange = {
+    maxZoom?: number;
+    minZoom?: number;
+    visible?: boolean;
+};
+type TileflowBackgroundPaint = {
+    color?: TileflowColorStyleValue;
+    opacity?: TileflowNumberStyleValue;
+    pattern?: TileflowImageStyleValue;
+};
+type TileflowBackgroundStyle = TileflowLayerRange & TileflowBackgroundPaint;
+type TileflowFillPaint = {
+    antialias?: boolean;
+    color?: TileflowColorStyleValue;
+    opacity?: TileflowNumberStyleValue;
+    pattern?: TileflowImageStyleValue;
+    translate?: TileflowNumberOffsetStyleValue;
+    translateAnchor?: 'map' | 'viewport';
+};
+type TileflowFillStyle = TileflowLayerRange & TileflowFillPaint;
+type TileflowLinePaint = {
+    blur?: TileflowNumberStyleValue;
+    color?: TileflowColorStyleValue;
+    dash?: TileflowNumberArrayStyleValue;
+    gapWidth?: TileflowNumberStyleValue;
+    offset?: TileflowNumberStyleValue;
+    opacity?: TileflowNumberStyleValue;
+    pattern?: TileflowImageStyleValue;
+    translate?: TileflowNumberOffsetStyleValue;
+    translateAnchor?: 'map' | 'viewport';
+    width?: TileflowNumberStyleValue;
+};
+type TileflowLineLayout = {
+    cap?: TileflowStructuralStyleValue<TileflowLineCap>;
+    join?: TileflowStructuralStyleValue<TileflowLineJoin>;
+    miterLimit?: TileflowNumberStyleValue;
+    roundLimit?: TileflowNumberStyleValue;
+};
+type TileflowLineStyle = TileflowLayerRange & TileflowLinePaint & TileflowLineLayout;
+/** Repeated diagonal marks placed along a stroked geographic feature. */
+type TileflowLineHatchStyle = TileflowLayerRange & {
+    angle?: TileflowNumberStyleValue;
+    color?: TileflowColorStyleValue;
+    opacity?: TileflowNumberStyleValue;
+    /** Sprite pattern clipped to the line deck; when set, it replaces glyph hatching. */
+    pattern?: TileflowImageStyleValue;
+    /**
+     * Intrinsic pixel heights available as `${pattern}-${width}` sprites. Tileflow
+     * selects the closest height to the rendered line width so marks retain a
+     * nearly fixed screen-pixel thickness instead of stretching with the road.
+     * Requires `pattern` to be a literal sprite-name prefix.
+     */
+    patternWidths?: TileflowThemeNumberArrayValue;
+    size?: TileflowNumberStyleValue;
+    spacing?: TileflowNumberStyleValue;
+};
+type TileflowTextPaint = {
+    color?: TileflowColorStyleValue;
+    haloBlur?: TileflowNumberStyleValue;
+    haloColor?: TileflowColorStyleValue;
+    haloWidth?: TileflowNumberStyleValue;
+    opacity?: TileflowNumberStyleValue;
+};
+type TileflowTextLayout = {
+    allowOverlap?: boolean;
+    anchor?: TileflowTextAnchor;
+    field?: TileflowStringStyleValue;
+    font?: TileflowThemeFontValue;
+    fallbacks?: readonly TileflowThemeFontValue[];
+    ignorePlacement?: boolean;
+    justify?: TileflowTextJustify;
+    keepUpright?: boolean;
+    letterSpacing?: TileflowNumberStyleValue;
+    lineHeight?: TileflowNumberStyleValue;
+    maxAngle?: TileflowNumberStyleValue;
+    maxWidth?: TileflowNumberStyleValue;
+    offset?: TileflowNumberOffsetStyleValue;
+    optional?: boolean;
+    padding?: TileflowNumberStyleValue;
+    pitchAlignment?: TileflowAlignment;
+    radialOffset?: TileflowNumberStyleValue;
+    rotate?: TileflowNumberStyleValue;
+    rotationAlignment?: TileflowAlignment;
+    size?: TileflowNumberStyleValue;
+    transform?: 'lowercase' | 'none' | 'uppercase';
+    variableAnchors?: readonly TileflowTextAnchor[];
+};
+type TileflowTextStyle = TileflowLayerRange & TileflowTextPaint & TileflowTextLayout;
+type TileflowIconPaint = {
+    color?: TileflowColorStyleValue;
+    haloBlur?: TileflowNumberStyleValue;
+    haloColor?: TileflowColorStyleValue;
+    haloWidth?: TileflowNumberStyleValue;
+    opacity?: TileflowNumberStyleValue;
+};
+type TileflowIconLayout = {
+    allowOverlap?: boolean;
+    anchor?: TileflowIconAnchor;
+    image?: TileflowImageStyleValue;
+    ignorePlacement?: boolean;
+    keepUpright?: boolean;
+    offset?: TileflowNumberOffsetStyleValue;
+    optional?: boolean;
+    padding?: TileflowNumberStyleValue;
+    pitchAlignment?: TileflowAlignment;
+    rotate?: TileflowNumberStyleValue;
+    rotationAlignment?: TileflowAlignment;
+    size?: TileflowNumberStyleValue;
+    textFit?: TileflowIconTextFit;
+    textFitPadding?: TileflowNumberInsetsStyleValue;
+};
+type TileflowIconStyle = TileflowLayerRange & TileflowIconPaint & TileflowIconLayout;
+type TileflowSymbolPlacementStyle = TileflowLayerRange & {
+    placement?: TileflowSymbolPlacement;
+    priority?: TileflowStructuralStyleValue<number>;
+    /** Collision order for the semantic priority value. Defaults to `higher-first`. */
+    priorityOrder?: TileflowPriorityOrder;
+    spacing?: TileflowNumberStyleValue;
+    zOrder?: TileflowSymbolZOrder;
+};
+type TileflowCirclePaint = {
+    blur?: TileflowNumberStyleValue;
+    color?: TileflowColorStyleValue;
+    opacity?: TileflowNumberStyleValue;
+    pitchAlignment?: 'map' | 'viewport';
+    pitchScale?: 'map' | 'viewport';
+    priority?: TileflowStructuralStyleValue<number>;
+    /** Drawing order for the semantic priority value. Defaults to `higher-first`. */
+    priorityOrder?: TileflowPriorityOrder;
+    radius?: TileflowNumberStyleValue;
+    strokeColor?: TileflowColorStyleValue;
+    strokeOpacity?: TileflowNumberStyleValue;
+    strokeWidth?: TileflowNumberStyleValue;
+    translate?: TileflowNumberOffsetStyleValue;
+    translateAnchor?: 'map' | 'viewport';
+};
+type TileflowCircleStyle = TileflowLayerRange & TileflowCirclePaint;
+type TileflowExtrusionPaint = {
+    base?: TileflowNumberStyleValue;
+    color?: TileflowColorStyleValue;
+    height?: TileflowNumberStyleValue;
+    opacity?: TileflowNumberStyleValue;
+    pattern?: TileflowImageStyleValue;
+    verticalGradient?: boolean;
+};
+type TileflowExtrusionStyle = TileflowLayerRange & TileflowExtrusionPaint;
+/** A polygon rendered as a fill and, when requested, a separate line layer. */
+type TileflowAreaStyle = {
+    fill?: TileflowFillStyle;
+    outline?: TileflowLineStyle;
+};
+/** The canonical ordered phases used for roads, aeroways, and other stroked paths. */
+type TileflowLineStackStyle = {
+    casing?: TileflowLineStyle;
+    fill?: TileflowLineStyle;
+    shadow?: TileflowLineStyle;
+};
+/** A symbol layer composed from one placement policy and optional text/icon parts. */
+type TileflowSymbolStyle = TileflowSymbolPlacementStyle & {
+    icon?: TileflowIconStyle;
+    text?: TileflowTextStyle;
+};
+/** A symbol style that may also materialize a separate circle marker layer. */
+type TileflowMarkerSymbolStyle = TileflowSymbolStyle & {
+    marker?: TileflowCircleStyle;
+};
+
+type TileflowColor = `#${string}`;
+type TileflowTypographyStyle = {
+    /** Ordered exact fallback face names; CSS generic families are allowed for local fonts. */
+    fallbacks?: readonly string[];
+    /** Exact OpenType full name or exact remote glyph face name. */
+    font?: string;
+    letterSpacing?: number;
+    transform?: 'lowercase' | 'none' | 'uppercase';
+};
+type ResolvedTileflowTypographyStyle = Required<Pick<TileflowTypographyStyle, 'font'>> & Omit<TileflowTypographyStyle, 'font'>;
+type ResolvedTileflowTypography = ResolvedTileflowTypographyStyle & {
+    places: ResolvedTileflowTypographyStyle;
+    roads: ResolvedTileflowTypographyStyle;
+    water: ResolvedTileflowTypographyStyle;
+    poi: ResolvedTileflowTypographyStyle;
+};
+type TileflowTerrainMode = 'none' | 'hillshade' | '3d';
+type TileflowTerrainEncoding = 'mapbox' | 'terrarium';
+type TileflowTerrainLayerRange = {
+    maxZoom?: number;
+    minZoom?: number;
+    visible?: boolean;
+};
+type TileflowTerrainHillshadeStyle = TileflowTerrainLayerRange & {
+    accentColor?: TileflowThemeColorValue;
+    exaggeration?: TileflowThemeNumberValue;
+    highlightColor?: TileflowThemeColorValue;
+    illuminationAnchor?: 'map' | 'viewport';
+    illuminationDirection?: TileflowThemeNumberValue;
+    shadowColor?: TileflowThemeColorValue;
+};
+type TileflowTerrainContourLineStyle = TileflowTerrainLayerRange & {
+    color?: TileflowThemeColorValue;
+    opacity?: TileflowThemeNumberValue;
+    width?: TileflowThemeNumberValue;
+};
+type TileflowTerrainContourLabelStyle = TileflowTerrainLayerRange & {
+    color?: TileflowThemeColorValue;
+    font?: TileflowThemeFontValue;
+    haloColor?: TileflowThemeColorValue;
+    haloWidth?: TileflowThemeNumberValue;
+    opacity?: TileflowThemeNumberValue;
+    size?: TileflowThemeNumberValue;
+    spacing?: TileflowThemeNumberValue;
+};
+type TileflowTerrainContoursConfig = {
+    /** Maximum native zoom exposed by the DEM tile template. */
+    demMaxZoom: number;
+    /** Explicit HTTP(S) DEM template containing {z}, {x}, and {y}. */
+    demUrl: string;
+    index?: TileflowTerrainContourLineStyle;
+    labels?: TileflowTerrainContourLabelStyle;
+    maxZoom?: number;
+    minZoom?: number;
+    minor?: TileflowTerrainContourLineStyle;
+    multiplier?: number;
+    overzoom?: number;
+    sourceId?: string;
+    /** Zoom-indexed [minor, index] elevation intervals. */
+    thresholds: Readonly<Record<number, readonly [number, number]>>;
+};
+type TileflowTerrainConfig = {
+    attribution?: string;
+    contours?: TileflowTerrainContoursConfig;
+    encoding?: TileflowTerrainEncoding;
+    exaggeration?: number;
+    hillshade?: TileflowTerrainHillshadeStyle;
+    mode?: TileflowTerrainMode;
+    sourceId?: string;
+    url?: string;
+};
+type TileflowTerrain = TileflowTerrainMode | TileflowTerrainConfig;
+type TileflowViewConfig = {
+    bearing?: number;
+    center?: readonly [number, number];
+    pitch?: number;
+    zoom?: number;
+};
+type TileflowRoadDetail = 'none' | 'highways' | 'major' | 'streets' | 'all';
+type TileflowRoadClass = 'motorway' | 'trunk' | 'primary' | 'secondary' | 'tertiary' | 'minor' | 'service' | 'track' | 'pathway' | 'footway' | 'cycleway' | 'steps' | 'pedestrian';
+type TileflowRoadHierarchy = 'subtle' | 'clear' | 'strong';
+type TileflowRoadWeight = 'thin' | 'regular' | 'bold';
+type TileflowRoadOutline = 'none' | 'subtle' | 'strong';
+type TileflowRoadStructure = 'bridge' | 'surface' | 'tunnel';
+type TileflowRoadExtras = {
+    paths?: boolean;
+};
+type TileflowRoadLayerStyle = TileflowLineStackStyle & {
+    hatch?: TileflowLineHatchStyle;
+};
+type TileflowRoadTreatmentLineStyle = Pick<TileflowLinePaint, 'blur' | 'color' | 'dash' | 'gapWidth' | 'offset' | 'opacity' | 'width'>;
+type TileflowRoadTreatmentLayerStyle = {
+    casing?: TileflowRoadTreatmentLineStyle;
+    fill?: TileflowRoadTreatmentLineStyle;
+    shadow?: TileflowRoadTreatmentLineStyle;
+};
+type TileflowRoadTreatmentStyle = Partial<Record<TileflowRoadStructure, TileflowRoadTreatmentLayerStyle>> & {
+    enabled?: boolean;
+    widthScale?: TileflowThemeNumberValue;
+};
+type TileflowRoadModifier = 'construction' | 'expressway' | 'indoor' | 'official' | 'ramp' | 'unpaved';
+type TileflowRoadRestriction = 'access' | 'bicycle' | 'foot' | 'horse' | 'toll';
+type TileflowMountainBikeScale = '0' | '0+' | '1' | '1+' | '2' | '2+' | '3' | '3+' | '4' | '5' | '6';
+type TileflowRoadServiceType = 'alley' | 'crossover' | 'driveway' | 'parkingAisle' | 'yard';
+type TileflowRoadClassStyle = Partial<Record<TileflowRoadStructure, TileflowRoadLayerStyle>> & {
+    enabled?: boolean;
+};
+type TileflowRoadAreaStyle = {
+    pedestrian?: TileflowAreaStyle;
+    pier?: TileflowAreaStyle;
+    road?: TileflowAreaStyle;
+};
+type TileflowRoadCrossingStyle = Omit<TileflowIconStyle, 'image'> & Required<Pick<TileflowIconStyle, 'image'>>;
+type TileflowRoadRoundaboutStyle = {
+    casing?: TileflowCircleStyle;
+    fill?: TileflowCircleStyle;
+};
+type TileflowRoadSidewalkStyle = {
+    outline?: TileflowLineStyle;
+    pattern?: TileflowFillStyle;
+    surface?: TileflowFillStyle;
+};
+type TileflowRoadsModuleConfig = {
+    type: 'roads';
+    areas?: TileflowRoadAreaStyle;
+    classes?: Partial<Record<TileflowRoadClass, TileflowRoadClassStyle>>;
+    crossings?: TileflowRoadCrossingStyle;
+    detail?: TileflowRoadDetail;
+    extras?: TileflowRoadExtras;
+    hierarchy?: TileflowRoadHierarchy;
+    modifiers?: Partial<Record<TileflowRoadModifier, TileflowRoadTreatmentStyle>>;
+    mountainBike?: Partial<Record<TileflowMountainBikeScale, TileflowRoadTreatmentStyle>>;
+    oneWayMarkers?: boolean;
+    outline?: TileflowRoadOutline;
+    restrictions?: Partial<Record<TileflowRoadRestriction, TileflowRoadTreatmentStyle>>;
+    roundabouts?: TileflowRoadRoundaboutStyle;
+    serviceTypes?: Partial<Record<TileflowRoadServiceType, TileflowRoadTreatmentStyle>>;
+    sidewalks?: TileflowRoadSidewalkStyle;
+    structures?: Partial<Record<TileflowRoadStructure, TileflowRoadLayerStyle>>;
+    weight?: TileflowRoadWeight;
+    widthScale?: Partial<Record<TileflowRoadClass, TileflowThemeNumberValue>>;
+};
+type TileflowRoadsModuleOptions = Omit<TileflowRoadsModuleConfig, 'type'>;
+type TileflowLabelDetail = 'none' | 'major' | 'all';
+type TileflowAerodromeCodeDetail = 'none' | 'iata' | 'all';
+type TileflowRoadLabelDetail = TileflowRoadDetail;
+type TileflowLabelLanguage = 'auto' | 'local' | 'en' | (string & {});
+type TileflowPlaceLabelClass = 'city' | 'continent' | 'country' | 'neighborhood' | 'other' | 'state' | 'town' | 'village';
+type TileflowWaterLabelClass = 'line' | 'ocean' | 'other' | 'waterway';
+type TileflowRoadShieldDetail = 'none' | 'major' | 'all';
+type TileflowLabelCollisionPriority = 'balanced' | 'navigation';
+type TileflowRoadShieldStyles = {
+    default?: TileflowSymbolStyle;
+    detail?: TileflowSymbolStyle;
+    kinds?: Record<string, {
+        image: TileflowThemeImageValue;
+    }>;
+    overview?: TileflowSymbolStyle;
+    textColors?: Record<string, {
+        color: TileflowThemeColorValue;
+    }>;
+};
+type TileflowLabelStyles = {
+    aerodrome?: TileflowSymbolStyle;
+    junctions?: TileflowSymbolStyle;
+    places?: Partial<Record<TileflowPlaceLabelClass, TileflowSymbolStyle>>;
+    roads?: Partial<Record<TileflowRoadClass, TileflowSymbolStyle>>;
+    shields?: TileflowRoadShieldStyles;
+    water?: Partial<Record<TileflowWaterLabelClass, TileflowSymbolStyle>>;
+};
+type TileflowLabelsModuleConfig = {
+    type: 'labels';
+    aerodromeCodes?: TileflowAerodromeCodeDetail;
+    collisionPriority?: TileflowLabelCollisionPriority;
+    junctions?: boolean;
+    language?: TileflowLabelLanguage;
+    places?: TileflowLabelDetail;
+    roadClasses?: readonly TileflowRoadClass[];
+    roads?: TileflowRoadLabelDetail;
+    shields?: TileflowRoadShieldDetail;
+    styles?: TileflowLabelStyles;
+    water?: TileflowLabelDetail;
+};
+type TileflowLabelsModuleOptions = Omit<TileflowLabelsModuleConfig, 'type'>;
+/** Closed editorial vocabulary emitted by Tileflow World's canonical POI projection. */
+declare const tileflowPoiCategories: readonly ["arts-entertainment", "education", "food-drink", "landmark", "lodging", "medical", "park-nature", "public-services", "religion", "retail", "sport-leisure", "transport", "visitor-amenity"];
+type TileflowPoiCategory = (typeof tileflowPoiCategories)[number];
+type TileflowPoiDensity = 1 | 2 | 3 | 4 | 5;
+type TileflowPoiColorMode = 'uniform' | 'category';
+type TileflowPoiCategoryStyle = Omit<TileflowMarkerSymbolStyle, 'priority'> & {
+    /** Optional category-local cap within the module's canonical density tiers. */
+    density?: TileflowPoiDensity;
+};
+type TileflowPoiModuleConfig = {
+    type: 'poi';
+    categories?: readonly TileflowPoiCategory[];
+    color?: TileflowPoiColorMode;
+    density?: TileflowPoiDensity;
+    icons?: boolean;
+    labels?: boolean;
+    minZoom?: number;
+    placement?: {
+        coupleIconAndLabel?: boolean;
+        iconPadding?: number;
+        textPadding?: number;
+    };
+    styles?: Partial<Record<TileflowPoiCategory, TileflowPoiCategoryStyle>>;
+};
+type TileflowPoiModuleOptions = Omit<TileflowPoiModuleConfig, 'type'>;
+type MapLibreSprite = string | Array<{
+    id: string;
+    url: string;
+}>;
+type TileflowProjection = 'globe' | 'mercator';
+type TileflowLight = {
+    anchor?: 'map' | 'viewport';
+    color?: TileflowColor;
+    intensity?: number;
+    position?: readonly [number, number, number];
+};
+type MapLibreStyle = {
+    version: 8;
+    name: string;
+    glyphs?: string;
+    light?: TileflowLight;
+    projection?: {
+        type: TileflowProjection;
+    };
+    sprite?: MapLibreSprite;
+    sources: Record<string, Record<string, unknown>>;
+    layers: Array<Record<string, unknown>>;
+    terrain?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+type ValidationMessage = {
+    level: 'error' | 'warning';
+    path: string;
+    message: string;
+};
+type ValidationResult = {
+    valid: boolean;
+    messages: ValidationMessage[];
+};
+
+declare const defaultTileflowManifestUrl = "/tileflow/manifest.json";
+declare const defaultTileflowRuntimeView: Readonly<{
+    bearing: 0;
+    center: readonly [number, number];
+    pitch: 0;
+    zoom: 2;
+}>;
+type TileflowAnalytics = {
+    apiUrl?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    mapId?: string;
+    metadata?: Record<string, unknown>;
+    projectId?: string;
+    sdkVersion?: string;
+    source?: string;
+    styleId?: string;
+    surfaceId?: string;
+};
+declare function normalizeTileflowSurfaceId(value: unknown): string;
+type TileflowSessionGrantResponse = {
+    billingEnabled?: false;
+    disposition?: 'ordinary' | 'unbilled_fail_open';
+    expiresAt?: string;
+    grant?: string;
+    meterMode?: 'disabled' | 'shadow' | 'enforced';
+    ok: boolean;
+    resourceOrigins?: string[];
+    sessionId: string;
+    usageMode?: 'session';
+    code?: string;
+    retryWithNewSession?: boolean;
+};
+type TileflowSessionController = {
+    readonly sessionId: string;
+    resolveRequestUrl(url: string, analytics: TileflowAnalytics | undefined): Promise<string | undefined>;
+};
+type TileflowMapMode = 'interactive' | 'image';
+type TileflowMapModeOptions = {
+    mode?: TileflowMapMode;
+};
+/** Runtime-ready logical map with all relative theme resources already resolved. */
+type TileflowRuntimeManifestMap = TileflowRuntimeManifestMapEntry & {
+    apiUrl?: string;
+    name: string;
+};
+/** `system` is a selector and therefore reserved as a published theme name. */
+type TileflowThemeSelection = string | 'system';
+type TileflowResolvedRuntimeTheme = TileflowRuntimeManifestTheme & {
+    name: string;
+};
+type TileflowRuntimeStyle = {
+    analytics?: TileflowAnalytics;
+    colorScheme?: TileflowRuntimeColorScheme;
+    /** An explicit empty array means the manifest declares that no web fonts are required. */
+    fontFaces?: TileflowStyleFontFace[];
+    revision?: string;
+    style: MapLibreStyle | string;
+    theme?: string;
+};
+declare const tileflowStyleFontFacesMetadataKey: "tileflow:fontFaces";
+declare const tileflowStyleFontFaceLimits: Readonly<{
+    maximumCount: 16;
+    maximumSourceLength: 2048;
+}>;
+type TileflowStyleFontFace = {
+    family: string;
+    source: string;
+    style?: 'italic' | 'normal' | 'oblique';
+    weight?: '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+};
+/** Browser input is either one published Tileflow map or one direct MapLibre style. */
+type TileflowRuntimeSource = {
+    kind: 'tileflow';
+    manifestUrl?: string;
+    map: string;
+} | {
+    kind: 'maplibre';
+    style: MapLibreStyle | string;
+};
+type TileflowRuntimeStyleOptions = {
+    colorScheme?: TileflowRuntimeColorScheme;
+    manifestMap?: TileflowRuntimeManifestMap | null;
+    source: TileflowRuntimeSource;
+    theme?: TileflowThemeSelection;
+};
+type TileflowRuntimeSourceValidation = {
+    ok: true;
+} | {
+    code: 'invalid-source' | 'missing-source';
+    error: string;
+    ok: false;
+};
+type TileflowManifestLoadOptions = {
+    source: TileflowRuntimeSource;
+};
+type TileflowManifestFetchOptions = {
+    /** Successful manifests are shared for this duration. Set to 0 to bypass the cache. */
+    cacheTtlMs?: number;
+    fetch?: typeof globalThis.fetch;
+    signal?: AbortSignal;
+    /** Hard request timeout in milliseconds. Defaults to 10 seconds and is capped at 60 seconds. */
+    timeoutMs?: number;
+};
+type TileflowRuntimeViewOptions = TileflowViewConfig & {
+    fallback?: TileflowViewConfig;
+    manifestMap?: TileflowRuntimeManifestMap | null;
+};
+type TileflowRuntimeCenterLike = readonly [number, number] | {
+    lat: number;
+    lng: number;
+} | {
+    lat: number;
+    lon: number;
+};
+declare function shouldLoadTileflowManifest(options: TileflowManifestLoadOptions): boolean;
+declare function validateTileflowRuntimeSource(source: unknown): TileflowRuntimeSourceValidation;
+/** Validate the only runtime selection grammar: one concrete portable name or `system`. */
+declare function validateTileflowThemeSelection(value: unknown): value is TileflowThemeSelection;
+declare function assertValidTileflowRuntimeSource(source: unknown): asserts source is TileflowRuntimeSource;
+declare function resolveTileflowRuntimeStyle(options: TileflowRuntimeStyleOptions): TileflowRuntimeStyle | null;
+/** Resolve one concrete published theme without consulting ambient browser state. */
+declare function resolveTileflowRuntimeTheme(map: TileflowRuntimeManifestMap, selection: TileflowThemeSelection | undefined, colorScheme?: TileflowRuntimeColorScheme): TileflowResolvedRuntimeTheme;
+/** Strictly reads Tileflow-owned web-font metadata from a compiled MapLibre style. */
+declare function getTileflowStyleFontFaces(style: Pick<MapLibreStyle, 'metadata'>): TileflowStyleFontFace[];
+declare function normalizeTileflowUrl(value: string): string;
+declare function createTileflowSessionId(): string;
+declare function createTileflowSessionController(input: {
+    fetch?: typeof fetch;
+    grantTimeoutMs?: number;
+    now?: () => Date;
+    sessionIdFactory?: () => string;
+    source: string;
+}): TileflowSessionController;
+declare function resolveTileflowAnalyticsRequestUrl(url: string, analytics: TileflowAnalytics | undefined, sessionId: string): string | undefined;
+declare function startTileflowSession(analytics: TileflowAnalytics | undefined, input: {
+    mapId?: string;
+    sessionId: string;
+    source: string;
+    styleId?: string;
+}): void;
+declare function getTileflowAnalyticsApiUrl(analytics: TileflowAnalytics): string;
+declare function mergeTileflowAnalytics(userAnalytics: TileflowAnalytics | undefined, runtimeAnalytics: TileflowAnalytics | undefined): TileflowAnalytics | undefined;
+declare function resolveTileflowMapMode(options: TileflowMapModeOptions): TileflowMapMode;
+declare function resolveTileflowRuntimeView(options: TileflowRuntimeViewOptions): TileflowViewConfig;
+declare function normalizeTileflowRuntimeCenter(center: TileflowRuntimeCenterLike | undefined, fallback?: readonly [number, number]): [number, number];
+declare function loadTileflowManifest(url: string, options?: TileflowManifestFetchOptions): Promise<TileflowRuntimeManifest | null>;
+declare function clearTileflowManifestCache(url?: string): void;
+declare function resolveTileflowManifestMap(manifest: TileflowRuntimeManifest, mapName: string): TileflowRuntimeManifestMap | null;
+declare function resolveTileflowStaticImageUrl(input: {
+    center: [number, number];
+    colorScheme?: TileflowRuntimeColorScheme;
+    imageSize: {
+        height: number;
+        width: number;
+    } | null;
+    manifestMap: TileflowRuntimeManifestMap | null;
+    theme?: TileflowThemeSelection;
+    zoom: number;
+}): string | undefined;
+declare function normalizeTileflowStaticImageSize(input: {
+    height: number;
+    width: number;
+}): {
+    height: number;
+    width: number;
+};
+declare function inferTileflowAnalyticsFromStyleUrl(styleUrl: string): TileflowAnalytics | undefined;
+
+/** The first and only public multi-theme runtime manifest contract. */
+declare const tileflowRuntimeManifestVersion: 1;
+declare const tileflowRuntimeManifestLimits: Readonly<{
+    maximumBytes: number;
+}>;
+type TileflowRuntimeColorScheme = 'dark' | 'light';
+type TileflowRuntimeManifestTheme = {
+    colorScheme: TileflowRuntimeColorScheme;
+    /** Complete font closure for this compiled theme. */
+    fontFaces?: TileflowStyleFontFace[];
+    /** Content or deployment revision used for cache identity and receipts. */
+    revision?: string;
+    /** Hosted style identity, when different from the logical map identity. */
+    styleId?: string;
+    styleUrl: string;
+};
+type TileflowRuntimeSystemThemes = {
+    dark: string;
+    light: string;
+};
+type TileflowRuntimeManifestMapEntry = {
+    apiUrl?: string;
+    defaultTheme: string;
+    environment?: string;
+    mapId?: string;
+    systemThemes?: TileflowRuntimeSystemThemes;
+    themes: Record<string, TileflowRuntimeManifestTheme>;
+    usageMode?: 'session';
+    view?: TileflowViewConfig;
+    worldGeneration?: 'v1';
+};
+/**
+ * One logical map catalog for local and Hosted delivery.
+ *
+ * Delivery-specific fields are optional metadata on a map. The wire shape never forks into
+ * self-hosted and Hosted variants, so every runtime follows the same theme resolution path.
+ */
+type TileflowRuntimeManifest = {
+    apiUrl?: string;
+    maps: Record<string, TileflowRuntimeManifestMapEntry>;
+    version: typeof tileflowRuntimeManifestVersion;
+};
+declare const tileflowRuntimeManifestSchema: z.ZodType<TileflowRuntimeManifest>;
+declare function parseTileflowRuntimeManifest(input: unknown): TileflowRuntimeManifest;
+declare function safeParseTileflowRuntimeManifest(input: unknown): z.ZodSafeParseResult<TileflowRuntimeManifest>;
+
+export { type TileflowNumberInsetsStyleValue as $, type TileflowFillPaint as A, type TileflowIconAnchor as B, type TileflowIconLayout as C, type TileflowIconPaint as D, type TileflowIconStyle as E, type TileflowIconTextFit as F, type TileflowImageStyleValue as G, type TileflowLabelDetail as H, type TileflowLabelLanguage as I, type TileflowLabelStyles as J, type TileflowLayerRange as K, type TileflowLight as L, type MapLibreStyle as M, type TileflowLineCap as N, type TileflowLineHatchStyle as O, type TileflowLineJoin as P, type TileflowLineLayout as Q, type TileflowLinePaint as R, type TileflowLineStackStyle as S, type TileflowRuntimeManifest as T, type TileflowManifestFetchOptions as U, type ValidationMessage as V, type TileflowManifestLoadOptions as W, type TileflowMapMode as X, type TileflowMapModeOptions as Y, type TileflowMarkerSymbolStyle as Z, type TileflowMountainBikeScale as _, type TileflowExpression as a, type TileflowTextPaint as a$, type TileflowNumberStyleValue as a0, type TileflowPlaceLabelClass as a1, type TileflowPoiCategory as a2, type TileflowPoiCategoryStyle as a3, type TileflowPoiColorMode as a4, type TileflowPoiDensity as a5, type TileflowPriorityOrder as a6, type TileflowProjection as a7, type TileflowResolvedRuntimeTheme as a8, type TileflowRoadAreaStyle as a9, type TileflowRuntimeSource as aA, type TileflowRuntimeSourceValidation as aB, type TileflowRuntimeStyle as aC, type TileflowRuntimeStyleOptions as aD, type TileflowRuntimeSystemThemes as aE, type TileflowRuntimeViewOptions as aF, type TileflowSessionController as aG, type TileflowSessionGrantResponse as aH, type TileflowStringStyleValue as aI, type TileflowStructuralStyleValue as aJ, type TileflowStyleFontFace as aK, type TileflowStyleValue as aL, type TileflowSymbolPlacement as aM, type TileflowSymbolPlacementStyle as aN, type TileflowSymbolZOrder as aO, type TileflowTerrain as aP, type TileflowTerrainConfig as aQ, type TileflowTerrainContourLabelStyle as aR, type TileflowTerrainContourLineStyle as aS, type TileflowTerrainContoursConfig as aT, type TileflowTerrainEncoding as aU, type TileflowTerrainHillshadeStyle as aV, type TileflowTerrainLayerRange as aW, type TileflowTerrainMode as aX, type TileflowTextAnchor as aY, type TileflowTextJustify as aZ, type TileflowTextLayout as a_, type TileflowRoadClass as aa, type TileflowRoadClassStyle as ab, type TileflowRoadCrossingStyle as ac, type TileflowRoadDetail as ad, type TileflowRoadExtras as ae, type TileflowRoadHierarchy as af, type TileflowRoadLabelDetail as ag, type TileflowRoadLayerStyle as ah, type TileflowRoadModifier as ai, type TileflowRoadOutline as aj, type TileflowRoadRestriction as ak, type TileflowRoadRoundaboutStyle as al, type TileflowRoadServiceType as am, type TileflowRoadShieldDetail as an, type TileflowRoadShieldStyles as ao, type TileflowRoadSidewalkStyle as ap, type TileflowRoadStructure as aq, type TileflowRoadTreatmentLayerStyle as ar, type TileflowRoadTreatmentLineStyle as as, type TileflowRoadTreatmentStyle as at, type TileflowRoadWeight as au, type TileflowRuntimeCenterLike as av, type TileflowRuntimeColorScheme as aw, type TileflowRuntimeManifestMap as ax, type TileflowRuntimeManifestMapEntry as ay, type TileflowRuntimeManifestTheme as az, type TileflowFixedValue as b, type TileflowTextStyle as b0, type TileflowThemeColorAlpha as b1, type TileflowThemeColorMix as b2, type TileflowThemeColorValue as b3, type TileflowThemeFontValue as b4, type TileflowThemeImageValue as b5, type TileflowThemeNumberValue as b6, type TileflowThemeSelection as b7, type TileflowThemeTokenCategory as b8, type TileflowThemeValue as b9, resolveTileflowRuntimeTheme as bA, resolveTileflowRuntimeView as bB, resolveTileflowStaticImageUrl as bC, safeParseTileflowRuntimeManifest as bD, shouldLoadTileflowManifest as bE, startTileflowSession as bF, tileflowPoiCategories as bG, tileflowRuntimeManifestLimits as bH, tileflowRuntimeManifestSchema as bI, tileflowRuntimeManifestVersion as bJ, tileflowStyleFontFaceLimits as bK, tileflowStyleFontFacesMetadataKey as bL, tileflowThemeTokenCategories as bM, token as bN, validateTileflowRuntimeSource as bO, validateTileflowThemeSelection as bP, zoom as bQ, type TileflowTypographyStyle as bR, type ResolvedTileflowTypography as bS, normalizeTileflowSurfaceId as bT, type TileflowViewConfig as ba, type TileflowWaterLabelClass as bb, type TileflowZoomInterpolation as bc, type TileflowZoomValue as bd, type ValidationResult as be, assertValidTileflowRuntimeSource as bf, clearTileflowManifestCache as bg, color as bh, createTileflowSessionController as bi, createTileflowSessionId as bj, defaultTileflowManifestUrl as bk, defaultTileflowRuntimeView as bl, fixed as bm, getTileflowAnalyticsApiUrl as bn, getTileflowStyleFontFaces as bo, inferTileflowAnalyticsFromStyleUrl as bp, loadTileflowManifest as bq, mergeTileflowAnalytics as br, normalizeTileflowRuntimeCenter as bs, normalizeTileflowStaticImageSize as bt, normalizeTileflowUrl as bu, parseTileflowRuntimeManifest as bv, resolveTileflowAnalyticsRequestUrl as bw, resolveTileflowManifestMap as bx, resolveTileflowMapMode as by, resolveTileflowRuntimeStyle as bz, type TileflowThemeTokenReference as c, type TileflowThemeColorOperation as d, type TileflowBackgroundStyle as e, type TileflowCircleStyle as f, type TileflowExtrusionStyle as g, type TileflowFillStyle as h, type TileflowLineStyle as i, type TileflowSymbolStyle as j, type TileflowRoadsModuleOptions as k, type TileflowRoadsModuleConfig as l, type TileflowLabelsModuleOptions as m, type TileflowLabelsModuleConfig as n, type TileflowPoiModuleOptions as o, type TileflowPoiModuleConfig as p, type MapLibreSprite as q, type TileflowAerodromeCodeDetail as r, type TileflowAlignment as s, type TileflowAnalytics as t, type TileflowAreaStyle as u, type TileflowBackgroundPaint as v, type TileflowCirclePaint as w, type TileflowColor as x, type TileflowColorStyleValue as y, type TileflowExtrusionPaint as z };