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

package/dist/index.d.ts

@@ -1,178 +1,1822 @@
-type TileflowDensity = 'clean' | 'balanced' | 'dense';
-type TileflowRoads = 'hidden' | 'soft' | 'standard' | 'detailed';
-type TileflowLabels = 'none' | 'essential' | 'balanced' | 'full';
-type TileflowPoi = 'none' | 'minimal' | 'balanced' | 'full';
-type TileflowTheme = 'standard' | 'light' | 'dark' | 'minimal' | 'osm-bright-2';
-type TileflowBuildings = 'hidden' | 'flat' | '3d';
-type TileflowTerrainMode = 'none' | 'hillshade' | '3d';
-type TileflowTerrainEncoding = 'mapbox' | 'terrarium';
-type TileflowThemeName = 'light' | 'dark';
-type TileflowThemeMode = TileflowThemeName;
-type TileflowColors = {
-    canvas: string;
-    land: string;
-    water: string;
-    nature: string;
-    road: string;
-    text: string;
-    accent: string;
-};
-type LegacyTileflowColorAliases = {
-    background?: string;
-    park?: string;
-    building?: string;
-    roadCasing?: string;
-};
-type TileflowColorConfig = Partial<TileflowColors> & LegacyTileflowColorAliases;
-type TileflowFontWeight = 'regular' | 'medium' | 'semibold' | 'bold';
-type TileflowTypography = {
-    font?: string;
-    weight?: TileflowFontWeight;
-};
-type TileflowFonts = {
-    body?: string;
-    labels?: string;
-};
-type TileflowThemeConfig = {
-    colors?: TileflowColorConfig;
-    fonts?: TileflowFonts;
-    typography?: TileflowTypography;
-};
-type TileflowSourceLayers = {
-    landuse?: string;
-    park?: string;
-    water?: string;
-    road?: string;
-    building?: string;
-    boundary?: string;
-    place?: string;
-    poi?: string;
-};
-type TileflowTiles = {
-    sourceId?: string;
-    tileset?: string;
-    url?: string;
-    attribution?: string;
-    sourceLayers?: TileflowSourceLayers;
-};
-type TileflowTerrainConfig = {
-    attribution?: string;
-    encoding?: TileflowTerrainEncoding;
-    exaggeration?: number;
-    mode?: TileflowTerrainMode;
-    sourceId?: string;
-    tileset?: string;
-    url?: string;
-};
-type TileflowTerrain = TileflowTerrainMode | TileflowTerrainConfig;
-type TileflowViewConfig = {
-    bearing?: number;
-    center?: readonly [number, number];
-    zoom?: number;
-};
-type TileflowOsmBasemapConfig = {
-    type: 'osm';
-    attribution?: string;
-    glyphs?: string;
-    sourceId?: string;
-    sourceLayers?: TileflowSourceLayers;
-    sprite?: string;
-    tileset?: string;
-    url?: string;
-};
-type TileflowBasemapConfig = TileflowOsmBasemapConfig;
-type TileflowOsmBasemapOptions = Omit<TileflowOsmBasemapConfig, 'type'>;
-type TileflowRoadsModulePreset = 'modern' | 'minimal';
-type TileflowRoadsModuleConfig = {
-    type: 'roads';
-    density?: TileflowDensity;
-    preset?: TileflowRoadsModulePreset;
-};
-type TileflowRoadsModuleOptions = Omit<TileflowRoadsModuleConfig, 'type'>;
-type TileflowModuleConfig = TileflowRoadsModuleConfig;
-type TileflowConfig = {
-    basemap?: TileflowBasemapConfig;
+import { u as TileflowBoundaryClass, w as TileflowBoundaryClassTier, x as TileflowBoundaryFamily, y as TileflowOverlayPlacement, z as TileflowMapLibreOverlay, d as TileflowMap, A as TileflowMapScene, B as TileflowMapShot, C as ResolveMapOptions, R as ResolvedTileflowMap, D as TileflowIconAppearance, O as OpenMapTilesFieldBindings, E as TileflowLayerDomain, F as TileflowBandPlacement, G as OpenMapTilesLayerBindings, H as tileflowCompilationPhases, I as tileflowCompilationPlannerStages, J as tileflowCompilationReportSchemaVersion, K as TileflowSemanticModuleName, L as tileflowHostedSourceLimit, M as tileflowOverlayPlacements, N as ResolvedTileflowTheme, P as TileflowThemeColorScheme, Q as TileflowIconSource, S as TileflowModelLightingRole, U as TileflowBuildingSurfaceDesign, V as TileflowModelPart, W as TileflowModel, X as TileflowModelBytes, Y as TileflowVegetationMode } from './icon-composition-CcSHApUm.js';
+export { Z as OpenMapTilesSchema, _ as OpenMapTilesSchemaOptions, $ as ParkLayerSemantics, a0 as ResolvedBathymetry, a1 as ResolvedBathymetryRelief, a2 as ResolvedBoundaryAreas, a3 as ResolvedMarine, a4 as ResolvedMarineSource, a5 as ResolvedTileflowData, a6 as ResolvedTileflowThemeTokens, a7 as TileflowAddressesModuleConfig, a8 as TileflowAddressesModuleOptions, a9 as TileflowAerowaysModuleConfig, aa as TileflowAerowaysModuleOptions, ab as TileflowAtmosphere, ac as TileflowAtmosphereOptions, ad as TileflowAuthoringModules, ae as TileflowBarrierClass, af as TileflowBarrierStyle, ag as TileflowBathymetryConfig, ah as TileflowBathymetryDemSourceIdentity, ai as TileflowBathymetryDisplay, aj as TileflowBathymetryNameLayer, ak as TileflowBathymetryNamePlacement, al as TileflowBathymetryNameStyle, am as TileflowBathymetryNameZoomRange, an as TileflowBathymetryOptions, ao as TileflowBathymetryReliefConfig, ap as TileflowBathymetryVectorLayers, aq as TileflowBoundariesModuleConfig, ar as TileflowBoundariesModuleOptions, as as TileflowBoundaryAreas, at as TileflowBoundaryAreasConfig, au as TileflowBoundaryAreasSourceIdentity, av as TileflowBuildingMode, aw as TileflowBuildingModelPart, ax as TileflowBuildingModelPlacementConfig, ay as TileflowBuildingSurfaces, az as TileflowBuildingsModuleConfig, aA as TileflowBuildingsModuleOptions, aB as TileflowBuildingsThreeDimensionalStyle, aC as TileflowCompilationDesignDecision, aD as TileflowCompilationDiagnostic, aE as TileflowCompilationDomainReport, aF as TileflowCompilationFailure, aG as TileflowCompilationOptions, aH as TileflowCompilationPhase, aI as TileflowCompilationPlannerDecision, aJ as TileflowCompilationPlannerStage, aK as TileflowCompilationReport, aL as TileflowCompilationResult, aM as TileflowCompilationSuccess, h as TileflowDataCompatibilityIssue, aN as TileflowDataConfig, i as TileflowDataFieldRequirement, j as TileflowDataFieldType, aO as TileflowDataIdentity, k as TileflowDataLayerRequirement, b as TileflowDataRequirementsV1, aP as TileflowDerivedMap, aQ as TileflowDisableOperation, aR as TileflowFontDirectory, aS as TileflowGlyphs, aT as TileflowHostedSourceCollection, aU as TileflowHostedTilesetSource, aV as TileflowHostedTilesetType, a as TileflowIconCompositionV1, aW as TileflowIconContributorIdentity, aX as TileflowIconDirectory, aY as TileflowIconSetError, aZ as TileflowIconSetErrorCode, a_ as TileflowIconSetReference, a$ as TileflowIconSetSource, b0 as TileflowLandModuleConfig, b1 as TileflowLandModuleOptions, b2 as TileflowLandcoverClass, b3 as TileflowLandformClass, b4 as TileflowLandformsModuleConfig, b5 as TileflowLandformsModuleOptions, b6 as TileflowLanduseClass, b7 as TileflowLayerBand, b8 as TileflowLocalDirectory, b9 as TileflowMapDesign, ba as TileflowMapIdentity, bb as TileflowMapLibreOverlayLayer, bc as TileflowMapTooling, bd as TileflowMarine, be as TileflowMarineConfig, bf as TileflowMarineMode, bg as TileflowMarineSourceConfig, bh as TileflowMarineSourceIdentity, bi as TileflowModelDirectory, bj as TileflowModelEmitter, bk as TileflowModelLevelBytes, bl as TileflowModelMaterial, bm as TileflowModelMaterialRange, bn as TileflowModelMesh, bo as TileflowModelSurface, bp as TileflowModelTexture, bq as TileflowModelTextureReference, br as TileflowModuleOperation, bs as TileflowModulePatch, bt as TileflowNauticalAreaLabelStyles, bu as TileflowNauticalModuleConfig, bv as TileflowNauticalModuleOptions, l as TileflowObservedDataContractV1, bw as TileflowOverlayCollection, bx as TileflowPackageDirectory, by as TileflowPreparedIconCapabilities, bz as TileflowRasterDemSourceRequirementV1, bA as TileflowRefineOperation, bB as TileflowRemoveOperation, T as TileflowRenderedIconIdentity, bC as TileflowReset, bD as TileflowResolvedThemeSelection, bE as TileflowSemanticModules, bF as TileflowSky, bG as TileflowSkyColours, bH as TileflowSkyMetadata, bI as TileflowSkyOptions, bJ as TileflowSkyTimesOfDay, c as TileflowSourceRequirementsV1, bK as TileflowStandaloneMap, e as TileflowStyleOptions, bL as TileflowSun, bM as TileflowSunPreset, bN as TileflowTheme, bO as TileflowThemeAmbient, bP as TileflowThemeAuditContext, bQ as TileflowThemeAuditDiagnostic, bR as TileflowThemeAuditError, bS as TileflowThemeAuditScope, bT as TileflowThemeDefinition, bU as TileflowThemeLighting, bV as TileflowThemeName, bW as TileflowThemeSun, bX as TileflowThemeTokens, bY as TileflowThemeTypography, bZ as TileflowThemeTypographyStyle, b_ as TileflowTransitModuleConfig, b$ as TileflowTransitModuleOptions, c0 as TileflowTransitRailStyle, c1 as TileflowTreeForm, c2 as TileflowTreeFormMix, c3 as TileflowTreeModel, c4 as TileflowTreeModelMesh, c5 as TileflowTreeRegion, c6 as TileflowVegetation3D, c7 as TileflowVegetationModuleConfig, c8 as TileflowVegetationModuleOptions, c9 as TileflowVegetationThreeDimensionalStyle, ca as TileflowVisualValueCategory, cb as TileflowWaterModuleConfig, cc as TileflowWaterModuleOptions, cd as TileflowWaterwayClass, ce as TileflowWorldData, cf as TileflowWorldReleaseReference, cg as TileflowWorldSelection, ch as TileflowWorldV1Schema, ci as VectorTilesData, cj as addresses, ck as aeroways, cl as assertTileflowMapThemeValues, cm as assertTileflowSdfPixels, cn as auditTileflowMapThemeValues, co as auditTileflowThemeValues, cp as bathymetry, cq as boundaries, cr as buildings, cs as checkTileflowModelSurface, ct as classifyTileflowVisualProperty, cu as collectTileflowIconSetReferences, cv as createStyle, cw as createStyleResult, cx as decodeTileflowTreeModel, cy as defineTheme, cz as disable, cA as encodeTileflowTreeModel, cB as hashTileflowIconComposition, cC as hostedTileset, cD as iconSet, r as inferTileflowDataRequirements, s as inferTileflowSourceRequirements, cE as isCanonicalOpenMapTilesSchema, cF as isSafeLocalPmtilesPath, cG as isTileflowBoundaryClass, cH as isTileflowBoundaryFamily, cI as isTileflowCompilationPhase, cJ as isTileflowIconSetSource, cK as isTileflowLocalDirectory, cL as land, cM as landforms, cN as maplibreOverlay, cO as mixTileflowSunPresets, cP as nautical, cQ as openMapTiles, cR as openMapTilesContractVersion, cS as parseTileflowIconComposition, cT as parseTileflowMap, cU as readTileflowSky, cV as readTileflowSunPreset, cW as readTileflowVegetation3D, cX as refine, cY as remove, cZ as reset, c_ as resolveBoundaryAreas, c$ as resolveMarine, d0 as resolveThemeSelection, d1 as resolveThemeValues, d2 as resolveTileflowData, d3 as resolveTileflowSun, d4 as resolveTileflowTheme, d5 as tileflowBandPlacements, d6 as tileflowBathymetryDemSourceId, d7 as tileflowBathymetryNameLayerLimits, d8 as tileflowBathymetrySourceId, d9 as tileflowBathymetryV1Schema, da as tileflowBoundaryAreasV1Schema, db as tileflowBoundaryClassTiers, dc as tileflowBoundaryClasses, dd as tileflowBoundaryFamilies, de as tileflowDefaultSunPreset, df as tileflowIconAppearanceSchema, dg as tileflowIconAuthorMetadataSchema, dh as tileflowIconCompositionMaximumBytes, di as tileflowIconCompositionSchema, dj as tileflowIconMetadataFileName, dk as tileflowIconSetIdSchema, dl as tileflowIconSetPackageIdSchema, dm as tileflowIconSetReferenceSchema, dn as tileflowIconSetSourceSchema, dp as tileflowIconSetTeamIdSchema, dq as tileflowIconSetVersionIdSchema, dr as tileflowIconSourceLimit, ds as tileflowInsideRings, dt as tileflowLandformClasses, du as tileflowLayerBands, dv as tileflowLocalDirectoryMaximumLength, dw as tileflowLocalDirectoryMessage, dx as tileflowMapIdSchema, dy as tileflowModelDefaultLightingRoles, dz as tileflowModelImageSize, dA as tileflowModelLightingRoles, dB as tileflowModelLimits, dC as tileflowModelParts, dD as tileflowModelSurfaceLimits, dE as tileflowModelTextureChannels, dF as tileflowModelVertexBytes, dG as tileflowNauticalFacilityIcons, dH as tileflowNauticalImageRoles, dI as tileflowNauticalNotice, dJ as tileflowNauticalPromoteId, dK as tileflowNauticalSourceId, dL as tileflowNauticalV1Schema, dM as tileflowPrimarySourceId, dN as tileflowRenderedIconIdentitySchema, dO as tileflowRingsOverlap, dP as tileflowSkyAtSun, dQ as tileflowSkyMetadataKey, dR as tileflowStyleSunPreset, dS as tileflowSunDirection, dT as tileflowSunMetadataKey, dU as tileflowSunPosition, dV as tileflowThemeLimits, dW as tileflowTreeForms, dX as tileflowTreeModelIdPattern, dY as tileflowTreeModelLimits, dZ as tileflowVegetationMetadataKey, d_ as tileflowWorld, d$ as tileflowWorldGeneration, e0 as tileflowWorldTileJsonUrl, e1 as tileflowWorldV1Schema, e2 as transit, e3 as validateTileflowCompiledIconCapabilities, v as validateTileflowDataCompatibility, e4 as validateTileflowMap, e5 as validateTileflowWorldV1Tilejson, e6 as vectorTiles, e7 as vegetation, e8 as water } from './icon-composition-CcSHApUm.js';
+import { z } from 'zod';
+import { V as ValidationMessage, i as TileflowExpression, j as TileflowFixedValue, k as TileflowThemeTokenReference, l as TileflowThemeColorOperation, m as TileflowBackgroundStyle, n as TileflowCircleStyle, o as TileflowExtrusionStyle, p as TileflowFillStyle, q as TileflowLineStyle, r as TileflowSymbolStyle, M as MapLibreStyle, s as TileflowRoadsModuleOptions, u as TileflowRoadsModuleConfig, v as TileflowLabelsModuleOptions, w as TileflowLabelsModuleConfig, x as TileflowPoiModuleOptions, y as TileflowPoiModuleConfig } from './manifest-types-DnhSJjCM.js';
+export { z as MapLibreSprite, A as TileflowAerodromeCodeDetail, B as TileflowAlignment, C as TileflowAnalytics, D as TileflowAreaStyle, E as TileflowBackgroundPaint, F as TileflowCirclePaint, G as TileflowColor, H as TileflowColorStyleValue, I as TileflowExtrusionPaint, J as TileflowFillPaint, K as TileflowIconAnchor, L as TileflowIconLayout, N as TileflowIconPaint, O as TileflowIconStyle, P as TileflowIconTextFit, Q as TileflowImageStyleValue, R as TileflowLabelDetail, S as TileflowLabelLanguage, U as TileflowLabelStyles, W as TileflowLayerRange, X as TileflowLight, Y as TileflowLineCap, Z as TileflowLineHatchStyle, _ as TileflowLineJoin, $ as TileflowLineLayout, a0 as TileflowLinePaint, a1 as TileflowLineStackStyle, a2 as TileflowManifestFetchOptions, a3 as TileflowManifestLoadOptions, a4 as TileflowMapMode, a5 as TileflowMapModeOptions, a6 as TileflowMarkerSymbolStyle, a7 as TileflowMountainBikeScale, a8 as TileflowNumberInsetsStyleValue, a9 as TileflowNumberStyleValue, aa as TileflowPlaceLabelClass, ab as TileflowPoiCategory, ac as TileflowPoiCategoryStyle, ad as TileflowPoiColorMode, ae as TileflowPoiDensity, af as TileflowPoiPlacementOrder, ag as TileflowPriorityOrder, ah as TileflowProjection, ai as TileflowResolvedRuntimeTheme, aj as TileflowRoadAreaStyle, ak as TileflowRoadClass, al as TileflowRoadClassStyle, am as TileflowRoadCrossingStyle, an as TileflowRoadDetail, ao as TileflowRoadExtras, ap as TileflowRoadHierarchy, aq as TileflowRoadLabelDetail, ar as TileflowRoadLayerStyle, as as TileflowRoadModifier, at as TileflowRoadOutline, au as TileflowRoadRestriction, av as TileflowRoadRoundaboutStyle, aw as TileflowRoadServiceType, ax as TileflowRoadShieldDetail, ay as TileflowRoadShieldStyles, az as TileflowRoadSidewalkStyle, aA as TileflowRoadStreetLightStyle, aB as TileflowRoadStructure, aC as TileflowRoadTreatmentLayerStyle, aD as TileflowRoadTreatmentLineStyle, aE as TileflowRoadTreatmentStyle, aF as TileflowRoadWeight, aG as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, aH as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, aI as TileflowRuntimeSource, aJ as TileflowRuntimeSourceValidation, aK as TileflowRuntimeStyle, aL as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, aM as TileflowRuntimeViewOptions, aN as TileflowSessionController, aO as TileflowSessionGrantResponse, aP as TileflowStringStyleValue, aQ as TileflowStructuralStyleValue, aR as TileflowStyleFontFace, aS as TileflowStyleValue, aT as TileflowSymbolOverlap, aU as TileflowSymbolPlacement, aV as TileflowSymbolPlacementStyle, aW as TileflowSymbolZOrder, aX as TileflowTerrain, aY as TileflowTerrainConfig, aZ as TileflowTerrainContourLabelStyle, a_ as TileflowTerrainContourLineStyle, a$ as TileflowTerrainContoursConfig, b0 as TileflowTerrainEncoding, b1 as TileflowTerrainHillshadeStyle, b2 as TileflowTerrainLayerRange, b3 as TileflowTerrainMode, b4 as TileflowTextAnchor, b5 as TileflowTextBackground, b6 as TileflowTextJustify, b7 as TileflowTextLayout, b8 as TileflowTextPaint, b9 as TileflowTextStyle, ba as TileflowThemeBlendSelection, bb as TileflowThemeColorAlpha, bc as TileflowThemeColorMix, bd as TileflowThemeColorValue, be as TileflowThemeFontValue, bf as TileflowThemeImageValue, bg as TileflowThemeNumberValue, bh as TileflowThemeSelection, bi as TileflowThemeTokenCategory, bj as TileflowThemeValue, e as TileflowTimeOfDay, f as TileflowTimeOfDayVariants, bk as TileflowViewConfig, bl as TileflowWaterLabelClass, bm as TileflowZoomInterpolation, bn as TileflowZoomValue, bo as ValidationResult, bp as assertValidTileflowRuntimeSource, bq as clearTileflowManifestCache, br as color, bs as createTileflowSessionController, bt as createTileflowSessionId, bu as defaultTileflowManifestUrl, bv as defaultTileflowRuntimeView, bw as fixed, bx as getTileflowAnalyticsApiUrl, by as getTileflowStyleFontFaces, bz as inferTileflowAnalyticsFromStyleUrl, bA as isTileflowTimeOfDay, bB as loadTileflowManifest, bC as mergeTileflowAnalytics, bD as nearestTileflowBlendTheme, bE as normalizeTileflowRuntimeCenter, bF as normalizeTileflowStaticImageSize, bG as normalizeTileflowUrl, bH as resolveTileflowAnalyticsRequestUrl, bI as resolveTileflowManifestMap, bJ as resolveTileflowMapMode, bK as resolveTileflowRuntimeStyle, bL as resolveTileflowRuntimeTheme, bM as resolveTileflowRuntimeThemeBlend, bN as resolveTileflowRuntimeView, bO as resolveTileflowStaticImageUrl, bP as shouldLoadTileflowManifest, bQ as startTileflowSession, bR as tileflowPoiCategories, t as tileflowRuntimeManifestLimits, g as tileflowRuntimeManifestVersion, bS as tileflowStyleFontFaceLimits, bT as tileflowStyleFontFacesMetadataKey, bU as tileflowThemeBlendLimits, bV as tileflowThemeTokenCategories, bW as tileflowTimesOfDay, bX as token, bY as validateTileflowRuntimeSource, bZ as validateTileflowThemeBlendSelection, b_ as validateTileflowThemeSelection, b$ as zoom } from './manifest-types-DnhSJjCM.js';
+export { N as NormalizedTileflowCaptureScene, b as NormalizedTileflowCaptureShot, c as NormalizedTileflowCaptureShotCamera, d as TileflowCaptureApplicationTarget, e as TileflowCaptureBoundsCamera, f as TileflowCaptureCamera, g as TileflowCaptureCenterCamera, h as TileflowCaptureMapTarget, T as TileflowCaptureScene, a as TileflowCaptureShot, i as TileflowCaptureShotBlend, j as TileflowCaptureShotEasing, k as TileflowCaptureShotFrame, l as TileflowCaptureShotKeyframe, m as TileflowCaptureTarget, n as TileflowCaptureViewport, o as normalizeTileflowCaptureId, p as normalizeTileflowCaptureScene, q as normalizeTileflowCaptureShot, t as tileflowCaptureApplicationTargetSchema, r as tileflowCaptureBoundsCameraSchema, s as tileflowCaptureCameraSchema, u as tileflowCaptureCenterCameraSchema, v as tileflowCaptureIdSchema, w as tileflowCaptureMapTargetSchema, x as tileflowCaptureSceneLimits, y as tileflowCaptureSceneNameSchema, z as tileflowCaptureSceneSchema, A as tileflowCaptureSceneSchemaVersion, B as tileflowCaptureShotBlendSchema, C as tileflowCaptureShotFrameCount, D as tileflowCaptureShotFrames, E as tileflowCaptureShotKeyframeSchema, F as tileflowCaptureShotLimits, G as tileflowCaptureShotNameSchema, H as tileflowCaptureShotSchema, I as tileflowCaptureShotSchemaVersion, J as tileflowCaptureTargetSchema, K as tileflowCaptureViewportSchema } from './capture-shot-ChPQvPyi.js';
+export { tileflowPortableIdSchema, tileflowThemeNameSchema } from './capture.js';
+export { parseTileflowRuntimeManifest, safeParseTileflowRuntimeManifest, tileflowRuntimeManifestSchema } from './manifest.js';
+
+declare const tileflowPortableIdMaximumLength: 64;
+declare function isTileflowPortableId(value: unknown): value is string;
+declare function isTileflowThemeName(value: unknown): value is string;
+
+/** A value a choropleth can colour: a number for scales, a string for categories. */
+type TileflowBoundaryValue = number | string;
+/** One row of an application's data, keyed by a registry ID or an official code. */
+type TileflowBoundaryRow = Readonly<{
+    key: number | string;
+    /** `null` leaves the area without a value. */
+    value: TileflowBoundaryValue | null;
+}>;
+/** Keys present on every `boundary_area` polygon, usable without the lookup table. */
+type TileflowBoundaryFeatureKey = 'id' | 'iso_3166_1' | 'ref';
+/** Keys a row can carry. Those absent from the polygons need the lookup table. */
+type TileflowBoundaryCode = TileflowBoundaryFeatureKey | 'iso_3166_2' | 'nuts' | 'wikidata';
+/** Rows joined to areas by one polygon key. */
+type TileflowBoundaryValues = Readonly<{
+    joinBy: TileflowBoundaryFeatureKey;
+    rows: readonly TileflowBoundaryRow[];
+}>;
+/** One unit drawn as one class, as the release's lookup table lists it. */
+type TileflowBoundaryLookupRow = Readonly<{
+    admin_level?: number;
+    class: TileflowBoundaryClass;
+    class_tier?: TileflowBoundaryClassTier;
+    id: number;
+    iso_3166_1?: string;
+    iso_3166_2?: string;
     name?: string;
-    tileset?: string;
-    theme?: TileflowTheme | string | TileflowThemeConfig;
-    modules?: readonly TileflowModuleConfig[];
-    colors?: TileflowColorConfig;
-    typography?: TileflowTypography;
-    density?: TileflowDensity;
-    roads?: TileflowRoads;
-    labels?: TileflowLabels;
-    poi?: TileflowPoi;
-    buildings?: TileflowBuildings;
-    terrain?: TileflowTerrain;
-    glyphs?: string;
-    sprite?: string;
-    tiles?: TileflowTiles;
-    view?: TileflowViewConfig;
+    name_en?: string;
+    nuts?: string;
+    ref?: string;
+    wikidata?: string;
+}>;
+type TileflowBoundaryLookup = Readonly<{
+    /** Lookup rows whose code equals `key`, optionally limited to some classes. */
+    find: (joinBy: TileflowBoundaryCode, key: number | string, classes?: readonly TileflowBoundaryClass[]) => readonly TileflowBoundaryLookupRow[];
+    rows: readonly TileflowBoundaryLookupRow[];
+}>;
+type TileflowBoundaryJoinResult = TileflowBoundaryValues & Readonly<{
+    /** Keys that resolved to more than one unit; their rows are left out. */
+    ambiguous: readonly (number | string)[];
+    /** Keys that appeared more than once; the last row wins. */
+    duplicates: readonly (number | string)[];
+    /** Keys that matched no unit. */
+    unmatched: readonly (number | string)[];
+}>;
+type JoinBoundaryRowsOptions = Readonly<{
+    /** Limit lookup matches to these classes, for codes shared across a unit's classes. */
+    classes?: readonly TileflowBoundaryClass[];
+    /** The key the rows carry. */
+    joinBy: TileflowBoundaryCode;
+    /** Required unless the rows already carry the target key. */
+    lookup?: TileflowBoundaryLookup;
+    /** The feature key to produce: the registry ID (default) or `ref`. */
+    to?: 'id' | 'ref';
+}>;
+/**
+ * Re-key rows to the feature key a choropleth or feature-state uses. Keys are normalized:
+ * ISO 3166, NUTS and Wikidata codes are trimmed and upper-cased; `ref` is trimmed.
+ */
+declare function joinBoundaryRows(rows: readonly TileflowBoundaryRow[], options: JoinBoundaryRowsOptions): TileflowBoundaryJoinResult;
+/** Index lookup rows by every code they carry. */
+declare function createBoundaryLookup(rows: readonly TileflowBoundaryLookupRow[]): TileflowBoundaryLookup;
+/**
+ * Parse the text of a Boundaries release's `boundaries-lookup.csv` (after decompressing the
+ * `.csv.gz`). Columns the join does not use are ignored; empty cells are omitted.
+ */
+declare function parseBoundaryLookupCsv(text: string): TileflowBoundaryLookupRow[];
+
+/** A MapLibre expression that evaluates to a color. */
+type TileflowColorExpression = readonly [string, ...unknown[]];
+type TileflowChoroplethStop = readonly [value: number, color: string];
+/** Colors below the first threshold are `base`; each stop starts a new color class. */
+type TileflowChoroplethStepScale = Readonly<{
+    base: string;
+    kind: 'step';
+    stops: readonly TileflowChoroplethStop[];
+}>;
+/** Colors interpolated linearly between stops and clamped outside them. */
+type TileflowChoroplethLinearScale = Readonly<{
+    kind: 'linear';
+    stops: readonly TileflowChoroplethStop[];
+}>;
+/** One color per category value. */
+type TileflowChoroplethCategoryScale = Readonly<{
+    categories: Readonly<Record<string, string>>;
+    kind: 'categories';
+}>;
+type TileflowChoroplethScale = TileflowChoroplethCategoryScale | TileflowChoroplethLinearScale | TileflowChoroplethStepScale;
+/** Validated color scales for choropleths. */
+declare const choroplethScale: Readonly<{
+    categories(categories: Readonly<Record<string, string>>): TileflowChoroplethCategoryScale;
+    linear(stops: readonly TileflowChoroplethStop[]): TileflowChoroplethLinearScale;
+    step(base: string, stops: readonly TileflowChoroplethStop[]): TileflowChoroplethStepScale;
+}>;
+/**
+ * The color a scale gives `input`. Areas whose value does not fit the scale (no value, a string on
+ * a numeric scale, or an unknown category) get `missingColor`.
+ */
+declare function choroplethColorExpression(scale: TileflowChoroplethScale, input: unknown, missingColor: string): TileflowColorExpression;
+type TileflowBoundaryChoroplethOutline = Readonly<{
+    color: string;
+    /** Line width in pixels. Defaults to 0.5. */
+    width?: number;
+}>;
+type TileflowBoundaryChoroplethOptions = Readonly<{
+    /** Classes to color, such as `['municipality']`. */
+    classes: readonly TileflowBoundaryClass[];
+    /** Limit areas to these ISO 3166-1 alpha-2 countries. */
+    countries?: readonly string[];
+    /** Defaults to `boundaries`. The map must declare the same family in `boundaryAreas`. */
+    family?: TileflowBoundaryFamily;
+    /** Portable ID; the overlay's layers are `<id>-fill` and, with an outline, `<id>-outline`. */
+    id: string;
+    maxzoom?: number;
+    /** Defaults to the first zoom at which the selected classes appear. */
+    minzoom?: number;
+    /** Defaults to transparent, which leaves areas without a value uncolored. */
+    missingColor?: string;
+    /** Fill opacity from 0 to 1. Defaults to 0.8. */
+    opacity?: number;
+    outline?: false | TileflowBoundaryChoroplethOutline;
+    /** Defaults to `below-labels`. */
+    placement?: TileflowOverlayPlacement;
+    scale: TileflowChoroplethScale;
+    /** Feature-state key read when `values` is omitted. Defaults to `value`. */
+    state?: string;
+    /** Limit areas to one class tier. */
+    tiers?: readonly TileflowBoundaryClassTier[];
     /**
-     * Domains allowed to load this map in production (e.g. "example.com" or
-     * "*.example.com"). When set, tile and session requests from other
-     * websites are rejected. Local development (localhost, private network
-     * addresses) is always allowed. Leave unset to allow any domain.
+     * Values compiled into the style. Omit them to color areas from feature-state set at run time
+     * with `createBoundaryFeatureState` from `@tileflow/core/browser`.
      */
-    allowedOrigins?: string[];
+    values?: TileflowBoundaryValues;
+}>;
+/** Layer metadata key that records how a choropleth reads its values. */
+declare const tileflowBoundaryChoroplethMetadataKey: "tileflow:boundaryChoropleth";
+type TileflowBoundaryChoroplethMetadata = Readonly<{
+    family: TileflowBoundaryFamily;
+    joinBy?: TileflowBoundaryFeatureKey;
+    state?: string;
+}>;
+/** An overlay that colors Boundaries areas from values or feature-state. */
+declare function boundaryChoropleth(options: TileflowBoundaryChoroplethOptions): TileflowMapLibreOverlay;
+
+/** Exact immutable release identity contract for the current World V1 product. */
+declare const tileflowWorldReleaseIdMinimumLength: 12;
+declare const tileflowWorldReleaseIdMaximumLength: 128;
+declare const tileflowWorldReleaseIdPatternSource: "^world-v1-[a-z0-9][a-z0-9._-]*[a-z0-9]$";
+declare const tileflowWorldReleaseIdPattern: RegExp;
+/** Validate without trimming, lowercasing, or otherwise normalizing an immutable release ID. */
+declare function isTileflowWorldReleaseId(value: unknown): value is string;
+
+declare const tileflowWorldReleaseIdSchema: z.ZodString;
+
+/** Base color roles required by the semantic compiler; other roles derive from these. */
+declare const tileflowRequiredThemeColorRoles: readonly ("boundaries.default" | "labels.halo" | "labels.muted" | "labels.primary" | "roads.casing" | "roads.default" | "roads.major" | "surface.background" | "surface.building" | "surface.land" | "surface.park" | "surface.water")[];
+
+type ExactTileflowMap<TContract, TMap extends TContract> = TMap & Record<Exclude<keyof TMap, keyof TContract>, never>;
+type ExactTileflowMapScenes<TMap> = TMap extends {
+    scenes: infer TScenes extends Record<string, TileflowMapScene>;
+} ? {
+    scenes: {
+        [TName in keyof TScenes]: ExactTileflowMap<TileflowMapScene, TScenes[TName]>;
+    };
+} : unknown;
+type ExactTileflowMapShots<TMap> = TMap extends {
+    shots: infer TShots extends Record<string, TileflowMapShot>;
+} ? {
+    shots: {
+        [TName in keyof TShots]: ExactTileflowMap<TileflowMapShot, TShots[TName]>;
+    };
+} : unknown;
+/** Preserve the exact inferred type of a standalone or inherited semantic map. */
+declare function defineMap<const TMap extends TileflowMap>(map: ExactTileflowMap<TileflowMap, TMap> & ExactTileflowMapScenes<TMap> & ExactTileflowMapShots<TMap>): TMap;
+
+declare const tileflowMapDefaultMaxDepth = 64;
+/** Structured authoring failure surfaced unchanged by validate/explain JSON commands. */
+declare class TileflowMapResolutionError extends Error {
+    readonly code: string;
+    readonly mapId: string;
+    readonly path: string;
+    constructor(code: string, mapId: string, path: string, message: string);
+}
+/** Resolve an imported map lineage to one standalone authoring map. */
+declare function resolveMap(map: TileflowMap, options?: ResolveMapOptions): ResolvedTileflowMap;
+
+/**
+ * The steepest camera pitch Tileflow supports, in degrees from looking straight down. Every
+ * portable view admits pitch 0–85, and Tileflow's maps raise MapLibre's own default of 60 to this,
+ * so a street-level view looks along the street to the sky. A map's `mapOptions.maxPitch` lowers it.
+ */
+declare const tileflowMaxPitch = 85;
+
+/** Portable generated-index shape; geometry and pixel integrity require paired artifact verification. */
+declare const tileflowIconSpriteIndexEntrySchema: 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>>;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    pixelRatio: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    sdf: z.ZodOptional<z.ZodLiteral<true>>;
+    tileflow: 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>>;
+}, z.core.$strict>;
+declare const tileflowIconSpriteIndexSchema: z.ZodRecord<z.ZodString, 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>>;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    pixelRatio: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    sdf: z.ZodOptional<z.ZodLiteral<true>>;
+    tileflow: 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>>;
+}, z.core.$strict>>;
+type TileflowIconSpriteIndexEntry = z.infer<typeof tileflowIconSpriteIndexEntrySchema>;
+type TileflowIconSpriteIndex = z.infer<typeof tileflowIconSpriteIndexSchema>;
+
+type PremultipliedColor = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
 };
