@tileflow/core 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/icon-composition-HUh_Lj8Z.d.ts

@@ -0,0 +1,2516 @@
+import { bd as TileflowThemeColorValue, r as TileflowSymbolStyle, D as TileflowAreaStyle, a1 as TileflowLineStackStyle, q as TileflowLineStyle, o as TileflowExtrusionStyle, bg as TileflowThemeNumberValue, bj as TileflowThemeValue, 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-DnhSJjCM.js';
+import * as zod from 'zod';
+import { z } from 'zod';
+import { T as TileflowCaptureScene, a as TileflowCaptureShot } from './capture-shot-ChPQvPyi.js';
+
+/** Optional globe atmosphere. Colors use theme tokens or explicit fixed values and must resolve to opaque colors. */
+type TileflowAtmosphereOptions = {
+    skyColor?: TileflowThemeColorValue;
+    horizonColor?: TileflowThemeColorValue;
+    fogColor?: TileflowThemeColorValue;
+    spaceColor?: TileflowThemeColorValue;
+    /** Star color. Default: #e0ebff. */
+    starColor?: TileflowThemeColorValue;
+    /** Stars per repeating 1600 × 1000 CSS-pixel area, integer 0–4096. Default: 1100. */
+    starCount?: number;
+    /** Star radius multiplier from 0 (hidden) to 4. Default: 1. */
+    starSize?: number;
+    /** Star brightness from 0 (hidden) to 1. Default: 0.6. */
+    starIntensity?: number;
+    /** Camera-relative star movement from 0 (still) to 1. Default: 0.4. */
+    starParallax?: number;
+};
+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;
+};
+type TileflowAddressesModuleConfig = TileflowAddressesModuleOptions & {
+    type: 'addresses';
+};
+declare function addresses(options?: TileflowAddressesModuleOptions): TileflowAddressesModuleConfig;
+
+type TileflowAerowaysModuleOptions = {
+    area?: TileflowAreaStyle;
+    runway?: TileflowLineStackStyle;
+    runwayRef?: TileflowSymbolStyle;
+    taxiway?: TileflowLineStackStyle;
+};
+type TileflowAerowaysModuleConfig = TileflowAerowaysModuleOptions & {
+    type: 'aeroways';
+};
+declare function aeroways(options?: TileflowAerowaysModuleOptions): TileflowAerowaysModuleConfig;
+
+type TileflowBoundariesModuleOptions = {
+    admin2?: TileflowLineStyle;
+    admin4?: TileflowLineStyle;
+    disputed?: TileflowLineStyle;
+    maritime?: TileflowLineStyle;
+};
+type TileflowBoundariesModuleConfig = TileflowBoundariesModuleOptions & {
+    type: 'boundaries';
+};
+declare function boundaries(options?: TileflowBoundariesModuleOptions): TileflowBoundariesModuleConfig;
+
+/** Decorative finishes for ordinary extruded buildings; they do not describe surveyed materials. */
+type TileflowBuildingSurfaces<Numeric = number, Size = readonly [number, number]> = {
+    walls?: {
+        kind: 'brick';
+        /** Brick width and course height in metres; defaults to [6, 3]. */
+        size?: Size;
+        /** Recessed joint width in metres; defaults to 0.12. */
+        jointWidth?: Numeric;
+        /** Strength of the shaded joints, from 0 to 1; defaults to 0.2. */
+        contrast?: Numeric;
+    };
+    roof?: {
+        kind: 'tiles';
+        /** Square size in projected Mercator metres; defaults to 8. */
+        size?: Numeric;
+        /** Joint width in projected Mercator metres; defaults to 0.12. */
+        jointWidth?: Numeric;
+        contrast?: Numeric;
+    };
+    /** A painted light band and seam at the roof edge, without adding geometry. */
+    cornice?: {
+        height?: Numeric;
+        contrast?: Numeric;
+    };
+};
+type TileflowBuildingSurfaceDesign = {
+    walls?: Required<NonNullable<TileflowBuildingSurfaces['walls']>>;
+    roof?: Required<NonNullable<TileflowBuildingSurfaces['roof']>>;
+    cornice?: Required<NonNullable<TileflowBuildingSurfaces['cornice']>>;
+};
+
+/** 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;
+    /** The part whose colour it takes, by name. */
+    part: string;
+}>;
+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 vertex's part, role and occlusion. */
+type TileflowModelSurface = Readonly<{
+    /** Eight floats per vertex: UV0, UV1 (zero to one), 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 architectural parts of a model. A map that gives one no colour of its own colours it from the
+ * buildings' colour, and a mesh that names no parts of its own numbers its vertices' parts in this
+ * order.
+ */
+declare const tileflowModelParts: Readonly<{
+    surface: 0;
+    secondary: 1;
+    glass: 2;
+    accent: 3;
+    roof: 4;
+}>;
+type TileflowModelPart = keyof typeof tileflowModelParts;
+/** The names of a mesh's parts when it names none of its own. */
+declare const tileflowModelArchitecturalPartNames: readonly ("accent" | "glass" | "roof" | "secondary" | "surface")[];
+/**
+ * Whether a value names a part of a model, as its material does: lower-case letters and digits,
+ * words joined by hyphens or underscores, at most 32 characters, such as `glass` or `water`.
+ */
+declare function isTileflowModelPartName(value: unknown): value is string;
+/** Architectural roles control lighting independently of the model's parts. */
+declare const tileflowModelLightingRoles: Readonly<{
+    unclassified: 0;
+    wall: 1;
+    door: 2;
+    roof: 3;
+    window: 4;
+    lamp: 5;
+    logo: 6;
+}>;
+type TileflowModelLightingRole = keyof typeof tileflowModelLightingRoles;
+/**
+ * The lighting role of a part whose material sets none: architectural parts are walls, a window
+ * and a roof; every other part is unclassified, so it never takes a window's light.
+ */
+declare function tileflowModelDefaultLightingRole(part: string): number;
+/** 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;
+    /** Differently named parts of one level. */
+    parts: 16;
+}>;
+/** 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, an index into `partNames`. */
+    parts: readonly number[];
+    /**
+     * The names of the level's parts, as its materials name them, such as `surface`, `glass` or
+     * `water`; without them, `tileflowModelArchitecturalPartNames`.
+     */
+    partNames?: readonly string[];
+    /** Optional architectural role per vertex; absent roles follow `tileflowModelDefaultLightingRole`. */
+    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 its lighting role (uint8).
+     */
+    vertices: Uint8Array;
+    /** The names of the parts the vertices' part indices count through. */
+    partNames: readonly string[];
+    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?: TileflowModelSurfaceBytes;
+}>;
+/**
+ * A decoded level's physical data. Its vertex attributes are split in two, each four floats a vertex
+ * or, when every vertex shares them, just four, so a value that never changes is not uploaded.
+ */
+type TileflowModelSurfaceBytes = Omit<TileflowModelSurface, 'attributes'> & Readonly<{
+    /** UV0 and UV1. */
+    uv: Float32Array;
+    /** Linear vertex RGBA. */
+    rgba: 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 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;
+    /** 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 model parts 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';
+        };
+    }>>;
+    /**
+     * The zoom bands the city comes in over: zooming in, across each band its part fades in and rises
+     * from the ground, and zooming out it sinks and fades again. Defaults to the 0.3 zooms from the
+     * renderer's `minzoom` (15) for the buildings, and to the 0.4 zooms from 0.8 before it for the
+     * placed models and landmarks, which stand first. With reduced motion they only fade.
+     */
+    entrance?: {
+        buildings?: readonly [number, number];
+        models?: readonly [number, number];
+    };
+    /** Contact shadow at the foot of the walls and in tight corners; defaults to true. */
+    occlusion?: boolean;
+    /** 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,
+     * barns, factories and churches, and homes lit apart from offices. Defaults to false.
+     */
+    windows?: boolean;
+    /** Decorative wall joints, roof tiles and painted cornices. Off by default; ordinary buildings only. */
+    surfaces?: TileflowBuildingSurfaces<TileflowThemeNumberValue, TileflowThemeValue<readonly [number, number]>>;
+    /**
+     * Building models the map places in its city, from the glTF binaries in its `models`
+     * directories. Each stands in for the buildings under its footprint.
+     */
+    models?: readonly TileflowBuildingModelPlacementConfig[];
+    /**
+     * The colours of the models' parts, by the names their materials give them, such as `glass` or
+     * `water`. A part the map gives no colour keeps its material's own.
+     */
+    modelColors?: Partial<Record<TileflowBuildingModelPart, TileflowThemeColorValue>>;
+    /**
+     * Tileflow's landmarks, such as the Eiffel Tower, drawn as models in place of the buildings
+     * under them. On by default with Tileflow World data; `false` switches them off, and `url` names
+     * the TileJSON of another landmarks tileset. The map's own `models` come first: a landmark with
+     * the same id as one, or whose footprint meets one's, is not drawn.
+     */
+    landmarks?: boolean | {
+        url: string;
+    };
+};
+/**
+ * A part of a building model, as its materials name it: lower-case words joined by hyphens or
+ * underscores, such as `surface`, `glass`, `roof` or `water`.
+ */
+type TileflowBuildingModelPart = string;
+/** Where a building model stands. */
+type TileflowBuildingModelPlacementConfig = {
+    /** The model's id: the name of its `.glb` file in the map's `models` directories. */
+    model: string;
+    /**
+     * The HTTPS address of the model's prepared file when it is served elsewhere, such as a model
+     * Tileflow hosts for its own maps; the map then needs no `.glb` of its own for it.
+     */
+    url?: string;
+    /** Longitude and latitude of the model's origin, where it stands on the ground. */
+    at: readonly [number, number];
+    /** Degrees clockwise from north that the model's own north (its +y) is turned to; defaults to 0. */
+    heading?: number;
+};
+type TileflowBuildingsModuleOptions = {
+    businessCorridor?: TileflowAreaStyle;
+    extrusion?: TileflowExtrusionStyle;
+    flat?: TileflowAreaStyle;
+    mode?: TileflowBuildingMode;
+    threeDimensional?: TileflowBuildingsThreeDimensionalStyle;
+};
+type TileflowBuildingsModuleConfig = TileflowBuildingsModuleOptions & {
+    type: 'buildings';
+};
+declare function buildings(options?: TileflowBuildingsModuleOptions): TileflowBuildingsModuleConfig;
+
+type TileflowLanduseClass = 'cemetery' | 'civic' | 'commercial' | 'education' | 'government' | 'industrial' | 'medical' | 'military' | 'parking' | 'railway' | 'recreation' | 'residential';
+type TileflowLandcoverClass = 'farmland' | 'flowerbed' | 'grass' | 'ice' | 'meadow' | 'protected' | 'recreationGround' | 'rock' | 'sand' | 'scrub' | 'urbanPark' | 'villageGreen' | 'wetland' | 'wood';
+/** 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>>;
+};
+type TileflowLandModuleConfig = TileflowLandModuleOptions & {
+    type: 'land';
+};
+declare function land(options?: TileflowLandModuleOptions): TileflowLandModuleConfig;
+
+declare const tileflowLandformClasses: readonly ["peak", "volcano", "saddle", "ridge", "cliff", "arete"];
+type TileflowLandformClass = (typeof tileflowLandformClasses)[number];
+type TileflowLandformsModuleOptions = {
+    classes?: Partial<Record<TileflowLandformClass, TileflowSymbolStyle>>;
+    /** Append source elevation in metres when the feature provides it. */
+    elevation?: boolean;
+};
+type TileflowLandformsModuleConfig = TileflowLandformsModuleOptions & {
+    type: 'landforms';
+};
+declare function landforms(options?: TileflowLandformsModuleOptions): TileflowLandformsModuleConfig;
+
+/**
+ * Labels anchored inside polygon features, and the clearance labels of bridges and overhead cables;
+ * other point-feature labels remain on their feature style.
+ */
+type TileflowNauticalAreaLabelStyles = {
+    /**
+     * Vertical clearance of bridges, or their clearance closed and open, at bridge points and inside
+     * bridge polygons; bridge lines carry it at their centre.
+     */
+    bridges?: TileflowSymbolStyle;
+    /** Provider coverage cells; hidden unless a map makes this style visible. */
+    coverage?: TileflowSymbolStyle;
+    hazards?: TileflowSymbolStyle;
+    navigationAreas?: TileflowSymbolStyle;
+    /** Safe vertical clearance of overhead cables, at cable points and along cable lines. */
+    overheadCables?: 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;
+    /**
+     * Flash each light in its rhythm where a browser runtime animates the map. Defaults to `true`.
+     * `false` keeps every light steady, as do reduced motion, capture, and native renderers.
+     */
+    animateLights?: boolean;
+    /** Fixed beacons and daymarks, coloured by their first colour. */
+    beacons?: TileflowMarkerSymbolStyle;
+    /** Berth polygons; the outline also strokes berth lines and emphasises guest berths. */
+    berths?: TileflowAreaStyle;
+    /** Bridge polygons; the outline also strokes bridge lines. */
+    bridges?: TileflowAreaStyle;
+    /** 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;
+    /** Waterway distance marks with their distance and unit. */
+    distanceMarks?: TileflowMarkerSymbolStyle;
+    /**
+     * Small-craft facilities such as fuel, water, slipways, pump-out, visitor berths, boat hoists,
+     * and boatyards, at facility points, inside facility polygons, and at the centre of their lines.
+     */
+    facilities?: TileflowMarkerSymbolStyle;
+    /** Harbour and marina polygons. */
+    harbourAreas?: TileflowAreaStyle;
+    /** Harbour and marina points, and their symbol and name inside harbour polygons. */
+    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;
+    /** Inland notice boards coloured by function, with the information they show. */
+    notices?: TileflowMarkerSymbolStyle;
+    /** Overhead cable lines. */
+    overheadCables?: TileflowLineStyle;
+    /** 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;
+};
+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";
+    }>;
+    distanceMarks: Readonly<{
+        default: "nautical.distance-mark";
+    }>;
+    /**
+     * A facility that lists several categories shows the first of `tileflowNauticalFacilityIcons`
+     * it lists; facilities without a variant token fall back to `nautical.facility`.
+     */
+    facilities: Readonly<{
+        'boat-hoist': "nautical.facility.boat-hoist";
+        boatyard: "nautical.facility.boatyard";
+        default: "nautical.facility";
+        'fuel-station': "nautical.facility.fuel-station";
+        'pump-out': "nautical.facility.pump-out";
+        slipway: "nautical.facility.slipway";
+        'visitor-berth': "nautical.facility.visitor-berth";
+        'water-tap': "nautical.facility.water-tap";
+    }>;
+    /** Harbours whose `subclass` lists a marina use `nautical.marina` when the theme declares it. */
+    harbours: Readonly<{
+        default: "nautical.harbour";
+        marina: "nautical.marina";
+    }>;
+    lighthouses: Readonly<{
+        default: "nautical.lighthouse";
+    }>;
+    lights: Readonly<{
+        default: "nautical.light";
+    }>;
+    /** Notice boards by function; a board without a variant token uses `nautical.notice`. */
+    notices: Readonly<{
+        default: "nautical.notice";
+        information: "nautical.notice.information";
+        prohibition: "nautical.notice.prohibition";
+        recommendation: "nautical.notice.recommendation";
+        regulation: "nautical.notice.regulation";
+        restriction: "nautical.notice.restriction";
+    }>;
+    ports: Readonly<{
+        default: "nautical.port";
+    }>;
+    wrecks: Readonly<{
+        default: "nautical.wreck";
+    }>;
+}>;
+/**
+ * Facility categories with their own icon, in the order that picks one for a facility listing
+ * several. `visitors-mooring` shares the visitor-berth icon.
+ */
+declare const tileflowNauticalFacilityIcons: readonly ["fuel-station", "slipway", "boat-hoist", "pump-out", "water-tap", "visitor-berth", "boatyard"];
+/** 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;
+
+/** Compiler-only state produced by semantic module operations during map resolution. */
+type TileflowResolvedModuleConfig<TModule extends {
+    type: string;
+}> = TModule & {
+    readonly enabled?: boolean;
+};
+
+type TileflowTransitModuleOptions = {
+    cableway?: TileflowLineStyle;
+    ferry?: TileflowLineStyle;
+    rail?: TileflowTransitRailStyle;
+    railHatching?: TileflowTransitRailStyle;
+    serviceRail?: TileflowTransitRailStyle;
+};
+type TileflowTransitRailStyle = {
+    bridge?: TileflowLineStyle;
+    surface?: TileflowLineStyle;
+    tunnel?: TileflowLineStyle;
+};
+type TileflowTransitModuleConfig = TileflowTransitModuleOptions & {
+    type: 'transit';
+};
+declare function transit(options?: TileflowTransitModuleOptions): TileflowTransitModuleConfig;
+
+/** What a map's tree models may hold. */
+declare const tileflowTreeModelLimits: Readonly<{
+    /** Triangles of a near model, the one drawn close to the camera. */
+    nearTriangles: 1000;
+    /** Triangles of a far model, drawn beyond the nearest tiles. */
+    farTriangles: 120;
+    /** Vertices of one model. */
+    vertices: 4096;
+    /** Models one map carries. */
+    models: 16;
+    /** Models one form draws from. */
+    perForm: 4;
+}>;
+/** A model as indexed triangles of a unit tree, before it is encoded. */
+type TileflowTreeModelMesh = Readonly<{
+    /** The model's crown width over its height, as its author drew it, from 0.1 to 3. */
+    proportion: number;
+    /** x, y and z of each vertex: x and y from about -0.5 to 0.5, z from 0 to 1. */
+    positions: readonly number[];
+    /** The vertex normals, x, y and z. */
+    normals: readonly number[];
+    /** Each vertex's part, a value of `tileflowTreeParts`. */
+    parts: readonly number[];
+    /** Each vertex's shade among its part's colours, from -1 (darkest) to 1. */
+    shades: readonly number[];
+    /** Each vertex's light, from 0 (fully occluded) to 1. */
+    occlusion: readonly number[];
+    /** Three vertex indices per triangle. */
+    indices: readonly number[];
+}>;
+/** A prepared model, near and optionally far, as the style's tree description carries it. */
+type TileflowTreeModel = Readonly<{
+    near: string;
+    far?: string;
+}>;
+/** Encodes a model as base64 text. Throws when it breaks `tileflowTreeModelLimits`. */
+declare function encodeTileflowTreeModel(mesh: TileflowTreeModelMesh, level: 'near' | 'far'): string;
+/**
+ * Decodes a model's base64 text, or undefined when it is not a tree model of this version or
+ * breaks `tileflowTreeModelLimits`.
+ */
+declare function decodeTileflowTreeModel(text: unknown, level: 'near' | 'far'): TileflowTreeModelMesh | undefined;
+
+/** The forms a 3D tree takes. */
+declare const tileflowTreeForms: readonly ["round", "open", "tall", "conifer", "columnar", "palm"];
+type TileflowTreeForm = (typeof tileflowTreeForms)[number];
+/** How a tree's surfaces take the light: facets, a smooth round shape, or bands as drawn. */
+declare const tileflowTreeFinishes: readonly ["faceted", "smooth", "toon"];
+type TileflowTreeFinish = (typeof tileflowTreeFinishes)[number];
+/** A form's own scales, on top of the map's, and the map's own models it draws. */
+type TileflowTreeFormStyle = Readonly<{
+    heightScale?: number;
+    crownScale?: number;
+    /** Ids of the map's own models, one to four; each tree draws one by its stable seed. */
+    models?: readonly string[];
+}>;
+/** Relative weights of the forms given to trees whose data gives none. */
+type TileflowTreeFormMix = Readonly<Partial<Record<TileflowTreeForm, number>>>;
+/** A region whose trees without a form in the data take their own mix. */
+type TileflowTreeRegion = Readonly<{
+    /** `[west, south, east, north]` in degrees. */
+    bounds: readonly [number, number, number, number];
+    unknownForms: TileflowTreeFormMix;
+}>;
+/** The fields of the tree and canopy layers, as World names them. */
+type TileflowTreeFields = Readonly<{
+    height: string;
+    diameterCrown: string;
+    circumference: string;
+    genus: string;
+    species: string;
+    leafType: string;
+    /** The tree's taxon at any rank, such as `Arecaceae` for palms or a genus or species. */
+    taxon: string;
+    canopyRank: string;
+    canopyClearance: string;
+    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;
+/** The style metadata key under which a compiled map describes its 3D trees. */
+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, the canopy points and the hedges. */
+    source: string;
+    layers: Readonly<{
+        tree: string;
+        canopy?: string;
+        hedge?: string;
+    }>;
+    fields: TileflowTreeFields;
+    /**
+     * 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;
+    /** Visual size floor in metres, after scaling; crowns keep their proportions. */
+    minimumHeight?: number;
+    /** Stable variation across trunks and within the theme's foliage palette. */
+    materialVariation?: number;
+    /** Each form's own scales and models. */
+    forms: Readonly<Partial<Record<TileflowTreeForm, TileflowTreeFormStyle>>>;
+    /** The map's own models its forms draw, by id, prepared from its `models` directories. */
+    models: Readonly<Record<string, TileflowTreeModel>>;
+    finish: TileflowTreeFinish;
+    /** How strongly an outline rings each tree, from 0 (none) to 1, and its colour. */
+    edges: number;
+    edgeColor?: string;
+    unknownForms: TileflowTreeFormMix;
+    regions: readonly TileflowTreeRegion[];
+    /** The style's layers that draw the trees flat, which the 3D trees stand in for while shown. */
+    flatLayers: readonly string[];
+}>;
+/**
+ * Reads the 3D trees a compiled style describes, or undefined when its metadata has none or holds
+ * a version or shape this Core does not know.
+ */
+declare function readTileflowVegetation3D(metadata: unknown): TileflowVegetation3D | undefined;
+
+type TileflowVegetationMode = '3d' | 'flat' | 'auto';
+type TileflowVegetationThreeDimensionalStyle = {
+    barkColor?: TileflowThemeColorValue;
+    /** Sunlit leaf colours of broadleaf trees, from darkest to lightest; up to four are used. */
+    broadleafColors?: readonly TileflowThemeColorValue[];
+    /** Sunlit needle colours of conifers and columns, from darkest to lightest. */
+    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;
+    /** Visual minimum height in metres (0–20); smaller trees grow proportionally, including crowns. Default 0 preserves measured sizes. */
+    minimumHeight?: TileflowThemeNumberValue;
+    /** Variation within the authored foliage palette and between trunks, from 0 (default) to 1. */
+    materialVariation?: TileflowThemeNumberValue;
+    /**
+     * How trees take the light: `faceted` (the default), low-poly facets softened towards a round
+     * crown; `smooth`, round crowns; or `toon`, three bands of light and a crisp shadow, as a drawn
+     * tree has them.
+     */
+    finish?: TileflowTreeFinish;
+    /** How strongly an outline rings each tree, from 0 (none, the default) to 1. */
+    edges?: TileflowThemeNumberValue;
+    /** The outline's colour; the crown's darkest colour, deepened, by default. */
+    edgeColor?: TileflowThemeColorValue;
+    /**
+     * Each form's own scales, on top of `heightScale` and `crownScale`, such as taller palms, and the
+     * map's own models it draws: ids of `.glb` files in the map's `models` directories, one to four,
+     * each tree drawing one. A model's materials named `bark`, `leaves`, `fronds` or `stem` take
+     * those parts' colours.
+     */
+    forms?: Partial<Record<TileflowTreeForm, {
+        heightScale?: TileflowThemeNumberValue;
+        crownScale?: TileflowThemeNumberValue;
+        models?: readonly string[];
+    }>>;
+    /**
+     * The forms of trees whose data gives none, as relative weights: `round`, `open` and `tall`
+     * (broadleaf), `conifer`, `columnar` and `palm`. Each tree draws one from a stable hash, so it
+     * keeps its form everywhere. Defaults to the three broadleaf forms, evenly. A tree the data calls
+     * broadleaved keeps to the broadleaf forms of the mix.
+     */
+    unknownForms?: TileflowTreeFormMix;
+    /**
+     * Regions whose trees without a form in the data take their own mix, such as palms along a
+     * subtropical coast. Bounds are `[west, south, east, north]` in degrees; the first region holding
+     * a tree applies. At most 16.
+     */
+    regions?: readonly TileflowTreeRegion[];
+};
+type TileflowVegetationModuleOptions = {
+    flat?: TileflowCircleStyle;
+    /** `3d` uses models at every pitch; `auto` follows the runtime's explicit 2D/3D view mode. */
+    mode?: TileflowVegetationMode;
+    /** Representation when a renderer cannot draw models. Defaults to `flat`. */
+    fallback?: 'flat' | 'none';
+    /** Initial visibility; a runtime control may override it. Defaults to true. */
+    visible?: boolean;
+    threeDimensional?: TileflowVegetationThreeDimensionalStyle;
+};
+type TileflowVegetationModuleConfig = TileflowVegetationModuleOptions & {
+    type: 'vegetation';
+};
+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. */
+    bathymetryContours?: TileflowLineStyle;
+    /** Contour-depth or legacy band-floor labels, not measured survey soundings. */
+    bathymetryLabels?: TileflowSymbolStyle;
+    /** Names from an explicitly declared seafloor_landform layer. */
+    bathymetryLandforms?: TileflowBathymetryNameStyle;
+    /** Names from an explicitly declared water_name layer. */
+    bathymetryWaterNames?: TileflowBathymetryNameStyle;
+    bodies?: TileflowAreaStyle;
+    intermittent?: {
+        bodies?: TileflowAreaStyle;
+        waterways?: TileflowLineStyle;
+    };
+    waterways?: Partial<Record<TileflowWaterwayClass, TileflowLineStyle>>;
+};
+type TileflowWaterModuleConfig = TileflowWaterModuleOptions & {
+    type: 'water';
+};
+declare function water(options?: TileflowWaterModuleOptions): TileflowWaterModuleConfig;
+
+declare const tileflowWorldGeneration: "v1";
+/** Mutable discovery selector. The server resolves it once to an immutable release in TileJSON. */
+declare const tileflowWorldTileJsonUrl: "https://api.tileflow.dev/tiles/world/tiles.json";
+
+declare const tileflowPrimarySourceId = "tileflow";
+declare const openMapTilesContractVersion = 1;
+type ParkLayerSemantics = 'mixed' | 'protected-only';
+type OpenMapTilesLayerBindings = {
+    aerodromeLabel: string;
+    aeroway: string;
+    boundary: string;
+    building: string;
+    /** Required low-zoom GEBCO extension in the Tileflow World V1 schema. */
+    bathymetry?: string;
+    /** Optional derived commercial-activity polygons rendered below buildings. */
+    businessCorridor?: string;
+    /**
+     * Optional decorative points inside parks and gardens, where measured tree canopy covers the
+     * ground. Each point tells how much room a drawn grove of tree crowns has. The points are not
+     * surveyed trees and are unrelated to `tree`.
+     */
+    canopy?: string;
+    /** Optional generated circle centers used for detailed roundabout rendering. */
+    circularFeature?: string;
+    /** Optional low-zoom global land-cover extension. Defaults to `globallandcover`. */
+    globalLandcover?: string;
+    houseNumber: string;
+    landcover: string;
+    landuse: string;
+    mountainPeak: string;
+    park: string;
+    place: string;
+    poi: string;
+    road: string;
+    roadName: string;
+    /** Optional generalized low-zoom route-shield points. Required by Tileflow World V1. */
+    roadShield?: string;
+    /** Optional detailed pedestrian-surface polygons. */
+    sidewalk?: string;
+    /** Optional point features such as pedestrian crossings. */
+    streetFurniture?: string;
+    /**
+     * Optional 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;
+    /**
+     * Optional outer boundaries of `road` areas, as lines. When bound, area outlines are drawn from
+     * it, so the holes of an area (tree pits, planting beds) are never stroked.
+     */
+    transportationOutline?: string;
+    water: string;
+    waterName: string;
+    waterway: string;
+};
+type OpenMapTilesFieldBindings = {
+    access: string;
+    activityScore: string;
+    adminLevel: string;
+    bicycle: string;
+    /** GEBCO depth-band upper boundary in metres. */
+    bathymetryMinDepth?: string;
+    /** Stable shallow-to-deep ordering for GEBCO bands. */
+    bathymetrySortKey?: string;
+    brunnel: string;
+    buildingTone: string;
+    /**
+     * Lower bound of the distance from a canopy point to the nearest edge a crown must not cover,
+     * in pixels of a 512-pixel tile at zoom 15: one of 4, 6, 8, 12, 16, or 24. A grove fits at zoom
+     * `z` when its reach in screen pixels is at most this value × 2^(z − 15).
+     */
+    canopyClearanceAtZoom15: string;
+    /**
+     * Lower bound, in percent, of canopy taller than 3 m within 10 m of a canopy point: 3, 30, or
+     * 60. Absent where no measurement exists; treat absence as a middle density.
+     */
+    canopyCoverPercent: string;
+    /** Stable integer from 0 through 15 per canopy point. Lower ranks appear first by zoom. */
+    canopyRank: string;
+    capital: string;
+    /** Roundabout geometry kind in the optional circular-feature layer. */
+    circularKind: string;
+    /** Precomputed roundabout radius in pixels at zoom 15. */
+    circularRadiusAtZoom15: string;
+    /** Extra precomputed clearance on road approaches to a circular road at zoom 15. */
+    circularClearanceExtraAtZoom15: string;
+    /** Roundabout radius in metres. */
+    circularRadiusMeters: string;
+    /** Roundabout inner radius in metres. */
+    circularInnerRadiusMeters: string;
+    /** Roundabout outer radius in metres. */
+    circularOuterRadiusMeters: string;
+    class: string;
+    /** Crossing control classification on street-furniture points. */
+    crossing: string;
+    circumference: string;
+    confidence: string;
+    diameterCrown: string;
+    disputed: string;
+    /** Direction in degrees for oriented street-furniture symbols. */
+    direction: string;
+    elevation: string;
+    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. */
+    hasParts: string;
+    horse: string;
+    houseNumber: string;
+    /** Sparse 1–4 semantic and locally normalized urban-importance tier. */
+    importanceTier: string;
+    iata: string;
+    icao: string;
+    indoor: string;
+    intermittent: string;
+    genus: string;
+    layer: string;
+    leafCycle: string;
+    leafType: string;
+    level: string;
+    maritime: string;
+    /** Physical crossing-marking classification on street-furniture points. */
+    markings: string;
+    minHeight: string;
+    minZoom: string;
+    /**
+     * Transport mode of World transit POIs and lines: `subway`, `train`, `light_rail`, `tram`,
+     * `monorail`, `funicular`, `bus`, `ferry` or `aerialway`.
+     */
+    mode: string;
+    mtbScale: string;
+    name: string;
+    nameEnglish: string;
+    nameLatin: string;
+    network: string;
+    official: string;
+    oneway: string;
+    /** Canonical editorial POI category. Never aliases OpenMapTiles `class`. */
+    poiCategory: string;
+    /** Per-zoom POI density tier from 0 (most selective) through 5. */
+    poiFilterRank: string;
+    /** Producer-selected POI icon key. */
+    poiIcon: string;
+    /** Physical-size tier from 0 (largest) through 16 (point-sized). */
+    poiSizeRank: string;
+    /** Canonical specific POI type. Never aliases OpenMapTiles `subclass`. */
+    poiType: string;
+    ramp: string;
+    rank: string;
+    ref: string;
+    refLength: string;
+    renderHeight: string;
+    renderMinHeight: string;
+    /** Optional producer-normalized route-shield family. Required by Tileflow World V1. */
+    shieldKind?: string;
+    /** Optional merged line length used to bound detailed route-shield repetition. */
+    shieldLineLengthMeters?: string;
+    /** Optional producer-normalized route network identifier. */
+    shieldNetwork?: string;
+    /** Optional producer-normalized route-shield collision rank. */
+    shieldRank?: string;
+    /** Optional producer-normalized route-shield text. */
+    shieldText?: string;
+    /** Optional producer-normalized route-shield ink role. Required by Tileflow World V1. */
+    shieldTextColor?: string;
+    service: string;
+    species: string;
+    speciesWikidata: string;
+    subclass: string;
+    surface: string;
+    toll: string;
+};
+type OpenMapTilesSchemaOptions = {
+    capabilities?: {
+        businessCorridor?: boolean;
+        bathymetry?: boolean;
+        canopy?: boolean;
+        globalLandcover?: boolean;
+        tree?: boolean;
+    };
+    fields?: Partial<OpenMapTilesFieldBindings>;
+    layers?: Partial<OpenMapTilesLayerBindings>;
+    semantics?: {
+        /** Whether the bound park layer mixes ordinary parks with protected areas. */
+        parkLayer?: ParkLayerSemantics;
+    };
+};
+type OpenMapTilesSchema = {
+    type: 'openmaptiles';
+    contractVersion: typeof openMapTilesContractVersion;
+    fields: OpenMapTilesFieldBindings;
+    layers: OpenMapTilesLayerBindings;
+    semantics: {
+        parkLayer: ParkLayerSemantics;
+    };
+};
+type TileflowWorldV1Schema = Omit<OpenMapTilesSchema, 'fields' | 'layers'> & {
+    fields: OpenMapTilesFieldBindings & {
+        bathymetryMinDepth: string;
+        bathymetrySortKey: string;
+        hedge: string;
+        shieldKind: string;
+        shieldLineLengthMeters: string;
+        shieldNetwork: string;
+        shieldRank: string;
+        shieldText: string;
+        shieldTextColor: string;
+    };
+    layers: OpenMapTilesLayerBindings & {
+        bathymetry: string;
+        circularFeature: string;
+        globalLandcover: string;
+        sidewalk: string;
+        streetFurniture: string;
+        roadShield: string;
+        trafficControl: string;
+        transportationOutline: string;
+    };
+};
+type TileflowWorldReleaseReference = Readonly<{
+    descriptorSha256: string;
+    releaseId: string;
+}>;
+type TileflowWorldSelection = Readonly<{
+    kind: 'current';
+    product: 'world-v1';
+}> | Readonly<{
+    kind: 'release';
+    product: 'world-v1';
+    release: TileflowWorldReleaseReference;
+}>;
+type TileflowWorldData = {
+    generation: typeof tileflowWorldGeneration;
+    selection: TileflowWorldSelection;
+    type: 'tileflow-world';
+};
+type VectorTilesDataCommon = {
+    type: 'vector-tiles';
+    attribution: string;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+};
+type VectorTilesData = VectorTilesDataCommon & ({
+    bounds?: never;
+    maxzoom?: never;
+    minzoom?: never;
+    tiles?: never;
+    url: string;
+} | {
+    bounds?: [number, number, number, number];
+    maxzoom?: number;
+    minzoom?: number;
+    tiles: [string, ...string[]];
+    url?: never;
+});
+type TileflowDataConfig = TileflowWorldData | VectorTilesData;
+type TileflowDataIdentity = {
+    bindings?: {
+        fields: OpenMapTilesFieldBindings;
+        layers: OpenMapTilesLayerBindings;
+    };
+    capabilities?: {
+        businessCorridor: boolean;
+        bathymetry: boolean;
+        canopy: boolean;
+        globalLandcover: boolean;
+        tree: boolean;
+    };
+    generation?: typeof tileflowWorldGeneration;
+    kind: TileflowDataConfig['type'];
+    /** External fixture identity. */
+    revision?: string;
+    schema: OpenMapTilesSchema['type'];
+    schemaVersion: number;
+    semantics: OpenMapTilesSchema['semantics'];
+    sourceId: typeof tileflowPrimarySourceId;
+    url?: string;
+    worldSelection?: TileflowWorldSelection;
+};
+type ResolvedTileflowData = {
+    attribution: string;
+    bounds?: [number, number, number, number];
+    generation?: typeof tileflowWorldGeneration;
+    identity: TileflowDataIdentity;
+    kind: TileflowDataConfig['type'];
+    maxzoom?: number;
+    minzoom?: number;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+    sourceId: typeof tileflowPrimarySourceId;
+    tiles?: string[];
+    url?: string;
+};
+declare function openMapTiles(options?: OpenMapTilesSchemaOptions): OpenMapTilesSchema;
+/** OpenMapTiles plus the required typed extensions emitted by Tileflow World V1. */
+declare function tileflowWorldV1Schema(options?: OpenMapTilesSchemaOptions): TileflowWorldV1Schema;
+declare function validateTileflowWorldV1Tilejson(tilejson: {
+    vector_layers?: readonly unknown[];
+} | null | undefined, schema?: TileflowWorldV1Schema): string[];
+declare function tileflowWorld(options?: {
+    release?: TileflowWorldReleaseReference;
+}): TileflowWorldData;
+declare function vectorTiles(options: {
+    attribution: string;
+    bounds?: [number, number, number, number];
+    maxzoom?: number;
+    minzoom?: number;
+    revision?: string;
+    schema: OpenMapTilesSchema;
+    tiles?: readonly [string, ...string[]];
+    url?: string;
+}): VectorTilesData;
+declare function resolveTileflowData(data: TileflowDataConfig | undefined, options?: {
+    apiBaseUrl?: string;
+}): ResolvedTileflowData;
+declare function isCanonicalOpenMapTilesSchema(schema: OpenMapTilesSchema): boolean;
+
+declare const tileflowBathymetrySourceId: "tileflow-bathymetry";
+declare const tileflowBathymetryDemSourceId: "tileflow-bathymetry-dem";
+declare const tileflowNauticalSourceId: "tileflow-nautical";
+declare const tileflowBathymetryV1Schema: Readonly<{
+    fields: Readonly<{
+        class: "class";
+        depth: "depth";
+        id: "id";
+        maxZoom: "max_zoom";
+        minDepth: "min_depth";
+        minZoom: "min_zoom";
+        name: "name";
+        sortKey: "sort_key";
+    }>;
+    layer: "bathymetry";
+    layers: Readonly<{
+        bands: "bathymetry";
+        contours: "bathymetry_contour";
+        coverage: "bathymetry_coverage";
+        landforms: "seafloor_landform";
+        waterNames: "water_name";
+    }>;
+    optionalLayers: readonly ["contours", "coverage", "landforms", "waterNames"];
+    product: "bathymetry-v1";
+    requiredLayers: readonly ["bands"];
+    schemaVersion: 1;
+    sources: Readonly<{
+        dem: Readonly<{
+            encoding: "terrarium";
+            sourceId: "tileflow-bathymetry-dem";
+            tileSize: 512;
+        }>;
+        vector: Readonly<{
+            sourceId: "tileflow-bathymetry";
+        }>;
+    }>;
+}>;
+/**
+ * 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`. A light's `sequence` lists its
+ * phases in seconds, eclipses in parentheses, for example `0.5+(1.5)+0.5+(4.5)`. Clearances,
+ * depths, and heights are in metres.
+ */
+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";
+        distance: "distance";
+        distanceUnit: "distance_unit";
+        edition: "edition";
+        families: "families";
+        group: "group";
+        heightM: "height_m";
+        horizontalClearance: "horizontal_clearance";
+        impact: "impact";
+        information: "information";
+        label: "label";
+        licence: "licence";
+        lit: "lit";
+        minZoom: "min_zoom";
+        name: "name";
+        orientation: "orientation";
+        periodS: "period_s";
+        position: "position";
+        provenance: "provenance";
+        provider: "provider";
+        rangeNm: "range_nm";
+        rank: "rank";
+        reference: "reference";
+        restriction: "restriction";
+        scale: "scale";
+        sectorEnd: "sector_end";
+        sectorStart: "sector_start";
+        sequence: "sequence";
+        shape: "shape";
+        size: "size";
+        subclass: "subclass";
+        system: "system";
+        topmark: "topmark";
+        unlocode: "unlocode";
+        update: "update";
+        verticalClearance: "vertical_clearance";
+        verticalClearanceClosed: "vertical_clearance_closed";
+        verticalClearanceOpen: "vertical_clearance_open";
+        verticalClearanceSafe: "vertical_clearance_safe";
+        waterLevel: "water_level";
+    }>;
+    geometryTypes: Readonly<{
+        aids: readonly ["Point"];
+        coverage: readonly ["Polygon"];
+        hazards: readonly ["Point", "LineString", "Polygon"];
+        lights: readonly ["Point"];
+        navigationAreas: readonly ["Point", "LineString", "Polygon"];
+        reefs: readonly ["Polygon"];
+        soundings: readonly ["Point"];
+        wrecks: readonly ["Point", "Polygon"];
+    }>;
+    layers: Readonly<{
+        aids: "aid";
+        coverage: "coverage";
+        hazards: "hazard";
+        lights: "light";
+        navigationAreas: "navigation_area";
+        reefs: "reef";
+        soundings: "sounding";
+        wrecks: "wreck";
+    }>;
+    product: "nautical-v1";
+    /**
+     * Known `provider` values and the `class` of their `coverage` cells. The source's TileJSON owns
+     * each provider's credit; the module never adds attribution.
+     */
+    providers: Readonly<{
+        'nga-list-of-lights': "list";
+        'noaa-office-of-coast-survey': "chart";
+        openstreetmap: "community";
+        'usace-ienc': "chart";
+    }>;
+    schemaVersion: 1;
+}>;
+type TileflowMarineMode = 'none' | 'bathymetry' | 'nautical' | 'chart';
+/** One schema-compatible vector TileJSON source used by a marine sidecar. */
+type TileflowMarineSourceConfig = {
+    attribution?: string;
+    sourceId?: string;
+    url?: string;
+};
+type TileflowBathymetryDisplay = 'bands' | 'relief' | 'hybrid';
+declare const tileflowBathymetryNameLayerLimits: Readonly<{
+    maxZoomRanges: 128;
+}>;
+/** One exact, inclusive minimum and exclusive maximum nominal source range. */
+type TileflowBathymetryNameZoomRange = Readonly<{
+    minZoom: number;
+    maxZoom: number;
+}>;
+/** Exhaustive source range inventory; unmatched pairs are omitted from rendering. */
+type TileflowBathymetryNameLayer = boolean | {
+    zoomRanges: readonly TileflowBathymetryNameZoomRange[];
+};
+/** Explicit availability of compatible optional vector layers; compilation never probes TileJSON. */
+type TileflowBathymetryVectorLayers = {
+    contours?: boolean;
+    landforms?: TileflowBathymetryNameLayer;
+    waterNames?: TileflowBathymetryNameLayer;
+};
+/**
+ * Styling and physical-source overrides for the optional Bathymetry DEM.
+ * Terrarium and 512 px tiles are the hosted defaults; advanced compatible sources may override
+ * either. `opacity` applies to both the continuous color relief and the hillshade tint.
+ */
+type TileflowBathymetryReliefConfig = TileflowTerrainHillshadeStyle & {
+    attribution?: string;
+    encoding?: TileflowTerrainEncoding;
+    illuminationAltitude?: TileflowThemeNumberValue;
+    multidirectional?: boolean;
+    opacity?: TileflowThemeNumberValue;
+    sourceId?: string;
+    tileSize?: 256 | 512;
+    url?: string;
+};
+/** One logical Bathymetry product backed by vector bands and, when requested, a DEM. */
+type TileflowBathymetryConfig = TileflowMarineSourceConfig & {
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display?: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: false | TileflowBathymetryReliefConfig;
+    type: 'bathymetry';
+    vectorLayers?: TileflowBathymetryVectorLayers;
+};
+type TileflowBathymetryOptions = Omit<TileflowBathymetryConfig, 'type'>;
+/** Configure Bathymetry as one product while loading only the physical sources its display needs. */
+declare function bathymetry(options?: TileflowBathymetryOptions): TileflowBathymetryConfig;
+/**
+ * Advanced marine selection. An omitted member selects Tileflow's current product; `false`
+ * disables only that member. Therefore `{}` is equivalent to `"chart"`.
+ */
+type TileflowMarineConfig = {
+    bathymetry?: false | TileflowBathymetryConfig | TileflowMarineSourceConfig;
+    nautical?: false | TileflowMarineSourceConfig;
+};
+type TileflowMarine = TileflowMarineMode | TileflowMarineConfig;
+type TileflowMarineSourceIdentity = Readonly<{
+    kind: 'tileflow-bathymetry' | 'tileflow-nautical';
+    product: 'bathymetry-v1' | 'nautical-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    url: string;
+}>;
+type TileflowBathymetryDemSourceIdentity = Readonly<{
+    encoding: TileflowTerrainEncoding;
+    kind: 'tileflow-bathymetry-dem';
+    product: 'bathymetry-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    tileSize: 256 | 512;
+    url: string;
+}>;
+type ResolvedMarineSource = Readonly<{
+    identity: TileflowMarineSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        type: 'vector';
+        url: string;
+    }>;
+    sourceId: string;
+}>;
+type ResolvedBathymetryRelief = Readonly<{
+    identity: TileflowBathymetryDemSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        encoding: TileflowTerrainEncoding;
+        tileSize: 256 | 512;
+        type: 'raster-dem';
+        url: string;
+    }>;
+    sourceId: string;
+    style: TileflowBathymetryReliefConfig;
+}>;
+type ResolvedBathymetry = Readonly<{
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: ResolvedBathymetryRelief;
+    vector?: ResolvedMarineSource;
+    vectorLayers?: TileflowBathymetryVectorLayers;
+}>;
+type ResolvedMarine = Readonly<{
+    bathymetry?: ResolvedBathymetry;
+    nautical?: ResolvedMarineSource;
+}>;
+/** Resolve the optional marine sidecars without fetching their TileJSON documents. */
+declare function resolveMarine(marine: TileflowMarine | undefined, apiBaseUrl?: string): ResolvedMarine | undefined;
+/**
+ * Feature IDs the Nautical source promotes for MapLibre feature state: each light's unique
+ * `provenance`, which is what animated lights are keyed by.
+ */
+declare const tileflowNauticalPromoteId: Readonly<{
+    light: "provenance";
+}>;
+
+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<{
+    /** 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;
+/**
+ * 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 TileflowVisualValueCategory = 'color' | 'font' | 'image' | 'number';
+/** Return the semantic theme category for one visual property, or undefined for structure/data. */
+declare function classifyTileflowVisualProperty(property: string, _value?: unknown): TileflowVisualValueCategory | undefined;
+
+type TileflowThemeColorScheme = 'dark' | 'light';
+type TileflowThemeName = string;
+declare const tileflowThemeLimits: Readonly<{
+    readonly maxThemes: 64;
+}>;
+type TileflowThemeTokens = {
+    color: Readonly<Record<string, TileflowThemeColorValue>>;
+    font: Readonly<Record<string, TileflowThemeFontValue>>;
+    image: Readonly<Record<string, TileflowThemeImageValue>>;
+    number: Readonly<Record<string, TileflowThemeNumberValue>>;
+};
+type TileflowThemeTypographyStyle = {
+    fallbacks?: readonly TileflowThemeFontValue[];
+    font?: TileflowThemeFontValue;
+    letterSpacing?: TileflowThemeNumberValue;
+    transform?: TileflowTypographyStyle['transform'];
+};
+type TileflowThemeTypography = TileflowThemeTypographyStyle & {
+    places?: TileflowThemeTypographyStyle;
+    poi?: TileflowThemeTypographyStyle;
+    roads?: TileflowThemeTypographyStyle;
+    water?: TileflowThemeTypographyStyle;
+};
+/**
+ * The theme's sun: where it stands and the light it gives, as a light preset for the theme. A
+ * theme for the evening sets a low sun in the west in warm light; one for the night, a moon with
+ * faint shadows. Unset values take the defaults in `tileflowDefaultSunPreset`.
+ */
+type TileflowThemeSun = {
+    /** Degrees clockwise from north. */
+    azimuth?: TileflowThemeNumberValue;
+    /** Degrees above the horizon, from -90 to 90; a sun below the horizon lights nothing. */
+    altitude?: TileflowThemeNumberValue;
+    /** The direct light's colour. */
+    color?: TileflowThemeColorValue;
+    /** The direct light's strength, from 0 to 1. */
+    intensity?: TileflowThemeNumberValue;
+    /** How dark the shadows the sun casts fall, from 0 (none) to 1. */
+    shadowIntensity?: TileflowThemeNumberValue;
+};
+/** The light from the sky, which reaches every surface and fills the shadows. */
+type TileflowThemeAmbient = {
+    color?: TileflowThemeColorValue;
+    /** From 0 to 1. */
+    intensity?: TileflowThemeNumberValue;
+};
+/**
+ * How the theme lights the map. `anchor`, `color`, `intensity`, and `position` are MapLibre's light,
+ * which shades 3D extrusions. `sun` and `ambient` describe the theme's sun and sky light for 3D
+ * scenes (`themeController.getSun()`); with a `sun`, the map's light is anchored to the map and
+ * points from the sun, and `anchor` and the direction in `position` no longer apply.
+ */
+type TileflowThemeLighting = {
+    anchor?: 'map' | 'viewport';
+    ambient?: TileflowThemeAmbient;
+    color?: TileflowThemeColorValue;
+    intensity?: TileflowThemeNumberValue;
+    position?: readonly [
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue
+    ];
+    sun?: TileflowThemeSun;
+};
+/** A complete, inheritance-free appearance document. */
+type TileflowTheme = {
+    colorScheme: TileflowThemeColorScheme;
+    id: string;
+    lighting: TileflowThemeLighting;
+    tokens: TileflowThemeTokens;
+    typography: TileflowThemeTypography;
+    version: number;
+};
+type TileflowThemeTokenOverrides = {
+    [TCategory in keyof TileflowThemeTokens]?: Readonly<Partial<TileflowThemeTokens[TCategory]>>;
+};
+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'> & {
+    /** Refine inherited light, or use reset() to remove all or one direct lighting property. */
+    lighting?: TileflowThemeLightingOverrides | TileflowReset;
+    tokens?: TileflowThemeTokenOverrides;
+    typography?: TileflowThemeTypography;
+};
+type ResolvedTileflowThemeTokens = {
+    color: Readonly<Record<string, string>>;
+    font: Readonly<Record<string, string>>;
+    image: Readonly<Record<string, string>>;
+    number: Readonly<Record<string, number>>;
+};
+type ResolvedTileflowTheme = Omit<TileflowTheme, 'lighting' | 'tokens' | 'typography'> & {
+    /** MapLibre's light; with a sun, anchored to the map and pointing from it. */
+    lighting: TileflowLight;
+    /** The theme's sun and sky light, when the theme describes either. */
+    sun?: TileflowSunPreset;
+    tokens: ResolvedTileflowThemeTokens;
+    typography: ResolvedTileflowTypography;
+};
+type TileflowResolvedThemeSelection = {
+    name: TileflowThemeName;
+    theme: TileflowTheme;
+};
+type TileflowThemeAuditScope = 'module' | 'terrain' | 'value';
+type TileflowThemeAuditContext = {
+    owner?: string;
+    scope: TileflowThemeAuditScope;
+    target?: string;
+};
+type TileflowThemeAuditDiagnostic = {
+    category: TileflowVisualValueCategory;
+    code: 'THEME_IMPLICIT_FIXED';
+    message: string;
+    owner?: string;
+    path: string;
+    phase: 'theme-audit';
+    scope: TileflowThemeAuditScope;
+    severity: 'error' | 'warning';
+    suggestion: string;
+    target?: string;
+    value: number | string;
+};
+/** A deterministic, machine-readable failure for blocking theme-audit diagnostics. */
+declare class TileflowThemeAuditError extends Error {
+    readonly diagnostics: readonly TileflowThemeAuditDiagnostic[];
+    constructor(diagnostics: readonly TileflowThemeAuditDiagnostic[]);
+}
+declare function defineTheme(definition: TileflowThemeDefinition): TileflowTheme;
+declare function defineTheme(base: TileflowTheme, definition: TileflowThemeDefinition): TileflowTheme;
+declare function resolveTileflowTheme(theme: TileflowTheme): ResolvedTileflowTheme;
+/** Resolve every theme node in modules, terrain, zoom values and expression arrays. */
+declare function resolveThemeValues<T>(value: T, theme: TileflowTheme, path?: string): T;
+/** Select an explicit theme or the map's deterministic default. Browser "system" is external. */
+declare function resolveThemeSelection(map: {
+    defaultTheme: string;
+    themes: Readonly<Record<string, TileflowTheme>>;
+    timeOfDay?: TileflowTimeOfDayVariants;
+}, requested?: string, timeOfDay?: TileflowTimeOfDay): TileflowResolvedThemeSelection;
+/** Find visual literals whose permanence is otherwise invisible to an agent. */
+declare function auditTileflowThemeValues(value: unknown, path?: string, context?: TileflowThemeAuditContext): TileflowThemeAuditDiagnostic[];
+/** Audit every appearance-bearing branch of a resolved map. */
+declare function auditTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): TileflowThemeAuditDiagnostic[];
+/** Fail closed when a map contains implicit chromatic, font, or image literals. */
+declare function assertTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): void;
+
+type TileflowLayerDomain = TileflowSemanticModuleName | 'terrain';
+
+declare const tileflowLayerSlots: readonly ["background", "land", "terrain", "hydro", "building-areas", "transport-areas", "transport-tunnel-shadow", "transport-tunnel-casing", "transport-tunnel-fill", "transport-pedestrian-areas", "aeroways", "transport-surface-shadow", "transport-surface-casing", "transport-surface-fill", "transport-bridge-shadow", "transport-bridge-casing", "transport-bridge-fill", "transport-symbols", "boundaries", "buildings", "vegetation", "symbols"];
+type TileflowLayerSlot = (typeof tileflowLayerSlots)[number];
+/**
+ * Public paint bands: stable names for consecutive compiler slots. Render passes, target
+ * placements and overlays address band edges instead of physical slots.
+ */
+declare const tileflowLayerBands: readonly ["land", "relief", "water", "roads", "boundaries", "buildings", "vegetation", "labels"];
+type TileflowLayerBand = (typeof tileflowLayerBands)[number];
+/** A band edge: `below-roads` is the start of the roads band, `above-roads` its end. */
+type TileflowBandPlacement = `${'above' | 'below'}-${TileflowLayerBand}`;
+declare const tileflowBandPlacements: readonly TileflowBandPlacement[];
+
+type TileflowSemanticModules = {
+    addresses?: TileflowAddressesModuleConfig;
+    aeroways?: TileflowAerowaysModuleConfig;
+    boundaries?: TileflowBoundariesModuleConfig;
+    buildings?: TileflowBuildingsModuleConfig;
+    labels?: TileflowLabelsModuleConfig;
+    land?: TileflowLandModuleConfig;
+    landforms?: TileflowLandformsModuleConfig;
+    nautical?: TileflowNauticalModuleConfig;
+    poi?: TileflowPoiModuleConfig;
+    roads?: TileflowRoadsModuleConfig;
+    transit?: TileflowTransitModuleConfig;
+    vegetation?: TileflowVegetationModuleConfig;
+    water?: TileflowWaterModuleConfig;
+};
+type TileflowSemanticModuleName = keyof TileflowSemanticModules;
+type TileflowResolvedSemanticModuleOverrides = {
+    readonly [TName in TileflowSemanticModuleName]?: TileflowResolvedModuleConfig<NonNullable<TileflowSemanticModules[TName]>>;
+};
+
+/** A directory resolved relative to the selected executable tileflow.config.ts. */
+type TileflowLocalDirectory = `./${string}` | `../${string}`;
+declare const tileflowLocalDirectoryMaximumLength = 512;
+declare const tileflowLocalDirectoryMessage = "Expected a canonical relative directory beginning with ./ or ../; only leading .. segments are allowed and segments must be non-empty, without backslashes or controls";
+/** Exact portable syntax shared by config validation and Node filesystem resolution. */
+declare function isTileflowLocalDirectory(value: unknown): value is TileflowLocalDirectory;
+/**
+ * A package-owned asset directory. Applications normally import one of these
+ * descriptors from the package that owns the assets instead of constructing it.
+ */
+type TileflowPackageDirectory = Readonly<{
+    kind: 'package-directory';
+    package: string;
+    path: string;
+}>;
+/** One icon directory in the ordered map icon search path. */
+type TileflowIconDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/** One font directory in the ordered map font search path. */
+type TileflowFontDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/** One directory of 3D models in the ordered map model search path. */
+type TileflowModelDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/**
+ * An explicit MapLibre glyph provider. `fontStacks` lists the exact comma-joined request keys
+ * produced by each compiled `text-font` array. The map owns the URL; World never supplies fonts.
+ */
+type TileflowGlyphs = Readonly<{
+    fontStacks: readonly string[];
+    kind: 'url';
+    url: string;
+}>;
+
+declare const tileflowIconSourceLimit = 32;
+type TileflowIconSetReference = `@${string}/${string}`;
+declare const tileflowIconSetReferenceSchema: z.ZodString;
+declare const tileflowIconSetSourceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"icon-set">;
+    reference: z.ZodString;
+}, z.core.$strict>;
+type TileflowIconSetSource = Readonly<{
+    kind: 'icon-set';
+    reference: TileflowIconSetReference;
+}>;
+type TileflowIconSource = TileflowIconDirectory | TileflowIconSetSource;
+/** Declare a dependency. This function never resolves a version or performs I/O. */
+declare function iconSet(reference: TileflowIconSetReference): TileflowIconSetSource;
+declare function isTileflowIconSetSource(value: unknown): value is TileflowIconSetSource;
+declare const tileflowIconSetIdSchema: z.ZodString;
+declare const tileflowIconSetVersionIdSchema: z.ZodString;
+declare const tileflowIconSetPackageIdSchema: z.ZodString;
+declare const tileflowIconSetTeamIdSchema: z.ZodString;
+type TileflowIconSetErrorCode = 'ICON_SET_INVALID' | 'ICON_LOCK_INVALID' | 'ICON_LOCK_MISSING' | 'ICON_LOCK_CONFLICT' | 'ICON_CACHE_MISS' | 'ICON_CACHE_UNSAFE' | 'ICON_DOWNLOAD_FAILED' | 'ICON_PACKAGE_INTEGRITY' | 'ICON_COMPOSITION_INVALID';
+declare class TileflowIconSetError extends Error {
+    readonly code: TileflowIconSetErrorCode;
+    readonly phase: "icon-resolution";
+    constructor(code: TileflowIconSetErrorCode, message: string, options?: ErrorOptions);
+}
+/** Validate the dependency sequence without consulting a lock or registry. */
+declare function collectTileflowIconSetReferences(sources: readonly TileflowIconSource[]): TileflowIconSetReference[];
+
+/**
+ * The sky above the horizon when the camera tilts up towards it, in either projection. Colours and
+ * numbers take theme tokens, so each theme paints its own sky: blue by day, warm at dusk, dark with
+ * stars at night. Colours must resolve to opaque colours.
+ */
+type TileflowSkyOptions = {
+    /** The sky overhead. Default: `#5c9ce6`. */
+    color?: TileflowThemeColorValue;
+    /** The pale band along the horizon, which also colours 3D terrain's distance fog. Default: `#dcebf7`. */
+    horizonColor?: TileflowThemeColorValue;
+    /** How far up the horizon band reaches, as a share of half the view's height, from 0 to 1. Default: 0.6. */
+    horizonBlend?: TileflowThemeNumberValue;
+    /** The light round a low sun, which glows on the horizon towards it. Default: `#ffc68a`. */
+    glowColor?: TileflowThemeColorValue;
+    /** The brightest the stars shine, from 0 (none) to 1, reached where the sky is dark. Default: 0.6. */
+    starIntensity?: TileflowThemeNumberValue;
+};
+type TileflowSky = boolean | TileflowSkyOptions;
+declare const tileflowSkyMetadataKey = "tileflow:sky";
+/** One theme's sky colours, as a time of day lends them to a sky that follows the sun. */
+type TileflowSkyColours = Readonly<{
+    color: string;
+    horizonColor: string;
+    horizonBlend: number;
+    glowColor: string;
+}>;
+/** The skies of a theme's time-of-day family, from which a sky that follows the sun is mixed. */
+type TileflowSkyTimesOfDay = Readonly<Record<'day' | 'dawn' | 'dusk' | 'night', TileflowSkyColours>>;
+/**
+ * The versioned runtime payload: what the browser needs to draw the stars and the glow round the
+ * sun, and, for a theme in a time-of-day family, the family's skies, so that a sun an application
+ * places brings the sky of its hour.
+ */
+type TileflowSkyMetadata = Readonly<{
+    version: 1;
+    starIntensity: number;
+    glowColor: string;
+    timesOfDay?: TileflowSkyTimesOfDay;
+}>;
+/** Validate the runtime payload without loading authoring schemas. */
+declare function readTileflowSky(value: unknown): TileflowSkyMetadata | undefined;
+/**
+ * The sky of a sun at this height and direction, mixed from a time-of-day family's skies: the day
+ * sky above the golden hour, the dawn or dusk sky within two degrees of sunrise or sunset (dawn while the sun is in
+ * the eastern half of the sky), and the night sky once twilight ends. Every colour comes from the
+ * family's themes, so a monochrome or a client's own family keeps its palette.
+ */
+declare function tileflowSkyAtSun(times: TileflowSkyTimesOfDay, sun: Readonly<{
+    altitude: number;
+    azimuth: number;
+}>): TileflowSkyColours;
+
+/** Portable, filesystem-safe identity shared by maps and their leaf-owned scenes. */
+declare const tileflowMapIdSchema: zod.ZodString;
+/** Identity is always owned by the map being resolved and never inherited. */
+type TileflowMapIdentity = {
+    id: string;
+    name?: string;
+    /** Editorial version of this map. */
+    version: number;
+};
+/** A capture scene owned by one singular map; its map id is implicit. */
+type TileflowMapScene = Omit<TileflowCaptureScene, 'map'>;
+/** A timed capture shot owned by one singular map; its map id is implicit. */
+type TileflowMapShot = Omit<TileflowCaptureShot, 'map'>;
+/** Tooling metadata belongs to the leaf definition and is never inherited. */
+type TileflowMapTooling = {
+    scenes?: Record<string, TileflowMapScene>;
+    shots?: Record<string, TileflowMapShot>;
+};
+type TileflowMapTextAssets = {
+    fonts?: never;
+    glyphs?: never;
+} | {
+    fonts: readonly TileflowFontDirectory[];
+    glyphs?: never;
+} | {
+    fonts?: never;
+    glyphs: TileflowGlyphs;
+};
+/** Cartographic fields supported by the V1 semantic compiler. */
+type TileflowMapDesign = TileflowMapTextAssets & {
+    /** 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;
+    /** Ordered icon contributors. Omission inherits; declaration replaces; [] means no icons. */
+    icons?: readonly TileflowIconSource[];
+    /** Independent Bathymetry and Nautical products composed by the compiler. */
+    marine?: TileflowMarine;
+    /**
+     * Directories of the map's own 3D models, glTF binaries (`.glb`) named by id, such as the trees a
+     * vegetation form draws. Omission inherits; declaration replaces; [] means no models.
+     */
+    models?: readonly TileflowModelDirectory[];
+    /** Semantic domains, expressed directly or with explicit refine/disable operations. */
+    modules?: TileflowAuthoringModules;
+    /** Keyed MapLibre overlay units. Omission inherits; entries replace atomically. */
+    overlays?: TileflowOverlayCollection;
+    projection?: TileflowProjection;
+    /**
+     * The sky above the horizon when the camera tilts up, in either projection, with stars where it
+     * is dark. Colours take theme tokens. False disables an inherited sky.
+     */
+    sky?: TileflowSky;
+    /** Keyed logical hosted sources. Omission inherits; entries replace atomically. */
+    sources?: TileflowHostedSourceCollection;
+    /** Browser color-scheme mapping. Runtime resolves "system" to one of these concrete names. */
+    systemThemes?: {
+        dark: TileflowThemeName;
+        light: TileflowThemeName;
+    };
+    terrain?: TileflowTerrain;
+    /** Complete named appearances. Omission inherits; declaration replaces the collection. */
+    themes?: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+    /** Optional artistic moments per theme family. Omission inherits; {} disables inheritance. */
+    timeOfDay?: TileflowTimeOfDayVariants;
+    view?: TileflowViewConfig;
+};
+/** Complete semantic map at the base of a lineage. The compiler is implicit. */
+type TileflowStandaloneMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type TileflowDerivedMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    extends: TileflowMap;
+};
+/** Executable authoring definition using the one implicit semantic compiler. */
+type TileflowMap = TileflowDerivedMap | TileflowStandaloneMap;
+type ResolvedTileflowMapDesign<TDesign extends TileflowMapDesign = TileflowMapDesign> = TDesign extends TileflowMapDesign ? Omit<TDesign, 'defaultTheme' | 'modules' | 'overlays' | 'sources' | 'themes'> : never;
+/** A standalone map definition with inheritance removed. */
+type ResolvedTileflowMap = Omit<TileflowMapIdentity, 'name'> & ResolvedTileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    modules?: TileflowResolvedSemanticModuleOverrides;
+    name: string;
+    overlays?: Readonly<Record<string, TileflowMapLibreOverlay>>;
+    sources?: Readonly<Record<string, TileflowHostedTilesetSource>>;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type ResolveMapOptions = {
+    /** Maximum number of map definitions in a lineage, including its standalone base. */
+    maxDepth?: number;
+};
+
+type TileflowDataFieldType = 'Boolean' | 'Number' | 'String';
+type TileflowDataFieldRequirement = Readonly<{
+    name: string;
+    type?: TileflowDataFieldType;
+}>;
+type TileflowDataLayerRequirement = Readonly<{
+    fields: readonly TileflowDataFieldRequirement[];
+    id: string;
+}>;
+type TileflowDataRequirementsV1 = Readonly<{
+    complete: boolean;
+    dynamicAccesses: readonly string[];
+    schemaVersion: 1;
+    sourceId: string;
+    sourceLayers: readonly TileflowDataLayerRequirement[];
+}>;
+/** Per-source requirements for styles that compose independent vector and DEM products. */
+type TileflowSourceRequirementsV1 = Readonly<{
+    rasterDemSources?: Readonly<Record<string, TileflowRasterDemSourceRequirementV1>>;
+    schemaVersion: 1;
+    sources: Readonly<Record<string, TileflowDataRequirementsV1>>;
+}>;
+type TileflowRasterDemSourceRequirementV1 = Readonly<{
+    encoding: 'mapbox' | 'terrarium';
+    sourceId: string;
+    tileSize: 256 | 512;
+    type: 'raster-dem';
+}>;
+type TileflowObservedDataContractV1 = Readonly<{
+    sourceLayers: readonly Readonly<{
+        fields: readonly Readonly<{
+            name: string;
+            type: TileflowDataFieldType;
+        }>[];
+        id: string;
+    }>[];
+}>;
+type TileflowDataCompatibilityIssue = Readonly<{
+    code: 'dynamic-field-access' | 'field-missing' | 'field-type-mismatch' | 'source-layer-missing';
+    field?: string;
+    message: string;
+    sourceLayer?: string;
+}>;
+/**
+ * Infer the effective data surface from finalized MapLibre layers. Disabled modules contribute no
+ * requirements, and fields hidden by map inheritance never reach this compiler output.
+ */
+declare function inferTileflowDataRequirements(style: MapLibreStyle, options?: {
+    additional?: readonly TileflowDataLayerRequirement[];
+    sourceId?: string;
+}): TileflowDataRequirementsV1;
+/**
+ * Infer the V1 layer/field contract for every referenced vector source and the physical contract
+ * for each included raster DEM. The singular helper remains unchanged for World-only consumers.
+ */
+declare function inferTileflowSourceRequirements(style: MapLibreStyle): TileflowSourceRequirementsV1;
+/** Compare inferred use with producer-observed layers and fields; no editorial allowlist exists. */
+declare function validateTileflowDataCompatibility(requirements: TileflowDataRequirementsV1, contract: TileflowObservedDataContractV1): readonly TileflowDataCompatibilityIssue[];
+
+/** Version of the opt-in, read-only physical-output inspection sidecar. */
+declare const tileflowStyleInspectionSchemaVersion: 1;
+type TileflowStyleInspectionRenderOperation = {
+    readonly kind: 'pass' | 'refinement';
+    readonly owner: TileflowLayerDomain;
+    readonly target: string;
+};
+/** One semantic contribution represented by a compiled physical style layer. */
+type TileflowStyleInspectionContribution = {
+    readonly owner: TileflowLayerDomain;
+    readonly slot: TileflowLayerSlot;
+    readonly target: string;
+    /** Ordered semantic render operations represented by this contribution. */
+    readonly operations: readonly TileflowStyleInspectionRenderOperation[];
+};
+type TileflowStyleInspectionLayer = {
+    /** Opaque physical output identity for diagnostics; never a public authoring target. */
+    readonly id: string;
+    readonly index: number;
+    readonly type: string;
+    /** Multiple entries are expected when the physical planner combines semantic layers. */
+    readonly contributions: readonly TileflowStyleInspectionContribution[];
+};
+/**
+ * Opt-in, read-only cartographic provenance for diagnostics and build tooling.
+ * Physical IDs are output observations, not stable or addressable authoring APIs.
+ * This object is never embedded in Style JSON.
+ */
+type TileflowStyleInspection = {
+    readonly schemaVersion: typeof tileflowStyleInspectionSchemaVersion;
+    readonly map: string;
+    readonly theme: string;
+    readonly layers: readonly TileflowStyleInspectionLayer[];
+};
+type TileflowInspectedStyle = {
+    readonly style: MapLibreStyle;
+    readonly inspection: TileflowStyleInspection;
+};
+
+declare const tileflowCompilationReportSchemaVersion: 1;
+declare const tileflowCompilationPhases: readonly ["assembly", "assets", "config-validation", "data", "domain-ir", "domains", "finalization", "input", "lowering", "physical-planner", "render-stack", "theme", "theme-audit", "validation"];
+declare const tileflowCompilationPlannerStages: readonly ["domain-ir", "assembly", "render-stack", "physical-planner", "lowering"];
+type TileflowCompilationPhase = (typeof tileflowCompilationPhases)[number];
+type TileflowCompilationPlannerStage = (typeof tileflowCompilationPlannerStages)[number];
+type TileflowCompilationDiagnostic = Readonly<{
+    code: string;
+    domain?: TileflowSemanticModuleName;
+    message: string;
+    path?: string;
+    phase: TileflowCompilationPhase;
+    severity: 'error' | 'warning';
+    suggestion?: string;
+    target?: string;
+}>;
+type TileflowCompilationDomainReport = Readonly<{
+    contributionCount: number;
+    name: TileflowSemanticModuleName;
+    renderOperationCount: number;
+    status: 'emitted' | 'suppressed';
+    suppressionReason?: 'disabled' | 'no-contributions';
+    targets: readonly string[];
+}>;
+type TileflowCompilationPlannerDecision = Readonly<{
+    candidateCount?: number;
+    inputCount: number;
+    outputCount: number;
+    selectedCount?: number;
+    stage: TileflowCompilationPlannerStage;
+}>;
+/** 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[];
+    /** Opt-in read-only physical diagnostics; its IDs are not addressable authoring targets. */
+    provenance?: TileflowStyleInspection;
+    requirements?: TileflowSourceRequirementsV1;
+    schemaVersion: typeof tileflowCompilationReportSchemaVersion;
+    targets: readonly string[];
+    theme?: string;
+}>;
+type TileflowCompilationSuccess = Readonly<{
+    diagnostics: readonly TileflowCompilationDiagnostic[];
+    ok: true;
+    report: TileflowCompilationReport;
+    style: MapLibreStyle;
+}>;
+type TileflowCompilationFailure = Readonly<{
+    diagnostics: readonly TileflowCompilationDiagnostic[];
+    ok: false;
+    report: TileflowCompilationReport;
+    style?: never;
+}>;
+type TileflowCompilationResult = TileflowCompilationFailure | TileflowCompilationSuccess;
+declare function isTileflowCompilationPhase(value: unknown): value is TileflowCompilationPhase;
+
+declare const tileflowIconAppearanceSchema: z.ZodObject<{
+    representation: z.ZodLiteral<"sdf">;
+    defaults: z.ZodObject<{
+        color: z.ZodString;
+        haloColor: z.ZodString;
+        haloWidth: z.ZodNumber;
+        haloBlur: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Absent metadata denotes unchanged fixed-color RGBA artwork. */
+type TileflowIconAppearance = z.infer<typeof tileflowIconAppearanceSchema>;
+/** Verify the generated representation from decoded pixels, independently of its declaration. */
+declare function assertTileflowSdfPixels(input: {
+    rgba: Uint8Array;
+    width: number;
+    height: number;
+    pixelRatio: 1 | 2;
+}): void;
+declare const tileflowIconMetadataFileName = "tileflow.icons.json";
+declare const tileflowIconAuthorMetadataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    icons: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        representation: z.ZodLiteral<"rgba">;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodDefault<z.ZodString>;
+            haloWidth: z.ZodDefault<z.ZodNumber>;
+            haloBlur: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+
+type TileflowPreparedIconCapabilities = {
+    ids: readonly string[];
+    appearances?: Readonly<Record<string, TileflowIconAppearance>>;
+};
+/** Admit a compiled style without repairing or changing its signed paint. */
+declare function validateTileflowCompiledIconCapabilities(style: MapLibreStyle, icons: TileflowPreparedIconCapabilities): void;
+
+type TileflowPreparedMapAssets = {
+    icons?: TileflowPreparedIconCapabilities & {
+        ids: readonly string[];
+        sprite: string;
+    };
+    /** The map's own 3D tree models by id, prepared from its `models` directories. */
+    models?: Readonly<Record<string, TileflowTreeModel>>;
+    /** Where each of the map's own building models is served, by id. */
+    buildingModels?: Readonly<Record<string, string>>;
+};
+type TileflowSemanticCompileOptions = {
+    apiBaseUrl?: string;
+    /** Resolved authoring identity. Internal build orchestration supplies this. */
+    map?: {
+        id: string;
+        lineage?: readonly string[];
+        version: number;
+    };
+    /** Build-owned assets prepared from the authoring directories. */
+    preparedAssets?: TileflowPreparedMapAssets;
+    /** Concrete named theme. Omission deterministically selects map.defaultTheme. */
+    theme?: string;
+    /** Optional artistic preset declared by the map. */
+    timeOfDay?: TileflowTimeOfDay;
+};
+type TileflowSemanticCompilationOptions = TileflowSemanticCompileOptions & {
+    /** Include opt-in read-only physical diagnostics; emitted IDs are not authoring targets. */
+    inspection?: boolean;
+};
+
+type TileflowStyleOptions = TileflowSemanticCompileOptions;
+type TileflowCompilationOptions = TileflowSemanticCompilationOptions;
+declare function createStyle(config: TileflowMap, options?: TileflowStyleOptions): MapLibreStyle;
+/** Resolve and compile one map without throwing, returning deterministic compiler diagnostics. */
+declare function createStyleResult(config: TileflowMap, options?: TileflowCompilationOptions): TileflowCompilationResult;
+declare function collectMapLineage(map: TileflowMap): string[];
+/** Resolve and validate one public authoring map before asset preparation or compilation. */
+declare function parseTileflowMap(map: TileflowMap): ResolvedTileflowMap;
+/** Validate one singular authoring map, including its complete extends lineage. */
+declare function validateTileflowMap(input: unknown): ValidationResult;
+
+declare const tileflowIconCompositionMaximumBytes: number;
+declare const tileflowRenderedIconIdentitySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rendered-icon">;
+    id: z.ZodString;
+    appearance: z.ZodOptional<z.ZodObject<{
+        representation: z.ZodLiteral<"sdf">;
+        defaults: z.ZodObject<{
+            color: z.ZodString;
+            haloColor: z.ZodString;
+            haloWidth: z.ZodNumber;
+            haloBlur: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    layout: z.ZodOptional<z.ZodObject<{
+        stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strict>>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    pixelSha256: z.ZodObject<{
+        oneX: z.ZodString;
+        twoX: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type TileflowRenderedIconIdentity = z.infer<typeof tileflowRenderedIconIdentitySchema>;
+declare const tileflowIconCompositionSchema: z.ZodObject<{
+    format: z.ZodEnum<{
+        'tileflow-icon-composition-v1': "tileflow-icon-composition-v1";
+        'tileflow-icon-composition-v2': "tileflow-icon-composition-v2";
+    }>;
+    compositionVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    packageHash: z.ZodString;
+    contributors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"local">;
+        iconIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"package">;
+        package: z.ZodString;
+        iconIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"icon-set">;
+        reference: z.ZodString;
+        teamId: z.ZodString;
+        setId: z.ZodString;
+        versionId: z.ZodString;
+        version: z.ZodNumber;
+        packageId: z.ZodString;
+        contentHash: z.ZodString;
+        iconIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+    winners: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        appearance: z.ZodOptional<z.ZodObject<{
+            representation: z.ZodLiteral<"sdf">;
+            defaults: z.ZodObject<{
+                color: z.ZodString;
+                haloColor: z.ZodString;
+                haloWidth: z.ZodNumber;
+                haloBlur: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        layout: z.ZodOptional<z.ZodObject<{
+            stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>>;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        pixelSha256: z.ZodObject<{
+            oneX: z.ZodString;
+            twoX: z.ZodString;
+        }, z.core.$strict>;
+        contributor: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type TileflowIconCompositionV1 = z.infer<typeof tileflowIconCompositionSchema>;
+type TileflowIconContributorIdentity = TileflowIconCompositionV1['contributors'][number];
+declare function parseTileflowIconComposition(input: unknown): TileflowIconCompositionV1;
+/** Dependency identity is separate from the generated artifact's content hash. */
+declare function hashTileflowIconComposition(input: TileflowIconCompositionV1): Promise<string>;
+
+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 TileflowBuildingSurfaceDesign 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 TileflowLandModuleConfig 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 TileflowBuildingsThreeDimensionalStyle as aA, type TileflowCompilationDesignDecision as aB, type TileflowCompilationDiagnostic as aC, type TileflowCompilationDomainReport as aD, type TileflowCompilationFailure as aE, type TileflowCompilationOptions as aF, type TileflowCompilationPhase as aG, type TileflowCompilationPlannerDecision as aH, type TileflowCompilationPlannerStage as aI, type TileflowCompilationReport as aJ, type TileflowCompilationResult as aK, type TileflowCompilationSuccess as aL, type TileflowDataConfig as aM, type TileflowDataIdentity as aN, type TileflowDerivedMap as aO, type TileflowDisableOperation as aP, type TileflowFontDirectory as aQ, type TileflowGlyphs as aR, type TileflowHostedSourceCollection as aS, type TileflowHostedTilesetSource as aT, type TileflowHostedTilesetType as aU, type TileflowIconContributorIdentity as aV, type TileflowIconDirectory as aW, TileflowIconSetError as aX, type TileflowIconSetErrorCode as aY, type TileflowIconSetReference as aZ, type TileflowIconSetSource 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 TileflowBuildingSurfaces as ax, type TileflowBuildingsModuleConfig as ay, type TileflowBuildingsModuleOptions as az, type TileflowDataRequirementsV1 as b, type TileflowTransitModuleConfig as b$, type TileflowLandModuleOptions as b0, type TileflowLandcoverClass as b1, type TileflowLandformClass as b2, type TileflowLandformsModuleConfig as b3, type TileflowLandformsModuleOptions as b4, type TileflowLanduseClass as b5, type TileflowLayerBand as b6, type TileflowLocalDirectory as b7, type TileflowMapDesign as b8, type TileflowMapIdentity as b9, type TileflowRasterDemSourceRequirementV1 as bA, type TileflowRefineOperation as bB, type TileflowRemoveOperation as bC, type TileflowReset as bD, type TileflowResolvedThemeSelection as bE, type TileflowSemanticModules as bF, type TileflowSky as bG, type TileflowSkyColours as bH, type TileflowSkyMetadata as bI, type TileflowSkyOptions as bJ, type TileflowSkyTimesOfDay as bK, type TileflowStandaloneMap as bL, type TileflowSun as bM, type TileflowSunPreset as bN, type TileflowTheme as bO, type TileflowThemeAmbient as bP, type TileflowThemeAuditContext as bQ, type TileflowThemeAuditDiagnostic as bR, TileflowThemeAuditError as bS, type TileflowThemeAuditScope as bT, type TileflowThemeDefinition as bU, type TileflowThemeLighting as bV, type TileflowThemeName as bW, type TileflowThemeSun as bX, type TileflowThemeTokens as bY, type TileflowThemeTypography as bZ, type TileflowThemeTypographyStyle as b_, type TileflowMapLibreOverlayLayer as ba, type TileflowMapTooling as bb, type TileflowMarine as bc, type TileflowMarineConfig as bd, type TileflowMarineMode as be, type TileflowMarineSourceConfig as bf, type TileflowMarineSourceIdentity as bg, type TileflowModelDirectory as bh, type TileflowModelEmitter as bi, type TileflowModelLevelBytes as bj, type TileflowModelMaterial as bk, type TileflowModelMaterialRange as bl, type TileflowModelMesh as bm, type TileflowModelPart as bn, type TileflowModelSurface as bo, type TileflowModelSurfaceBytes as bp, type TileflowModelTexture as bq, type TileflowModelTextureReference as br, type TileflowModuleOperation as bs, type TileflowModulePatch as bt, type TileflowNauticalAreaLabelStyles as bu, type TileflowNauticalModuleConfig as bv, type TileflowNauticalModuleOptions as bw, type TileflowOverlayCollection as bx, type TileflowPackageDirectory as by, type TileflowPreparedIconCapabilities as bz, type TileflowSourceRequirementsV1 as c, reset as c$, type TileflowTransitModuleOptions as c0, type TileflowTransitRailStyle as c1, type TileflowTreeForm as c2, type TileflowTreeFormMix as c3, type TileflowTreeModel as c4, type TileflowTreeModelMesh as c5, type TileflowTreeRegion as c6, type TileflowVegetation3D as c7, type TileflowVegetationModuleConfig as c8, type TileflowVegetationModuleOptions as c9, disable as cA, encodeTileflowTreeModel as cB, hashTileflowIconComposition as cC, hostedTileset as cD, iconSet as cE, isCanonicalOpenMapTilesSchema as cF, isSafeLocalPmtilesPath as cG, isTileflowBoundaryClass as cH, isTileflowBoundaryFamily as cI, isTileflowCompilationPhase as cJ, isTileflowIconSetSource as cK, isTileflowLocalDirectory as cL, isTileflowModelPartName as cM, land as cN, landforms as cO, maplibreOverlay as cP, mixTileflowSunPresets as cQ, nautical as cR, openMapTiles as cS, openMapTilesContractVersion as cT, parseTileflowIconComposition as cU, parseTileflowMap as cV, readTileflowSky as cW, readTileflowSunPreset as cX, readTileflowVegetation3D as cY, refine as cZ, remove as c_, type TileflowVegetationThreeDimensionalStyle as ca, type TileflowVisualValueCategory as cb, type TileflowWaterModuleConfig as cc, type TileflowWaterModuleOptions as cd, type TileflowWaterwayClass as ce, type TileflowWorldData as cf, type TileflowWorldReleaseReference as cg, type TileflowWorldSelection as ch, type TileflowWorldV1Schema as ci, type VectorTilesData as cj, addresses as ck, aeroways as cl, assertTileflowMapThemeValues as cm, assertTileflowSdfPixels as cn, auditTileflowMapThemeValues as co, auditTileflowThemeValues as cp, bathymetry as cq, boundaries as cr, buildings as cs, checkTileflowModelSurface as ct, classifyTileflowVisualProperty as cu, collectTileflowIconSetReferences as cv, createStyle as cw, createStyleResult as cx, decodeTileflowTreeModel as cy, defineTheme as cz, type TileflowMap as d, tileflowTreeModelLimits as d$, resolveBoundaryAreas as d0, resolveMarine as d1, resolveThemeSelection as d2, resolveThemeValues as d3, resolveTileflowData as d4, resolveTileflowSun as d5, resolveTileflowTheme as d6, tileflowBandPlacements as d7, tileflowBathymetryDemSourceId as d8, tileflowBathymetryNameLayerLimits as d9, tileflowModelArchitecturalPartNames as dA, tileflowModelDefaultLightingRole as dB, tileflowModelImageSize as dC, tileflowModelLightingRoles as dD, tileflowModelLimits as dE, tileflowModelParts as dF, tileflowModelSurfaceLimits as dG, tileflowModelTextureChannels as dH, tileflowModelVertexBytes as dI, tileflowNauticalFacilityIcons as dJ, tileflowNauticalImageRoles as dK, tileflowNauticalNotice as dL, tileflowNauticalPromoteId as dM, tileflowNauticalSourceId as dN, tileflowNauticalV1Schema as dO, tileflowPrimarySourceId as dP, tileflowRenderedIconIdentitySchema as dQ, tileflowRingsOverlap as dR, tileflowSkyAtSun as dS, tileflowSkyMetadataKey as dT, tileflowStyleSunPreset as dU, tileflowSunDirection as dV, tileflowSunMetadataKey as dW, tileflowSunPosition as dX, tileflowThemeLimits as dY, tileflowTreeForms as dZ, tileflowTreeModelIdPattern as d_, tileflowBathymetrySourceId as da, tileflowBathymetryV1Schema as db, tileflowBoundaryAreasV1Schema as dc, tileflowBoundaryClassTiers as dd, tileflowBoundaryClasses as de, tileflowBoundaryFamilies as df, tileflowDefaultSunPreset as dg, tileflowIconAppearanceSchema as dh, tileflowIconAuthorMetadataSchema as di, tileflowIconCompositionMaximumBytes as dj, tileflowIconCompositionSchema as dk, tileflowIconMetadataFileName as dl, tileflowIconSetIdSchema as dm, tileflowIconSetPackageIdSchema as dn, tileflowIconSetReferenceSchema as dp, tileflowIconSetSourceSchema as dq, tileflowIconSetTeamIdSchema as dr, tileflowIconSetVersionIdSchema as ds, tileflowIconSourceLimit as dt, tileflowInsideRings as du, tileflowLandformClasses as dv, tileflowLayerBands as dw, tileflowLocalDirectoryMaximumLength as dx, tileflowLocalDirectoryMessage as dy, tileflowMapIdSchema as dz, type TileflowStyleOptions as e, tileflowVegetationMetadataKey as e0, tileflowWorld as e1, tileflowWorldGeneration as e2, tileflowWorldTileJsonUrl as e3, tileflowWorldV1Schema as e4, transit as e5, validateTileflowCompiledIconCapabilities as e6, validateTileflowMap as e7, validateTileflowWorldV1Tilejson as e8, vectorTiles as e9, vegetation as ea, water as eb, 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 };