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

package/dist/{icon-composition-DSjIKmrK.d.ts → icon-composition-C5X3Q9Ya.d.ts}

@@ -1,4 +1,4 @@
-import { bd as TileflowThemeColorValue, r as TileflowSymbolStyle, D as TileflowAreaStyle, a1 as TileflowLineStackStyle, q as TileflowLineStyle, o as TileflowExtrusionStyle, bg as TileflowThemeNumberValue, m as TileflowBackgroundStyle, p as TileflowFillStyle, a6 as TileflowMarkerSymbolStyle, n as TileflowCircleStyle, b1 as TileflowTerrainHillshadeStyle, b0 as TileflowTerrainEncoding, be as TileflowThemeFontValue, bf as TileflowThemeImageValue, c0 as TileflowTypographyStyle, X as TileflowLight, c1 as ResolvedTileflowTypography, f as TileflowTimeOfDayVariants, e as TileflowTimeOfDay, w as TileflowLabelsModuleConfig, y as TileflowPoiModuleConfig, u as TileflowRoadsModuleConfig, ah as TileflowProjection, aX as TileflowTerrain, bk as TileflowViewConfig, M as MapLibreStyle, bo as ValidationResult } from './manifest-types-Bzxon3dx.js';
+import { bd as TileflowThemeColorValue, r as TileflowSymbolStyle, D as TileflowAreaStyle, a1 as TileflowLineStackStyle, q as TileflowLineStyle, o as TileflowExtrusionStyle, bg as TileflowThemeNumberValue, m as TileflowBackgroundStyle, p as TileflowFillStyle, a6 as TileflowMarkerSymbolStyle, n as TileflowCircleStyle, aU as TileflowSymbolPlacement, b1 as TileflowTerrainHillshadeStyle, b0 as TileflowTerrainEncoding, be as TileflowThemeFontValue, bf as TileflowThemeImageValue, c0 as TileflowTypographyStyle, X as TileflowLight, c1 as ResolvedTileflowTypography, f as TileflowTimeOfDayVariants, e as TileflowTimeOfDay, w as TileflowLabelsModuleConfig, y as TileflowPoiModuleConfig, u as TileflowRoadsModuleConfig, ah as TileflowProjection, aX as TileflowTerrain, bk as TileflowViewConfig, M as MapLibreStyle, bo as ValidationResult } from './manifest-types-jrBdBrES.js';
 import * as zod from 'zod';
 import { z } from 'zod';
 import { T as TileflowCaptureScene, a as TileflowCaptureShot } from './capture-shot-ChPQvPyi.js';
@@ -16,6 +16,177 @@ type TileflowAtmosphereOptions = {
 };
 type TileflowAtmosphere = boolean | TileflowAtmosphereOptions;
 