-type TileflowMapConfig = TileflowConfig;
-type TileflowTilesetConfig = {
-    id?: string;
-    name?: string;
-    attribution?: string;
-    sourceLayers?: TileflowSourceLayers;
+type TileflowIconPreviewPaint = {
+    color: PremultipliedColor;
+    haloColor: PremultipliedColor;
+    haloWidth: number;
+    haloBlur: number;
 };
-type TileflowProjectThemes = Partial<Record<TileflowThemeName, TileflowThemeConfig>>;
-type TileflowProjectConfig = {
-    themes?: TileflowProjectThemes;
-    tilesets?: Record<string, TileflowTilesetConfig>;
-    maps: Record<string, TileflowMapConfig>;
+declare function resolveTileflowIconPreviewPaint(appearance: TileflowIconAppearance): TileflowIconPreviewPaint;
+/** Self-contained runtime for default-appearance previews and static canvas composition. */
+declare function createTileflowIconPreviewRuntime(): {
+    render: (rgba: Uint8Array, pixelRatio: number, paint: TileflowIconPreviewPaint) => Uint8ClampedArray;
 };
-type TileflowStyleOptions = {
-    themes?: TileflowProjectThemes;
-    tileBaseUrl?: string;
-    tileset?: string;
+/** Preserve RGBA cells and replace only SDF rectangles with their default appearance. */
+declare function renderTileflowIconAtlasPixels(rgba: Uint8Array, width: number, height: number, index: TileflowIconSpriteIndex): Uint8ClampedArray;
+
+/** Structured schema failure preserved for CLI/editor diagnostics. */
+declare class TileflowResolvedMapValidationError extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly messages: ValidationMessage[];
+    readonly phase: "config-validation";
+    constructor(name: string, messages: ValidationMessage[]);
+}
+declare function parseResolvedTileflowMap(input: unknown): ResolvedTileflowMap;
+
+declare const auxiliaryFieldBindings: Readonly<{
+    bathymetryContourDepth: "depth";
+}>;
+type TileflowDataFieldName = keyof OpenMapTilesFieldBindings | keyof typeof auxiliaryFieldBindings;
+/** A schema-bound data field whose physical name is assigned only during compilation. */
+type TileflowDataFieldReference<TName extends TileflowDataFieldName = TileflowDataFieldName> = Readonly<{
+    kind: 'tileflow-data-field';
+    name: TName;
+}>;
+type TileflowNumericDataFieldName = 'activityScore' | 'adminLevel' | 'bathymetryContourDepth' | 'bathymetryMinDepth' | 'bathymetrySortKey' | 'canopyClearanceAtZoom15' | 'canopyCoverPercent' | 'canopyRank' | 'circularClearanceExtraAtZoom15' | 'circularInnerRadiusMeters' | 'circularOuterRadiusMeters' | 'circularRadiusAtZoom15' | 'circularRadiusMeters' | 'confidence' | 'circumference' | 'diameterCrown' | 'elevation' | 'elevationFeet' | 'hasParts' | 'height' | 'hide3d' | 'importanceTier' | 'minHeight' | 'minZoom' | 'oneway' | 'poiFilterRank' | 'poiSizeRank' | 'ramp' | 'rank' | 'refLength' | 'renderHeight' | 'renderMinHeight' | 'shieldLineLengthMeters' | 'shieldRank';
+/** Runtime value implied by one registered semantic field, independent of its physical name. */
+type TileflowDataFieldValue<TName extends TileflowDataFieldName> = TName extends TileflowNumericDataFieldName ? number : string;
+/**
+ * Reference a semantic field in a typed expression. Primary fields follow the active data schema;
+ * auxiliary fields use their fixed product contract at the final lowering boundary.
+ */
+declare function field<const TName extends TileflowDataFieldName>(name: TName): TileflowDataFieldReference<TName>;
+
+/** The value a themed authoring node produces after theme resolution. */
+type TileflowDataExpressionResult<T> = T extends TileflowFixedValue<infer TValue> ? TValue : T extends TileflowThemeTokenReference<infer TCategory> ? TCategory extends 'number' ? number : string : T extends TileflowThemeColorOperation ? string : T;
+type TileflowDataExpressionInput<T> = TileflowDataFieldReference | TileflowExpression<T> | T;
+type TileflowDataMatchBranch<TInput extends boolean | number | string, TOutput> = Readonly<{
+    labels: TInput | readonly TInput[];
+    value: TileflowDataExpressionInput<TOutput>;
+}>;
+type TileflowDataCaseBranch<T> = Readonly<{
+    value: TileflowDataExpressionInput<T>;
+    when: TileflowDataExpressionInput<boolean>;
+}>;
+type TileflowDataInterpolation = Readonly<{
+    kind: 'linear';
+}> | Readonly<{
+    base: number;
+    kind: 'exponential';
+}> | Readonly<{
+    kind: 'cubic-bezier';
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+}>;
+type TileflowDataStop<T> = readonly [number, TileflowDataExpressionInput<T>];
+declare const tileflowDataExpressionLimits: Readonly<{
+    readonly maxBranches: 16;
+    readonly maxOperands: 16;
+    readonly maxStops: 16;
+}>;
+declare function get<TName extends TileflowDataFieldReference['name']>(reference: TileflowDataFieldReference<TName>): TileflowExpression<TileflowDataFieldValue<TName>>;
+declare function literal<T>(value: T): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function zoom(): TileflowExpression<number>;
+declare function id(): TileflowExpression<string | number | null>;
+declare function coalesce<T>(first: TileflowDataExpressionInput<T>, ...rest: readonly TileflowDataExpressionInput<T>[]): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function toNumber(value: TileflowDataExpressionInput<unknown>, fallback?: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function toBoolean(value: TileflowDataExpressionInput<unknown>, fallback?: TileflowDataExpressionInput<boolean>): TileflowExpression<boolean>;
+declare function toString(value: TileflowDataExpressionInput<unknown>): TileflowExpression<string>;
+declare function featureState(name: string): TileflowExpression<unknown>;
+declare function globalState(name: string): TileflowExpression<unknown>;
+declare function variable<T>(name: string): TileflowExpression<T>;
+declare function letValue<TBinding, TResult>(name: string, value: TileflowDataExpressionInput<TBinding>, body: TileflowDataExpressionInput<TResult>): TileflowExpression<TileflowDataExpressionResult<TResult>>;
+declare function abs(value: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function add(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function subtract(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function divide(dividend: TileflowDataExpressionInput<number>, divisor: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function modulo(dividend: TileflowDataExpressionInput<number>, divisor: TileflowDataExpressionInput<number>): TileflowExpression<number>;
+declare function multiply(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function minimum(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function maximum(first: TileflowDataExpressionInput<number>, second: TileflowDataExpressionInput<number>, ...rest: readonly TileflowDataExpressionInput<number>[]): TileflowExpression<number>;
+declare function concat(first: TileflowDataExpressionInput<string>, ...rest: readonly TileflowDataExpressionInput<string>[]): TileflowExpression<string>;
+declare function all(first: TileflowDataExpressionInput<boolean>, ...rest: readonly TileflowDataExpressionInput<boolean>[]): TileflowExpression<boolean>;
+declare function any(first: TileflowDataExpressionInput<boolean>, ...rest: readonly TileflowDataExpressionInput<boolean>[]): TileflowExpression<boolean>;
+declare function not(value: TileflowDataExpressionInput<boolean>): TileflowExpression<boolean>;
+declare function has(reference: TileflowDataFieldReference): TileflowExpression<boolean>;
+declare function match<TInput extends boolean | number | string, TOutput>(input: TileflowDataExpressionInput<TInput>, branches: readonly [
+    TileflowDataMatchBranch<TInput, TOutput>,
+    ...TileflowDataMatchBranch<TInput, TOutput>[]
+], fallback: TileflowDataExpressionInput<TOutput>): TileflowExpression<TileflowDataExpressionResult<TOutput>>;
+declare function caseValue<T>(branches: readonly [TileflowDataCaseBranch<T>, ...TileflowDataCaseBranch<T>[]], fallback: TileflowDataExpressionInput<T>): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function step<T>(input: TileflowDataExpressionInput<number>, fallback: TileflowDataExpressionInput<T>, stops: readonly [TileflowDataStop<T>, ...TileflowDataStop<T>[]]): TileflowExpression<TileflowDataExpressionResult<T>>;
+declare function interpolate<T>(interpolation: TileflowDataInterpolation, input: TileflowDataExpressionInput<number>, stops: readonly [TileflowDataStop<T>, ...TileflowDataStop<T>[]]): TileflowExpression<TileflowDataExpressionResult<T>>;
+/**
+ * Closed, typed data-expression builders. They preserve semantic field refs
+ * and lower to byte-equivalent MapLibre expressions only inside the compiler.
+ */
+declare const expr: Readonly<{
+    abs: typeof abs;
+    add: typeof add;
+    all: typeof all;
+    any: typeof any;
+    case: typeof caseValue;
+    coalesce: typeof coalesce;
+    concat: typeof concat;
+    divide: typeof divide;
+    eq: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    get: typeof get;
+    gt: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    gte: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    has: typeof has;
+    id: typeof id;
+    featureState: typeof featureState;
+    globalState: typeof globalState;
+    interpolate: typeof interpolate;
+    let: typeof letValue;
+    literal: typeof literal;
+    lt: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    lte: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    match: typeof match;
+    max: typeof maximum;
+    min: typeof minimum;
+    modulo: typeof modulo;
+    multiply: typeof multiply;
+    ne: <T>(left: TileflowDataExpressionInput<T>, right: TileflowDataExpressionInput<T>) => TileflowExpression<boolean>;
+    not: typeof not;
+    step: typeof step;
+    subtract: typeof subtract;
+    toBoolean: typeof toBoolean;
+    toNumber: typeof toNumber;
+    toString: typeof toString;
+    var: typeof variable;
+    zoom: typeof zoom;
+}>;
+
+declare const tileflowRenderStackRenderers: readonly ["background", "circle", "extrusion", "fill", "line", "symbol"];
+declare const tileflowRenderSelectorKinds: readonly ["all", "any", "compare", "geometry", "has", "in", "literal", "match", "not", "step"];
+declare const tileflowRenderSelectorComparisons: readonly ["eq", "gt", "gte", "lt", "lte", "ne"];
+declare const tileflowRenderSelectorGeometries: readonly ["line", "point", "polygon"];
+declare const tileflowRenderStackLimits: Readonly<{
+    readonly maxMatchBranches: 16;
+    readonly maxOperations: 64;
+    readonly maxRequirements: number;
+    readonly maxScalarValues: 16;
+    readonly maxSelectorChildren: 16;
+    readonly maxSelectorDepth: 64;
+    readonly maxSelectorNodes: 256;
+    readonly maxStepStops: 16;
+}>;
+/**
+ * Where a render pass draws, or where a refinement moves its target: at a band edge, or
+ * immediately above or below one semantic target. Operations sharing a placement paint in
+ * declaration order, the first lowest.
+ */
+type TileflowRenderPlacement = TileflowBandPlacement | {
+    readonly above: string;
+    readonly below?: never;
+} | {
+    readonly above?: never;
+    readonly below: string;
 };
-type TileflowManifest = {
-    version: 1;
-    tileBaseUrl: string;
-    styles: Record<string, string>;
-    maps: Record<string, string>;
-};
-type MapLibreStyle = {
-    version: 8;
-    name: string;
-    glyphs?: string;
-    sprite?: string;
-    sources: Record<string, Record<string, unknown>>;
-    layers: Array<Record<string, unknown>>;
-    terrain?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-};
-type ValidationMessage = {
-    level: 'error' | 'warning';
+type TileflowRenderFeature = keyof OpenMapTilesLayerBindings;
+type TileflowRenderField = keyof OpenMapTilesFieldBindings;
+type TileflowRenderScalar = boolean | number | string;
+type TileflowRenderGeometry = (typeof tileflowRenderSelectorGeometries)[number];
+type TileflowRenderComparison = (typeof tileflowRenderSelectorComparisons)[number];
+type TileflowNormalizedRenderField = {
+    /** Convert the bound field before comparing it. */
+    readonly coerce?: 'number';
+    /** Coalesced value, or the numeric conversion fallback when `coerce` is `number`. */
+    readonly fallback?: TileflowRenderScalar;
+    readonly field: TileflowRenderField;
+};
+type TileflowRenderSelector = {
+    readonly kind: 'all' | 'any';
+    readonly selectors: readonly TileflowRenderSelector[];
+} | (TileflowNormalizedRenderField & {
+    readonly kind: 'compare';
+    readonly operator: TileflowRenderComparison;
+    readonly value: TileflowRenderScalar;
+}) | {
+    readonly geometry: TileflowRenderGeometry;
+    readonly kind: 'geometry';
+} | {
+    readonly field: TileflowRenderField;
+    readonly kind: 'has';
+} | (TileflowNormalizedRenderField & {
+    readonly kind: 'in';
+    readonly values: readonly TileflowRenderScalar[];
+}) | {
+    readonly kind: 'literal';
+    readonly value: boolean;
+} | (TileflowNormalizedRenderField & {
+    readonly branches: readonly {
+        readonly result: boolean;
+        readonly values: readonly TileflowRenderScalar[];
+    }[];
+    readonly kind: 'match';
+    readonly otherwise: boolean;
+}) | {
+    readonly kind: 'not';
+    readonly selector: TileflowRenderSelector;
+} | {
+    readonly fallback: TileflowRenderSelector;
+    readonly kind: 'step';
+    readonly stops: readonly {
+        readonly selector: TileflowRenderSelector;
+        readonly zoom: number;
+    }[];
+};
+type TileflowRenderVisibilityGroup = 'building';
+type TileflowRenderStyle<TStyle> = TStyle & {
+    /** Runtime-controlled group; hidden initially and toggled without raw metadata authoring. */
+    readonly visibilityGroup?: TileflowRenderVisibilityGroup;
+};
+type TileflowRenderPassCommon = {
+    /**
+     * A band edge, or above/below one semantic target. Passes placed beside a target take its
+     * band and, without their own `feature`, its vector data.
+     */
+    readonly placement: TileflowRenderPlacement;
+    /** Additional rendered domains required by this pass. Data `feature` bindings are independent. */
+    readonly requirements?: readonly TileflowLayerDomain[];
+};
+type TileflowVectorRenderPass<TRenderer extends string, TStyle> = TileflowRenderPassCommon & {
+    readonly feature?: TileflowRenderFeature;
+    readonly renderer: TRenderer;
+    readonly selector?: TileflowRenderSelector;
+    readonly style: TileflowRenderStyle<TStyle>;
+};
+type TileflowRenderPassInput = (TileflowRenderPassCommon & {
+    readonly feature?: never;
+    readonly renderer: 'background';
+    readonly selector?: never;
+    readonly style: TileflowRenderStyle<TileflowBackgroundStyle>;
+}) | TileflowVectorRenderPass<'circle', TileflowCircleStyle> | TileflowVectorRenderPass<'extrusion', TileflowExtrusionStyle> | TileflowVectorRenderPass<'fill', TileflowFillStyle> | TileflowVectorRenderPass<'line', TileflowLineStyle> | TileflowVectorRenderPass<'symbol', TileflowSymbolStyle>;
+type TileflowRenderPass = TileflowRenderPassInput & {
+    readonly kind: 'render-pass';
+};
+type TileflowRefinementCommon<TRenderer extends string, TStyle> = {
+    /** Moves the target, with every pass placed beside it, to another position. */
+    readonly placement?: TileflowRenderPlacement;
+    /** Rendered domains required for this refinement's semantic target to exist. */
+    readonly requirements?: readonly TileflowLayerDomain[];
+    readonly renderer: TRenderer;
+    readonly selector?: TileflowRenderSelector;
+    readonly style: TileflowRenderStyle<TStyle>;
+    readonly target: string;
+};
+/** A refinement that only moves its target, keeping its style and selection. */
+type TileflowPlacementRefinement = {
+    readonly placement: TileflowRenderPlacement;
+    readonly renderer?: never;
+    readonly requirements?: readonly TileflowLayerDomain[];
+    readonly selector?: never;
+    readonly style?: never;
+    readonly target: string;
+};
+type TileflowRenderTargetRefinementInput = (Omit<TileflowRefinementCommon<'background', TileflowBackgroundStyle>, 'selector'> & {
+    readonly selector?: never;
+}) | TileflowRefinementCommon<'circle', TileflowCircleStyle> | TileflowRefinementCommon<'extrusion', TileflowExtrusionStyle> | TileflowRefinementCommon<'fill', TileflowFillStyle> | TileflowRefinementCommon<'line', TileflowLineStyle> | TileflowRefinementCommon<'symbol', TileflowSymbolStyle> | TileflowPlacementRefinement;
+type TileflowRenderTargetRefinement = TileflowRenderTargetRefinementInput & {
+    readonly kind: 'refine-render-target';
+};
+type TileflowRenderStackOperation = TileflowRenderPass | TileflowRenderTargetRefinement;
+type TileflowNamedRenderStack = Readonly<Record<string, TileflowRenderStackOperation>>;
+type TileflowModuleWithRenderStack<TModule extends {
+    readonly type: TileflowLayerDomain;
+}, TStack extends TileflowNamedRenderStack> = TModule & {
+    readonly renderStack: TStack;
+};
+/** Define one ownerless render pass. Its owner and stable name are assigned by `withRenderStack`. */
+declare function renderPass(input: TileflowRenderPassInput): TileflowRenderPass;
+/** Define an owner-local refinement without exposing a raw layer patch. */
+declare function refineRenderTarget(input: TileflowRenderTargetRefinementInput): TileflowRenderTargetRefinement;
+/** Attach a named render stack while retaining the module's exact inferred owner and options. */
+declare function withRenderStack<const TModule extends {
+    readonly type: TileflowLayerDomain;
+}, const TStack extends TileflowNamedRenderStack>(module: TModule & {
+    readonly renderStack?: never;
+}, namedRecord: TStack): TileflowModuleWithRenderStack<TModule, TStack>;
+
+/** Internal compiler identity. Authoring maps never select or version this implementation. */
+declare const tileflowSemanticCompilerIdentity: Readonly<{
+    readonly name: "tileflow-semantic";
+    readonly version: 1;
+}>;
+
+declare const tileflowAuthoringManifestSchemaVersion: 2;
+type TileflowAuthoringCommandName = 'explain' | 'inspect' | 'language-manifest' | 'language-schema' | 'semantic-diff' | 'validate';
+type TileflowAuthoringCommandOutputKind = 'command-envelope' | 'raw-authoring-manifest' | 'raw-config-reference';
+type TileflowAuthoringCommand = Readonly<{
+    command: string;
+    name: TileflowAuthoringCommandName;
+    output: string;
+    outputKind: TileflowAuthoringCommandOutputKind;
+    /** Stable identifier for the exact versioned JSON contract emitted on success. */
+    outputSchemaRef: string;
+    outputVersion: 1 | 2 | 4;
+    purpose: string;
+    writes: false;
+}>;
+type TileflowAuthoringExpressionBuilder = Readonly<{
+    arguments: readonly string[];
+    name: keyof typeof expr;
+    returns: string;
+    serializedOperator: string;
+}>;
+type TileflowAuthoringOperation = Readonly<{
+    api: string;
+    description: string;
+    name: 'define-map' | 'data-expression' | 'disable-domain' | 'hosted-source' | 'maplibre-overlay' | 'remove-resource' | 'extend-map' | 'refine-domain' | 'refine-render-target' | 'render-pass' | 'reset-value' | 'replace-domain';
+    scope: 'domain' | 'expression' | 'map' | 'render-stack' | 'resource';
+}>;
+type TileflowAuthoringManifestDomain = Readonly<{
+    api: string;
+    authoringSchemaRef: string;
+    dependencies: Readonly<{
+        modules: readonly TileflowSemanticModuleName[];
+        services: readonly string[];
+    }>;
+    name: TileflowSemanticModuleName;
+    optionsSchemaRef: string;
+    order: number;
+    patchSchemaRef: string;
+    provides: readonly string[];
+    resolvedSchemaRef: string;
+    targetDiscovery: Readonly<{
+        command: 'tileflow explain --json';
+        domain: TileflowSemanticModuleName;
+        reportPath: 'compilation.report.domains[].targets';
+    }>;
+}>;
+type TileflowAuthoringManifest = Readonly<{
+    compilation: Readonly<{
+        diagnostic: Readonly<{
+            optional: readonly ['domain', 'path', 'suggestion', 'target'];
+            phases: typeof tileflowCompilationPhases;
+            required: readonly ['code', 'message', 'phase', 'severity'];
+            severities: readonly ['error', 'warning'];
+        }>;
+        report: Readonly<{
+            domain: Readonly<{
+                optional: readonly ['suppressionReason'];
+                required: readonly [
+                    'contributionCount',
+                    'name',
+                    'renderOperationCount',
+                    'status',
+                    'targets'
+                ];
+                statuses: readonly ['emitted', 'suppressed'];
+                suppressionReasons: readonly ['disabled', 'no-contributions'];
+            }>;
+            optional: readonly ['decisions', 'provenance', 'requirements', 'theme'];
+            decisions: Readonly<{
+                required: readonly ['path', 'source', 'value', 'reason', 'override'];
+                sources: readonly ['default', 'map', 'theme', 'derived'];
+                scope: 'color-roles-and-selected-module-policies';
+            }>;
+            planner: Readonly<{
+                optional: readonly ['candidateCount', 'selectedCount'];
+                required: readonly ['inputCount', 'outputCount', 'stage'];
+                stages: typeof tileflowCompilationPlannerStages;
+            }>;
+            required: readonly ['domains', 'map', 'planner', 'schemaVersion', 'targets'];
+            schemaVersion: typeof tileflowCompilationReportSchemaVersion;
+        }>;
+        physicalInspection: Readonly<{
+            addressable: false;
+            command: 'tileflow explain --inspection --json';
+            mode: 'opt-in-read-only';
+            reportPath: 'compilation.report.provenance';
+            stability: 'physical-output-only';
+        }>;
+        result: Readonly<{
+            discriminator: 'ok';
+            failure: Readonly<{
+                forbidden: readonly ['style'];
+                ok: false;
+                required: readonly ['diagnostics', 'ok', 'report'];
+            }>;
+            success: Readonly<{
+                ok: true;
+                required: readonly ['diagnostics', 'ok', 'report', 'style'];
+            }>;
+        }>;
+    }>;
+    compiler: Readonly<{
+        name: typeof tileflowSemanticCompilerIdentity.name;
+        version: typeof tileflowSemanticCompilerIdentity.version;
+    }>;
+    commands: readonly TileflowAuthoringCommand[];
+    domains: readonly TileflowAuthoringManifestDomain[];
+    expressions: Readonly<{
+        builders: readonly TileflowAuthoringExpressionBuilder[];
+        categorySchemaRefs: Readonly<{
+            color: '#/$defs/TileflowDataExpressionColor';
+            image: '#/$defs/TileflowDataExpressionImage';
+            number: '#/$defs/TileflowDataExpressionNumber';
+            structural: '#/$defs/TileflowDataExpressionStructural';
+        }>;
+        limits: typeof tileflowDataExpressionLimits;
+        fieldReference: 'field(name)';
+    }>;
+    language: 'tileflow-semantic-v1';
+    themes: Readonly<{
+        api: 'defineTheme(definition) or defineTheme(base, definition)';
+        requiredColorRoles: typeof tileflowRequiredThemeColorRoles;
+        lightingReset: 'reset() removes inherited lighting, sun, ambient, or individual light properties during defineTheme composition';
+        timeOfDay: 'optional; an omitted catalog adds no variants or clock';
+        decisionReport: 'compilation.report.decisions';
+    }>;
+    operations: readonly TileflowAuthoringOperation[];
+    renderStack: Readonly<{
+        comparisons: readonly string[];
+        features: readonly string[];
+        fields: readonly string[];
+        geometries: readonly string[];
+        limits: typeof tileflowRenderStackLimits;
+        operationNamePattern: string;
+        placements: Readonly<{
+            bands: readonly string[];
+            targets: readonly string[];
+        }>;
+        renderers: readonly string[];
+        selectorKinds: readonly string[];
+        targetPattern: string;
+    }>;
+    resources: Readonly<{
+        hostedSources: Readonly<{
+            api: 'hostedTileset({ tileset, local, attribution, type?, tileSize? })';
+            localResolution: 'explicit-relative-pmtiles';
+            maxPerMap: typeof tileflowHostedSourceLimit;
+            identity: 'keyed-source-id-and-team-local-tileset';
+        }>;
+        overlays: Readonly<{
+            api: 'maplibreOverlay({ source, placement, layers })';
+            layers: 'ordered-maplibre-style-layers-without-source';
+            placement: typeof tileflowOverlayPlacements;
+            replacement: 'atomic-by-overlay-id';
+        }>;
+        removal: 'remove()';
+    }>;
+    resolution: Readonly<{
+        arrays: 'replace';
+        domains: 'replace-refine-disable-reset';
+        identity: 'leaf-owned';
+        inheritance: Readonly<{
+            maxDepth: typeof tileflowMapDefaultMaxDepth;
+        }>;
+        keyedResources: 'merge-replace-remove';
+        namedRecords: 'merge-by-key';
+        records: 'deep-merge';
+        scalars: 'replace';
+        themes: 'replace-collection';
+        view: 'deep-merge';
+    }>;
+    schemaVersion: typeof tileflowAuthoringManifestSchemaVersion;
+    schemas: Readonly<{
+        authoring: '#/$defs/TileflowAuthoringMap';
+        document: 'https://tileflow.dev/schemas/tileflow-config-reference-v4.json';
+        modules: '#/$defs/TileflowAuthoringModules';
+        resolved: '#/$defs/ResolvedTileflowMap';
+    }>;
+    workflows: Readonly<{
+        author: readonly ['validate', 'inspect', 'explain'];
+        discover: readonly ['language-manifest', 'language-schema'];
+        review: readonly ['semantic-diff', 'validate', 'explain'];
+    }>;
+}>;
+/**
+ * Stable, JSON-serializable description of the complete public V1 authoring surface.
+ * Domain order and dependencies come directly from the closed compiler registry.
+ */
+declare const tileflowAuthoringManifest: TileflowAuthoringManifest;
+
+declare const tileflowSemanticDiffSchemaVersion: 1;
+type TileflowSemanticMapIdentity = Readonly<{
+    id: string;
+    version: number;
+}>;
+type TileflowSemanticJsonValue = boolean | null | number | string | readonly TileflowSemanticJsonValue[] | Readonly<{
+    [key: string]: TileflowSemanticJsonValue;
+}>;
+type TileflowSemanticAdd = Readonly<{
+    after: TileflowSemanticJsonValue;
+    kind: 'add';
+    path: string;
+}>;
+type TileflowSemanticRemove = Readonly<{
+    before: TileflowSemanticJsonValue;
+    kind: 'remove';
     path: string;
-    message: string;
+}>;
+type TileflowSemanticChange = Readonly<{
+    after: TileflowSemanticJsonValue;
+    before: TileflowSemanticJsonValue;
+    kind: 'change';
+    path: string;
+}>;
+type TileflowSemanticDifference = TileflowSemanticAdd | TileflowSemanticChange | TileflowSemanticRemove;
+type TileflowSemanticDiff = Readonly<{
+    changes: readonly TileflowSemanticDifference[];
+    from: TileflowSemanticMapIdentity;
+    schemaVersion: typeof tileflowSemanticDiffSchemaVersion;
+    summary: Readonly<{
+        add: number;
+        change: number;
+        remove: number;
+        total: number;
+    }>;
+    to: TileflowSemanticMapIdentity;
+}>;
+/**
+ * Compare the resolved semantic designs of two maps. Identity metadata identifies the endpoints
+ * but is intentionally not reported as a cartographic change. Arrays are atomic because map
+ * inheritance replaces them rather than merging their members.
+ */
+declare function diffTileflowMaps(from: TileflowMap | ResolvedTileflowMap, to: TileflowMap | ResolvedTileflowMap): TileflowSemanticDiff;
+
+type TileflowZoomPerformance = {
+    activeLayers: number;
+    sourceLayers: Record<string, number>;
+    styleLayerFamilies: number;
+    symbols: number;
+    zoom: number;
 };
-type ValidationResult = {
-    valid: boolean;
-    messages: ValidationMessage[];
+type TileflowStylePerformance = {
+    styleBytes: number;
+    totalLayers: number;
+    zooms: TileflowZoomPerformance[];
 };
-declare function createStyle(input?: TileflowConfig, options?: TileflowStyleOptions): MapLibreStyle;
-declare function createStyleFromProject(projectConfig: TileflowProjectConfig, mapName: string, options?: TileflowStyleOptions): MapLibreStyle;
-declare function createManifest(projectConfig: TileflowProjectConfig, options?: {
-    styleBaseUrl?: string;
-    tileBaseUrl?: string;
-}): TileflowManifest;
-declare function getDefaultColors(): TileflowColors;
+/** A deterministic, network-free structural sweep of a compiled style. */
+declare function analyzeTileflowStylePerformance(style: MapLibreStyle, zooms?: readonly number[]): TileflowStylePerformance;
 
-declare function validateConfig(input: unknown): ValidationResult;
+declare const tileflowRouteMetadataKey = "tileflow:route";
+/** The resolved inks of a route, from its outer glow to its bright core. */
+type TileflowRouteInks = Readonly<{
+    /** The chosen route's line. */
+    line: string;
+    /** The edge on each side of the line, which sets it apart from the roads under it. */
+    casing: string;
+    /** A thin line along the middle of the route. */
+    core: string;
+    /** A soft halo around the route. */
+    glow: string;
+    /** Other routes offered beside the chosen one. */
+    alternative: string;
+    /** Opacity of the glow, from 0 (no glow) to 1. */
+    glowOpacity: number;
+    /** Opacity of the core, from 0 (no core) to 1. */
+    coreOpacity: number;
+}>;
+/** The token each ink is read from; a theme may set any of them. */
+declare const tileflowRouteTokens: Readonly<{
+    readonly color: Readonly<{
+        line: "route.line";
+        casing: "route.casing";
+        core: "route.core";
+        glow: "route.glow";
+        alternative: "route.alternative";
+    }>;
+    readonly number: Readonly<{
+        glowOpacity: "route.glow.opacity";
+        coreOpacity: "route.core.opacity";
+    }>;
+}>;
+/** The inks of a theme that sets no route tokens: a blue that reads on either kind of map. */
+declare const tileflowDefaultRouteInks: Readonly<Record<TileflowThemeColorScheme, TileflowRouteInks>>;
+/** A resolved theme's route inks: its own `route.*` tokens over its colour scheme's defaults. */
+declare function resolveTileflowRouteInks(theme: ResolvedTileflowTheme): TileflowRouteInks;
 
-declare function defineTileflow(config: TileflowProjectConfig): TileflowProjectConfig;
+/** Style metadata key for notices that must stay visible whenever the map is displayed. */
+declare const tileflowNoticesMetadataKey: "tileflow:notices";
+/**
+ * A short plain-text notice the compiled style declares for the sources it names. Runtimes render
+ * it on the map, next to the attribution; it never replaces a source's own attribution.
+ */
+type TileflowMapNotice = Readonly<{
+    id: string;
+    sources: readonly string[];
+    text: string;
+}>;
+declare const tileflowNoticeLimits: Readonly<{
+    maxNotices: 8;
+    maxSources: 16;
+    maxTextLength: 120;
+}>;
+/** Read bounded notices from style metadata; malformed entries are ignored, never rendered. */
+declare function readTileflowNotices(metadata: unknown): readonly TileflowMapNotice[];
 
-declare function osm(options?: TileflowOsmBasemapOptions): TileflowOsmBasemapConfig;
+/** Style metadata key that names the layers whose Nautical lights flash in their rhythm. */
+declare const tileflowNauticalLightsMetadataKey: "tileflow:nautical-lights";
+/**
+ * MapLibre feature-state keys the light layers read. A runtime writes them per light feature; a
+ * light without them shows steadily, exactly as a map that is not animated.
+ */
+declare const tileflowNauticalLightStates: Readonly<{
+    /** Index of the colour shown, into the light's comma-separated `color` list. */
+    colour: "tileflowLightColour";
+    /** `1` while the light shines, `0` while it is eclipsed, in between for a fixed part. */
+    intensity: "tileflowLightIntensity";
+}>;
+/** The opacity, as a share of the light's own opacity, of a light in eclipse. */
+declare const tileflowNauticalLightEclipseOpacity = 0.15;
+/** The light layers of a compiled style and the source features they draw. */
+type TileflowNauticalLights = Readonly<{
+    layers: readonly string[];
+    source: string;
+    sourceLayer: string;
+    version: 1;
+}>;
+declare const tileflowNauticalLightsLimits: Readonly<{
+    maxLayers: 16;
+}>;
+/** Read the bounded light declaration of style metadata; a malformed one is ignored. */
+declare function readTileflowNauticalLights(metadata: unknown): TileflowNauticalLights | undefined;
+type StyleLayer = Readonly<Record<string, unknown>>;
+/**
+ * The light declaration for the compiled layers that read Nautical light states from `sourceId`,
+ * or `undefined` when no layer does.
+ */
+declare function declareTileflowNauticalLights(layers: readonly StyleLayer[], sourceId: string | undefined, sourceLayer: string): TileflowNauticalLights | undefined;
+/**
+ * A copy of `style` in which every light shows steadily: light-state reads become their steady
+ * value and the light declaration is removed. Renderers without feature state, such as native
+ * ones, draw this copy; it looks exactly like the animated style with no state written.
+ */
+declare function steadyTileflowNauticalLights<T extends {
+    layers?: unknown;
+    metadata?: unknown;
+}>(style: T): T;
+
+/** One phase of a light's cycle. */
+type TileflowLightPhase = Readonly<{
+    /** Index of the colour shown, into the light's comma-separated `color` list. */
+    colour: number;
+    /** Seconds, with millisecond precision. */
+    duration: number;
+    /**
+     * `1` while the light shines, `0` while it is eclipsed, and
+     * `tileflowLightRhythmConventions.fixedIntensity` for the steady part of a fixed-and-flashing light.
+     */
+    intensity: number;
+}>;
+/** A light's repeating cycle. Lights with the same `key` flash identically. */
+type TileflowLightRhythm = Readonly<{
+    /** A canonical description of the phases; equal rhythms have equal keys. */
+    key: string;
+    /** Seconds, the sum of the phase durations. */
+    period: number;
+    phases: readonly TileflowLightPhase[];
+}>;
+/** What the light shows at a moment, and for how many more seconds. */
+type TileflowLightState = Readonly<{
+    colour: number;
+    intensity: number;
+    /** Seconds until the next phase begins; always positive. */
+    remaining: number;
+}>;
+/** The `nautical-v1` light fields that define a rhythm; other properties are ignored. */
+type TileflowLightCharacteristic = Readonly<{
+    character?: unknown;
+    color?: unknown;
+    group?: unknown;
+    period_s?: unknown;
+    sequence?: unknown;
+}>;
+/**
+ * The conventions used when a light publishes no `sequence`. Durations are in seconds.
+ *
+ * - `Fl`: flashes of `min(flash, flashShare × period / flashes)`. Flashes of one group are
+ *   separated by an eclipse of at most twice the flash, groups of a composite group such as
+ *   `2+1` by twice that eclipse, and the remainder of the period is the final eclipse.
+ * - `LFl`: the same layout with flashes of `longFlash`, or `flashShare × period / flashes` when
+ *   the period is too short for them.
+ * - `Q`, `VQ`, `UQ`: one flash per `quickCycle` (60, 120 and 240 per minute), lit for
+ *   `quickDuty` of each cycle. Without a group they flash continuously; with a group of `n` they
+ *   flash `n` times, then stay eclipsed until the period ends.
+ * - `IQ`, `IVQ`, `IUQ`: quick flashes for `interruptedShare` of the period, then an eclipse.
+ * - `Iso`: light and eclipse of equal length.
+ * - `Oc`: eclipses of `occultingShare × period / eclipses`, laid out like `Fl` with light and
+ *   eclipse exchanged, so the light is always longer than the eclipse.
+ * - `Mo`: the Morse letters of `group`, with dots of `morseUnit` (shortened to fit the
+ *   period), dashes of three units, one unit between signals and three between letters; the
+ *   remainder of the period, or seven units without one, is the eclipse.
+ * - `FFl`: a fixed light at `fixedIntensity` with full-intensity flashes laid out like `Fl`;
+ *   `F+LFl` does the same with long flashes.
+ * - `Q+LFl`, `VQ+LFl`, `UQ+LFl`, `Fl+LFl`: the group of the first part (six quick flashes when
+ *   absent), then one long flash, then the eclipse.
+ * - `Oc+Fl`: drawn as its occulting part.
+ * - `Al.<character>`: the rhythm of that character, each lit phase taking the next colour of
+ *   `color`; `Al` alone shows each colour for an equal share of the period.
+ * - Grouped `Q`/`VQ` and `Q+LFl`/`VQ+LFl` without a period use the cardinal-mark periods of
+ *   `cardinalPeriods`.
+ *
+ * `F`, an absent or unknown character, a missing period where one is needed, or a layout that
+ * does not fit its period leaves the light steady.
+ */
+declare const tileflowLightRhythmConventions: Readonly<{
+    cardinalPeriods: Readonly<{
+        Q: Readonly<{
+            3: 10;
+            6: 15;
+            9: 15;
+        }>;
+        'Q+LFl': 15;
+        VQ: Readonly<{
+            3: 5;
+            6: 10;
+            9: 10;
+        }>;
+        'VQ+LFl': 10;
+    }>;
+    fixedIntensity: 0.5;
+    flash: 1;
+    flashShare: 0.3;
+    interruptedShare: 0.6;
+    longFlash: 2;
+    morseUnit: 0.5;
+    occultingShare: 0.25;
+    quickCycle: Readonly<{
+        Q: 1;
+        UQ: 0.25;
+        VQ: 0.5;
+    }>;
+    quickDuty: 0.3;
+}>;
+/** Bounds that keep a rhythm drawable and its cost small. */
+declare const tileflowLightRhythmLimits: Readonly<{
+    maxPeriod: 600;
+    maxPhases: 256;
+    maxSequenceLength: 512;
+    minPhase: 0.05;
+}>;
+/**
+ * The rhythm of one light, or `undefined` when it shows steadily: a fixed light, or one without a
+ * usable characteristic. `sequence` wins when it is well formed; otherwise the rhythm follows
+ * `tileflowLightRhythmConventions`.
+ */
+declare function tileflowLightRhythm(light: TileflowLightCharacteristic): TileflowLightRhythm | undefined;
+/** What `rhythm` shows `seconds` after the shared epoch of every rhythm. */
+declare function tileflowLightStateAt(rhythm: TileflowLightRhythm, seconds: number): TileflowLightState;
+
+declare const tileflowRoadClasses: readonly ["motorway", "trunk", "primary", "secondary", "tertiary", "minor", "service", "track", "pathway", "footway", "cycleway", "steps", "pedestrian"];
 
 declare function roads(options?: TileflowRoadsModuleOptions): TileflowRoadsModuleConfig;
 
-export { type MapLibreStyle, type TileflowBasemapConfig, type TileflowBuildings, type TileflowColorConfig, type TileflowColors, type TileflowConfig, type TileflowDensity, type TileflowFontWeight, type TileflowFonts, type TileflowLabels, type TileflowManifest, type TileflowMapConfig, type TileflowModuleConfig, type TileflowOsmBasemapConfig, type TileflowOsmBasemapOptions, type TileflowPoi, type TileflowProjectConfig, type TileflowProjectThemes, type TileflowRoads, type TileflowRoadsModuleConfig, type TileflowRoadsModuleOptions, type TileflowRoadsModulePreset, type TileflowSourceLayers, type TileflowStyleOptions, type TileflowTerrain, type TileflowTerrainConfig, type TileflowTerrainEncoding, type TileflowTerrainMode, type TileflowTheme, type TileflowThemeConfig, type TileflowThemeMode, type TileflowThemeName, type TileflowTiles, type TileflowTilesetConfig, type TileflowTypography, type TileflowViewConfig, type ValidationMessage, type ValidationResult, createManifest, createStyle, createStyleFromProject, defineTileflow, getDefaultColors, osm, roads, validateConfig };
+declare function labels(options?: TileflowLabelsModuleOptions): TileflowLabelsModuleConfig;
+
+/**
+ * Stable built-in POI image convention. A theme token with the declared role
+ * takes precedence; `fallback` is the invariant sprite ID used when omitted.
+ */
+declare const tileflowPoiImageRoles: Readonly<{
+    readonly 'arts-entertainment': {
+        readonly fallback: "culture";
+        readonly token: "poi.arts-entertainment";
+    };
+    readonly education: {
+        readonly fallback: "education";
+        readonly token: "poi.education";
+    };
+    readonly 'food-drink': {
+        readonly fallback: "food";
+        readonly token: "poi.food-drink";
+    };
+    readonly landmark: {
+        readonly fallback: "culture";
+        readonly token: "poi.landmark";
+    };
+    readonly lodging: {
+        readonly fallback: "lodging";
+        readonly token: "poi.lodging";
+    };
+    readonly medical: {
+        readonly fallback: "health";
+        readonly token: "poi.medical";
+    };
+    readonly 'park-nature': {
+        readonly fallback: "services";
+        readonly token: "poi.park-nature";
+    };
+    readonly 'public-services': {
+        readonly fallback: "services";
+        readonly token: "poi.public-services";
+    };
+    readonly religion: {
+        readonly fallback: "culture";
+        readonly token: "poi.religion";
+    };
+    readonly retail: {
+        readonly fallback: "shopping";
+        readonly token: "poi.retail";
+    };
+    readonly 'sport-leisure': {
+        readonly fallback: "culture";
+        readonly token: "poi.sport-leisure";
+    };
+    readonly transport: {
+        readonly fallback: "major-transit";
+        readonly token: "poi.transport";
+    };
+    readonly 'visitor-amenity': {
+        readonly fallback: "services";
+        readonly token: "poi.visitor-amenity";
+    };
+}>;
+/**
+ * World POI types whose pictogram explains them without a name: parking and public toilets.
+ * Applies when a map draws both pictograms and names.
+ */
+declare const tileflowPoiIconOnlyTypes: readonly ["parking", "parking_garage", "parking_lot", "public_restroom"];
+declare function poi(options?: TileflowPoiModuleOptions): TileflowPoiModuleConfig;
+
+/**
+ * Line-fitted text backgrounds through derived glyph stacks.
+ *
+ * MapLibre paints an SDF text halo wherever a glyph's distance value lies between the halo edge,
+ * `(6 - haloWidth / fontScale) / 8`, and the fill edge at 0.75. A derived glyph keeps its source
+ * advance and distance field, and also carries a rectangular cell encoded at distance 0.5. With
+ * `text-halo-width` equal to `text-size / 6`, the halo edge sits at 0.25, so the halo pass paints
+ * exactly those cells: every shaped line receives one strip fitted to its own width. Shaping, line
+ * breaking, collision, anchors and fading remain the renderer's, and no renderer change is needed.
+ *
+ * Cells overlap their neighbours, which keeps strips seamless but requires an opaque colour.
+ *
+ * Glyph units are MapLibre's 24px em. x is relative to a glyph's pen position and y to the line
+ * origin before MapLibre's -17 shaping offset; bitmap row 0, including the 3px border, sits at
+ * y = -20 - top.
+ */
+/** Metrics a derived stack bakes into its glyphs. Every value is in ems. */
+type TileflowLineBackgroundMetrics = {
+    /** Must equal the layer's constant `text-letter-spacing`. */
+    letterSpacing: number;
+    /** Must equal the layer's constant `text-line-height`; rows are exactly this tall. */
+    lineHeight: number;
+    /** Strip extension beyond the first and last glyph of each line. */
+    padding: number;
+};
+type TileflowLineBackgroundFontStack = {
+    metrics: TileflowLineBackgroundMetrics;
+    source: string;
+};
+declare const tileflowLineBackgroundDefaults: Readonly<TileflowLineBackgroundMetrics>;
+declare const tileflowLineBackgroundLimits: Readonly<{
+    letterSpacing: Readonly<{
+        max: 0.5;
+        min: 0;
+    }>;
+    lineHeight: Readonly<{
+        max: 3;
+        min: 0.8;
+    }>;
+    padding: Readonly<{
+        max: 1;
+        min: 0;
+    }>;
+}>;
+/** `text-halo-width` per unit of `text-size` that places the halo edge on the derived cells. */
+declare const tileflowLineBackgroundHaloRatio: number;
+/** Rounds metrics to the thousandths a stack name encodes and checks their ranges. */
+declare function normalizeTileflowLineBackgroundMetrics(metrics?: Partial<TileflowLineBackgroundMetrics>): TileflowLineBackgroundMetrics;
+/** Names the derived stack for one source stack: `<source> lines-v1-t<ls>-l<lh>-p<pad>`. */
+declare function createTileflowLineBackgroundFontStack(source: string, metrics?: Partial<TileflowLineBackgroundMetrics>): string;
+/** Recognizes a derived stack name; returns undefined for ordinary or out-of-range names. */
+declare function parseTileflowLineBackgroundFontStack(stack: string): TileflowLineBackgroundFontStack | undefined;
+/**
+ * Scales a lowered MapLibre `text-size` value to the matching `text-halo-width`. Zoom curves keep
+ * their stops, because `zoom` may only be the input of a top-level `interpolate` or `step`.
+ */
+declare function scaleTileflowTextSizeForLineBackground(size: unknown): unknown;
+/**
+ * Derives one MapLibre glyph PBF range. Every glyph keeps its id, advance and distance field and
+ * gains the background cell; the range and stack names are preserved.
+ */
+declare function deriveTileflowLineBackgroundGlyphs(range: Uint8Array, metrics?: Partial<TileflowLineBackgroundMetrics>): Uint8Array;
+
+declare const tileflowIconPackageFileNames: readonly ["sprite.json", "sprite.png", "sprite@2x.json", "sprite@2x.png"];
+type TileflowIconPackageFileName = (typeof tileflowIconPackageFileNames)[number];
+/** Canonical sprite ID shared by authoring, generated manifests, diffs, and runtime indexes. */
+declare const tileflowIconIdPattern: RegExp;
+declare const tileflowIconPackageLimits: {
+    readonly decodeConcurrency: 4;
+    readonly maxAtlasDimension: 2048;
+    readonly maxDecodedPixelsPerIcon: 4194304;
+    readonly maxGeneratedFileBytes: number;
+    readonly maxGeneratedPackageBytes: number;
+    readonly maxIconCount: 1000;
+    readonly maxSourceBytes: number;
+    readonly maxSourceFileBytes: number;
+};
+/**
+ * Portable compatibility values shared by the public CLI and hosted policy.
+ * Commercial entitlements still belong to the database package.
+ */
+declare const tileflowHostedAlphaCompatibility: {
+    readonly iconPackages: {
+        readonly maxGeneratedBytesPerProject: number;
+        readonly maxRetainedPerProject: 24;
+    };
+    readonly maxMapsPerDeploy: 20;
+};
+declare const tileflowIconPackageContentHashSchema: z.ZodString;
+declare const tileflowIconIdSchema: z.ZodString;
+declare const tileflowRenderedIconManifestEntrySchema: z.ZodObject<{
+    name: 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>>;
+    pixelSha256: z.ZodObject<{
+        oneX: z.ZodString;
+        twoX: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const tileflowIconPackageLabelSchema: z.ZodString;
+declare const tileflowIconPackageManifestSchema: z.ZodObject<{
+    files: z.ZodTuple<[z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"application/json" | "image/png">;
+        name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+        sha256: z.ZodString;
+    }, z.core.$strict>], null>;
+    format: z.ZodEnum<{
+        "tileflow-icon-package-v1": "tileflow-icon-package-v1";
+        "tileflow-icon-package-v2": "tileflow-icon-package-v2";
+    }>;
+    iconNames: z.ZodArray<z.ZodString>;
+    renderedIcons: z.ZodArray<z.ZodObject<{
+        name: 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>>;
+        pixelSha256: z.ZodObject<{
+            oneX: z.ZodString;
+            twoX: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    sprites: z.ZodObject<{
+        oneX: z.ZodObject<{
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+            pixelRatio: z.ZodLiteral<1>;
+        }, z.core.$strict>;
+        twoX: z.ZodObject<{
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+            pixelRatio: z.ZodLiteral<2>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type TileflowIconPackageManifest = z.infer<typeof tileflowIconPackageManifestSchema>;
+type TileflowRenderedIconManifestEntry = z.infer<typeof tileflowRenderedIconManifestEntrySchema>;
+declare function compareCodeUnits(left: string, right: string): number;
+declare function serializeCanonicalJson(value: unknown): string;
+declare function serializeTileflowIconPackageManifest(input: TileflowIconPackageManifest): string;
+declare function sha256Hex(input: string | Uint8Array): Promise<string>;
+declare function hashTileflowIconPackageManifest(input: TileflowIconPackageManifest): Promise<string>;
+/**
+ * Hashes the delivered pixels of one rendered icon without including its name.
+ *
+ * The v1 binary frame is the UTF-8 domain `tileflow-rendered-icon-pixels-v1\0`, followed by one
+ * byte for the pixel ratio, unsigned 32-bit big-endian width and height, then row-major RGBA.
+ * Fully transparent pixels have their RGB channels zeroed in a copy before hashing so invisible
+ * decoder data cannot create a visual difference.
+ */
+declare function hashTileflowRenderedIconPixels(input: {
+    height: number;
+    pixelRatio: 1 | 2;
+    rgba: Uint8Array;
+    width: number;
+}): Promise<string>;
+
+declare const tileflowFontBundleLimits: {
+    readonly maxFaceCount: 16;
+    readonly maxFileCount: 32;
+    readonly maxFontFileBytes: number;
+    readonly maxLicenseFileBytes: number;
+    readonly maxManifestBytes: number;
+    readonly maxPackageBytes: number;
+};
+declare const tileflowFontBundleContentHashSchema: z.ZodString;
+declare const tileflowFontBundleManifestSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodEnum<{
+            "font/otf": "font/otf";
+            "font/ttf": "font/ttf";
+            "font/woff2": "font/woff2";
+        }>;
+        kind: z.ZodLiteral<"font">;
+        name: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        byteLength: z.ZodNumber;
+        contentType: z.ZodLiteral<"text/plain; charset=utf-8">;
+        kind: z.ZodLiteral<"license">;
+        name: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    fontFaces: z.ZodArray<z.ZodObject<{
+        family: z.ZodString;
+        file: z.ZodString;
+        licenseFile: z.ZodString;
+        style: z.ZodEnum<{
+            italic: "italic";
+            normal: "normal";
+            oblique: "oblique";
+        }>;
+        weight: z.ZodEnum<{
+            100: "100";
+            200: "200";
+            300: "300";
+            400: "400";
+            500: "500";
+            600: "600";
+            700: "700";
+            800: "800";
+            900: "900";
+        }>;
+    }, z.core.$strict>>;
+    format: z.ZodLiteral<"tileflow-font-bundle-v1">;
+}, z.core.$strict>;
+type TileflowFontBundleManifest = z.infer<typeof tileflowFontBundleManifestSchema>;
+type TileflowFontBundleFile = TileflowFontBundleManifest['files'][number];
+type TileflowFontBundleFontFace = TileflowFontBundleManifest['fontFaces'][number];
+declare function serializeTileflowFontBundleManifest(input: TileflowFontBundleManifest): string;
+declare function hashTileflowFontBundleManifest(input: TileflowFontBundleManifest): Promise<string>;
+
+type TileflowIconManifestDiff = {
+    added: string[];
+    afterBytes: number;
+    beforeBytes: number;
+    modified: string[];
+    removed: string[];
+    unchangedCount: number;
+};
+declare function diffTileflowIconPackageManifests(before: TileflowIconPackageManifest | null, after: TileflowIconPackageManifest | null): TileflowIconManifestDiff;
+
+declare const tileflowIconsLockfileName = "tileflow.icons.lock.json";
+declare const tileflowIconsLockfileMaximumBytes: number;
+declare const tileflowIconSetPinSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    setId: z.ZodString;
+    versionId: z.ZodString;
+    version: z.ZodNumber;
+    packageId: z.ZodString;
+    contentHash: z.ZodString;
+    manifest: z.ZodObject<{
+        files: z.ZodTuple<[z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            byteLength: z.ZodNumber;
+            contentType: z.ZodLiteral<"application/json" | "image/png">;
+            name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+            sha256: z.ZodString;
+        }, z.core.$strict>], null>;
+        format: z.ZodEnum<{
+            "tileflow-icon-package-v1": "tileflow-icon-package-v1";
+            "tileflow-icon-package-v2": "tileflow-icon-package-v2";
+        }>;
+        iconNames: z.ZodArray<z.ZodString>;
+        renderedIcons: z.ZodArray<z.ZodObject<{
+            name: 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>>;
+            pixelSha256: z.ZodObject<{
+                oneX: z.ZodString;
+                twoX: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        sprites: z.ZodObject<{
+            oneX: z.ZodObject<{
+                height: z.ZodNumber;
+                width: z.ZodNumber;
+                pixelRatio: z.ZodLiteral<1>;
+            }, z.core.$strict>;
+            twoX: z.ZodObject<{
+                height: z.ZodNumber;
+                width: z.ZodNumber;
+                pixelRatio: z.ZodLiteral<2>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    spriteUrl: z.ZodString;
+}, z.core.$strict>;
+declare const tileflowIconsLockfileSchema: z.ZodObject<{
+    lockfileVersion: z.ZodLiteral<1>;
+    sets: z.ZodRecord<z.ZodString, z.ZodObject<{
+        teamId: z.ZodString;
+        setId: z.ZodString;
+        versionId: z.ZodString;
+        version: z.ZodNumber;
+        packageId: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            files: z.ZodTuple<[z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                byteLength: z.ZodNumber;
+                contentType: z.ZodLiteral<"application/json" | "image/png">;
+                name: z.ZodLiteral<"sprite.json" | "sprite.png" | "sprite@2x.json" | "sprite@2x.png">;
+                sha256: z.ZodString;
+            }, z.core.$strict>], null>;
+            format: z.ZodEnum<{
+                "tileflow-icon-package-v1": "tileflow-icon-package-v1";
+                "tileflow-icon-package-v2": "tileflow-icon-package-v2";
+            }>;
+            iconNames: z.ZodArray<z.ZodString>;
+            renderedIcons: z.ZodArray<z.ZodObject<{
+                name: 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>>;
+                pixelSha256: z.ZodObject<{
+                    oneX: z.ZodString;
+                    twoX: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            sprites: z.ZodObject<{
+                oneX: z.ZodObject<{
+                    height: z.ZodNumber;
+                    width: z.ZodNumber;
+                    pixelRatio: z.ZodLiteral<1>;
+                }, z.core.$strict>;
+                twoX: z.ZodObject<{
+                    height: z.ZodNumber;
+                    width: z.ZodNumber;
+                    pixelRatio: z.ZodLiteral<2>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        spriteUrl: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type TileflowIconSetPin = z.infer<typeof tileflowIconSetPinSchema>;
+type TileflowIconsLockfileV1 = z.infer<typeof tileflowIconsLockfileSchema>;
+/** Parse a complete snapshot; no credentials, originals or floating versions belong in a lock. */
+declare function parseTileflowIconsLockfile(input: unknown, sources?: readonly TileflowIconSource[]): Promise<TileflowIconsLockfileV1>;
+declare function serializeTileflowIconsLockfile(input: TileflowIconsLockfileV1): Promise<string>;
+
+/** Bounded JSON parser which rejects duplicate keys, including escaped equivalents. */
+declare function parseTileflowIconJson(text: string, maximumBytes: number): unknown;
+
+declare const tileflowIconLayoutFields: {
+    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>>;
+};
+/** Asset-owned geometry in logical pixels; sprite indexes scale it by pixelRatio. */
+declare const tileflowIconLayoutSchema: 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>;
+type TileflowIconLayoutMetadata = z.infer<typeof tileflowIconLayoutSchema>;
+declare function assertTileflowIconLayoutBounds(layout: TileflowIconLayoutMetadata, width: number, height: number): void;
+/** Read only native layout fields; other sprite fields retain their own validation. */
+declare function readTileflowIconLayout(entry: Partial<TileflowIconLayoutMetadata>): TileflowIconLayoutMetadata | undefined;
+declare function scaleTileflowIconLayout(layout: TileflowIconLayoutMetadata, scale: number): TileflowIconLayoutMetadata;
+
+/** A part of a tree: bark, leaves, palm fronds (leaves seen from both sides), or a palm's stem. */
+declare const tileflowTreeParts: {
+    readonly bark: 0;
+    readonly leaves: 1;
+    readonly fronds: 2;
+    readonly stem: 3;
+};
+
+/** Begin/end height fractions, begin/end multipliers and the base-10 curve exponent. */
+type TileflowModelEmissionGradient = readonly [number, number, number, number, number];
+type TileflowModelRoleLighting = Readonly<{
+    emissiveStrength: number;
+    emissiveVariation?: number;
+    emissiveColor?: string;
+    emissiveHeight: TileflowModelEmissionGradient;
+    color?: string;
+    colorMix?: number;
+    metallic?: number;
+    roughness?: number;
+    colorVariation?: Readonly<{
+        hue: readonly [number, number];
+        saturation: readonly [number, number];
+        lightness: readonly [number, number];
+        /** Colour factors may be authored in linear light, as in glTF. Defaults to sRGB. */
+        space?: 'srgb' | 'linear';
+    }>;
+}>;
+type TileflowBuildingFloodLight = Readonly<{
+    intensity: number;
+    brightnessScale: number;
+    color: string;
+    groundRadius: readonly [number, number];
+    minGroundHeight: number;
+    minWallHeight: number;
+    wallHeightRatio: number;
+}>;
+
+/** The style metadata key under which a compiled map describes its 3D buildings. */
+declare const tileflowBuildingsMetadataKey = "tileflow:buildings";
+/** A compiled map's 3D buildings, resolved for one theme. */
+type TileflowBuildings3DDesign = Readonly<{
+    /** The vector source and its layers with the buildings and the places they hold. */
+    source: string;
+    layers: Readonly<{
+        building: string;
+        places?: string;
+    }>;
+    /**
+     * Each building's colour: a CSS colour, or a MapLibre expression over the building's
+     * properties that gives one, as the map colours its 3D buildings (or its roofs).
+     */
+    color: string | readonly unknown[];
+    /** How strongly roof outlines and outer corners catch the light, from 0 to 1. */
+    edges: number;
+    /** Exterior corner radius and roof lighting transition, in metres; 0 keeps sharp edges. */
+    edgeRadius?: number;
+    /** Scene sun lighting by default; `style` uses the native extrusion light. */
+    lighting: 'style' | 'sun';
+    /** Per-building brightness variation, from 0 to 1; 0 preserves the authored colour. */
+    colorVariation: number;
+    /** The authored extrusion's vertical wall gradient. */
+    verticalGradient: boolean;
+    /** Their own colour, drawn unlit; without it they take the building's colour, lightened. */
+    edgeColor?: string;
+    /** How bright the buildings light the street at night, from 0 to 2. */
+    nightLight: number;
+    /** Height-selected light on ordinary buildings and the ground, independent of shop windows. */
+    floodLight?: TileflowBuildingFloodLight;
+    /** Emission by architectural role, independent of model palette slots. */
+    modelLighting?: Readonly<Partial<Record<TileflowModelLightingRole, TileflowModelRoleLighting>>>;
+    /** Invented night windows, lit by rooms: decoration, not data. */
+    windows: boolean;
+    /** Optional decoration on ordinary walls and roofs, independent of model materials. */
+    surfaces?: TileflowBuildingSurfaceDesign;
+    /**
+     * The zoom bands, `[from, to]`, the buildings and the placed models and landmarks come in over:
+     * across its band each fades in and rises from the ground. The renderer's defaults stand for a
+     * band left out.
+     */
+    entrance?: Readonly<{
+        buildings?: readonly [number, number];
+        models?: readonly [number, number];
+    }>;
+    /** Shadows from the sun, and contact shadow at the foot of the walls. */
+    shadows: boolean;
+    occlusion: boolean;
+    /** Strength of prepared model ambient visibility; zero leaves the sky contribution unchanged. */
+    modelOcclusion?: number;
+    /** Building models the map places in its city, each replacing the buildings under it. */
+    models?: readonly TileflowBuildingModelPlacement[];
+    /** The colours of the models' parts; a part without one takes it from the building colour. */
+    modelColors?: Readonly<Partial<Record<TileflowModelPart, string>>>;
+    /**
+     * Tileflow's landmarks, drawn as models in place of the buildings under them: the TileJSON of
+     * their tileset. Without it, the map shows none.
+     */
+    landmarks?: Readonly<{
+        url: string;
+    }>;
+}>;
+/** A building model standing in the map's city. */
+type TileflowBuildingModelPlacement = Readonly<{
+    /** The model's id, its file's name in the map's `models` directories. */
+    model: string;
+    /** Where the prepared model file is served, absolute or relative to the page. */
+    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 is turned to. */
+    heading: number;
+}>;
+/**
+ * Reads the 3D buildings a compiled style describes, or undefined when its metadata has none or a
+ * version or shape this Core does not know.
+ */
+declare function readTileflowBuildings3D(metadata: unknown): TileflowBuildings3DDesign | undefined;
+/** The most models one map places. */
+declare const tileflowBuildingModelPlacementLimit = 256;
+/**
+ * The address a hosted build gives a placement of one of the map's own models: a placeholder that
+ * Tileflow replaces, when the map is deployed, with that model's address in the map's Team.
+ */
+declare function tileflowTeamModelUrl(model: string): string;
+/** The Team model a placement's address is the placeholder of, if it is one. */
+declare function readTileflowTeamModelName(url: string): string | undefined;
+
+/** The zoom of a landmarks tileset's tiles. */
+declare const tileflowLandmarkTileZoom = 14;
+/** The zoom of the regions whose indexes name those tiles. */
+declare const tileflowLandmarkRegionZoom = 6;
+/** A landmarks tileset as its TileJSON describes it. */
+type TileflowLandmarksTileJson = Readonly<{
+    /** Where the TileJSON was read, which relative addresses resolve against. */
+    url: string;
+    /** A tile's address, with `{sha256}` in place of its hash. */
+    tile: string;
+    /** A region index's address, with `{z}`, `{x}` and `{y}`. */
+    region: string;
+    tileZoom: number;
+    regionZoom: number;
+    /** The regions that hold landmarks, as `x/y`. */
+    regions: ReadonlySet<string>;
+}>;
+/** A landmark as its region's index names it: where it stands and the footprint it replaces. */
+type TileflowLandmarkFootprint = Readonly<{
+    id: string;
+    /** Its origin, longitude and latitude. */
+    at: readonly [number, number];
+    /** Degrees clockwise from north. */
+    heading: number;
+    /** Rings as flat `[x, y, ...]` arrays in metres, x east and y north of the origin. */
+    footprint: readonly (readonly number[])[];
+}>;
+/** A tile in a region's index: `[x, y, sha256]`, and the landmarks it holds. */
+type TileflowLandmarkRegionTile = readonly [number, number, string] | readonly [number, number, string, readonly TileflowLandmarkFootprint[]];
+/** A region's index: the tiles inside it that hold landmarks, by their hash. */
+type TileflowLandmarkRegion = Readonly<{
+    region: readonly [number, number];
+    /**
+     * Each tile, sorted by x, then y. A written index names every tile's landmarks; an index of the
+     * first format, which did not, is still read.
+     */
+    tiles: readonly TileflowLandmarkRegionTile[];
+}>;
+/** The zoom-14 tile a landmark's origin, longitude and latitude, stands in. */
+declare function tileflowLandmarkTileOf(at: readonly [number, number]): [number, number];
+/** The region a zoom-14 tile lies in. */
+declare function tileflowLandmarkRegionOf(tile: readonly [number, number]): [number, number];
+/**
+ * Writes a region's index as the bytes a tileset serves: canonical JSON, its tiles sorted and each
+ * tile's landmarks sorted by id, footprints in whole decimetres. Throws a `RangeError` when a tile
+ * lies outside the region, appears twice, has no hash or names no landmark, or when a landmark
+ * stands outside its tile or has no valid footprint.
+ */
+declare function serializeTileflowLandmarkRegion(region: TileflowLandmarkRegion): Uint8Array;
+/**
+ * Reads a region's index, or undefined when it is not one. An index of the first format names no
+ * landmarks; its tiles come back as `[x, y, sha256]`.
+ */
+declare function readTileflowLandmarkRegion(json: unknown): TileflowLandmarkRegion | undefined;
+/** Reads a landmarks tileset's TileJSON, or undefined when it is not one. */
+declare function readTileflowLandmarksTileJson(json: unknown, url: string): TileflowLandmarksTileJson | undefined;
+
+/** A model as a file holds it: its id and, in a landmark tile, where it stands. */
+type TileflowModelEntry = TileflowModel & Readonly<{
+    id: string;
+    /** Longitude and latitude of its origin. */
+    at?: readonly [number, number];
+    /** Degrees clockwise from north its own north is turned to. */
+    heading?: number;
+}>;
+/** What compresses a file's buffers: meshoptimizer's encoder, once ready. */
+type TileflowModelCompressor = Readonly<{
+    reorderMesh(indices: Uint32Array, triangles: boolean, optsize: boolean): [Uint32Array, number];
+    encodeGltfBuffer(source: Uint8Array, count: number, size: number, mode: string): Uint8Array;
+}>;
+/** What decompresses them: meshoptimizer's decoder, once ready. */
+type TileflowModelDecompressor = Readonly<{
+    decodeGltfBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string): void;
+}>;
+/** The media type of a prepared model file. */
+declare const tileflowModelContentType = "model/gltf-binary";
+declare const levelNames: readonly ["near", "mid", "far"];
+/**
+ * Encodes models as a prepared model file: compressed when given meshoptimizer's encoder, else with
+ * plain buffers of the same layout. Throws a `RangeError` when a model breaks `tileflowModelLimits`.
+ */
+declare function encodeTileflowModels(models: readonly TileflowModelEntry[], compressor?: TileflowModelCompressor): Uint8Array;
+/**
+ * Decodes a prepared model file for drawing, or undefined when it is not one or breaks
+ * `tileflowModelLimits`. A compressed file loads meshoptimizer's decoder unless one is given.
+ */
+declare function decodeTileflowModels(buffer: ArrayBuffer | Uint8Array, decompressor?: TileflowModelDecompressor): Promise<readonly TileflowModelBytes[] | undefined>;
+/**
+ * The ids of the models a prepared model file holds, in the order of its scene, read from its glTF
+ * header and JSON chunk without decoding a mesh; undefined when it is not a prepared model file. A
+ * server checks an uploaded file with it without running meshoptimizer's decoder.
+ */
+declare function readTileflowModelFileIds(buffer: ArrayBuffer | Uint8Array): readonly string[] | undefined;
+/** A prepared model file's name: its id and the start of its SHA-256, so a change is a new name. */
+declare function tileflowModelFileName(id: string, sha256: string): string;
+/** What a file holding one model is, in metres, read without decompressing its meshes. */
+type TileflowModelFileSummary = Readonly<{
+    /** The model's id, as maps name it. */
+    model: string;
+    /** Its levels of detail, nearest first. */
+    levels: readonly Readonly<{
+        level: (typeof levelNames)[number];
+        vertices: number;
+        triangles: number;
+    }>[];
+    /** The nearest level's extent along east, north and up, from the ground. */
+    width: number;
+    depth: number;
+    height: number;
+    /** The base the model stands in for: its rings, their points and their area in square metres. */
+    footprint: Readonly<{
+        rings: number;
+        points: number;
+        area: number;
+    }>;
+}>;
+/**
+ * Summarises a prepared file of one model from its glTF JSON alone: its id, the vertices and
+ * triangles of each level, its size and its footprint. It decompresses nothing, so it suits a
+ * server that checks an upload; `undefined` means the file is not a Tileflow model file of exactly
+ * one model.
+ */
+declare function readTileflowModelFileSummary(buffer: ArrayBuffer | Uint8Array): TileflowModelFileSummary | undefined;
+/**
+ * The landmarks a landmarks tileset's tile holds, where each stands and the footprint it replaces,
+ * read from its glTF header and JSON chunk without decoding a mesh; undefined when it is not a
+ * prepared model file whose every model stands at a place. A region's index carries them so the
+ * renderer knows a landmark's footprint before its tile arrives.
+ */
+declare function readTileflowLandmarkTileFootprints(buffer: ArrayBuffer | Uint8Array): readonly TileflowLandmarkFootprint[] | undefined;
+
+/**
+ * Where light is estimated where the data maps no lamps: `lit` (the default) along the streets and
+ * pavements the data maps as lit; `streets` also along the streets the data says nothing about,
+ * wherever it maps few lamps, which invents light as night windows do; `none` nowhere, so only
+ * mapped lamps shine.
+ */
+type TileflowStreetLightEstimate = 'streets' | 'lit' | 'none';
+/** The style metadata key under which a compiled map describes its street lights. */
+declare const tileflowStreetLightsMetadataKey = "tileflow:street-lights";
+/** A compiled map's street lights, as the roads module describes them, resolved for one theme. */
+type TileflowStreetLightsDesign = Readonly<{
+    /** The vector source and its layers with the lamps, the streets and the pavements. */
+    source: string;
+    layers: Readonly<{
+        streetFurniture: string;
+        transportation: string;
+        sidewalk?: string;
+    }>;
+    estimate: TileflowStreetLightEstimate;
+    /** The light of lamps whose data gives no colour, as a CSS colour. */
+    color: string;
+    /** How bright the lights shine, from 0 to 2. */
+    intensity: number;
+}>;
+/**
+ * Reads the street lights a compiled style describes, or undefined when its metadata has none or a
+ * version or shape this Core does not know.
+ */
+declare function readTileflowStreetLights(metadata: unknown): TileflowStreetLightsDesign | undefined;
+
+type TileflowViewMode = '2d' | '3d';
+type TileflowVegetationRepresentation = 'none' | 'flat' | '3d';
+declare const tileflowVegetationDisplayMetadataKey = "tileflow:vegetation-display";
+/** Display policy, separate from the models' design and the camera's pitch. */
+type TileflowVegetationDisplay = Readonly<{
+    version: 1;
+    mode: TileflowVegetationMode;
+    fallback: 'flat' | 'none';
+    visible: boolean;
+    /** Authored visibility before the compiler applies the static fallback. */
+    flatLayers: readonly Readonly<{
+        id: string;
+        visible: boolean;
+    }>[];
+}>;
+declare function readTileflowVegetationDisplay(metadata: unknown): TileflowVegetationDisplay | undefined;
+declare function resolveTileflowVegetationRepresentation(policy: TileflowVegetationDisplay | undefined, options: {
+    visible?: boolean | undefined;
+    viewMode?: TileflowViewMode;
+    supports3D: boolean;
+}): TileflowVegetationRepresentation;
+
+export { type JoinBoundaryRowsOptions, MapLibreStyle, OpenMapTilesFieldBindings, OpenMapTilesLayerBindings, ResolveMapOptions, ResolvedTileflowMap, ResolvedTileflowTheme, type TileflowAuthoringCommand, type TileflowAuthoringCommandName, type TileflowAuthoringCommandOutputKind, type TileflowAuthoringExpressionBuilder, type TileflowAuthoringManifest, type TileflowAuthoringManifestDomain, type TileflowAuthoringOperation, TileflowBackgroundStyle, TileflowBandPlacement, type TileflowBoundaryChoroplethMetadata, type TileflowBoundaryChoroplethOptions, type TileflowBoundaryChoroplethOutline, TileflowBoundaryClass, TileflowBoundaryClassTier, type TileflowBoundaryCode, TileflowBoundaryFamily, type TileflowBoundaryFeatureKey, type TileflowBoundaryJoinResult, type TileflowBoundaryLookup, type TileflowBoundaryLookupRow, type TileflowBoundaryRow, type TileflowBoundaryValue, type TileflowBoundaryValues, type TileflowBuildingModelPlacement, TileflowBuildingSurfaceDesign, type TileflowBuildings3DDesign, type TileflowChoroplethCategoryScale, type TileflowChoroplethLinearScale, type TileflowChoroplethScale, type TileflowChoroplethStepScale, type TileflowChoroplethStop, TileflowCircleStyle, type TileflowColorExpression, type TileflowDataCaseBranch, type TileflowDataExpressionInput, type TileflowDataExpressionResult, type TileflowDataFieldName, type TileflowDataFieldReference, type TileflowDataFieldValue, type TileflowDataInterpolation, type TileflowDataMatchBranch, type TileflowDataStop, TileflowExtrusionStyle, TileflowFillStyle, TileflowFixedValue, type TileflowFontBundleFile, type TileflowFontBundleFontFace, type TileflowFontBundleManifest, TileflowIconAppearance, type TileflowIconLayoutMetadata, type TileflowIconManifestDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, type TileflowIconPreviewPaint, type TileflowIconSetPin, TileflowIconSource, type TileflowIconSpriteIndex, type TileflowIconSpriteIndexEntry, type TileflowIconsLockfileV1, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, type TileflowLandmarkFootprint, type TileflowLandmarkRegion, type TileflowLandmarkRegionTile, type TileflowLandmarksTileJson, type TileflowLightCharacteristic, type TileflowLightPhase, type TileflowLightRhythm, type TileflowLightState, type TileflowLineBackgroundFontStack, type TileflowLineBackgroundMetrics, TileflowLineStyle, TileflowMap, TileflowMapLibreOverlay, type TileflowMapNotice, TileflowMapResolutionError, TileflowMapScene, TileflowMapShot, TileflowModel, TileflowModelBytes, type TileflowModelCompressor, type TileflowModelDecompressor, type TileflowModelEmissionGradient, type TileflowModelEntry, type TileflowModelFileSummary, TileflowModelLightingRole, TileflowModelPart, type TileflowModuleWithRenderStack, type TileflowNamedRenderStack, type TileflowNauticalLights, type TileflowNumericDataFieldName, TileflowOverlayPlacement, TileflowPoiModuleConfig, TileflowPoiModuleOptions, type TileflowRenderComparison, type TileflowRenderFeature, type TileflowRenderField, type TileflowRenderGeometry, type TileflowRenderPass, type TileflowRenderPassInput, type TileflowRenderPlacement, type TileflowRenderScalar, type TileflowRenderSelector, type TileflowRenderStackOperation, type TileflowRenderTargetRefinement, type TileflowRenderTargetRefinementInput, type TileflowRenderVisibilityGroup, type TileflowRenderedIconManifestEntry, TileflowResolvedMapValidationError, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, type TileflowRouteInks, type TileflowSemanticAdd, type TileflowSemanticChange, type TileflowSemanticDiff, type TileflowSemanticDifference, type TileflowSemanticJsonValue, type TileflowSemanticMapIdentity, type TileflowSemanticRemove, type TileflowStreetLightsDesign, type TileflowStylePerformance, TileflowSymbolStyle, TileflowThemeColorOperation, TileflowThemeColorScheme, TileflowThemeTokenReference, type TileflowVegetationDisplay, TileflowVegetationMode, type TileflowVegetationRepresentation, type TileflowViewMode, type TileflowZoomPerformance, ValidationMessage, analyzeTileflowStylePerformance, assertTileflowIconLayoutBounds, boundaryChoropleth, choroplethColorExpression, choroplethScale, compareCodeUnits, createBoundaryLookup, createTileflowIconPreviewRuntime, createTileflowLineBackgroundFontStack, declareTileflowNauticalLights, decodeTileflowModels, defineMap, deriveTileflowLineBackgroundGlyphs, diffTileflowIconPackageManifests, diffTileflowMaps, encodeTileflowModels, expr, field, hashTileflowFontBundleManifest, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, isTileflowPortableId, isTileflowThemeName, isTileflowWorldReleaseId, joinBoundaryRows, labels, normalizeTileflowLineBackgroundMetrics, parseBoundaryLookupCsv, parseResolvedTileflowMap, parseTileflowIconJson, parseTileflowIconsLockfile, parseTileflowLineBackgroundFontStack, poi, readTileflowBuildings3D, readTileflowIconLayout, readTileflowLandmarkRegion, readTileflowLandmarkTileFootprints, readTileflowLandmarksTileJson, readTileflowModelFileIds, readTileflowModelFileSummary, readTileflowNauticalLights, readTileflowNotices, readTileflowStreetLights, readTileflowTeamModelName, readTileflowVegetationDisplay, refineRenderTarget, renderPass, renderTileflowIconAtlasPixels, resolveMap, resolveTileflowIconPreviewPaint, resolveTileflowRouteInks, resolveTileflowVegetationRepresentation, roads, scaleTileflowIconLayout, scaleTileflowTextSizeForLineBackground, serializeCanonicalJson, serializeTileflowFontBundleManifest, serializeTileflowIconPackageManifest, serializeTileflowIconsLockfile, serializeTileflowLandmarkRegion, sha256Hex, steadyTileflowNauticalLights, tileflowAuthoringManifest, tileflowAuthoringManifestSchemaVersion, tileflowBoundaryChoroplethMetadataKey, tileflowBuildingModelPlacementLimit, tileflowBuildingsMetadataKey, tileflowCompilationPhases, tileflowCompilationPlannerStages, tileflowCompilationReportSchemaVersion, tileflowDefaultRouteInks, tileflowFontBundleContentHashSchema, tileflowFontBundleLimits, tileflowFontBundleManifestSchema, tileflowHostedAlphaCompatibility, tileflowHostedSourceLimit, tileflowIconIdPattern, tileflowIconIdSchema, tileflowIconLayoutFields, tileflowIconLayoutSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowIconSetPinSchema, tileflowIconSpriteIndexEntrySchema, tileflowIconSpriteIndexSchema, tileflowIconsLockfileMaximumBytes, tileflowIconsLockfileName, tileflowIconsLockfileSchema, tileflowLandmarkRegionOf, tileflowLandmarkRegionZoom, tileflowLandmarkTileOf, tileflowLandmarkTileZoom, tileflowLightRhythm, tileflowLightRhythmConventions, tileflowLightRhythmLimits, tileflowLightStateAt, tileflowLineBackgroundDefaults, tileflowLineBackgroundHaloRatio, tileflowLineBackgroundLimits, tileflowMapDefaultMaxDepth, tileflowMaxPitch, tileflowModelContentType, tileflowModelFileName, tileflowNauticalLightEclipseOpacity, tileflowNauticalLightStates, tileflowNauticalLightsLimits, tileflowNauticalLightsMetadataKey, tileflowNoticeLimits, tileflowNoticesMetadataKey, tileflowOverlayPlacements, tileflowPoiIconOnlyTypes, tileflowPoiImageRoles, tileflowPortableIdMaximumLength, tileflowRenderSelectorComparisons, tileflowRenderSelectorGeometries, tileflowRenderSelectorKinds, tileflowRenderStackLimits, tileflowRenderStackRenderers, tileflowRenderedIconManifestEntrySchema, tileflowRequiredThemeColorRoles, tileflowRoadClasses, tileflowRouteMetadataKey, tileflowRouteTokens, tileflowSemanticDiffSchemaVersion, tileflowStreetLightsMetadataKey, tileflowTeamModelUrl, tileflowTreeParts, tileflowVegetationDisplayMetadataKey, tileflowWorldReleaseIdMaximumLength, tileflowWorldReleaseIdMinimumLength, tileflowWorldReleaseIdPattern, tileflowWorldReleaseIdPatternSource, tileflowWorldReleaseIdSchema, withRenderStack };