@tileflow/core 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/manifest-types-CTT2eLbp.d.ts

@@ -0,0 +1,790 @@
+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;
+};
+/**
+ * One opaque strip behind each shaped line of a label. Tileflow lowers it to a derived glyph stack
+ * whose cells MapLibre's text halo paints, so placement, wrapping and collision stay native.
+ */
+type TileflowTextBackground = {
+    /** Strip colour. Cells overlap at their joins, so the colour must be opaque. */
+    color: TileflowColorStyleValue;
+    /** `lines` fits one strip to each shaped line. */
+    fit: 'lines';
+    /** Strip extension beyond the first and last glyph of each line, in ems. Defaults to 0.33. */
+    padding?: TileflowThemeNumberValue;
+};
+type TileflowTextLayout = {
+    allowOverlap?: boolean;
+    anchor?: TileflowTextAnchor;
+    /**
+     * Replaces the text halo with line-fitted strips. Requires a map `glyphs` provider that serves
+     * derived stacks, one font without fallbacks, and constant `letterSpacing` and `lineHeight`.
+     */
+    background?: TileflowTextBackground;
+    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 = {
+    sky?: Record<string, unknown>;
+    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';
+};
+/** One published Tileflow map. Renderer-specific styles are not framework Map inputs. */
+type TileflowRuntimeSource = {
+    manifestUrl?: string;
+    map: 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;
+/**
+ * A continuous blend of named themes of one Tileflow map. `position` places the map between
+ * neighbouring themes: 0 is the first, 1 the second, and 1.25 a quarter of the way from the second
+ * to the third.
+ */
+type TileflowThemeBlendSelection = Readonly<{
+    /** From 0 to `themes.length - 1`. */
+    position: number;
+    /** Two to eight concrete theme names of the map, in blend order. */
+    themes: readonly string[];
+}>;
+declare const tileflowThemeBlendLimits: Readonly<{
+    maximumThemes: 8;
+    minimumThemes: 2;
+}>;
+declare function validateTileflowThemeBlendSelection(value: unknown): value is TileflowThemeBlendSelection;
+/** The theme nearest to a blend position, which a blend shows when it cannot blend. */
+declare function nearestTileflowBlendTheme(blend: TileflowThemeBlendSelection): string;
+/** Resolves every theme of a blend to its published runtime style, in blend order. */
+declare function resolveTileflowRuntimeThemeBlend(options: {
+    blend: TileflowThemeBlendSelection;
+    manifestMap: TileflowRuntimeManifestMap;
+    source: TileflowRuntimeSource;
+}): TileflowRuntimeStyle[];
+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;
+};
+
+export { type TileflowManifestFetchOptions as $, type TileflowAreaStyle as A, type TileflowBackgroundPaint as B, type TileflowCirclePaint as C, type TileflowColor as D, type TileflowColorStyleValue as E, type TileflowExtrusionPaint as F, type TileflowFillPaint as G, type TileflowIconAnchor as H, type TileflowIconLayout as I, type TileflowIconPaint as J, type TileflowIconStyle as K, type TileflowIconTextFit as L, type MapLibreStyle as M, type TileflowImageStyleValue as N, type TileflowLabelDetail as O, type TileflowLabelLanguage as P, type TileflowLabelStyles as Q, type TileflowLayerRange as R, type TileflowLight as S, type TileflowRuntimeManifest as T, type TileflowLineCap as U, type ValidationMessage as V, type TileflowLineHatchStyle as W, type TileflowLineJoin as X, type TileflowLineLayout as Y, type TileflowLinePaint as Z, type TileflowLineStackStyle as _, type TileflowRuntimeColorScheme as a, type TileflowTextBackground as a$, type TileflowManifestLoadOptions as a0, type TileflowMapMode as a1, type TileflowMapModeOptions as a2, type TileflowMarkerSymbolStyle as a3, type TileflowMountainBikeScale as a4, type TileflowNumberInsetsStyleValue as a5, type TileflowNumberStyleValue as a6, type TileflowPlaceLabelClass as a7, type TileflowPoiCategory as a8, type TileflowPoiCategoryStyle as a9, type TileflowRoadWeight as aA, type TileflowRuntimeCenterLike as aB, type TileflowRuntimeManifestMap as aC, type TileflowRuntimeSource as aD, type TileflowRuntimeSourceValidation as aE, type TileflowRuntimeStyle as aF, type TileflowRuntimeStyleOptions as aG, type TileflowRuntimeViewOptions as aH, type TileflowSessionController as aI, type TileflowSessionGrantResponse as aJ, type TileflowStringStyleValue as aK, type TileflowStructuralStyleValue as aL, type TileflowStyleFontFace as aM, type TileflowStyleValue as aN, type TileflowSymbolPlacement as aO, type TileflowSymbolPlacementStyle as aP, type TileflowSymbolZOrder as aQ, type TileflowTerrain as aR, type TileflowTerrainConfig as aS, type TileflowTerrainContourLabelStyle as aT, type TileflowTerrainContourLineStyle as aU, type TileflowTerrainContoursConfig as aV, type TileflowTerrainEncoding as aW, type TileflowTerrainHillshadeStyle as aX, type TileflowTerrainLayerRange as aY, type TileflowTerrainMode as aZ, type TileflowTextAnchor as a_, type TileflowPoiColorMode as aa, type TileflowPoiDensity as ab, type TileflowPriorityOrder as ac, type TileflowProjection as ad, type TileflowResolvedRuntimeTheme as ae, type TileflowRoadAreaStyle as af, type TileflowRoadClass as ag, type TileflowRoadClassStyle as ah, type TileflowRoadCrossingStyle as ai, type TileflowRoadDetail as aj, type TileflowRoadExtras as ak, type TileflowRoadHierarchy as al, type TileflowRoadLabelDetail as am, type TileflowRoadLayerStyle as an, type TileflowRoadModifier as ao, type TileflowRoadOutline as ap, type TileflowRoadRestriction as aq, type TileflowRoadRoundaboutStyle as ar, type TileflowRoadServiceType as as, type TileflowRoadShieldDetail as at, type TileflowRoadShieldStyles as au, type TileflowRoadSidewalkStyle as av, type TileflowRoadStructure as aw, type TileflowRoadTreatmentLayerStyle as ax, type TileflowRoadTreatmentLineStyle as ay, type TileflowRoadTreatmentStyle as az, type TileflowRuntimeManifestMapEntry as b, type TileflowTextJustify as b0, type TileflowTextLayout as b1, type TileflowTextPaint as b2, type TileflowTextStyle as b3, type TileflowThemeBlendSelection as b4, type TileflowThemeColorAlpha as b5, type TileflowThemeColorMix as b6, type TileflowThemeColorValue as b7, type TileflowThemeFontValue as b8, type TileflowThemeImageValue as b9, resolveTileflowAnalyticsRequestUrl as bA, resolveTileflowManifestMap as bB, resolveTileflowMapMode as bC, resolveTileflowRuntimeStyle as bD, resolveTileflowRuntimeTheme as bE, resolveTileflowRuntimeThemeBlend as bF, resolveTileflowRuntimeView as bG, resolveTileflowStaticImageUrl as bH, shouldLoadTileflowManifest as bI, startTileflowSession as bJ, tileflowPoiCategories as bK, tileflowStyleFontFaceLimits as bL, tileflowStyleFontFacesMetadataKey as bM, tileflowThemeBlendLimits as bN, tileflowThemeTokenCategories as bO, token as bP, validateTileflowRuntimeSource as bQ, validateTileflowThemeBlendSelection as bR, validateTileflowThemeSelection as bS, zoom as bT, type TileflowTypographyStyle as bU, type ResolvedTileflowTypography as bV, normalizeTileflowSurfaceId as bW, type TileflowThemeNumberValue as ba, type TileflowThemeSelection as bb, type TileflowThemeTokenCategory as bc, type TileflowThemeValue as bd, type TileflowViewConfig as be, type TileflowWaterLabelClass as bf, type TileflowZoomInterpolation as bg, type TileflowZoomValue as bh, type ValidationResult as bi, assertValidTileflowRuntimeSource as bj, clearTileflowManifestCache as bk, color as bl, createTileflowSessionController as bm, createTileflowSessionId as bn, defaultTileflowManifestUrl as bo, defaultTileflowRuntimeView as bp, fixed as bq, getTileflowAnalyticsApiUrl as br, getTileflowStyleFontFaces as bs, inferTileflowAnalyticsFromStyleUrl as bt, loadTileflowManifest as bu, mergeTileflowAnalytics as bv, nearestTileflowBlendTheme as bw, normalizeTileflowRuntimeCenter as bx, normalizeTileflowStaticImageSize as by, normalizeTileflowUrl as bz, type TileflowRuntimeManifestTheme as c, type TileflowRuntimeSystemThemes as d, tileflowRuntimeManifestVersion as e, type TileflowExpression as f, type TileflowFixedValue as g, type TileflowThemeTokenReference as h, type TileflowThemeColorOperation as i, type TileflowBackgroundStyle as j, type TileflowCircleStyle as k, type TileflowExtrusionStyle as l, type TileflowFillStyle as m, type TileflowLineStyle as n, type TileflowSymbolStyle as o, type TileflowRoadsModuleOptions as p, type TileflowRoadsModuleConfig as q, type TileflowLabelsModuleOptions as r, type TileflowLabelsModuleConfig as s, tileflowRuntimeManifestLimits as t, type TileflowPoiModuleOptions as u, type TileflowPoiModuleConfig as v, type MapLibreSprite as w, type TileflowAerodromeCodeDetail as x, type TileflowAlignment as y, type TileflowAnalytics as z };