+declare const tileflowOverlayPlacements: readonly ["above-water", "below-roads", "above-roads", "above-buildings", "below-labels", "above-labels"];
+declare const tileflowHostedSourceLimit: 16;
+type TileflowOverlayPlacement = (typeof tileflowOverlayPlacements)[number];
+type TileflowHostedTilesetType = 'raster' | 'vector';
+type TileflowHostedTilesetSource = Readonly<{
+    attribution: string;
+    kind: 'hosted-tileset';
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type: TileflowHostedTilesetType;
+}>;
+type TileflowMapLibreOverlayLayer = Readonly<Record<string, unknown> & {
+    id: string;
+    source?: never;
+    type: string;
+}>;
+type TileflowMapLibreOverlay = Readonly<{
+    kind: 'maplibre-overlay';
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}>;
+type TileflowRemoveOperation = Readonly<{
+    op: 'remove';
+}>;
+type TileflowHostedSourceCollection = Readonly<Record<string, TileflowHostedTilesetSource | TileflowRemoveOperation>>;
+type TileflowOverlayCollection = Readonly<Record<string, TileflowMapLibreOverlay | TileflowRemoveOperation>>;
+/** Bind one logical Team tileset to an explicit account-free local PMTiles archive. */
+declare function hostedTileset(options: {
+    attribution: string;
+    local: string;
+    tileset: string;
+    tileSize?: 256 | 512;
+    type?: TileflowHostedTilesetType;
+}): TileflowHostedTilesetSource;
+/** Group one or more ordinary MapLibre layers around one named Tileflow source. */
+declare function maplibreOverlay(options: {
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}): TileflowMapLibreOverlay;
+/** Remove one inherited keyed source or overlay. */
+declare function remove(): TileflowRemoveOperation;
+declare function isSafeLocalPmtilesPath(value: unknown): value is string;
+
+/** Administrative and neighbourhood classes of the Boundaries tileset, from the largest. */
+declare const tileflowBoundaryClasses: readonly ["country", "dependency", "region", "province_or_county", "municipality", "district", "neighbourhood"];
+type TileflowBoundaryClass = (typeof tileflowBoundaryClasses)[number];
+/** `primary` is the level that covers a country with its class; `secondary` is any other. */
+declare const tileflowBoundaryClassTiers: readonly ["primary", "secondary"];
+type TileflowBoundaryClassTier = (typeof tileflowBoundaryClassTiers)[number];
+/**
+ * Version 1 of the Boundaries tile schema. Polygons carry only the properties needed to filter and
+ * join them; labels and the lookup table carry the rest.
+ */
+declare const tileflowBoundaryAreasV1Schema: Readonly<{
+    classes: readonly ["country", "dependency", "region", "province_or_county", "municipality", "district", "neighbourhood"];
+    /** First zoom at which each class appears, by tier. */
+    classMinzoom: Readonly<{
+        country: Readonly<{
+            primary: 0;
+            secondary: 0;
+        }>;
+        dependency: Readonly<{
+            primary: 0;
+            secondary: 0;
+        }>;
+        region: Readonly<{
+            primary: 3;
+            secondary: 3;
+        }>;
+        province_or_county: Readonly<{
+            primary: 6;
+            secondary: 7;
+        }>;
+        municipality: Readonly<{
+            primary: 8;
+            secondary: 8;
+        }>;
+        district: Readonly<{
+            primary: 10;
+            secondary: 10;
+        }>;
+        neighbourhood: Readonly<{
+            primary: 11;
+            secondary: 11;
+        }>;
+    }>;
+    fields: Readonly<{
+        adminDepth: "admin_depth";
+        adminLevel: "admin_level";
+        class: "class";
+        classTier: "class_tier";
+        iso31661: "iso_3166_1";
+        iso31662: "iso_3166_2";
+        name: "name";
+        nuts: "nuts";
+        ref: "ref";
+        wikidata: "wikidata";
+    }>;
+    layers: Readonly<{
+        areas: "boundary_area";
+        labels: "boundary_label";
+    }>;
+    /** Properties present on `boundary_area` polygons. */
+    areaProperties: readonly ["class", "class_tier", "admin_level", "admin_depth", "ref", "iso_3166_1"];
+    maxzoom: 12;
+    minzoom: 0;
+    product: "boundaries-v1";
+    schemaVersion: 1;
+    tiers: readonly ["primary", "secondary"];
+}>;
+/**
+ * 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;
+declare function isTileflowBoundaryFamily(value: unknown): value is TileflowBoundaryFamily;
+declare function isTileflowBoundaryClass(value: unknown): value is TileflowBoundaryClass;
+
+/**
+ * Tileflow's Boundaries tileset as a map source. It is a separate product from World: World's
+ * border lines belong to the `boundaries` module, while this source holds the areas themselves.
+ */
+type TileflowBoundaryAreasConfig = Readonly<{
+    /** The licensed family to draw. Its attribution is always shown with its layers. */
+    family: TileflowBoundaryFamily;
+    /**
+     * The property MapLibre uses as feature ID for feature-state. By default it is the registry ID,
+     * which survives releases; `ref` keys feature-state by official code instead.
+     */
+    promoteId?: 'ref';
+    /**
+     * A schema-compatible vector TileJSON or `pmtiles://` archive, such as a local copy for offline
+     * development. Defaults to the family's TileJSON under the Tileflow API.
+     */
+    url?: string;
+}>;
+/** `false` removes Boundaries inherited from a parent map. */
+type TileflowBoundaryAreas = false | TileflowBoundaryAreasConfig;
+type TileflowBoundaryAreasSourceIdentity = Readonly<{
+    family: TileflowBoundaryFamily;
+    kind: 'tileflow-boundaries';
+    product: typeof tileflowBoundaryAreasV1Schema.product;
+    promoteId?: 'ref';
+    schemaVersion: typeof tileflowBoundaryAreasV1Schema.schemaVersion;
+    sourceId: string;
+    url: string;
+}>;
+type ResolvedBoundaryAreas = Readonly<{
+    identity: TileflowBoundaryAreasSourceIdentity;
+    source: Readonly<{
+        attribution: string;
+        promoteId?: Readonly<Record<string, string>>;
+        type: 'vector';
+        url: string;
+    }>;
+    sourceId: string;
+}>;
+/** Resolve a map's Boundaries declaration into its style source without fetching its TileJSON. */
+declare function resolveBoundaryAreas(config: TileflowBoundaryAreas | undefined, apiBaseUrl?: string): ResolvedBoundaryAreas | undefined;
+
 type TileflowAddressesModuleOptions = {
     /** Styling for OpenMapTiles point house-number labels. */
     labels?: TileflowSymbolStyle;
@@ -47,25 +218,260 @@ type TileflowBoundariesModuleConfig = TileflowBoundariesModuleOptions & {
 };
 declare function boundaries(options?: TileflowBoundariesModuleOptions): TileflowBoundariesModuleConfig;
 
+/** An embedded glTF image and its sampler. Colour space belongs to its material channel. */
+type TileflowModelTexture = Readonly<{
+    mimeType: 'image/png' | 'image/jpeg';
+    bytes: Uint8Array;
+    width: number;
+    height: number;
+    wrapS?: 33071 | 33648 | 10497;
+    wrapT?: 33071 | 33648 | 10497;
+    minFilter?: 9728 | 9729 | 9984 | 9985 | 9986 | 9987;
+    magFilter?: 9728 | 9729;
+}>;
+/** A texture channel, including KHR_texture_transform and channel-specific strength. */
+type TileflowModelTextureReference = Readonly<{
+    texture: number;
+    texCoord?: 0 | 1;
+    offset?: readonly [number, number];
+    scale?: readonly [number, number];
+    rotation?: number;
+    strength?: number;
+}>;
+/** Metallic/roughness material values use glTF's linear factors and channel conventions. */
+type TileflowModelMaterial = Readonly<{
+    baseColorFactor?: readonly [number, number, number, number];
+    metallicFactor?: number;
+    roughnessFactor?: number;
+    emissiveFactor?: readonly [number, number, number];
+    emissiveStrength?: number;
+    baseColorTexture?: TileflowModelTextureReference;
+    metallicRoughnessTexture?: TileflowModelTextureReference;
+    normalTexture?: TileflowModelTextureReference;
+    occlusionTexture?: TileflowModelTextureReference;
+    emissiveTexture?: TileflowModelTextureReference;
+    alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
+    alphaCutoff?: number;
+    doubleSided?: boolean;
+    unlit?: boolean;
+}>;
+/** An explicitly authored area emitter. Endpoints are its lower edge, in model metres, Z up. */
+type TileflowModelEmitter = Readonly<{
+    start: readonly [number, number, number];
+    end: readonly [number, number, number];
+    height: number;
+    depth?: number;
+    role: TileflowModelLightingRole;
+    part: TileflowModelPart;
+}>;
+type TileflowModelMaterialRange = Readonly<{
+    /** First index, and number of indices. */
+    from: number;
+    count: number;
+    material: number;
+    /** The source mesh's vertical extent in model metres, for its role emission gradient. */
+    emissiveBounds?: readonly [number, number];
+}>;
+/** Optional physical surface data, independent of the legacy palette/role/AO vertex. */
+type TileflowModelSurface = Readonly<{
+    /** Eight floats per vertex: UV0, UV1, linear vertex RGBA. */
+    attributes: readonly number[] | Float32Array;
+    materials: readonly TileflowModelMaterial[];
+    textures: readonly TileflowModelTexture[];
+    ranges: readonly TileflowModelMaterialRange[];
+    emitters?: readonly TileflowModelEmitter[];
+}>;
+declare const tileflowModelSurfaceLimits: Readonly<{
+    materials: 256;
+    textures: 32;
+    textureDimension: 4096;
+    texturePixels: 16777216;
+    emitters: 128;
+}>;
+declare const tileflowModelTextureChannels: readonly ["baseColorTexture", "metallicRoughnessTexture", "normalTexture", "occlusionTexture", "emissiveTexture"];
+/** Validate before preparation, encoding, or browser allocation. */
+declare function checkTileflowModelSurface(surface: TileflowModelSurface, vertices: number, indices: number): void;
+/** Read bounded image dimensions without a DOM or image decoder. */
+declare function tileflowModelImageSize(bytes: Uint8Array, mimeType: 'image/png' | 'image/jpeg'): readonly [number, number] | undefined;
+
+/** 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;
+/** Legacy palette slots map to wall, wall, window, wall and roof; doors and logos are explicit. */
+declare const tileflowModelDefaultLightingRoles: readonly [1, 1, 4, 1, 3];
+/** What a model may hold. */
+declare const tileflowModelLimits: Readonly<{
+    /** Levels of detail, nearest first. */
+    levels: 3;
+    /** Vertices of one level. */
+    vertices: 200000;
+    /** Triangles of one level. */
+    triangles: 200000;
+    /** Points of the footprint's rings, together. */
+    footprintPoints: 4096;
+    /** Half the model's widest extent, in metres. */
+    radius: 2000;
+    /** The model's height, in metres. */
+    height: 1000;
+    /** Models in one prepared file, as a landmark tile holds them. */
+    models: 512;
+    /** Bytes of one prepared file. */
+    bytes: number;
+}>;
+/** One level of detail, as indexed triangles. */
+type TileflowModelMesh = Readonly<{
+    /** x, y and z of each vertex in metres: x east and y north of the origin, z up from the ground. */
+    positions: readonly number[];
+    /** The vertex normals, x, y and z. */
+    normals: readonly number[];
+    /** Each vertex's part, a value of `tileflowModelParts`. */
+    parts: readonly number[];
+    /** Optional architectural role per vertex; absent roles use the palette slot's legacy mapping. */
+    lightingRoles?: readonly number[];
+    /** Each vertex's shade within its part's colour, from -1 (darkest) to 1 (lightest). */
+    shades: readonly number[];
+    /** Each vertex's light, from 0 (fully occluded) to 1. */
+    occlusion: readonly number[];
+    /** Three vertex indices per triangle. */
+    indices: readonly number[];
+    /** Optional physical materials and their independent texture coordinates. */
+    surface?: TileflowModelSurface;
+}>;
+/** A prepared model: its levels, nearest first, and the footprint it replaces on the ground. */
+type TileflowModel = Readonly<{
+    levels: readonly TileflowModelMesh[];
+    /**
+     * Closed rings on the ground, in metres round the origin as `[x, y, x, y, …]`: the outline of
+     * what the model stands in for. The map's own buildings that reach into it are not raised while
+     * the model stands.
+     */
+    footprint: readonly (readonly number[])[];
+}>;
+/** A decoded level, ready for the GPU: its vertex bytes as the file holds them. */
+type TileflowModelLevelBytes = Readonly<{
+    /**
+     * 16 bytes a vertex, in glTF's axes (x east, y up, z south): its position as whole steps from
+     * `centre` (int16 ×3, then two bytes of padding), its normal (int8 ×3, then one), and its part,
+     * shade and light (uint8 ×3, then one).
+     */
+    vertices: Uint8Array;
+    indices: Uint16Array | Uint32Array;
+    /** The point the positions count from, in glTF's axes, in metres. */
+    centre: readonly [number, number, number];
+    /** Metres in one step of a position. */
+    step: number;
+    /** Optional physical data; absent data retains the legacy palette lighting. */
+    surface?: TileflowModelSurface & {
+        attributes: Float32Array;
+    };
+}>;
+/** A decoded model, as the renderer draws it. */
+type TileflowModelBytes = Readonly<{
+    /** The model's id. */
+    id: string;
+    /** Its bounds in metres round its origin, `[minX, minY, minZ, maxX, maxY, maxZ]` (x east, y north, z up). */
+    bounds: readonly [number, number, number, number, number, number];
+    levels: readonly TileflowModelLevelBytes[];
+    footprint: readonly (readonly number[])[];
+    /** Where it stands, longitude and latitude, when the file says so, as a landmark tile does. */
+    at?: readonly [number, number];
+    /** Degrees clockwise from north its own north is turned to, when the file says so. */
+    heading?: number;
+}>;
+/** Bytes per vertex in a model file and on the GPU. */
+declare const tileflowModelVertexBytes = 16;
+/** Whether a point lies inside any of the rings (even-odd), as `[x, y, x, y, …]`. */
+declare function tileflowInsideRings(rings: readonly (readonly number[])[], px: number, py: number): boolean;
+/**
+ * Whether the rings `outline` (a building's) reach more than `margin` into any of the rings
+ * `footprints` (the models'), all as `[x, y, x, y, …]` in the same units: a corner of one deep
+ * inside the other, or an edge passing through it. A building that only touches a footprint, as a
+ * neighbour sharing a wall does, does not.
+ */
+declare function tileflowRingsOverlap(outline: readonly (readonly number[])[], footprints: readonly (readonly number[])[], margin: number): boolean;
+
 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,
@@ -119,8 +525,24 @@ declare function buildings(options?: TileflowBuildingsModuleOptions): TileflowBu
 
 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>>;
@@ -144,22 +566,47 @@ declare function landforms(options?: TileflowLandformsModuleOptions): TileflowLa
 
 /** 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;
@@ -167,6 +614,46 @@ type TileflowNauticalModuleOptions = {
 type TileflowNauticalModuleConfig = TileflowNauticalModuleOptions & {
     type: 'nautical';
 };
+/**
+ * Theme image tokens for nautical point symbols. When the selected theme declares a group's token,
+ * that group draws the image as its icon instead of the default circle marker. Buoy variants fall
+ * back to `nautical.buoy`. Declare every token of one group with the same icon representation; SDF
+ * icons take the mark's colour.
+ */
+declare const tileflowNauticalImageRoles: Readonly<{
+    aids: Readonly<{
+        default: "nautical.aid";
+    }>;
+    beacons: Readonly<{
+        default: "nautical.beacon";
+    }>;
+    buoys: Readonly<{
+        cardinal: "nautical.buoy.cardinal";
+        default: "nautical.buoy";
+        port: "nautical.buoy.port";
+        starboard: "nautical.buoy.starboard";
+    }>;
+    harbours: Readonly<{
+        default: "nautical.harbour";
+    }>;
+    lighthouses: Readonly<{
+        default: "nautical.lighthouse";
+    }>;
+    lights: Readonly<{
+        default: "nautical.light";
+    }>;
+    ports: Readonly<{
+        default: "nautical.port";
+    }>;
+    wrecks: Readonly<{
+        default: "nautical.wreck";
+    }>;
+}>;
+/** The fixed notice every map that draws `nautical-v1` objects declares in its style. */
+declare const tileflowNauticalNotice: Readonly<{
+    id: "nautical-not-for-navigation";
+    text: "Not for navigation";
+}>;
 /** Style the semantic objects published by the `nautical-v1` sidecar. */
 declare function nautical(options?: TileflowNauticalModuleOptions): TileflowNauticalModuleConfig;
 
@@ -273,6 +760,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;
 }>;
 /** A model's id: its file's name, in lowercase letters, digits and hyphens. */
 declare const tileflowTreeModelIdPattern: RegExp;
