@tileflow/core 0.1.0-alpha.35 → 0.1.0-alpha.37

package/dist/browser.d.ts

@@ -380,386 +380,6 @@ type TileflowMarkerSymbolStyle = TileflowSymbolStyle & {
     marker?: TileflowCircleStyle;
 };
 
-type TileflowColor = `#${string}`;
-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;
-};
-/**
- * How Core's street lights renderer lights the map's streets at night, from the lamps and lit
- * streets its data holds.
- */
-type TileflowRoadStreetLightStyle = {
-    /** The light of lamps whose data gives no colour; a warm white by default. */
-    color?: TileflowThemeColorValue;
-    /** Whether the map has street lights; defaults to true where the data binds street furniture. */
-    enabled?: boolean;
-    /**
-     * Where light is estimated where the data maps no lamps: `lit` (the default) along streets and
-     * pavements mapped as lit; `streets` also along streets the data says nothing about, in tiles
-     * that map few lamps, which invents light; `none` nowhere.
-     */
-    estimate?: 'lit' | 'streets' | 'none';
-    /** How bright the lights shine, from 0 to 2; defaults to 1. */
-    intensity?: TileflowThemeNumberValue;
-};
-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;
-    streetLights?: TileflowRoadStreetLightStyle;
-    structures?: Partial<Record<TileflowRoadStructure, TileflowRoadLayerStyle>>;
-    weight?: TileflowRoadWeight;
-    widthScale?: Partial<Record<TileflowRoadClass, TileflowThemeNumberValue>>;
-};
-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;
-};
-/** 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';
-/**
- * How POI categories are placed against each other. `importance` places every category in one
- * order, by World's ranks. `categories` gives each category its own layer and places the
- * categories in the order they are listed, the first on top; ranks order each category only.
- */
-type TileflowPoiPlacementOrder = 'categories' | 'importance';
-/**
- * The appearance of one POI category. With the default `importance` order every category shares
- * one placement layer, so categories may differ only in properties MapLibre evaluates per feature
- * (image, size, colors, font, offsets); layer-wide properties such as zoom ranges, padding,
- * overlap or `optional` must match, or the module uses `placement.order: 'categories'`.
- */
-type TileflowPoiCategoryStyle = Omit<TileflowMarkerSymbolStyle, 'priority'>;
-type TileflowPoiModuleConfig = {
-    type: 'poi';
-    categories?: readonly TileflowPoiCategory[];
-    color?: TileflowPoiColorMode;
-    /** One density for the whole module: World's ranks decide what each category shows. */
-    density?: TileflowPoiDensity;
-    icons?: boolean;
-    labels?: boolean;
-    minZoom?: number;
-    placement?: {
-        /**
-         * Places each pictogram with its name as one unit that needs room for both. Defaults to
-         * `false`.
-         */
-        coupleIconAndLabel?: boolean;
-        iconPadding?: number;
-        /**
-         * World POI `type` values whose pictogram explains them. When pictograms and names are both
-         * drawn, every other POI needs a name, and these types are drawn as a pictogram alone.
-         * Defaults to parking and public toilets.
-         */
-        iconOnlyTypes?: readonly string[];
-        /** Defaults to `importance`. */
-        order?: TileflowPoiPlacementOrder;
-        /**
-         * With the `importance` order, POIs whose World `filter_rank` is at most this value are placed
-         * before the map's road and place labels, and the others after them. A map that gives street
-         * names priority over POIs (labels `collisionPriority: 'navigation'`) keeps its landmarks this
-         * way. Unset, every POI is placed at the module's own position.
-         */
-        prominentRank?: 0 | 1 | 2 | 3 | 4 | 5;
-        textPadding?: number;
-    };
-    styles?: Partial<Record<TileflowPoiCategory, TileflowPoiCategoryStyle>>;
-};
-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>;
-};
-
-declare const tileflowSunMetadataKey = "tileflow:sun";
-/** A theme's sun and sky light with every value resolved; see `TileflowThemeSun`. */
-type TileflowSunPreset = Readonly<{
-    /** Degrees clockwise from north, from 0 to 360. */
-    azimuth: number;
-    /** Degrees above the horizon, from -90 to 90. */
-    altitude: number;
-    /** The direct light's colour. */
-    color: string;
-    /** The direct light's strength, from 0 to 1. */
-    intensity: number;
-    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
-    shadowIntensity: number;
-    /** The light from the sky, which reaches every surface and fills the shadows. */
-    ambient: Readonly<{
-        color: string;
-        intensity: number;
-    }>;
-}>;
-/** The sun as the map shows it, ready for an application's own layers. */
-type TileflowSun = Readonly<{
-    /** Degrees clockwise from north, from 0 to 360. */
-    azimuth: number;
-    /** Degrees above the horizon, from -90 to 90. */
-    altitude: number;
-    /** A unit vector towards the sun: x east, y north, z up. */
-    direction: readonly [number, number, number];
-    /** The direct light's colour, as a CSS colour. */
-    color: string;
-    /** The direct light's colour as sRGB channels from 0 to 1. */
-    rgb: readonly [number, number, number];
-    /**
-     * The direct light's strength, from 0 to 1. It fades to 0 as the sun sets: a sun below the
-     * horizon lights nothing and casts no shadow.
-     */
-    intensity: number;
-    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
-    shadowIntensity: number;
-    /** The light from the sky, which reaches every surface and fills the shadows. */
-    ambient: Readonly<{
-        color: string;
-        rgb: readonly [number, number, number];
-        intensity: number;
-    }>;
-    /**
-     * How bright flat, open ground is under this light, from 0 (dark) to 1: the sky's light plus the
-     * sun's at its height, each weighted by its colour's luminance. Use it to switch lamps or windows
-     * on as a scene darkens, whatever theme or sun lights it.
-     */
-    brightness: number;
-    /** Where the direction comes from: the themes, angles, or a date and place. */
-    source: 'theme' | 'direction' | 'date';
-}>;
-/** The sun of a theme that leaves a value unset: high in the south-south-west, in white light. */
-declare const tileflowDefaultSunPreset: TileflowSunPreset;
-/**
- * Where the sun stands for an instant and a place ([longitude, latitude] in degrees): its azimuth
- * in degrees clockwise from north and its apparent altitude above the horizon, with atmospheric
- * refraction. It follows NOAA's solar equations, accurate to about a hundredth of a degree for
- * years 1800 to 2200.
- */
-declare function tileflowSunPosition(date: Date | number, location: readonly [number, number]): Readonly<{
-    azimuth: number;
-    altitude: number;
-}>;
-/** A unit vector towards a direction in the sky: x east, y north, z up. */
-declare function tileflowSunDirection(azimuth: number, altitude: number): readonly [number, number, number];
-/**
- * The sun as the map shows it: a preset's light from a direction. Direct light fades out over the
- * sun's last degrees above the horizon and is gone below it.
- */
-declare function resolveTileflowSun(preset: TileflowSunPreset, direction?: Readonly<{
-    azimuth: number;
-    altitude: number;
-}>, source?: TileflowSun['source']): TileflowSun;
-/**
- * A preset `t` of the way from `from` to `to`: the azimuth turns the short way round, colours mix
- * in OKLab, as theme blends mix paint colours, and numbers linearly.
- */
-declare function mixTileflowSunPresets(from: TileflowSunPreset, to: TileflowSunPreset, t: number): TileflowSunPreset;
-/** Reads the sun a compiled style publishes, or undefined when its metadata has none. */
-declare function readTileflowSunPreset(metadata: unknown): TileflowSunPreset | undefined;
-/**
- * The sun of a compiled style: the one it publishes, else one read from its light (a style whose
- * theme describes no sun lights its extrusions from `light.position`), else the default.
- */
-declare function tileflowStyleSunPreset(style: {
-    light?: unknown;
-    metadata?: unknown;
-} | undefined): TileflowSunPreset;
-
-type TileflowThemeColorScheme = 'dark' | 'light';
-
-declare const tileflowRouteMetadataKey = "tileflow:route";
-/** The resolved inks of a route, from its outer glow to its bright core. */
-type TileflowRouteInks = Readonly<{
-    /** The chosen route's line. */
-    line: string;
-    /** The edge on each side of the line, which sets it apart from the roads under it. */
-    casing: string;
-    /** A thin line along the middle of the route. */
-    core: string;
-    /** A soft halo around the route. */
-    glow: string;
-    /** Other routes offered beside the chosen one. */
-    alternative: string;
-    /** Opacity of the glow, from 0 (no glow) to 1. */
-    glowOpacity: number;
-    /** Opacity of the core, from 0 (no core) to 1. */
-    coreOpacity: number;
-}>;
-/** The inks of a theme that sets no route tokens: a blue that reads on either kind of map. */
-declare const tileflowDefaultRouteInks: Readonly<Record<TileflowThemeColorScheme, TileflowRouteInks>>;
-/**
- * Reads the route inks a compiled style publishes, or undefined when its metadata has none (a
- * style compiled before route inks, or not by Tileflow).
- */
-declare function readTileflowRouteInks(metadata: unknown): TileflowRouteInks | undefined;
-/**
- * The route inks of a compiled style: those it publishes, or the defaults of its colour scheme
- * (from its `tileflow:colorScheme` metadata, else `fallbackScheme`).
- */
-declare function tileflowStyleRouteInks(style: {
-    metadata?: unknown;
-} | undefined, fallbackScheme?: TileflowThemeColorScheme): TileflowRouteInks;
-/**
- * Inks between two themes' inks, `t` of the way from `from` to `to`: colours mix in OKLab, as theme
- * blends mix paint colours, and opacities linearly.
- */
-declare function mixTileflowRouteInks(from: TileflowRouteInks, to: TileflowRouteInks, t: number): TileflowRouteInks;
-
-type TileflowRuntimeColorScheme = 'dark' | 'light';
-
-type TileflowAnalytics = {
-    apiUrl?: string;
-    endpoint?: string;
-    enabled?: boolean;
-    mapId?: string;
-    metadata?: Record<string, unknown>;
-    projectId?: string;
-    sdkVersion?: string;
-    source?: string;
-    styleId?: string;
-    surfaceId?: string;
-};
-type TileflowSessionController = {
-    readonly sessionId: string;
-    resolveRequestUrl(url: string, analytics: TileflowAnalytics | undefined): Promise<string | undefined>;
-};
-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;
-};
-type TileflowStyleFontFace = {
-    family: string;
-    source: string;
-    style?: 'italic' | 'normal' | 'oblique';
-    weight?: '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
-};
-/**
- * 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[];
-}>;
-
 type TileflowAddressesModuleOptions = {
     /** Styling for OpenMapTiles point house-number labels. */
     labels?: TileflowSymbolStyle;
@@ -788,25 +408,92 @@ type TileflowBoundariesModuleConfig = TileflowBoundariesModuleOptions & {
     type: 'boundaries';
 };
 
+/** The parts of a model, each coloured by the theme: the model's materials name them. */
+declare const tileflowModelParts: Readonly<{
+    surface: 0;
+    secondary: 1;
+    glass: 2;
+    accent: 3;
+    roof: 4;
+}>;
+type TileflowModelPart = keyof typeof tileflowModelParts;
+/** Architectural roles control lighting independently of the model's palette slots. */
+declare const tileflowModelLightingRoles: Readonly<{
+    unclassified: 0;
+    wall: 1;
+    door: 2;
+    roof: 3;
+    window: 4;
+    lamp: 5;
+    logo: 6;
+}>;
+type TileflowModelLightingRole = keyof typeof tileflowModelLightingRoles;
+
 type TileflowBuildingMode = '3d' | 'flat';
 /**
  * How Core's 3D buildings renderer draws the map's buildings. Their colour is the map's own 3D
  * building colour (its extrusion), else its roofs'.
  */
 type TileflowBuildingsThreeDimensionalStyle = {
-    /** Use the style's extrusion light (default), or the theme controller's scene sun. */
+    /** Use the scene sun (default), or the style's native extrusion light. */
     lighting?: 'style' | 'sun';
     /** Per-building brightness variation, from 0 to 1; defaults to 0 (authored colour). */
     colorVariation?: TileflowThemeNumberValue;
     /** How strongly roof outlines and outer corners catch the light, from 0 (default) to 1. */
     edges?: TileflowThemeNumberValue;
+    /** Radius in metres for softened exterior corners and roof lighting, from 0 to 1; defaults to 0.8. */
+    edgeRadius?: number;
     /** Their own colour, drawn unlit; without it they take the building's colour, lightened. */
     edgeColor?: TileflowThemeColorValue;
     /** How bright the buildings light the street at night, from 0 (none) to 2; defaults to 0. */
     nightLight?: TileflowThemeNumberValue;
-    /** Contact shadow at the foot of the walls and in tight corners; defaults to false. */
+    /** Height-selected architectural flood lighting. Off by default; follows scene darkness. */
+    floodLight?: {
+        intensity?: TileflowThemeNumberValue;
+        /** Compensates authored light-colour transforms during darkness evaluation; defaults to 1. */
+        brightnessScale?: TileflowThemeNumberValue;
+        color?: TileflowThemeColorValue;
+        /** Stable per-building ground radius range in metres; defaults to [30, 100]. */
+        groundRadius?: readonly [number, number];
+        /** Ground light starts at this height in metres; defaults to 30. */
+        minGroundHeight?: number;
+        /** Wall light starts above this height in metres; defaults to 200. */
+        minWallHeight?: number;
+        /** Wall radius as a fraction of building height; defaults to 1/3. */
+        wallHeightRatio?: number;
+    };
+    /** Per-role physical materials and emission, separate from palette slots and occlusion. */
+    modelLighting?: Partial<Record<TileflowModelLightingRole, {
+        emissiveStrength?: TileflowThemeNumberValue;
+        /** Stable per-model addition to emission, from zero to this amount. */
+        emissiveVariation?: TileflowThemeNumberValue;
+        emissiveColor?: TileflowThemeColorValue;
+        /** Height fractions, multipliers and curve exponent; defaults to a constant multiplier of one. */
+        emissiveHeight?: readonly [
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue,
+            TileflowThemeNumberValue
+        ];
+        /** Physical-material tint. Explicit modelColors take precedence. */
+        color?: TileflowThemeColorValue;
+        colorMix?: TileflowThemeNumberValue;
+        metallic?: TileflowThemeNumberValue;
+        roughness?: TileflowThemeNumberValue;
+        /** Independent HSL ranges, seeded by model identity; no window geometry is invented. */
+        colorVariation?: {
+            hue: readonly [TileflowThemeNumberValue, TileflowThemeNumberValue];
+            saturation: readonly [TileflowThemeNumberValue, TileflowThemeNumberValue];
+            lightness: readonly [TileflowThemeNumberValue, TileflowThemeNumberValue];
+            space?: 'srgb' | 'linear';
+        };
+    }>>;
+    /** Contact shadow at the foot of the walls and in tight corners; defaults to true. */
     occlusion?: boolean;
-    /** Shadows from the sun, on the buildings and the flat map; defaults to false. */
+    /** Prepared model ambient occlusion strength, from 0 to 1; defaults to 0.75. */
+    modelOcclusion?: TileflowThemeNumberValue;
+    /** Shadows from the sun, on the buildings and the flat map; defaults to true. */
     shadows?: boolean;
     /**
      * Invented night windows, lit by rooms: decoration, not data. With World's `class`, none on sheds,
@@ -859,8 +546,24 @@ type TileflowBuildingsModuleConfig = TileflowBuildingsModuleOptions & {
 
 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';
+/** The barriers of the data's barrier layer (World's `traffic_control`) the land module draws. */
+type TileflowBarrierClass = 'fence' | 'hedge' | 'wall';
+/**
+ * A barrier's line, a shadow line drawn under it (usually offset with `translate`), and the fill of
+ * those mapped as areas, such as broad hedges.
+ */
+type TileflowBarrierStyle = {
+    area?: TileflowFillStyle;
+    shadow?: TileflowLineStyle;
+    line?: TileflowLineStyle;
+};
 type TileflowLandModuleOptions = {
     background?: TileflowBackgroundStyle;
+    /**
+     * Hedges, fences and walls, drawn at the top of the land band with hedges uppermost. A barrier
+     * without a style is not drawn, and neither is any when the data has no barrier layer.
+     */
+    barriers?: Partial<Record<TileflowBarrierClass, TileflowBarrierStyle>>;
     globalLandcover?: TileflowFillStyle;
     landcover?: Partial<Record<TileflowLandcoverClass, TileflowAreaStyle>>;
     landuse?: Partial<Record<TileflowLanduseClass, TileflowAreaStyle>>;
@@ -882,22 +585,47 @@ type TileflowLandformsModuleConfig = TileflowLandformsModuleOptions & {
 
 /** Labels anchored inside polygon features; point-feature labels remain on their feature style. */
 type TileflowNauticalAreaLabelStyles = {
+    /** Provider coverage cells; hidden unless a map makes this style visible. */
     coverage?: TileflowSymbolStyle;
     hazards?: TileflowSymbolStyle;
     navigationAreas?: TileflowSymbolStyle;
     reefs?: TileflowSymbolStyle;
     wrecks?: TileflowSymbolStyle;
 };
+/**
+ * One style per semantic group of `nautical-v1` objects. Point groups draw a circle `marker`, an
+ * `icon` from the theme's nautical image tokens, and `text`; area groups draw a `fill` and an
+ * `outline`; line groups draw one stroke. Every group respects each feature's `min_zoom`, and
+ * point groups place more important features (lower `rank`) first.
+ */
 type TileflowNauticalModuleOptions = {
+    /** Other aids: moorings, fog signals, racons, radio and signal stations, and virtual aids. */
     aids?: TileflowMarkerSymbolStyle;
+    /** Fixed beacons and daymarks, coloured by their first colour. */
+    beacons?: TileflowMarkerSymbolStyle;
+    /** Buoys, light floats, and light vessels, coloured by their first colour. */
+    buoys?: TileflowMarkerSymbolStyle;
+    /** Submarine cable and pipeline lines. */
+    cables?: TileflowLineStyle;
+    /** Restrained indication of where a provider publishes marks. */
     coverage?: TileflowAreaStyle;
+    /** Harbour and marina points. */
+    harbours?: TileflowMarkerSymbolStyle;
+    /** Hazard areas; the outline also strokes linear hazards such as booms. */
     hazardAreas?: TileflowAreaStyle;
+    /** Rocks by water level, obstructions, and offshore platforms. */
     hazards?: TileflowMarkerSymbolStyle;
     labels?: TileflowNauticalAreaLabelStyles;
     lighthouses?: TileflowMarkerSymbolStyle;
+    /** Light flares coloured by the light's first colour, with the chart light label. */
     lights?: TileflowMarkerSymbolStyle;
+    /** Restricted, military, anchorage, traffic-separation, and other navigation areas. */
     navigationAreas?: TileflowAreaStyle;
+    /** Ports, sized by `size` and placed by `rank` from low zooms. */
+    ports?: TileflowMarkerSymbolStyle;
     reefs?: TileflowAreaStyle;
+    /** Traffic-separation lines and recommended routes, tracks, and ferry routes. */
+    routes?: TileflowLineStyle;
     soundings?: TileflowMarkerSymbolStyle;
     wreckAreas?: TileflowAreaStyle;
     wrecks?: TileflowMarkerSymbolStyle;
@@ -989,6 +717,10 @@ type TileflowTreeFields = Readonly<{
     canopyCover: string;
     /** A canopy point's measured canopy height, in metres. */
     canopyHeight: string;
+    /** The kind of barrier in the hedge layer: hedges are `hedge`. */
+    subclass: string;
+    /** A hedge's kind: `hedge_bank` when it stands on an earth bank. */
+    hedge: string;
 }>;
 type TileflowTreePlacementOptions = Readonly<{
     /** The tile's address, for regions and for a stable look per tree. */
@@ -1016,6 +748,11 @@ type TileflowTreeLayers = Readonly<{
     trees?: TileflowTileLayer;
     /** Decorative canopy points in parks and gardens (World's `canopy`). */
     canopy?: TileflowTileLayer;
+    /**
+     * World's `traffic_control`: its hedges, lines and areas of `subclass=hedge`, stand as clipped
+     * pieces along each line and round each area. Other barriers are left out.
+     */
+    hedges?: TileflowTileLayer;
 }>;
 /** Where some trees are in a placement, and how many of them have each rank or a lower one. */
 type TileflowTreeRange = Readonly<{
@@ -1034,7 +771,12 @@ type TileflowTreePlacement = Readonly<{
     /** `tileflowTreeBytes` bytes per tree, ordered by form, model, then rank; see the layout below. */
     trees: Uint8Array;
     forms: Readonly<Record<TileflowTreeForm, TileflowTreeFormRange>>;
-    /** The tallest tree, in metres. */
+    /**
+     * `tileflowTreeBytes` bytes per piece of hedge, as a tree's: its middle, its height, its length
+     * as the crown, and its turn along the hedge.
+     */
+    hedges: Uint8Array;
+    /** The tallest tree or hedge, in metres. */
     tallest: number;
     /** Trees from the data's trees and rows, and trees from canopy points. */
     mapped: number;
@@ -1059,19 +801,24 @@ declare function placeTileflowTrees(layers: TileflowTreeLayers, options: Tileflo
 declare const tileflowVegetationMetadataKey = "tileflow:vegetation";
 /** How a compiled map's 3D trees look and where their data is, resolved for one theme. */
 type TileflowVegetation3D = Readonly<{
-    /** The vector source and its layers with the trees and the canopy points. */
+    /** The vector source and its layers with the trees, the canopy points and the hedges. */
     source: string;
     layers: Readonly<{
         tree: string;
         canopy?: string;
+        hedge?: string;
     }>;
     fields: TileflowTreeFields;
-    /** Sunlit colours: bark, and the leaves of each kind of tree from darkest to lightest. */
+    /**
+     * Sunlit colours: bark, the leaves of each kind of tree from darkest to lightest, and those of
+     * hedges.
+     */
     colors: Readonly<{
         bark: string;
         broadleaf: readonly string[];
         conifer: readonly string[];
         palm: readonly string[];
+        hedge: readonly string[];
     }>;
     heightScale: number;
     crownScale: number;
@@ -1103,6 +850,13 @@ type TileflowVegetationThreeDimensionalStyle = {
     coniferColors?: readonly TileflowThemeColorValue[];
     /** Sunlit frond colours of palms, from darkest to lightest; the broadleaf colours by default. */
     palmColors?: readonly TileflowThemeColorValue[];
+    /**
+     * Whether the data's hedges stand as clipped green walls beside the trees, at their height or
+     * 1.3 m, a metre higher on an earth bank. Defaults to true where the data has hedges.
+     */
+    hedges?: boolean;
+    /** Sunlit colours of hedges, from darkest to lightest; the two darkest broadleaf colours by default. */
+    hedgeColors?: readonly TileflowThemeColorValue[];
     crownScale?: TileflowThemeNumberValue;
     heightScale?: TileflowThemeNumberValue;
     /**
@@ -1155,6 +909,16 @@ type TileflowVegetationModuleConfig = TileflowVegetationModuleOptions & {
 };
 
 type TileflowWaterwayClass = 'canal' | 'other' | 'river' | 'stream';
+/** Explicit placement for every geometry family in a declared Bathymetry name layer. */
+type TileflowBathymetryNamePlacement = {
+    point: 'point';
+    line: TileflowSymbolPlacement;
+    polygon: TileflowSymbolPlacement;
+};
+type TileflowBathymetryNameStyle = TileflowSymbolStyle & {
+    /** Overrides scalar placement for these names; omission preserves scalar placement. */
+    placementByGeometry?: TileflowBathymetryNamePlacement;
+};
 type TileflowWaterModuleOptions = {
     bathymetry?: TileflowFillStyle;
     /** Contour lines when declared by Bathymetry; otherwise approximate polygon band edges. */
@@ -1162,20 +926,247 @@ type TileflowWaterModuleOptions = {
     /** Contour-depth or legacy band-floor labels, not measured survey soundings. */
     bathymetryLabels?: TileflowSymbolStyle;
     /** Names from an explicitly declared seafloor_landform layer. */
-    bathymetryLandforms?: TileflowSymbolStyle;
+    bathymetryLandforms?: TileflowBathymetryNameStyle;
     /** Names from an explicitly declared water_name layer. */
-    bathymetryWaterNames?: TileflowSymbolStyle;
+    bathymetryWaterNames?: TileflowBathymetryNameStyle;
     bodies?: TileflowAreaStyle;
     intermittent?: {
         bodies?: TileflowAreaStyle;
         waterways?: TileflowLineStyle;
     };
-    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
-};
-type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
-    type: 'water';
+    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
+};
+type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
+    type: 'water';
+};
+
+type TileflowColor = `#${string}`;
+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 = {
+    /** Extra casing width in pixels, split equally across both edges; defaults to the road border. */
+    borderWidth?: TileflowNumberStyleValue;
+    casing?: TileflowCircleStyle;
+    /** Road width in pixels when metric radii are absent; defaults to the effective surface fill width. */
+    fallbackWidth?: TileflowNumberStyleValue;
+    fill?: TileflowCircleStyle;
+};
+/**
+ * How Core's street lights renderer lights the map's streets at night, from the lamps and lit
+ * streets its data holds.
+ */
+type TileflowRoadStreetLightStyle = {
+    /** The light of lamps whose data gives no colour; a warm white by default. */
+    color?: TileflowThemeColorValue;
+    /** Whether the map has street lights; defaults to false. Set true to opt in. */
+    enabled?: boolean;
+    /**
+     * Where light is estimated where the data maps no lamps: `lit` (the default) along streets and
+     * pavements mapped as lit; `streets` also along streets the data says nothing about, in tiles
+     * that map few lamps, which invents light; `none` nowhere.
+     */
+    estimate?: 'lit' | 'streets' | 'none';
+    /** How bright the lights shine, from 0 to 2; defaults to 1. */
+    intensity?: TileflowThemeNumberValue;
+};
+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;
+    /** Draw ramp fills below receiving roads by default; `by-class` keeps their class's order. */
+    rampOrder?: 'below-roads' | 'by-class';
+    restrictions?: Partial<Record<TileflowRoadRestriction, TileflowRoadTreatmentStyle>>;
+    roundabouts?: TileflowRoadRoundaboutStyle;
+    serviceTypes?: Partial<Record<TileflowRoadServiceType, TileflowRoadTreatmentStyle>>;
+    sidewalks?: TileflowRoadSidewalkStyle;
+    streetLights?: TileflowRoadStreetLightStyle;
+    structures?: Partial<Record<TileflowRoadStructure, TileflowRoadLayerStyle>>;
+    weight?: TileflowRoadWeight;
+    widthScale?: Partial<Record<TileflowRoadClass, TileflowThemeNumberValue>>;
+};
+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[];
+    /**
+     * Where street names draw. `foreground` (the default) keeps them above buildings and
+     * vegetation. `ground` places them below buildings, with map-aligned text by default.
+     * Ground names retain their road-class collision order, but foreground symbols are offered
+     * first by the renderer; `collisionPriority` cannot make ground names outrank those symbols.
+     * Shields and junction numbers keep their foreground placement.
+     */
+    roadPlacement?: 'ground' | 'foreground';
+    roads?: TileflowRoadLabelDetail;
+    shields?: TileflowRoadShieldDetail;
+    styles?: TileflowLabelStyles;
+    water?: TileflowLabelDetail;
+};
+/** 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';
+/**
+ * How POI categories are placed against each other. `importance` places every category in one
+ * order, by World's ranks. `categories` gives each category its own layer and places the
+ * categories in the order they are listed, the first on top; ranks order each category only.
+ */
+type TileflowPoiPlacementOrder = 'categories' | 'importance';
+/**
+ * The appearance of one POI category. With the default `importance` order every category shares
+ * one placement layer, so categories may differ only in properties MapLibre evaluates per feature
+ * (image, size, colors, font, offsets); layer-wide properties such as zoom ranges, padding,
+ * overlap or `optional` must match, or the module uses `placement.order: 'categories'`.
+ */
+type TileflowPoiCategoryStyle = Omit<TileflowMarkerSymbolStyle, 'priority'>;
+type TileflowPoiModuleConfig = {
+    type: 'poi';
+    categories?: readonly TileflowPoiCategory[];
+    color?: TileflowPoiColorMode;
+    /** One density for the whole module: World's ranks decide what each category shows. */
+    density?: TileflowPoiDensity;
+    icons?: boolean;
+    labels?: boolean;
+    minZoom?: number;
+    placement?: {
+        /**
+         * Places each pictogram with its name as one unit that needs room for both. Defaults to
+         * `false`.
+         */
+        coupleIconAndLabel?: boolean;
+        iconPadding?: number;
+        /**
+         * World POI `type` values whose pictogram explains them. When pictograms and names are both
+         * drawn, every other POI needs a name, and these types are drawn as a pictogram alone.
+         * Defaults to parking and public toilets.
+         */
+        iconOnlyTypes?: readonly string[];
+        /** Defaults to `importance`. */
+        order?: TileflowPoiPlacementOrder;
+        /**
+         * With the `importance` order, POIs whose World `filter_rank` is at most this value are placed
+         * before the map's road and place labels, and the others after them. A map that gives street
+         * names priority over POIs (labels `collisionPriority: 'navigation'`) keeps its landmarks this
+         * way. Unset, every POI is placed at the module's own position.
+         */
+        prominentRank?: 0 | 1 | 2 | 3 | 4 | 5;
+        textPadding?: number;
+    };
+    styles?: Partial<Record<TileflowPoiCategory, TileflowPoiCategoryStyle>>;
+};
+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>;
 };
 
+/**
+ * Layer metadata naming the semantic module that owns a compiled layer, such as `roads` or `water`.
+ * Runtime features that address a module, such as map emphasis, read it instead of physical layer
+ * IDs. Layers that a theme blend splits or copies keep it.
+ */
+declare const tileflowLayerDomainMetadataKey: "tileflow:domain";
+
+type TileflowLayerDomain = TileflowSemanticModuleName | 'terrain';
+
 type TileflowSemanticModules = {
     addresses?: TileflowAddressesModuleConfig;
     aeroways?: TileflowAerowaysModuleConfig;
@@ -1193,14 +1184,181 @@ type TileflowSemanticModules = {
 };
 type TileflowSemanticModuleName = keyof TileflowSemanticModules;
 
+declare const tileflowSunMetadataKey = "tileflow:sun";
+/** A theme's sun and sky light with every value resolved; see `TileflowThemeSun`. */
+type TileflowSunPreset = Readonly<{
+    /** Degrees clockwise from north, from 0 to 360. */
+    azimuth: number;
+    /** Degrees above the horizon, from -90 to 90. */
+    altitude: number;
+    /** The direct light's colour. */
+    color: string;
+    /** The direct light's strength, from 0 to 1. */
+    intensity: number;
+    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
+    shadowIntensity: number;
+    /** The light from the sky, which reaches every surface and fills the shadows. */
+    ambient: Readonly<{
+        color: string;
+        intensity: number;
+    }>;
+}>;
+/** The sun as the map shows it, ready for an application's own layers. */
+type TileflowSun = Readonly<{
+    /** Degrees clockwise from north, from 0 to 360. */
+    azimuth: number;
+    /** Degrees above the horizon, from -90 to 90. */
+    altitude: number;
+    /** A unit vector towards the sun: x east, y north, z up. */
+    direction: readonly [number, number, number];
+    /** The direct light's colour, as a CSS colour. */
+    color: string;
+    /** The direct light's colour as sRGB channels from 0 to 1. */
+    rgb: readonly [number, number, number];
+    /**
+     * The direct light's strength, from 0 to 1. It fades to 0 as the sun sets: a sun below the
+     * horizon lights nothing and casts no shadow.
+     */
+    intensity: number;
+    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
+    shadowIntensity: number;
+    /** The light from the sky, which reaches every surface and fills the shadows. */
+    ambient: Readonly<{
+        color: string;
+        rgb: readonly [number, number, number];
+        intensity: number;
+    }>;
+    /**
+     * How bright flat, open ground is under this light, from 0 (dark) to 1: the sky's light plus the
+     * sun's at its height, each weighted by its colour's luminance. Use it to switch lamps or windows
+     * on as a scene darkens, whatever theme or sun lights it.
+     */
+    brightness: number;
+    /** Where the direction comes from: the themes, angles, or a date and place. */
+    source: 'theme' | 'direction' | 'date';
+}>;
+/** Unset sun values: high in the south-south-west, with soft white daylight and ambient fill. */
+declare const tileflowDefaultSunPreset: TileflowSunPreset;
 /**
- * Layer metadata naming the semantic module that owns a compiled layer, such as `roads` or `water`.
- * Runtime features that address a module, such as map emphasis, read it instead of physical layer
- * IDs. Layers that a theme blend splits or copies keep it.
+ * Where the sun stands for an instant and a place ([longitude, latitude] in degrees): its azimuth
+ * in degrees clockwise from north and its apparent altitude above the horizon, with atmospheric
+ * refraction. It follows NOAA's solar equations, accurate to about a hundredth of a degree for
+ * years 1800 to 2200.
  */
-declare const tileflowLayerDomainMetadataKey: "tileflow:domain";
+declare function tileflowSunPosition(date: Date | number, location: readonly [number, number]): Readonly<{
+    azimuth: number;
+    altitude: number;
+}>;
+/** A unit vector towards a direction in the sky: x east, y north, z up. */
+declare function tileflowSunDirection(azimuth: number, altitude: number): readonly [number, number, number];
+/**
+ * The sun as the map shows it: a preset's light from a direction. Direct light fades out over the
+ * sun's last degrees above the horizon and is gone below it.
+ */
+declare function resolveTileflowSun(preset: TileflowSunPreset, direction?: Readonly<{
+    azimuth: number;
+    altitude: number;
+}>, source?: TileflowSun['source']): TileflowSun;
+/**
+ * A preset `t` of the way from `from` to `to`: the azimuth turns the short way round, colours mix
+ * in OKLab, as theme blends mix paint colours, and numbers linearly.
+ */
+declare function mixTileflowSunPresets(from: TileflowSunPreset, to: TileflowSunPreset, t: number): TileflowSunPreset;
+/** Reads the sun a compiled style publishes, or undefined when its metadata has none. */
+declare function readTileflowSunPreset(metadata: unknown): TileflowSunPreset | undefined;
+/**
+ * The sun of a compiled style: the one it publishes, else one read from its light (a style whose
+ * theme describes no sun lights its extrusions from `light.position`), else the default.
+ */
+declare function tileflowStyleSunPreset(style: {
+    light?: unknown;
+    metadata?: unknown;
+} | undefined): TileflowSunPreset;
 
-type TileflowLayerDomain = TileflowSemanticModuleName | 'terrain';
+type TileflowThemeColorScheme = 'dark' | 'light';
+
+declare const tileflowRouteMetadataKey = "tileflow:route";
+/** The resolved inks of a route, from its outer glow to its bright core. */
+type TileflowRouteInks = Readonly<{
+    /** The chosen route's line. */
+    line: string;
+    /** The edge on each side of the line, which sets it apart from the roads under it. */
+    casing: string;
+    /** A thin line along the middle of the route. */
+    core: string;
+    /** A soft halo around the route. */
+    glow: string;
+    /** Other routes offered beside the chosen one. */
+    alternative: string;
+    /** Opacity of the glow, from 0 (no glow) to 1. */
+    glowOpacity: number;
+    /** Opacity of the core, from 0 (no core) to 1. */
+    coreOpacity: number;
+}>;
+/** The inks of a theme that sets no route tokens: a blue that reads on either kind of map. */
+declare const tileflowDefaultRouteInks: Readonly<Record<TileflowThemeColorScheme, TileflowRouteInks>>;
+/**
+ * Reads the route inks a compiled style publishes, or undefined when its metadata has none (a
+ * style compiled before route inks, or not by Tileflow).
+ */
+declare function readTileflowRouteInks(metadata: unknown): TileflowRouteInks | undefined;
+/**
+ * The route inks of a compiled style: those it publishes, or the defaults of its colour scheme
+ * (from its `tileflow:colorScheme` metadata, else `fallbackScheme`).
+ */
+declare function tileflowStyleRouteInks(style: {
+    metadata?: unknown;
+} | undefined, fallbackScheme?: TileflowThemeColorScheme): TileflowRouteInks;
+/**
+ * Inks between two themes' inks, `t` of the way from `from` to `to`: colours mix in OKLab, as theme
+ * blends mix paint colours, and opacities linearly.
+ */
+declare function mixTileflowRouteInks(from: TileflowRouteInks, to: TileflowRouteInks, t: number): TileflowRouteInks;
+
+type TileflowRuntimeColorScheme = 'dark' | 'light';
+
+type TileflowAnalytics = {
+    apiUrl?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    mapId?: string;
+    metadata?: Record<string, unknown>;
+    projectId?: string;
+    sdkVersion?: string;
+    source?: string;
+    styleId?: string;
+    surfaceId?: string;
+};
+type TileflowSessionController = {
+    readonly sessionId: string;
+    resolveRequestUrl(url: string, analytics: TileflowAnalytics | undefined): Promise<string | undefined>;
+};
+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;
+};
+type TileflowStyleFontFace = {
+    family: string;
+    source: string;
+    style?: 'italic' | 'normal' | 'oblique';
+    weight?: '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+};
+/**
+ * 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[];
+}>;
 
 /**
  * Map emphasis lets an application's own content read first: chosen modules of the map recede
@@ -1286,6 +1444,79 @@ type TileflowAtmosphereMap = {
  */
 declare function attachTileflowAtmosphere(map: TileflowAtmosphereMap): () => void;
 
+/**
+ * Boundaries families. Each one has its own license, attribution, TileJSON path and style source
+ * ID; families are never merged.
+ */
+declare const tileflowBoundaryFamilies: Readonly<{
+    boundaries: Readonly<{
+        attribution: "© OpenStreetMap contributors";
+        license: "ODbL-1.0";
+        path: "/tiles/boundaries/tiles.json";
+        sourceId: "tileflow-boundaries";
+    }>;
+}>;
+type TileflowBoundaryFamily = keyof typeof tileflowBoundaryFamilies;
+
+/** A value a choropleth can colour: a number for scales, a string for categories. */
+type TileflowBoundaryValue = number | string;
+/** One row of an application's data, keyed by a registry ID or an official code. */
+type TileflowBoundaryRow = Readonly<{
+    key: number | string;
+    /** `null` leaves the area without a value. */
+    value: TileflowBoundaryValue | null;
+}>;
+/** Keys present on every `boundary_area` polygon, usable without the lookup table. */
+type TileflowBoundaryFeatureKey = 'id' | 'iso_3166_1' | 'ref';
+/** Rows joined to areas by one polygon key. */
+type TileflowBoundaryValues = Readonly<{
+    joinBy: TileflowBoundaryFeatureKey;
+    rows: readonly TileflowBoundaryRow[];
+}>;
+
+type FeatureTarget = {
+    id?: number | string;
+    source: string;
+    sourceLayer?: string;
+};
+/** The part of a MapLibre map the controller uses. */
+type TileflowFeatureStateMap = {
+    getSource(id: string): unknown;
+    getStyle?(): {
+        sources?: Record<string, unknown>;
+    } | undefined;
+    off(type: 'styledata', listener: () => void): unknown;
+    on(type: 'styledata', listener: () => void): unknown;
+    removeFeatureState(target: FeatureTarget, key?: string): void;
+    setFeatureState(target: FeatureTarget & {
+        id: number | string;
+    }, state: Record<string, unknown>): void;
+};
+type CreateBoundaryFeatureStateOptions = Readonly<{
+    /** Defaults to `boundaries`. */
+    family?: TileflowBoundaryFamily;
+    /** Also set the values on `boundary_label` points, for labels styled by value. */
+    labels?: boolean;
+    /** Feature-state key; it must match the choropleth's `state`. Defaults to `value`. */
+    state?: string;
+}>;
+type TileflowBoundaryFeatureState = Readonly<{
+    /** Remove every value this controller set. */
+    clear: () => void;
+    /** Remove the values and stop following style reloads. */
+    dispose: () => void;
+    /**
+     * Replace the values. Rows must be keyed by the source's feature ID: `id` by default, or `ref`
+     * when the map declares `promoteId: 'ref'`. Rows with a `null` value are removed.
+     */
+    set: (values: TileflowBoundaryValues) => void;
+}>;
+/**
+ * Keep Boundaries feature-state in sync with application rows. Values survive a style reload: the
+ * controller sets them again once the source is back.
+ */
+declare function createBoundaryFeatureState(map: TileflowFeatureStateMap, options?: CreateBoundaryFeatureStateOptions): TileflowBoundaryFeatureState;
+
 /** The drawn stretch of a line and its highlights, as shares of the line's length from its start. */
 type TileflowLineProgressState = Readonly<{
     /** Where the drawn stretch starts, from 0 (the default) to 1. */
@@ -1484,16 +1715,26 @@ declare function readTileflowMapTileSource(map: TileflowTileSourceMap, sourceId:
     maxzoom: number;
 } | undefined;
 
+type ShadowPoint = readonly number[];
+type ShadowBox = Readonly<{
+    min: ShadowPoint;
+    max: ShadowPoint;
+}>;
+type ShadowView = Readonly<{
+    /** Visible receiver points, in the caster box's metre frame. All casters still draw. */
+    receivers?: readonly ShadowPoint[];
+    /** Snap to world-aligned texels; omit for an unsnapped mathematical projection. */
+    resolution?: number;
+    origin?: ShadowPoint;
+    /** Metres per fixed world unit; keeps texel quantization independent of latitude scale. */
+    gridScale?: number;
+}>;
 /**
- * The sun's view of a box of buildings: an orthographic projection along `direction` (towards the
- * sun; x east, y north, z up, in metres) as a column-major matrix to clip space, with the metres its
- * depth runs over and the metres its wider side spans. It follows only the sun, never the camera,
- * so shadows hold still while the camera moves.
+ * The sun's orthographic view, in metres, with room for each caster's shadow to reach the ground.
+ * Optional receivers concentrate XY resolution without dropping offscreen casters along a ray;
+ * quantized extents and a world-anchored texel grid keep stationary shadows stable during pans.
  */
-declare function tileflowSunLightMatrix(direction: readonly number[], box: Readonly<{
-    min: readonly number[];
-    max: readonly number[];
-}>): {
+declare function tileflowSunLightMatrix(direction: readonly number[], box: ShadowBox, view?: ShadowView): {
     matrix: Float32Array;
     depth: number;
     extent: number;
@@ -1507,6 +1748,10 @@ type TileflowBuildings3DMap = {
         lng: number;
     };
     getBearing(): number;
+    getCanvas?(): {
+        clientHeight: number;
+    };
+    getVerticalFieldOfView?(): number;
     getLight?(): unknown;
     getLayer(id: string): unknown;
     getPaintProperty(layer: string, name: string): unknown;
@@ -1532,7 +1777,7 @@ type TileflowBuildings3DOptions = Readonly<{
     map: TileflowBuildings3DMap;
     /** The theme controller, for the sun and the buildings' design in every theme. */
     controller?: TileflowBuildings3DThemes;
-    /** The zoom from which buildings stand; below it they sink into the flat map. Defaults to 14.5. */
+    /** The zoom where buildings start fading in, reaching full opacity 0.25 zoom later. Defaults to 15. */
     minzoom?: number;
     /** The most tiles raised round the camera, from 1 to 64; defaults to 25. */
     maxTiles?: number;
@@ -1575,7 +1820,7 @@ type TileflowBuildings3D = {
 };
 declare const tileflowBuildings3DLayerId = "tileflow-buildings-3d";
 /**
- * Creates the renderer and puts its layer on the map, flat until `show()`. It reads the source's
+ * Creates the renderer, showing buildings automatically above zoom 15 unless hidden. It reads the source's
  * z15 tiles round the camera, the zoom at which World's buildings carry their heights.
  */
 declare function createTileflowBuildings3D(options: TileflowBuildings3DOptions): TileflowBuildings3D;
@@ -1589,6 +1834,10 @@ type TileflowBuildingMeshOptions = Readonly<{
     tileMetres: number;
     /** Height used where a building has none, in metres; defaults to 5, World's own fallback. */
     defaultHeight?: number;
+    /** Exterior corner radius in metres, up to 1; 0 leaves the footprint unchanged. */
+    edgeRadius?: number;
+    /** Maximum turn per rounded segment; defaults to 30 degrees for close views. */
+    cornerAngle?: number;
     /**
      * The tile's places (World's `poi` layer), for the night use of buildings when the tile's
      * buildings do not carry World's `night_use`: a place inside a building, or on its facade, gives
@@ -1602,8 +1851,17 @@ type TileflowBuildingMeshOptions = Readonly<{
      */
     masks?: readonly (readonly number[])[];
 }>;
+type BuildingMeshGroup = {
+    /** Conservative tile-space x/y bounds and maximum height in metres. */
+    bounds: [number, number, number, number, number];
+    roofsFrom: number;
+    roofsCount: number;
+    wallsFrom: number;
+    wallsCount: number;
+};
 /** One tile's buildings, ready to upload. */
 type TileflowBuildingMesh = Readonly<{
+    groups?: readonly BuildingMeshGroup[];
     vertices: Uint8Array;
     indices: Uint32Array;
     /** The first wall index: roofs come before it, walls from it. */
@@ -1655,6 +1913,11 @@ type TileflowStreetLightsMap = {
 };
 type TileflowStreetLightsOptions = Readonly<{
     map: TileflowStreetLightsMap;
+    /**
+     * By default, only a map that enables roads.streetLights supplies lights. Set true to opt in
+     * with the fallback design when metadata is absent, or false to keep every theme's lights off.
+     */
+    enabled?: boolean;
     /**
      * The theme controller, whose sun switches the lights on and off and whose themes hold the map's
      * street lights (the roads module's `streetLights`).
@@ -1699,15 +1962,34 @@ declare const tileflowStreetLightsLayerId = "tileflow-street-lights";
  */
 declare function createTileflowStreetLights(options: TileflowStreetLightsOptions): TileflowStreetLights;
 
-/** The parts of a model, each coloured by the theme: the model's materials name them. */
-declare const tileflowModelParts: Readonly<{
-    surface: 0;
-    secondary: 1;
-    glass: 2;
-    accent: 3;
-    roof: 4;
+/** Begin/end height fractions, begin/end multipliers and the base-10 curve exponent. */
+type TileflowModelEmissionGradient = readonly [number, number, number, number, number];
+type TileflowModelRoleLighting = Readonly<{
+    emissiveStrength: number;
+    emissiveVariation?: number;
+    emissiveColor?: string;
+    emissiveHeight: TileflowModelEmissionGradient;
+    color?: string;
+    colorMix?: number;
+    metallic?: number;
+    roughness?: number;
+    colorVariation?: Readonly<{
+        hue: readonly [number, number];
+        saturation: readonly [number, number];
+        lightness: readonly [number, number];
+        /** Colour factors may be authored in linear light, as in glTF. Defaults to sRGB. */
+        space?: 'srgb' | 'linear';
+    }>;
+}>;
+type TileflowBuildingFloodLight = Readonly<{
+    intensity: number;
+    brightnessScale: number;
+    color: string;
+    groundRadius: readonly [number, number];
+    minGroundHeight: number;
+    minWallHeight: number;
+    wallHeightRatio: number;
 }>;
-type TileflowModelPart = keyof typeof tileflowModelParts;
 
 /** The style metadata key under which a compiled map describes its 3D buildings. */
 declare const tileflowBuildingsMetadataKey = "tileflow:buildings";
@@ -1726,7 +2008,9 @@ type TileflowBuildings3DDesign = Readonly<{
     color: string | readonly unknown[];
     /** How strongly roof outlines and outer corners catch the light, from 0 to 1. */
     edges: number;
-    /** Style extrusion light by default; scene sun lighting is opt-in. */
+    /** Exterior corner radius and roof lighting transition, in metres; 0 keeps sharp edges. */
+    edgeRadius?: number;
+    /** Scene sun lighting by default; `style` uses the native extrusion light. */
     lighting: 'style' | 'sun';
     /** Per-building brightness variation, from 0 to 1; 0 preserves the authored colour. */
     colorVariation: number;
@@ -1736,11 +2020,17 @@ type TileflowBuildings3DDesign = Readonly<{
     edgeColor?: string;
     /** How bright the buildings light the street at night, from 0 to 2. */
     nightLight: number;
+    /** Height-selected light on ordinary buildings and the ground, independent of shop windows. */
+    floodLight?: TileflowBuildingFloodLight;
+    /** Emission by architectural role, independent of model palette slots. */
+    modelLighting?: Readonly<Partial<Record<TileflowModelLightingRole, TileflowModelRoleLighting>>>;
     /** Invented night windows, lit by rooms: decoration, not data. */
     windows: boolean;
     /** Shadows from the sun, and contact shadow at the foot of the walls. */
     shadows: boolean;
     occlusion: boolean;
+    /** Strength of prepared model ambient visibility; zero leaves the sky contribution unchanged. */
+    modelOcclusion?: number;
     /** Building models the map places in its city, each replacing the buildings under it. */
     models?: readonly TileflowBuildingModelPlacement[];
     /** The colours of the models' parts; a part without one takes it from the building colour. */
@@ -1771,6 +2061,13 @@ type TileflowBuildingModelPlacement = Readonly<{
 declare function readTileflowBuildings3D(metadata: unknown): TileflowBuildings3DDesign | undefined;
 /** The most models one map places. */
 declare const tileflowBuildingModelPlacementLimit = 256;
+/**
+ * The address a hosted build gives a placement of one of the map's own models: a placeholder that
+ * Tileflow replaces, when the map is deployed, with that model's address in the map's Team.
+ */
+declare function tileflowTeamModelUrl(model: string): string;
+/** The Team model a placement's address is the placeholder of, if it is one. */
+declare function readTileflowTeamModelName(url: string): string | undefined;
 
 /** The MapLibre GL JS map capabilities the trees use. */
 type TileflowTrees3DMap = {
@@ -1807,7 +2104,7 @@ type TileflowTrees3DOptions = Readonly<{
     controller?: TileflowTrees3DThemes;
     /** The vector source with the canopy points, when not the map's World source. */
     canopySource?: string;
-    /** The zoom from which trees stand; they fade in over the zoom above it. Defaults to 15. */
+    /** The zoom from which trees stand; they reach full opacity 0.25 zoom later. Defaults to 15. */
     minzoom?: number;
     /** The most tiles of trees round the camera, from 1 to 64; defaults to 25. */
     maxTiles?: number;
@@ -1836,7 +2133,8 @@ type TileflowTrees3D = {
     readonly scale: number;
     /**
      * Whether the map's style describes 3D trees (`vegetation({mode: '3d'})`), tiles of trees,
-     * trees placed (mapped and from canopy points) and trees drawn in the last frame.
+     * trees placed (mapped and from canopy points), pieces of hedge placed and trees drawn in the
+     * last frame.
      */
     readonly stats: Readonly<{
         declared: boolean;
@@ -1844,6 +2142,7 @@ type TileflowTrees3D = {
         trees: number;
         mapped: number;
         canopy: number;
+        hedges: number;
         drawn: number;
     }>;
     /** Takes the layer off the map and lets go of its buffers. */
@@ -2156,6 +2455,54 @@ type TileflowShotPlayback = {
  */
 declare function playTileflowShot(map: TileflowShotPlayerMap, shot: TileflowShotMotion, options?: TileflowShotPlaybackOptions): TileflowShotPlayback;
 
+type TileflowNoticeControlPosition = 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+/** A MapLibre control; its methods receive the map that owns it. */
+type TileflowNoticeControl = {
+    onAdd(map: unknown): HTMLElement;
+    onRemove(map: unknown): void;
+};
+type TileflowNoticeEvent = 'remove' | 'style.load' | 'styledata';
+/** Structural MapLibre capabilities; importing this module never loads a renderer. */
+type TileflowNoticesMap = {
+    addControl(control: TileflowNoticeControl, position?: TileflowNoticeControlPosition): unknown;
+    getContainer(): HTMLElement;
+    getStyle(): {
+        metadata?: unknown;
+    } | undefined;
+    off(event: TileflowNoticeEvent, listener: () => void): unknown;
+    on(event: TileflowNoticeEvent, listener: () => void): unknown;
+    removeControl(control: TileflowNoticeControl): unknown;
+};
+type TileflowNoticesOptions = {
+    /** Map corner for the notice. Defaults to the attribution corner, `bottom-right`. */
+    position?: TileflowNoticeControlPosition;
+};
+/**
+ * Render the notices a compiled style declares, such as "Not for navigation" for Nautical, as a
+ * compact always-visible map control. Call after constructing a browser map. Follows style
+ * replacements and removes its control, listeners, and pending read on disposal or map removal.
+ */
+declare function attachTileflowNotices(map: TileflowNoticesMap, options?: TileflowNoticesOptions): () => void;
+
+/** Style metadata key for notices that must stay visible whenever the map is displayed. */
+declare const tileflowNoticesMetadataKey: "tileflow:notices";
+/**
+ * A short plain-text notice the compiled style declares for the sources it names. Runtimes render
+ * it on the map, next to the attribution; it never replaces a source's own attribution.
+ */
+type TileflowMapNotice = Readonly<{
+    id: string;
+    sources: readonly string[];
+    text: string;
+}>;
+declare const tileflowNoticeLimits: Readonly<{
+    maxNotices: 8;
+    maxSources: 16;
+    maxTextLength: 120;
+}>;
+/** Read bounded notices from style metadata; malformed entries are ignored, never rendered. */
+declare function readTileflowNotices(metadata: unknown): readonly TileflowMapNotice[];
+
 declare const tileflowMaplibreContourVersion: "0.1.0";
 type TileflowContourProtocolRequest = Readonly<{
     url: string;
@@ -2476,4 +2823,4 @@ declare function createTileflowTransformRequest<TRequest extends TileflowTransfo
     worldRequestBridge?: TileflowWorldRequestBridge;
 }): TileflowTransformRequest<TRequest, TResourceType>;
 
-export { type TileflowAtmosphereMap, type TileflowBrowserThemeBlendSelection, type TileflowBuildingMesh, type TileflowBuildingMeshOptions, type TileflowBuildingModelPlacement, type TileflowBuildings3D, type TileflowBuildings3DChange, type TileflowBuildings3DDesign, type TileflowBuildings3DMap, type TileflowBuildings3DOptions, type TileflowBuildings3DThemes, type TileflowComposedRequest, type TileflowContourProtocolHandler, type TileflowContourProtocolRegistrationOptions, type TileflowContourProtocolRegistry, type TileflowContourProtocolRequest, type TileflowContourProtocolResponse, type TileflowDepthMarker, type TileflowDepthMarkerHandle, type TileflowDepthMarkerMap, type TileflowDepthMarkers, type TileflowDepthMarkersOptions, type TileflowDynamicImage, type TileflowDynamicImageContext, type TileflowDynamicImageHandle, type TileflowEmphasis, type TileflowEmphasisArea, type TileflowEmphasisModule, type TileflowFairUseNotice, type TileflowFairUseNoticeController, type TileflowFairUseNoticeState, type TileflowFrameScheduler, type TileflowGroundLayer, type TileflowGroundLayers, type TileflowGroundLayersMap, type TileflowGroundLayersOptions, type TileflowGroundOrderMap, type TileflowLineProgressAnimation, type TileflowLineProgressController, type TileflowLineProgressGradientOptions, type TileflowLineProgressLayer, type TileflowLineProgressMap, type TileflowLineProgressOptions, type TileflowLineProgressShown, type TileflowLineProgressState, type TileflowMapLifecycleAttachment, type TileflowMapLifecycleEvent, type TileflowMapLifecycleSubscriber, type TileflowMapReadinessState, type TileflowPmtilesProtocolHandler, type TileflowPmtilesProtocolRegistrationOptions, type TileflowPmtilesProtocolRegistry, type TileflowRouteInks, type TileflowSessionSender, type TileflowSessionStarter, type TileflowShotCamera, type TileflowShotCue, type TileflowShotKeyframe, type TileflowShotMotion, type TileflowShotPlayback, type TileflowShotPlaybackOptions, type TileflowShotPlayerMap, type TileflowShotState, type TileflowStreetLightEstimate, type TileflowStreetLightLayers, type TileflowStreetLightPlacement, type TileflowStreetLightPlacementOptions, type TileflowStreetLights, type TileflowStreetLightsDesign, type TileflowStreetLightsMap, type TileflowStreetLightsOptions, type TileflowStyleFontLoadOptions, type TileflowStyleStateValue, type TileflowStyleSwitchMap, type TileflowSun, type TileflowSunPreset, type TileflowSunRequest, type TileflowThemeBlendRequest, type TileflowThemeBlendState, type TileflowThemeChangeOptions, type TileflowThemeController, type TileflowThemeTransition, type TileflowThemeTransitionOptions, type TileflowThemeTransitionPhase, type TileflowThemeTransitionResult, type TileflowTile, type TileflowTileAddress, type TileflowTileAreaRequest, type TileflowTileFeature, type TileflowTileGeometryType, type TileflowTileLayer, type TileflowTileReader, type TileflowTileReaderOptions, type TileflowTileRequestTransform, type TileflowTileSourceMap, type TileflowTransformRequest, type TileflowTransformRequestParameters, type TileflowTreeFields, type TileflowTreeForm, type TileflowTreeFormMix, type TileflowTreeFormRange, type TileflowTreeLayers, type TileflowTreePlacement, type TileflowTreePlacementOptions, type TileflowTreeRange, type TileflowTreeRegion, type TileflowTrees3D, type TileflowTrees3DChange, type TileflowTrees3DMap, type TileflowTrees3DOptions, type TileflowTrees3DThemes, type TileflowUserTransformRequest, type TileflowVectorTileDecodeOptions, type TileflowVegetation3D, type TileflowVegetationController, type TileflowVegetationDisplay, type TileflowVegetationOptions, type TileflowVegetationRepresentation, type TileflowViewMode, type TileflowWorldProtocolHandler, type TileflowWorldProtocolRequest, type TileflowWorldProtocolResponse, type TileflowWorldRequestBridge, attachTileflowAtmosphere, attachTileflowFairUseNotice, attachTileflowMapLifecycle, createTileflowBuildings3D, createTileflowDepthMarkers, createTileflowGroundLayers, createTileflowLineProgress, createTileflowSessionStarter, createTileflowStreetLights, createTileflowThemeController, createTileflowTileReader, createTileflowTransformRequest, createTileflowTrees3D, createTileflowVegetation, decodeTileflowVectorTile, getTileflowSystemColorScheme, loadTileflowStyleFonts, meshTileflowBuildings, mixTileflowRouteInks, mixTileflowSunPresets, placeTileflowStreetLights, placeTileflowTrees, playTileflowShot, readTileflowBuildings3D, readTileflowMapTileSource, readTileflowRouteInks, readTileflowStreetLights, readTileflowSunPreset, readTileflowVegetation3D, readTileflowVegetationDisplay, registerTileflowContourProtocol, registerTileflowPmtilesProtocol, registerTileflowWorldRequestBridge, resolveTileflowSun, resolveTileflowVegetationRepresentation, subscribeTileflowSystemColorScheme, tileflowBuildingExtent, tileflowBuildingModelPlacementLimit, tileflowBuildingVertexBytes, tileflowBuildings3DLayerId, tileflowBuildingsMetadataKey, tileflowDefaultRouteInks, tileflowDefaultSunPreset, tileflowDepthMarkerPlacement, tileflowFairUseNoticeMessage, tileflowGroundBeforeId, tileflowLayerDomainMetadataKey, tileflowLineProgressGradient, tileflowMaplibreContourVersion, tileflowPmtilesMaximumDirectoryDepth, tileflowPmtilesProtocol, tileflowRouteMetadataKey, tileflowShotStateAt, tileflowStreetLightBytes, tileflowStreetLightsLayerId, tileflowStreetLightsMetadataKey, tileflowStyleRouteInks, tileflowStyleSunPreset, tileflowSunDirection, tileflowSunLightMatrix, tileflowSunMetadataKey, tileflowSunPosition, tileflowTilePointToLngLat, tileflowTilesForBounds, tileflowTreeBytes, tileflowTreeFormOf, tileflowTreeForms, tileflowTrees3DLayerId, tileflowVegetationDisplayMetadataKey, tileflowVegetationMetadataKey, validateTileflowBrowserThemeBlendSelection, validateTileflowEmphasis };
+export { type CreateBoundaryFeatureStateOptions, type TileflowAtmosphereMap, type TileflowBoundaryFeatureState, type TileflowBrowserThemeBlendSelection, type TileflowBuildingMesh, type TileflowBuildingMeshOptions, type TileflowBuildingModelPlacement, type TileflowBuildings3D, type TileflowBuildings3DChange, type TileflowBuildings3DDesign, type TileflowBuildings3DMap, type TileflowBuildings3DOptions, type TileflowBuildings3DThemes, type TileflowComposedRequest, type TileflowContourProtocolHandler, type TileflowContourProtocolRegistrationOptions, type TileflowContourProtocolRegistry, type TileflowContourProtocolRequest, type TileflowContourProtocolResponse, type TileflowDepthMarker, type TileflowDepthMarkerHandle, type TileflowDepthMarkerMap, type TileflowDepthMarkers, type TileflowDepthMarkersOptions, type TileflowDynamicImage, type TileflowDynamicImageContext, type TileflowDynamicImageHandle, type TileflowEmphasis, type TileflowEmphasisArea, type TileflowEmphasisModule, type TileflowFairUseNotice, type TileflowFairUseNoticeController, type TileflowFairUseNoticeState, type TileflowFeatureStateMap, type TileflowFrameScheduler, type TileflowGroundLayer, type TileflowGroundLayers, type TileflowGroundLayersMap, type TileflowGroundLayersOptions, type TileflowGroundOrderMap, type TileflowLineProgressAnimation, type TileflowLineProgressController, type TileflowLineProgressGradientOptions, type TileflowLineProgressLayer, type TileflowLineProgressMap, type TileflowLineProgressOptions, type TileflowLineProgressShown, type TileflowLineProgressState, type TileflowMapLifecycleAttachment, type TileflowMapLifecycleEvent, type TileflowMapLifecycleSubscriber, type TileflowMapNotice, type TileflowMapReadinessState, type TileflowNoticeControl, type TileflowNoticeControlPosition, type TileflowNoticesMap, type TileflowNoticesOptions, type TileflowPmtilesProtocolHandler, type TileflowPmtilesProtocolRegistrationOptions, type TileflowPmtilesProtocolRegistry, type TileflowRouteInks, type TileflowSessionSender, type TileflowSessionStarter, type TileflowShotCamera, type TileflowShotCue, type TileflowShotKeyframe, type TileflowShotMotion, type TileflowShotPlayback, type TileflowShotPlaybackOptions, type TileflowShotPlayerMap, type TileflowShotState, type TileflowStreetLightEstimate, type TileflowStreetLightLayers, type TileflowStreetLightPlacement, type TileflowStreetLightPlacementOptions, type TileflowStreetLights, type TileflowStreetLightsDesign, type TileflowStreetLightsMap, type TileflowStreetLightsOptions, type TileflowStyleFontLoadOptions, type TileflowStyleStateValue, type TileflowStyleSwitchMap, type TileflowSun, type TileflowSunPreset, type TileflowSunRequest, type TileflowThemeBlendRequest, type TileflowThemeBlendState, type TileflowThemeChangeOptions, type TileflowThemeController, type TileflowThemeTransition, type TileflowThemeTransitionOptions, type TileflowThemeTransitionPhase, type TileflowThemeTransitionResult, type TileflowTile, type TileflowTileAddress, type TileflowTileAreaRequest, type TileflowTileFeature, type TileflowTileGeometryType, type TileflowTileLayer, type TileflowTileReader, type TileflowTileReaderOptions, type TileflowTileRequestTransform, type TileflowTileSourceMap, type TileflowTransformRequest, type TileflowTransformRequestParameters, type TileflowTreeFields, type TileflowTreeForm, type TileflowTreeFormMix, type TileflowTreeFormRange, type TileflowTreeLayers, type TileflowTreePlacement, type TileflowTreePlacementOptions, type TileflowTreeRange, type TileflowTreeRegion, type TileflowTrees3D, type TileflowTrees3DChange, type TileflowTrees3DMap, type TileflowTrees3DOptions, type TileflowTrees3DThemes, type TileflowUserTransformRequest, type TileflowVectorTileDecodeOptions, type TileflowVegetation3D, type TileflowVegetationController, type TileflowVegetationDisplay, type TileflowVegetationOptions, type TileflowVegetationRepresentation, type TileflowViewMode, type TileflowWorldProtocolHandler, type TileflowWorldProtocolRequest, type TileflowWorldProtocolResponse, type TileflowWorldRequestBridge, attachTileflowAtmosphere, attachTileflowFairUseNotice, attachTileflowMapLifecycle, attachTileflowNotices, createBoundaryFeatureState, createTileflowBuildings3D, createTileflowDepthMarkers, createTileflowGroundLayers, createTileflowLineProgress, createTileflowSessionStarter, createTileflowStreetLights, createTileflowThemeController, createTileflowTileReader, createTileflowTransformRequest, createTileflowTrees3D, createTileflowVegetation, decodeTileflowVectorTile, getTileflowSystemColorScheme, loadTileflowStyleFonts, meshTileflowBuildings, mixTileflowRouteInks, mixTileflowSunPresets, placeTileflowStreetLights, placeTileflowTrees, playTileflowShot, readTileflowBuildings3D, readTileflowMapTileSource, readTileflowNotices, readTileflowRouteInks, readTileflowStreetLights, readTileflowSunPreset, readTileflowTeamModelName, readTileflowVegetation3D, readTileflowVegetationDisplay, registerTileflowContourProtocol, registerTileflowPmtilesProtocol, registerTileflowWorldRequestBridge, resolveTileflowSun, resolveTileflowVegetationRepresentation, subscribeTileflowSystemColorScheme, tileflowBuildingExtent, tileflowBuildingModelPlacementLimit, tileflowBuildingVertexBytes, tileflowBuildings3DLayerId, tileflowBuildingsMetadataKey, tileflowDefaultRouteInks, tileflowDefaultSunPreset, tileflowDepthMarkerPlacement, tileflowFairUseNoticeMessage, tileflowGroundBeforeId, tileflowLayerDomainMetadataKey, tileflowLineProgressGradient, tileflowMaplibreContourVersion, tileflowNoticeLimits, tileflowNoticesMetadataKey, tileflowPmtilesMaximumDirectoryDepth, tileflowPmtilesProtocol, tileflowRouteMetadataKey, tileflowShotStateAt, tileflowStreetLightBytes, tileflowStreetLightsLayerId, tileflowStreetLightsMetadataKey, tileflowStyleRouteInks, tileflowStyleSunPreset, tileflowSunDirection, tileflowSunLightMatrix, tileflowSunMetadataKey, tileflowSunPosition, tileflowTeamModelUrl, tileflowTilePointToLngLat, tileflowTilesForBounds, tileflowTreeBytes, tileflowTreeFormOf, tileflowTreeForms, tileflowTrees3DLayerId, tileflowVegetationDisplayMetadataKey, tileflowVegetationMetadataKey, validateTileflowBrowserThemeBlendSelection, validateTileflowEmphasis };