@@ -280,19 +771,24 @@ declare const tileflowTreeModelIdPattern: RegExp;
 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;
@@ -324,6 +820,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;
     /**
@@ -377,6 +880,16 @@ type TileflowVegetationModuleConfig = TileflowVegetationModuleOptions & {
 declare function vegetation(options?: TileflowVegetationModuleOptions): TileflowVegetationModuleConfig;
 
 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. */
@@ -384,9 +897,9 @@ 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;
@@ -440,6 +953,11 @@ type OpenMapTilesLayerBindings = {
     sidewalk?: string;
     /** Optional point features such as pedestrian crossings. */
     streetFurniture?: string;
+    /**
+     * Optional barriers and traffic calming at native zoom 15: hedges, fences, walls, kerbs and
+     * guard rails as lines, and hedges mapped as areas of their own as polygons.
+     */
+    trafficControl?: string;
     /** Optional individual-tree point extension used by the vegetation module. */
     tree?: string;
     water: string;
@@ -496,6 +1014,8 @@ type OpenMapTilesFieldBindings = {
     elevationFeet: string;
     expressway: string;
     foot: string;
+    /** Optional kind of a barrier hedge: `hedge_bank` when it stands on an earth bank. */
+    hedge?: string;
     height: string;
     hide3d: string;
     /** Whether a building footprint owns separately materialized building parts. */
@@ -593,6 +1113,7 @@ type TileflowWorldV1Schema = Omit<OpenMapTilesSchema, 'fields' | 'layers'> & {
     fields: OpenMapTilesFieldBindings & {
         bathymetryMinDepth: string;
         bathymetrySortKey: string;
+        hedge: string;
         shieldKind: string;
         shieldLineLengthMeters: string;
         shieldNetwork: string;
@@ -607,6 +1128,7 @@ type TileflowWorldV1Schema = Omit<OpenMapTilesSchema, 'fields' | 'layers'> & {
         sidewalk: string;
         streetFurniture: string;
         roadShield: string;
+        trafficControl: string;
     };
 };
 type TileflowWorldReleaseReference = Readonly<{
@@ -744,32 +1266,60 @@ declare const tileflowBathymetryV1Schema: Readonly<{
         }>;
     }>;
 }>;
+/**
+ * The `nautical-v1` vector contract styled by the `nautical` module. Every feature carries the
+ * provenance fields (`provider`, `provenance`, `edition`, `coverage`, `licence`) and `min_zoom`,
+ * the first zoom at which it appears; `rank` (1 is most important within its layer) and `name`
+ * are optional. Colours are S-57 colour names, and multi-valued colours and categories are
+ * comma-separated in source order, for example `black,yellow`.
+ */
 declare const tileflowNauticalV1Schema: Readonly<{
     fields: Readonly<{
+        category: "category";
         cell: "cell";
         character: "character";
         class: "class";
         color: "color";
+        colorPattern: "color_pattern";
+        country: "country";
         coverage: "coverage";
         depth: "depth";
-        direction: "direction";
         edition: "edition";
+        families: "families";
+        group: "group";
+        heightM: "height_m";
+        label: "label";
         licence: "licence";
+        lit: "lit";
+        minZoom: "min_zoom";
         name: "name";
-        provider: "provider";
+        orientation: "orientation";
+        periodS: "period_s";
+        position: "position";
         provenance: "provenance";
-        quality: "quality";
+        provider: "provider";
         rangeNm: "range_nm";
+        rank: "rank";
+        reference: "reference";
+        restriction: "restriction";
         scale: "scale";
+        sectorEnd: "sector_end";
+        sectorStart: "sector_start";
+        shape: "shape";
+        size: "size";
         subclass: "subclass";
+        system: "system";
+        topmark: "topmark";
+        unlocode: "unlocode";
         update: "update";
+        waterLevel: "water_level";
     }>;
     geometryTypes: Readonly<{
         aids: readonly ["Point"];
         coverage: readonly ["Polygon"];
-        hazards: readonly ["Point", "Polygon"];
+        hazards: readonly ["Point", "LineString", "Polygon"];
         lights: readonly ["Point"];
-        navigationAreas: readonly ["Polygon"];
+        navigationAreas: readonly ["Point", "LineString", "Polygon"];
         reefs: readonly ["Polygon"];
         soundings: readonly ["Point"];
         wrecks: readonly ["Point", "Polygon"];
@@ -901,6 +1451,42 @@ type ResolvedMarine = Readonly<{
 /** Resolve the optional marine sidecars without fetching their TileJSON documents. */
 declare function resolveMarine(marine: TileflowMarine | undefined, apiBaseUrl?: string): ResolvedMarine | undefined;
 
+declare const tileflowResetBrand: unique symbol;
+/** Removes an inherited override in `refine()` or lighting in `defineTheme()`. */
+type TileflowReset = Readonly<{
+    readonly $tileflow: 'reset';
+    readonly [tileflowResetBrand]: true;
+}>;
+type TileflowPatchValue<TValue> = TileflowReset | (TValue extends readonly unknown[] ? TValue : TValue extends object ? TileflowNestedPatch<TValue> : TValue);
+type TileflowNestedPatch<TValue extends object> = {
+    readonly [TKey in keyof TValue]?: TileflowPatchValue<TValue[TKey]>;
+};
+/**
+ * A recursive semantic patch. Records merge; arrays and scalar values replace.
+ * Module ownership and compiler visibility are immutable only at the patch root;
+ * nested domain options named `type` or `enabled` retain their ordinary meaning.
+ */
+type TileflowModulePatch<TModule extends object> = {
+    readonly [TKey in Exclude<keyof TModule, 'enabled' | 'type'>]?: TileflowPatchValue<TModule[TKey]>;
+};
+type TileflowRefineOperation<TPatch extends object = object> = Readonly<{
+    readonly op: 'refine';
+    readonly patches: readonly TPatch[];
+}>;
+type TileflowDisableOperation = Readonly<{
+    readonly op: 'disable';
+}>;
+type TileflowModuleOperation<TModule extends object> = TileflowDisableOperation | TileflowRefineOperation<TileflowModulePatch<TModule>>;
+type TileflowAuthoringModules = {
+    readonly [TName in keyof TileflowSemanticModules]?: NonNullable<TileflowSemanticModules[TName]> | TileflowModuleOperation<NonNullable<TileflowSemanticModules[TName]>>;
+};
+/** Deeply refine an inherited module; arrays and scalar values replace atomically. */
+declare function refine<const TPatch extends object>(...patches: readonly [TPatch, ...TPatch[]]): TileflowRefineOperation<TPatch>;
+/** Disable a complete semantic module while retaining an explicit compiler decision. */
+declare function disable(): TileflowDisableOperation;
+/** Remove an inherited module override or theme lighting value, restoring the SDK fallback. */
+declare function reset(): TileflowReset;
+
 declare const tileflowSunMetadataKey = "tileflow:sun";
 /** A theme's sun and sky light with every value resolved; see `TileflowThemeSun`. */
 type TileflowSunPreset = Readonly<{
@@ -954,7 +1540,7 @@ type TileflowSun = Readonly<{
     /** 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. */
+/** Unset sun values: high in the south-south-west, with soft white daylight and ambient fill. */
 declare const tileflowDefaultSunPreset: TileflowSunPreset;
 /**
  * Where the sun stands for an instant and a place ([longitude, latitude] in degrees): its azimuth
@@ -1072,9 +1658,13 @@ type TileflowTheme = {
 type TileflowThemeTokenOverrides = {
     [TCategory in keyof TileflowThemeTokens]?: Readonly<Partial<TileflowThemeTokens[TCategory]>>;
 };
+type TileflowThemeLightingOverrides = {
+    [TKey in keyof TileflowThemeLighting]?: TileflowThemeLighting[TKey] | TileflowReset;
+};
 /** Input accepted by defineTheme. The returned theme is always fully materialized. */
 type TileflowThemeDefinition = Pick<TileflowTheme, 'colorScheme' | 'id' | 'version'> & {
-    lighting?: TileflowThemeLighting;
+    /** Refine inherited light, or use reset() to remove all or one direct lighting property. */
+    lighting?: TileflowThemeLightingOverrides | TileflowReset;
     tokens?: TileflowThemeTokenOverrides;
     typography?: TileflowThemeTypography;
 };
@@ -1237,88 +1827,6 @@ declare class TileflowIconSetError extends Error {
 /** Validate the dependency sequence without consulting a lock or registry. */
 declare function collectTileflowIconSetReferences(sources: readonly TileflowIconSource[]): TileflowIconSetReference[];
 
-declare const tileflowOverlayPlacements: readonly ["above-water", "below-roads", "above-roads", "above-buildings", "below-labels", "above-labels"];
-declare const tileflowHostedSourceLimit: 16;
-type TileflowOverlayPlacement = (typeof tileflowOverlayPlacements)[number];
-type TileflowHostedTilesetType = 'raster' | 'vector';
-type TileflowHostedTilesetSource = Readonly<{
-    attribution: string;
-    kind: 'hosted-tileset';
-    local: string;
-    tileset: string;
-    tileSize?: 256 | 512;
-    type: TileflowHostedTilesetType;
-}>;
-type TileflowMapLibreOverlayLayer = Readonly<Record<string, unknown> & {
-    id: string;
-    source?: never;
-    type: string;
-}>;
-type TileflowMapLibreOverlay = Readonly<{
-    kind: 'maplibre-overlay';
-    layers: readonly TileflowMapLibreOverlayLayer[];
-    placement: TileflowOverlayPlacement;
-    source: string;
-}>;
-type TileflowRemoveOperation = Readonly<{
-    op: 'remove';
-}>;
-type TileflowHostedSourceCollection = Readonly<Record<string, TileflowHostedTilesetSource | TileflowRemoveOperation>>;
-type TileflowOverlayCollection = Readonly<Record<string, TileflowMapLibreOverlay | TileflowRemoveOperation>>;
-/** Bind one logical Team tileset to an explicit account-free local PMTiles archive. */
-declare function hostedTileset(options: {
-    attribution: string;
-    local: string;
-    tileset: string;
-    tileSize?: 256 | 512;
-    type?: TileflowHostedTilesetType;
-}): TileflowHostedTilesetSource;
-/** Group one or more ordinary MapLibre layers around one named Tileflow source. */
-declare function maplibreOverlay(options: {
-    layers: readonly TileflowMapLibreOverlayLayer[];
-    placement: TileflowOverlayPlacement;
-    source: string;
-}): TileflowMapLibreOverlay;
-/** Remove one inherited keyed source or overlay. */
-declare function remove(): TileflowRemoveOperation;
-declare function isSafeLocalPmtilesPath(value: unknown): value is string;
-
-declare const tileflowResetBrand: unique symbol;
-/** Serializable sentinel that removes one inherited override during `refine()`. */
-type TileflowReset = Readonly<{
-    readonly $tileflow: 'reset';
-    readonly [tileflowResetBrand]: true;
-}>;
-type TileflowPatchValue<TValue> = TileflowReset | (TValue extends readonly unknown[] ? TValue : TValue extends object ? TileflowNestedPatch<TValue> : TValue);
-type TileflowNestedPatch<TValue extends object> = {
-    readonly [TKey in keyof TValue]?: TileflowPatchValue<TValue[TKey]>;
-};
-/**
- * A recursive semantic patch. Records merge; arrays and scalar values replace.
- * Module ownership and compiler visibility are immutable only at the patch root;
- * nested domain options named `type` or `enabled` retain their ordinary meaning.
- */
-type TileflowModulePatch<TModule extends object> = {
-    readonly [TKey in Exclude<keyof TModule, 'enabled' | 'type'>]?: TileflowPatchValue<TModule[TKey]>;
-};
-type TileflowRefineOperation<TPatch extends object = object> = Readonly<{
-    readonly op: 'refine';
-    readonly patches: readonly TPatch[];
-}>;
-type TileflowDisableOperation = Readonly<{
-    readonly op: 'disable';
-}>;
-type TileflowModuleOperation<TModule extends object> = TileflowDisableOperation | TileflowRefineOperation<TileflowModulePatch<TModule>>;
-type TileflowAuthoringModules = {
-    readonly [TName in keyof TileflowSemanticModules]?: NonNullable<TileflowSemanticModules[TName]> | TileflowModuleOperation<NonNullable<TileflowSemanticModules[TName]>>;
-};
-/** Deeply refine an inherited module; arrays and scalar values replace atomically. */
-declare function refine<const TPatch extends object>(...patches: readonly [TPatch, ...TPatch[]]): TileflowRefineOperation<TPatch>;
-/** Disable a complete semantic module while retaining an explicit compiler decision. */
-declare function disable(): TileflowDisableOperation;
-/** Remove an inherited override so the domain registry can supply its semantic default. */
-declare function reset(): TileflowReset;
-
 /** Portable, filesystem-safe identity shared by maps and their leaf-owned scenes. */
 declare const tileflowMapIdSchema: zod.ZodString;
 /** Identity is always owned by the map being resolved and never inherited. */
@@ -1351,6 +1859,11 @@ type TileflowMapTextAssets = {
 type TileflowMapDesign = TileflowMapTextAssets & {
     /** Optional atmosphere for globe projection. False disables an inherited atmosphere. */
     atmosphere?: TileflowAtmosphere;
+    /**
+     * Tileflow's Boundaries tileset: administrative and neighbourhood areas for choropleths and
+     * selections. World's border lines remain the `boundaries` module. False removes inherited areas.
+     */
+    boundaryAreas?: TileflowBoundaryAreas;
     data?: TileflowDataConfig;
     /** Name used whenever a concrete theme is not explicitly requested. */
     defaultTheme?: TileflowThemeName;
@@ -1537,7 +2050,18 @@ type TileflowCompilationPlannerDecision = Readonly<{
     selectedCount?: number;
     stage: TileflowCompilationPlannerStage;
 }>;
+/** A resolved semantic choice, with an authoring path rather than a physical layer ID. */
+type TileflowCompilationDesignDecision = Readonly<{
+    /** Dot path in the resolved map; a theme token's complete role is its final key. */
+    path: string;
+    source: 'default' | 'map' | 'theme' | 'derived';
+    value: unknown;
+    reason: string;
+    override: string;
+}>;
 type TileflowCompilationReport = Readonly<{
+    /** Color roles and selected module policies, not a trace of every paint/layout property. */
+    decisions?: readonly TileflowCompilationDesignDecision[];
     domains: readonly TileflowCompilationDomainReport[];
     map: string;
     planner: readonly TileflowCompilationPlannerDecision[];
@@ -1737,4 +2261,4 @@ declare function parseTileflowIconComposition(input: unknown): TileflowIconCompo
 /** Dependency identity is separate from the generated artifact's content hash. */
 declare function hashTileflowIconComposition(input: TileflowIconCompositionV1): Promise<string>;
 
-export { type TileflowAerowaysModuleOptions as $, type TileflowBandPlacement as A, type OpenMapTilesLayerBindings as B, tileflowCompilationPhases as C, tileflowCompilationPlannerStages as D, tileflowCompilationReportSchemaVersion as E, type TileflowSemanticModuleName as F, tileflowHostedSourceLimit as G, tileflowOverlayPlacements as H, type ResolvedTileflowTheme as I, type TileflowThemeColorScheme as J, type TileflowIconSource as K, type TileflowVegetationMode as L, type OpenMapTilesSchema as M, type OpenMapTilesSchemaOptions as N, type OpenMapTilesFieldBindings as O, type ParkLayerSemantics as P, type ResolvedBathymetry as Q, type ResolvedTileflowMap as R, type ResolvedBathymetryRelief as S, type TileflowRenderedIconIdentity as T, type ResolvedMarine as U, type ResolvedMarineSource as V, type ResolvedTileflowData as W, type ResolvedTileflowThemeTokens as X, type TileflowAddressesModuleConfig as Y, type TileflowAddressesModuleOptions as Z, type TileflowAerowaysModuleConfig as _, type TileflowIconCompositionV1 as a, type TileflowModelDirectory as a$, type TileflowAtmosphere as a0, type TileflowAtmosphereOptions as a1, type TileflowAuthoringModules as a2, type TileflowBathymetryConfig as a3, type TileflowBathymetryDemSourceIdentity as a4, type TileflowBathymetryDisplay as a5, type TileflowBathymetryNameLayer as a6, type TileflowBathymetryNameZoomRange as a7, type TileflowBathymetryOptions as a8, type TileflowBathymetryReliefConfig as a9, type TileflowHostedTilesetSource as aA, type TileflowHostedTilesetType as aB, type TileflowIconContributorIdentity as aC, type TileflowIconDirectory as aD, TileflowIconSetError as aE, type TileflowIconSetErrorCode as aF, type TileflowIconSetReference as aG, type TileflowIconSetSource as aH, type TileflowLandModuleConfig as aI, type TileflowLandModuleOptions as aJ, type TileflowLandcoverClass as aK, type TileflowLandformClass as aL, type TileflowLandformsModuleConfig as aM, type TileflowLandformsModuleOptions as aN, type TileflowLanduseClass as aO, type TileflowLayerBand as aP, type TileflowLocalDirectory as aQ, type TileflowMapDesign as aR, type TileflowMapIdentity as aS, type TileflowMapLibreOverlay as aT, type TileflowMapLibreOverlayLayer as aU, type TileflowMapTooling as aV, type TileflowMarine as aW, type TileflowMarineConfig as aX, type TileflowMarineMode as aY, type TileflowMarineSourceConfig as aZ, type TileflowMarineSourceIdentity as a_, type TileflowBathymetryVectorLayers as aa, type TileflowBoundariesModuleConfig as ab, type TileflowBoundariesModuleOptions as ac, type TileflowBuildingMode as ad, type TileflowBuildingModelPart as ae, type TileflowBuildingModelPlacementConfig as af, type TileflowBuildingsModuleConfig as ag, type TileflowBuildingsModuleOptions as ah, type TileflowBuildingsThreeDimensionalStyle as ai, type TileflowCompilationDiagnostic as aj, type TileflowCompilationDomainReport as ak, type TileflowCompilationFailure as al, type TileflowCompilationOptions as am, type TileflowCompilationPhase as an, type TileflowCompilationPlannerDecision as ao, type TileflowCompilationPlannerStage as ap, type TileflowCompilationReport as aq, type TileflowCompilationResult as ar, type TileflowCompilationSuccess as as, type TileflowDataConfig as at, type TileflowDataIdentity as au, type TileflowDerivedMap as av, type TileflowDisableOperation as aw, type TileflowFontDirectory as ax, type TileflowGlyphs as ay, type TileflowHostedSourceCollection as az, type TileflowDataRequirementsV1 as b, createStyle as b$, type TileflowModuleOperation as b0, type TileflowModulePatch as b1, type TileflowNauticalAreaLabelStyles as b2, type TileflowNauticalModuleConfig as b3, type TileflowNauticalModuleOptions as b4, type TileflowOverlayCollection as b5, type TileflowOverlayPlacement as b6, type TileflowPackageDirectory as b7, type TileflowPreparedIconCapabilities as b8, type TileflowRasterDemSourceRequirementV1 as b9, type TileflowTreeModel as bA, type TileflowTreeModelMesh as bB, type TileflowTreeRegion as bC, type TileflowVegetation3D as bD, type TileflowVegetationModuleConfig as bE, type TileflowVegetationModuleOptions as bF, type TileflowVegetationThreeDimensionalStyle as bG, type TileflowVisualValueCategory as bH, type TileflowWaterModuleConfig as bI, type TileflowWaterModuleOptions as bJ, type TileflowWaterwayClass as bK, type TileflowWorldData as bL, type TileflowWorldReleaseReference as bM, type TileflowWorldSelection as bN, type TileflowWorldV1Schema as bO, type VectorTilesData as bP, addresses as bQ, aeroways as bR, assertTileflowMapThemeValues as bS, assertTileflowSdfPixels as bT, auditTileflowMapThemeValues as bU, auditTileflowThemeValues as bV, bathymetry as bW, boundaries as bX, buildings as bY, classifyTileflowVisualProperty as bZ, collectTileflowIconSetReferences as b_, type TileflowRefineOperation as ba, type TileflowRemoveOperation as bb, type TileflowReset as bc, type TileflowResolvedThemeSelection as bd, type TileflowSemanticModules as be, type TileflowStandaloneMap as bf, type TileflowSun as bg, type TileflowSunPreset as bh, type TileflowTheme as bi, type TileflowThemeAmbient as bj, type TileflowThemeAuditContext as bk, type TileflowThemeAuditDiagnostic as bl, TileflowThemeAuditError as bm, type TileflowThemeAuditScope as bn, type TileflowThemeDefinition as bo, type TileflowThemeLighting as bp, type TileflowThemeName as bq, type TileflowThemeSun as br, type TileflowThemeTokens as bs, type TileflowThemeTypography as bt, type TileflowThemeTypographyStyle as bu, type TileflowTransitModuleConfig as bv, type TileflowTransitModuleOptions as bw, type TileflowTransitRailStyle as bx, type TileflowTreeForm as by, type TileflowTreeFormMix as bz, type TileflowSourceRequirementsV1 as c, tileflowSunPosition as c$, createStyleResult as c0, decodeTileflowTreeModel as c1, defineTheme as c2, disable as c3, encodeTileflowTreeModel as c4, hashTileflowIconComposition as c5, hostedTileset as c6, iconSet as c7, isCanonicalOpenMapTilesSchema as c8, isSafeLocalPmtilesPath as c9, tileflowBathymetrySourceId as cA, tileflowBathymetryV1Schema as cB, tileflowDefaultSunPreset as cC, tileflowIconAppearanceSchema as cD, tileflowIconAuthorMetadataSchema as cE, tileflowIconCompositionMaximumBytes as cF, tileflowIconCompositionSchema as cG, tileflowIconMetadataFileName as cH, tileflowIconSetIdSchema as cI, tileflowIconSetPackageIdSchema as cJ, tileflowIconSetReferenceSchema as cK, tileflowIconSetSourceSchema as cL, tileflowIconSetTeamIdSchema as cM, tileflowIconSetVersionIdSchema as cN, tileflowIconSourceLimit as cO, tileflowLandformClasses as cP, tileflowLayerBands as cQ, tileflowLocalDirectoryMaximumLength as cR, tileflowLocalDirectoryMessage as cS, tileflowMapIdSchema as cT, tileflowNauticalSourceId as cU, tileflowNauticalV1Schema as cV, tileflowPrimarySourceId as cW, tileflowRenderedIconIdentitySchema as cX, tileflowStyleSunPreset as cY, tileflowSunDirection as cZ, tileflowSunMetadataKey as c_, isTileflowCompilationPhase as ca, isTileflowIconSetSource as cb, isTileflowLocalDirectory as cc, land as cd, landforms as ce, maplibreOverlay as cf, mixTileflowSunPresets as cg, nautical as ch, openMapTiles as ci, openMapTilesContractVersion as cj, parseTileflowIconComposition as ck, parseTileflowMap as cl, readTileflowSunPreset as cm, readTileflowVegetation3D as cn, refine as co, remove as cp, reset as cq, resolveMarine as cr, resolveThemeSelection as cs, resolveThemeValues as ct, resolveTileflowData as cu, resolveTileflowSun as cv, resolveTileflowTheme as cw, tileflowBandPlacements as cx, tileflowBathymetryDemSourceId as cy, tileflowBathymetryNameLayerLimits as cz, type TileflowMap as d, tileflowThemeLimits as d0, tileflowTreeForms as d1, tileflowTreeModelIdPattern as d2, tileflowTreeModelLimits as d3, tileflowVegetationMetadataKey as d4, tileflowWorld as d5, tileflowWorldGeneration as d6, tileflowWorldTileJsonUrl as d7, tileflowWorldV1Schema as d8, transit as d9, validateTileflowCompiledIconCapabilities as da, validateTileflowMap as db, validateTileflowWorldV1Tilejson as dc, vectorTiles as dd, vegetation as de, water as df, type TileflowStyleOptions as e, type TileflowInspectedStyle as f, type TileflowPreparedMapAssets as g, type TileflowDataCompatibilityIssue as h, type TileflowDataFieldRequirement as i, type TileflowDataFieldType as j, type TileflowDataLayerRequirement as k, type TileflowObservedDataContractV1 as l, type TileflowStyleInspection as m, type TileflowStyleInspectionContribution as n, type TileflowStyleInspectionLayer as o, type TileflowStyleInspectionRenderOperation as p, collectMapLineage as q, inferTileflowDataRequirements as r, inferTileflowSourceRequirements as s, tileflowStyleInspectionSchemaVersion as t, type TileflowMapScene as u, validateTileflowDataCompatibility as v, type TileflowMapShot as w, type ResolveMapOptions as x, type TileflowIconAppearance as y, type TileflowLayerDomain as z };
+export { type ResolvedBathymetry as $, type TileflowMapScene as A, type TileflowMapShot as B, type ResolveMapOptions as C, type TileflowIconAppearance as D, type TileflowLayerDomain as E, type TileflowBandPlacement as F, type OpenMapTilesLayerBindings as G, tileflowCompilationPhases as H, tileflowCompilationPlannerStages as I, tileflowCompilationReportSchemaVersion as J, type TileflowSemanticModuleName as K, tileflowHostedSourceLimit as L, tileflowOverlayPlacements as M, type ResolvedTileflowTheme as N, type OpenMapTilesFieldBindings as O, type TileflowThemeColorScheme as P, type TileflowIconSource as Q, type ResolvedTileflowMap as R, type TileflowModelLightingRole as S, type TileflowRenderedIconIdentity as T, type TileflowModelPart as U, type TileflowModel as V, type TileflowModelBytes as W, type TileflowVegetationMode as X, type OpenMapTilesSchema as Y, type OpenMapTilesSchemaOptions as Z, type ParkLayerSemantics as _, type TileflowIconCompositionV1 as a, type TileflowLandModuleOptions as a$, type ResolvedBathymetryRelief as a0, type ResolvedBoundaryAreas as a1, type ResolvedMarine as a2, type ResolvedMarineSource as a3, type ResolvedTileflowData as a4, type ResolvedTileflowThemeTokens as a5, type TileflowAddressesModuleConfig as a6, type TileflowAddressesModuleOptions as a7, type TileflowAerowaysModuleConfig as a8, type TileflowAerowaysModuleOptions as a9, type TileflowCompilationDesignDecision as aA, type TileflowCompilationDiagnostic as aB, type TileflowCompilationDomainReport as aC, type TileflowCompilationFailure as aD, type TileflowCompilationOptions as aE, type TileflowCompilationPhase as aF, type TileflowCompilationPlannerDecision as aG, type TileflowCompilationPlannerStage as aH, type TileflowCompilationReport as aI, type TileflowCompilationResult as aJ, type TileflowCompilationSuccess as aK, type TileflowDataConfig as aL, type TileflowDataIdentity as aM, type TileflowDerivedMap as aN, type TileflowDisableOperation as aO, type TileflowFontDirectory as aP, type TileflowGlyphs as aQ, type TileflowHostedSourceCollection as aR, type TileflowHostedTilesetSource as aS, type TileflowHostedTilesetType as aT, type TileflowIconContributorIdentity as aU, type TileflowIconDirectory as aV, TileflowIconSetError as aW, type TileflowIconSetErrorCode as aX, type TileflowIconSetReference as aY, type TileflowIconSetSource as aZ, type TileflowLandModuleConfig as a_, type TileflowAtmosphere as aa, type TileflowAtmosphereOptions as ab, type TileflowAuthoringModules as ac, type TileflowBarrierClass as ad, type TileflowBarrierStyle as ae, type TileflowBathymetryConfig as af, type TileflowBathymetryDemSourceIdentity as ag, type TileflowBathymetryDisplay as ah, type TileflowBathymetryNameLayer as ai, type TileflowBathymetryNamePlacement as aj, type TileflowBathymetryNameStyle as ak, type TileflowBathymetryNameZoomRange as al, type TileflowBathymetryOptions as am, type TileflowBathymetryReliefConfig as an, type TileflowBathymetryVectorLayers as ao, type TileflowBoundariesModuleConfig as ap, type TileflowBoundariesModuleOptions as aq, type TileflowBoundaryAreas as ar, type TileflowBoundaryAreasConfig as as, type TileflowBoundaryAreasSourceIdentity as at, type TileflowBuildingMode as au, type TileflowBuildingModelPart as av, type TileflowBuildingModelPlacementConfig as aw, type TileflowBuildingsModuleConfig as ax, type TileflowBuildingsModuleOptions as ay, type TileflowBuildingsThreeDimensionalStyle as az, type TileflowDataRequirementsV1 as b, type TileflowVegetation3D as b$, type TileflowLandcoverClass as b0, type TileflowLandformClass as b1, type TileflowLandformsModuleConfig as b2, type TileflowLandformsModuleOptions as b3, type TileflowLanduseClass as b4, type TileflowLayerBand as b5, type TileflowLocalDirectory as b6, type TileflowMapDesign as b7, type TileflowMapIdentity as b8, type TileflowMapLibreOverlayLayer as b9, type TileflowReset as bA, type TileflowResolvedThemeSelection as bB, type TileflowSemanticModules as bC, type TileflowStandaloneMap as bD, type TileflowSun as bE, type TileflowSunPreset as bF, type TileflowTheme as bG, type TileflowThemeAmbient as bH, type TileflowThemeAuditContext as bI, type TileflowThemeAuditDiagnostic as bJ, TileflowThemeAuditError as bK, type TileflowThemeAuditScope as bL, type TileflowThemeDefinition as bM, type TileflowThemeLighting as bN, type TileflowThemeName as bO, type TileflowThemeSun as bP, type TileflowThemeTokens as bQ, type TileflowThemeTypography as bR, type TileflowThemeTypographyStyle as bS, type TileflowTransitModuleConfig as bT, type TileflowTransitModuleOptions as bU, type TileflowTransitRailStyle as bV, type TileflowTreeForm as bW, type TileflowTreeFormMix as bX, type TileflowTreeModel as bY, type TileflowTreeModelMesh as bZ, type TileflowTreeRegion as b_, type TileflowMapTooling as ba, type TileflowMarine as bb, type TileflowMarineConfig as bc, type TileflowMarineMode as bd, type TileflowMarineSourceConfig as be, type TileflowMarineSourceIdentity as bf, type TileflowModelDirectory as bg, type TileflowModelEmitter as bh, type TileflowModelLevelBytes as bi, type TileflowModelMaterial as bj, type TileflowModelMaterialRange as bk, type TileflowModelMesh as bl, type TileflowModelSurface as bm, type TileflowModelTexture as bn, type TileflowModelTextureReference as bo, type TileflowModuleOperation as bp, type TileflowModulePatch as bq, type TileflowNauticalAreaLabelStyles as br, type TileflowNauticalModuleConfig as bs, type TileflowNauticalModuleOptions as bt, type TileflowOverlayCollection as bu, type TileflowPackageDirectory as bv, type TileflowPreparedIconCapabilities as bw, type TileflowRasterDemSourceRequirementV1 as bx, type TileflowRefineOperation as by, type TileflowRemoveOperation as bz, type TileflowSourceRequirementsV1 as c, tileflowBathymetryNameLayerLimits as c$, type TileflowVegetationModuleConfig as c0, type TileflowVegetationModuleOptions as c1, type TileflowVegetationThreeDimensionalStyle as c2, type TileflowVisualValueCategory as c3, type TileflowWaterModuleConfig as c4, type TileflowWaterModuleOptions as c5, type TileflowWaterwayClass as c6, type TileflowWorldData as c7, type TileflowWorldReleaseReference as c8, type TileflowWorldSelection as c9, isTileflowBoundaryFamily as cA, isTileflowCompilationPhase as cB, isTileflowIconSetSource as cC, isTileflowLocalDirectory as cD, land as cE, landforms as cF, maplibreOverlay as cG, mixTileflowSunPresets as cH, nautical as cI, openMapTiles as cJ, openMapTilesContractVersion as cK, parseTileflowIconComposition as cL, parseTileflowMap as cM, readTileflowSunPreset as cN, readTileflowVegetation3D as cO, refine as cP, remove as cQ, reset as cR, resolveBoundaryAreas as cS, resolveMarine as cT, resolveThemeSelection as cU, resolveThemeValues as cV, resolveTileflowData as cW, resolveTileflowSun as cX, resolveTileflowTheme as cY, tileflowBandPlacements as cZ, tileflowBathymetryDemSourceId as c_, type TileflowWorldV1Schema as ca, type VectorTilesData as cb, addresses as cc, aeroways as cd, assertTileflowMapThemeValues as ce, assertTileflowSdfPixels as cf, auditTileflowMapThemeValues as cg, auditTileflowThemeValues as ch, bathymetry as ci, boundaries as cj, buildings as ck, checkTileflowModelSurface as cl, classifyTileflowVisualProperty as cm, collectTileflowIconSetReferences as cn, createStyle as co, createStyleResult as cp, decodeTileflowTreeModel as cq, defineTheme as cr, disable as cs, encodeTileflowTreeModel as ct, hashTileflowIconComposition as cu, hostedTileset as cv, iconSet as cw, isCanonicalOpenMapTilesSchema as cx, isSafeLocalPmtilesPath as cy, isTileflowBoundaryClass as cz, type TileflowMap as d, tileflowBathymetrySourceId as d0, tileflowBathymetryV1Schema as d1, tileflowBoundaryAreasV1Schema as d2, tileflowBoundaryClassTiers as d3, tileflowBoundaryClasses as d4, tileflowBoundaryFamilies as d5, tileflowDefaultSunPreset as d6, tileflowIconAppearanceSchema as d7, tileflowIconAuthorMetadataSchema as d8, tileflowIconCompositionMaximumBytes as d9, tileflowNauticalSourceId as dA, tileflowNauticalV1Schema as dB, tileflowPrimarySourceId as dC, tileflowRenderedIconIdentitySchema as dD, tileflowRingsOverlap as dE, tileflowStyleSunPreset as dF, tileflowSunDirection as dG, tileflowSunMetadataKey as dH, tileflowSunPosition as dI, tileflowThemeLimits as dJ, tileflowTreeForms as dK, tileflowTreeModelIdPattern as dL, tileflowTreeModelLimits as dM, tileflowVegetationMetadataKey as dN, tileflowWorld as dO, tileflowWorldGeneration as dP, tileflowWorldTileJsonUrl as dQ, tileflowWorldV1Schema as dR, transit as dS, validateTileflowCompiledIconCapabilities as dT, validateTileflowMap as dU, validateTileflowWorldV1Tilejson as dV, vectorTiles as dW, vegetation as dX, water as dY, tileflowIconCompositionSchema as da, tileflowIconMetadataFileName as db, tileflowIconSetIdSchema as dc, tileflowIconSetPackageIdSchema as dd, tileflowIconSetReferenceSchema as de, tileflowIconSetSourceSchema as df, tileflowIconSetTeamIdSchema as dg, tileflowIconSetVersionIdSchema as dh, tileflowIconSourceLimit as di, tileflowInsideRings as dj, tileflowLandformClasses as dk, tileflowLayerBands as dl, tileflowLocalDirectoryMaximumLength as dm, tileflowLocalDirectoryMessage as dn, tileflowMapIdSchema as dp, tileflowModelDefaultLightingRoles as dq, tileflowModelImageSize as dr, tileflowModelLightingRoles as ds, tileflowModelLimits as dt, tileflowModelParts as du, tileflowModelSurfaceLimits as dv, tileflowModelTextureChannels as dw, tileflowModelVertexBytes as dx, tileflowNauticalImageRoles as dy, tileflowNauticalNotice as dz, type TileflowStyleOptions as e, type TileflowInspectedStyle as f, type TileflowPreparedMapAssets as g, type TileflowDataCompatibilityIssue as h, type TileflowDataFieldRequirement as i, type TileflowDataFieldType as j, type TileflowDataLayerRequirement as k, type TileflowObservedDataContractV1 as l, type TileflowStyleInspection as m, type TileflowStyleInspectionContribution as n, type TileflowStyleInspectionLayer as o, type TileflowStyleInspectionRenderOperation as p, collectMapLineage as q, inferTileflowDataRequirements as r, inferTileflowSourceRequirements as s, tileflowStyleInspectionSchemaVersion as t, type TileflowBoundaryClass as u, validateTileflowDataCompatibility as v, type TileflowBoundaryClassTier as w, type TileflowBoundaryFamily as x, type TileflowOverlayPlacement as y, type TileflowMapLibreOverlay as z };