@tileflow/core 0.1.0-alpha.20 → 0.1.0-alpha.21

package/dist/index.d.ts

@@ -1,170 +1,137 @@
-import { b as TileflowBaseColors, c as TileflowConfig, d as TileflowProjectConfig, V as ValidationResult, e as TileflowRoadsModuleOptions, f as TileflowRoadsModuleConfig, g as TileflowLabelsModuleOptions, h as TileflowLabelsModuleConfig, i as TileflowPoiModuleOptions, j as TileflowPoiModuleConfig } from './runtime-DroKDIuB.js';
-export { M as MapLibreSprite, k as MapLibreStyle, N as NormalizedTileflowCaptureScene, O as OpenMapTilesFieldBindings, l as OpenMapTilesLayerBindings, m as OpenMapTilesSchema, n as OpenMapTilesSchemaOptions, R as ResolvedTileflowData, o as ResolvedTileflowTypography, p as TileflowAerowaysModuleConfig, q as TileflowAerowaysModuleOptions, r as TileflowAlignment, T as TileflowAnalytics, s as TileflowAreaStyle, t as TileflowBackgroundPaint, u as TileflowBackgroundStyle, v as TileflowBoundariesModuleConfig, w as TileflowBoundariesModuleOptions, x as TileflowBoundaryColorConfig, y as TileflowBuildingColorConfig, z as TileflowBuildingMode, A as TileflowBuildingsModuleConfig, B as TileflowBuildingsModuleOptions, C as TileflowCaptureApplicationTarget, D as TileflowCaptureBoundsCamera, E as TileflowCaptureCamera, F as TileflowCaptureCenterCamera, G as TileflowCaptureMapTarget, H as TileflowCaptureScene, I as TileflowCaptureTarget, J as TileflowCaptureViewport, K as TileflowCirclePaint, L as TileflowCircleStyle, P as TileflowColor, Q as TileflowColorConfig, S as TileflowColors, U as TileflowDataConfig, W as TileflowDataIdentity, X as TileflowExpression, Y as TileflowExtrusionPaint, Z as TileflowExtrusionStyle, _ as TileflowFillPaint, $ as TileflowFillStyle, a0 as TileflowFilterExpression, a1 as TileflowFontWeight, a2 as TileflowHostedNotoSansWeight, a3 as TileflowHydroColorConfig, a4 as TileflowIconAnchor, a5 as TileflowIconLayout, a6 as TileflowIconPaint, a7 as TileflowIconSet, a8 as TileflowIconSetConfig, a9 as TileflowIconStyle, aa as TileflowLabelColorConfig, ab as TileflowLabelDetail, ac as TileflowLabelLanguage, ad as TileflowLabelStyles, ae as TileflowLandModuleConfig, af as TileflowLandModuleOptions, ag as TileflowLandcoverClass, ah as TileflowLandcoverColorConfig, ai as TileflowLanduseClass, aj as TileflowLanduseColorConfig, ak as TileflowLayerPlacement, al as TileflowLayerRange, am as TileflowLineCap, an as TileflowLineHatchStyle, ao as TileflowLineJoin, ap as TileflowLineLayout, aq as TileflowLinePaint, ar as TileflowLineStackStyle, as as TileflowLineStyle, at as TileflowManifest, au as TileflowManifestLoadOptions, av as TileflowMapConfig, aw as TileflowMapMarker, ax as TileflowMapMode, ay as TileflowMapModeOptions, az as TileflowMountainBikeScale, aA as TileflowPlaceLabelClass, aB as TileflowPoi, aC as TileflowPoiCategory, aD as TileflowPoiCategoryStyle, aE as TileflowPoiClassMapping, aF as TileflowPoiColorConfig, aG as TileflowPoiColorMode, aH as TileflowPoiDensity, aI as TileflowPoiIcons, aJ as TileflowPoiLabels, aK as TileflowProjectIconSets, aL as TileflowProjectThemes, aM as TileflowRawOverride, aN as TileflowRoadAreaStyle, aO as TileflowRoadClass, aP as TileflowRoadClassStyle, aQ as TileflowRoadColorConfig, aR as TileflowRoadDetail, aS as TileflowRoadExtras, aT as TileflowRoadHierarchy, aU as TileflowRoadLabelDetail, aV as TileflowRoadLayerStyle, aW as TileflowRoadModifier, aX as TileflowRoadOutline, aY as TileflowRoadRestriction, aZ as TileflowRoadServiceType, a_ as TileflowRoadShieldDetail, a$ as TileflowRoadShieldStyles, b0 as TileflowRoadStructure, b1 as TileflowRoadTreatmentLayerStyle, b2 as TileflowRoadTreatmentLineStyle, b3 as TileflowRoadTreatmentStyle, b4 as TileflowRoadWeight, b5 as TileflowRuntimeManifest, b6 as TileflowRuntimeManifestMap, b7 as TileflowRuntimeManifestMapEntry, b8 as TileflowRuntimeStyle, b9 as TileflowRuntimeStyleOptions, a as TileflowSessionController, ba as TileflowSessionGrantResponse, bb as TileflowStreetsBasemapConfig, bc as TileflowStreetsCompileOptions, bd as TileflowStreetsMapConfig, be as TileflowStreetsModules, bf as TileflowStreetsOptions, bg as TileflowStreetsVariant, bh as TileflowStyleOptions, bi as TileflowStyleValue, bj as TileflowSymbolPlacement, bk as TileflowSymbolPlacementStyle, bl as TileflowSymbolStyle, bm as TileflowSymbolZOrder, bn as TileflowTerrain, bo as TileflowTerrainConfig, bp as TileflowTerrainEncoding, bq as TileflowTerrainMode, br as TileflowTextAnchor, bs as TileflowTextJustify, bt as TileflowTextLayout, bu as TileflowTextPaint, bv as TileflowTextStyle, bw as TileflowTheme, bx as TileflowThemeConfig, by as TileflowThemeMode, bz as TileflowThemeModulesConfig, bA as TileflowThemeName, bB as TileflowTransitModuleConfig, bC as TileflowTransitModuleOptions, bD as TileflowTransitRailStyle, bE as TileflowTypography, bF as TileflowTypographyDomain, bG as TileflowTypographyStyle, bH as TileflowViewConfig, bI as TileflowWaterLabelClass, bJ as TileflowWaterModuleConfig, bK as TileflowWaterModuleOptions, bL as TileflowWaterwayClass, bM as TileflowWorldData, bN as TileflowZoomInterpolation, bO as TileflowZoomValue, bP as ValidationMessage, bQ as VectorTilesData, bR as addLayer, bS as aeroways, bT as boundaries, bU as buildings, bV as createManifest, bW as createStreetsStyle, bX as createStyle, bY as createStyleFromProject, bZ as createTileflowSessionController, b_ as createTileflowSessionId, b$ as defaultTileflowManifestUrl, c0 as defaultTileflowStyleBaseUrl, c1 as expression, c2 as filter, c3 as getDefaultTileflowStyleBaseUrl, c4 as getTileflowAnalyticsApiUrl, c5 as inferTileflowAnalyticsFromStyleUrl, c6 as isCanonicalOpenMapTilesSchema, c7 as isTileflowLocalDevHost, c8 as land, c9 as loadTileflowManifest, ca as mergeTileflowAnalytics, cb as moveLayer, cc as normalizeTileflowCaptureId, cd as normalizeTileflowCaptureScene, ce as normalizeTileflowStaticImageSize, cf as normalizeTileflowUrl, cg as openMapTiles, ch as openMapTilesContractVersion, ci as patchLayer, cj as removeLayer, ck as resolveTileflowAnalyticsRequestUrl, cl as resolveTileflowData, cm as resolveTileflowManifestMap, cn as resolveTileflowMapMode, co as resolveTileflowRuntimeStyle, cp as resolveTileflowStaticImageUrl, cq as resolveTileflowStyleUrl, cr as shouldLoadTileflowManifest, cs as startTileflowSession, ct as streets, cu as tileflowCaptureApplicationTargetSchema, cv as tileflowCaptureBoundsCameraSchema, cw as tileflowCaptureCameraSchema, cx as tileflowCaptureCenterCameraSchema, cy as tileflowCaptureIdSchema, cz as tileflowCaptureMapTargetSchema, cA as tileflowCaptureSceneLimits, cB as tileflowCaptureSceneNameSchema, cC as tileflowCaptureSceneSchema, cD as tileflowCaptureSceneSchemaVersion, cE as tileflowCaptureTargetSchema, cF as tileflowCaptureViewportSchema, cG as tileflowFontStack, cH as tileflowHostedNotoSansWeights, cI as tileflowPrimarySourceId, cJ as tileflowStreetsBasemapVersion, cK as tileflowStreetsPoiIconMapping, cL as tileflowWorld, cM as tileflowWorldRevision, cN as transit, cO as vectorTiles, cP as water, cQ as zoom } from './runtime-DroKDIuB.js';
+import { m as TileflowDerivedMap, n as TileflowMapScene, o as TileflowRootMap, T as TileflowMap, p as ResolveMapOptions, R as ResolvedTileflowMap } from './requirements-BV77ZVhR.js';
+export { q as ResolvedBathymetry, r as ResolvedBathymetryRelief, s as ResolvedMarine, t as ResolvedMarineSource, u as ResolvedTileflowTheme, w as ResolvedTileflowThemeTokens, x as TileflowBathymetryConfig, y as TileflowBathymetryDemSourceIdentity, z as TileflowBathymetryDisplay, A as TileflowBathymetryOptions, B as TileflowBathymetryReliefConfig, e as TileflowDataCompatibilityIssue, f as TileflowDataFieldRequirement, g as TileflowDataFieldType, h as TileflowDataLayerRequirement, a as TileflowDataRequirementsV1, C as TileflowFontDirectory, D as TileflowGlyphs, E as TileflowHostedDelivery, F as TileflowIconDirectory, G as TileflowLocalDirectory, H as TileflowMapDelivery, I as TileflowMapDesign, J as TileflowMapIdentity, K as TileflowMapRoot, L as TileflowMapTooling, M as TileflowMarine, N as TileflowMarineConfig, O as TileflowMarineMode, P as TileflowMarineSourceConfig, Q as TileflowMarineSourceIdentity, i as TileflowObservedDataContractV1, S as TileflowPackageDirectory, U as TileflowRasterDemSourceRequirementV1, V as TileflowResolvedThemeSelection, b as TileflowSourceRequirementsV1, c as TileflowStyleOptions, W as TileflowTheme, X as TileflowThemeAuditContext, Y as TileflowThemeAuditDiagnostic, Z as TileflowThemeAuditEffectKind, _ as TileflowThemeAuditError, $ as TileflowThemeAuditScope, a0 as TileflowThemeColorScheme, a1 as TileflowThemeDefinition, a2 as TileflowThemeLighting, a3 as TileflowThemeName, a4 as TileflowThemeTokens, a5 as TileflowThemeTypography, a6 as TileflowThemeTypographyStyle, a7 as assertTileflowMapThemeValues, a8 as auditTileflowMapThemeValues, a9 as auditTileflowThemeValues, aa as bathymetry, ab as createStyle, ac as defineTheme, k as inferTileflowDataRequirements, l as inferTileflowSourceRequirements, ad as isTileflowLocalDirectory, ae as parseTileflowMap, af as resolveMarine, ag as resolveThemeSelection, ah as resolveThemeValues, ai as resolveTileflowTheme, aj as tileflowBathymetryDemSourceId, ak as tileflowBathymetrySourceId, al as tileflowBathymetryV1Schema, am as tileflowLocalDirectoryMaximumLength, an as tileflowLocalDirectoryMessage, ao as tileflowMapIdSchema, ap as tileflowNauticalSourceId, aq as tileflowNauticalV1Schema, v as validateTileflowDataCompatibility, ar as validateTileflowMap } from './requirements-BV77ZVhR.js';
+import { n as ValidationMessage, M as MapLibreStyle, o as TileflowRoadsModuleOptions, p as TileflowRoadsModuleConfig, q as TileflowLabelsModuleOptions, r as TileflowLabelsModuleConfig, s as TileflowPoiModuleOptions, u as TileflowPoiModuleConfig } from './types-DlUGI6LC.js';
+export { v as MapLibreSprite, w as TileflowAerodromeCodeDetail, x as TileflowAlignment, y as TileflowAreaStyle, z as TileflowBackgroundPaint, A as TileflowBackgroundStyle, B as TileflowCirclePaint, C as TileflowCircleStyle, D as TileflowColor, E as TileflowColorStyleValue, F as TileflowExpression, G as TileflowExtrusionPaint, H as TileflowExtrusionStyle, I as TileflowFillPaint, a as TileflowFillStyle, J as TileflowFilterExpression, K as TileflowFixedValue, L as TileflowIconAnchor, N as TileflowIconLayout, O as TileflowIconPaint, P as TileflowIconStyle, Q as TileflowIconTextFit, S as TileflowImageStyleValue, U as TileflowLabelDetail, W as TileflowLabelLanguage, X as TileflowLabelStyles, Y as TileflowLayerRange, k as TileflowLight, Z as TileflowLineCap, _ as TileflowLineHatchStyle, $ as TileflowLineJoin, a0 as TileflowLineLayout, a1 as TileflowLinePaint, a2 as TileflowLineStackStyle, b as TileflowLineStyle, a3 as TileflowMountainBikeScale, a4 as TileflowNumberInsetsStyleValue, a5 as TileflowNumberStyleValue, a6 as TileflowPlaceLabelClass, a7 as TileflowPoiCategory, a8 as TileflowPoiCategoryStyle, a9 as TileflowPoiColorMode, aa as TileflowPoiDensity, l as TileflowProjection, ab as TileflowRoadAreaStyle, ac as TileflowRoadClass, ad as TileflowRoadClassStyle, ae as TileflowRoadCrossingStyle, af as TileflowRoadDetail, ag as TileflowRoadExtras, ah as TileflowRoadHierarchy, ai as TileflowRoadLabelDetail, aj as TileflowRoadLayerStyle, ak as TileflowRoadModifier, al as TileflowRoadOutline, am as TileflowRoadRestriction, an as TileflowRoadRoundaboutStyle, ao as TileflowRoadServiceType, ap as TileflowRoadShieldDetail, aq as TileflowRoadShieldStyles, ar as TileflowRoadSidewalkStyle, as as TileflowRoadStructure, at as TileflowRoadTreatmentLayerStyle, au as TileflowRoadTreatmentLineStyle, av as TileflowRoadTreatmentStyle, aw as TileflowRoadWeight, ax as TileflowStringStyleValue, ay as TileflowStructuralStyleValue, az as TileflowStyleValue, aA as TileflowSymbolPlacement, aB as TileflowSymbolPlacementStyle, c as TileflowSymbolStyle, aC as TileflowSymbolZOrder, m as TileflowTerrain, aD as TileflowTerrainConfig, aE as TileflowTerrainContourLabelStyle, aF as TileflowTerrainContourLineStyle, aG as TileflowTerrainContoursConfig, e as TileflowTerrainEncoding, d as TileflowTerrainHillshadeStyle, aH as TileflowTerrainLayerRange, aI as TileflowTerrainMode, aJ as TileflowTextAnchor, aK as TileflowTextJustify, aL as TileflowTextLayout, aM as TileflowTextPaint, aN as TileflowTextStyle, aO as TileflowThemeColorAlpha, aP as TileflowThemeColorMix, aQ as TileflowThemeColorOperation, g as TileflowThemeColorValue, h as TileflowThemeFontValue, i as TileflowThemeImageValue, f as TileflowThemeNumberValue, aR as TileflowThemeTokenCategory, aS as TileflowThemeTokenReference, aT as TileflowThemeValue, T as TileflowViewConfig, aU as TileflowWaterLabelClass, aV as TileflowZoomInterpolation, aW as TileflowZoomValue, V as ValidationResult, aX as color, aY as expression, aZ as filter, a_ as fixed, a$ as tileflowPoiCategories, b0 as token, b1 as zoom } from './types-DlUGI6LC.js';
+export { N as NormalizedTileflowCaptureScene, a as TileflowCaptureApplicationTarget, b as TileflowCaptureBoundsCamera, c as TileflowCaptureCamera, d as TileflowCaptureCenterCamera, e as TileflowCaptureMapTarget, T as TileflowCaptureScene, f as TileflowCaptureTarget, g as TileflowCaptureViewport, n as normalizeTileflowCaptureId, h as normalizeTileflowCaptureScene, t as tileflowCaptureApplicationTargetSchema, i as tileflowCaptureBoundsCameraSchema, j as tileflowCaptureCameraSchema, k as tileflowCaptureCenterCameraSchema, l as tileflowCaptureIdSchema, m as tileflowCaptureMapTargetSchema, o as tileflowCaptureSceneLimits, p as tileflowCaptureSceneNameSchema, q as tileflowCaptureSceneSchema, r as tileflowCaptureSceneSchemaVersion, s as tileflowCaptureTargetSchema, u as tileflowCaptureViewportSchema } from './capture-scene-BK_0J2oR.js';
+export { tileflowPortableIdSchema, tileflowThemeNameSchema } from './capture.js';
+export { T as TileflowAnalytics, f as TileflowManifestFetchOptions, g as TileflowManifestLoadOptions, h as TileflowMapMarker, i as TileflowMapMode, j as TileflowMapModeOptions, k as TileflowResolvedRuntimeTheme, l as TileflowRuntimeCenterLike, d as TileflowRuntimeColorScheme, e as TileflowRuntimeManifest, m as TileflowRuntimeManifestMap, n as TileflowRuntimeManifestMapEntry, o as TileflowRuntimeManifestTheme, p as TileflowRuntimeSource, q as TileflowRuntimeSourceValidation, b as TileflowRuntimeStyle, r as TileflowRuntimeStyleOptions, s as TileflowRuntimeSystemThemes, t as TileflowRuntimeViewOptions, c as TileflowSessionController, u as TileflowSessionGrantResponse, a as TileflowStyleFontFace, v as TileflowThemeSelection, w as assertValidTileflowRuntimeSource, x as clearTileflowManifestCache, y as createTileflowSessionController, z as createTileflowSessionId, A as defaultTileflowManifestUrl, B as defaultTileflowRuntimeView, C as getTileflowAnalyticsApiUrl, D as getTileflowStyleFontFaces, E as inferTileflowAnalyticsFromStyleUrl, F as loadTileflowManifest, G as mergeTileflowAnalytics, H as normalizeTileflowRuntimeCenter, I as normalizeTileflowStaticImageSize, J as normalizeTileflowUrl, K as parseTileflowRuntimeManifest, L as resolveTileflowAnalyticsRequestUrl, M as resolveTileflowManifestMap, N as resolveTileflowMapMode, O as resolveTileflowRuntimeStyle, P as resolveTileflowRuntimeTheme, Q as resolveTileflowRuntimeView, R as resolveTileflowStaticImageUrl, S as safeParseTileflowRuntimeManifest, U as shouldLoadTileflowManifest, V as startTileflowSession, W as tileflowRuntimeManifestLimits, X as tileflowRuntimeManifestSchema, Y as tileflowRuntimeManifestVersion, Z as tileflowStyleFontFaceLimits, _ as tileflowStyleFontFacesMetadataKey, $ as validateTileflowRuntimeSource, a0 as validateTileflowThemeSelection } from './runtime-C4MtSzkB.js';
+export { O as OpenMapTilesFieldBindings, a as OpenMapTilesLayerBindings, f as OpenMapTilesSchema, g as OpenMapTilesSchemaOptions, P as ParkLayerSemantics, R as ResolvedTileflowData, h as TileflowAddressesModuleConfig, i as TileflowAddressesModuleOptions, j as TileflowAerowaysModuleConfig, k as TileflowAerowaysModuleOptions, l as TileflowBoundariesModuleConfig, m as TileflowBoundariesModuleOptions, n as TileflowBuildingMode, o as TileflowBuildingsModuleConfig, p as TileflowBuildingsModuleOptions, d as TileflowDataConfig, q as TileflowDataIdentity, r as TileflowLandModuleConfig, s as TileflowLandModuleOptions, t as TileflowLandcoverClass, u as TileflowLandformClass, v as TileflowLandformsModuleConfig, w as TileflowLandformsModuleOptions, x as TileflowLanduseClass, y as TileflowNauticalAreaLabelStyles, z as TileflowNauticalModuleConfig, A as TileflowNauticalModuleOptions, e as TileflowStreetsModules, B as TileflowTransitModuleConfig, C as TileflowTransitModuleOptions, D as TileflowTransitRailStyle, E as TileflowVegetationMode, F as TileflowVegetationModuleConfig, G as TileflowVegetationModuleOptions, H as TileflowVegetationThreeDimensionalStyle, b as TileflowVisualValueCategory, I as TileflowWaterModuleConfig, J as TileflowWaterModuleOptions, K as TileflowWaterwayClass, L as TileflowWorldData, M as TileflowWorldReleaseReference, N as TileflowWorldSelection, Q as TileflowWorldV1Schema, V as VectorTilesData, S as addresses, U as aeroways, W as boundaries, X as buildings, c as classifyTileflowVisualProperty, Y as isCanonicalOpenMapTilesSchema, Z as land, _ as landforms, $ as nautical, a0 as openMapTiles, a1 as openMapTilesContractVersion, a2 as resolveTileflowData, a3 as tileflowLandformClasses, a4 as tileflowPrimarySourceId, a5 as tileflowWorld, a6 as tileflowWorldGeneration, a7 as tileflowWorldTileJsonUrl, a8 as tileflowWorldV1Schema, a9 as transit, aa as validateTileflowWorldV1Tilejson, ab as vectorTiles, ac as vegetation, ad as water } from './visual-semantics-DTC-8Hsb.js';
 import { z } from 'zod';
 
-declare function getDefaultColors(): TileflowBaseColors;
+declare const tileflowPortableIdMaximumLength: 64;
+declare function isTileflowPortableId(value: unknown): value is string;
+declare function isTileflowThemeName(value: unknown): value is string;
 
-declare const tileflowThemeSchema: z.ZodObject<{
-    colors: z.ZodOptional<z.ZodObject<{
-        background: z.ZodOptional<z.ZodString>;
-        boundary: z.ZodOptional<z.ZodString>;
-        building: z.ZodOptional<z.ZodString>;
-        land: z.ZodOptional<z.ZodString>;
-        park: z.ZodOptional<z.ZodString>;
-        road: z.ZodOptional<z.ZodString>;
-        roadCasing: z.ZodOptional<z.ZodString>;
-        roadMajor: z.ZodOptional<z.ZodString>;
-        text: z.ZodOptional<z.ZodString>;
-        textHalo: z.ZodOptional<z.ZodString>;
-        textMuted: z.ZodOptional<z.ZodString>;
-        water: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    extends: z.ZodOptional<z.ZodString>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        light: "light";
-        dark: "dark";
-    }>>;
-    modules: z.ZodOptional<z.ZodObject<{
-        boundaries: z.ZodOptional<z.ZodObject<{
-            major: z.ZodOptional<z.ZodString>;
-            disputed: z.ZodOptional<z.ZodString>;
-            admin: z.ZodOptional<z.ZodString>;
-            maritime: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        buildings: z.ZodOptional<z.ZodObject<{
-            fill: z.ZodOptional<z.ZodString>;
-            outline: z.ZodOptional<z.ZodString>;
-            extrusion: z.ZodOptional<z.ZodString>;
-            highRise: z.ZodOptional<z.ZodString>;
-            highRiseOutline: z.ZodOptional<z.ZodString>;
-            lowRise: z.ZodOptional<z.ZodString>;
-            lowRiseOutline: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        hydro: z.ZodOptional<z.ZodObject<{
-            water: z.ZodOptional<z.ZodString>;
-            waterway: z.ZodOptional<z.ZodString>;
-            ferry: z.ZodOptional<z.ZodString>;
-            label: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        labels: z.ZodOptional<z.ZodObject<{
-            water: z.ZodOptional<z.ZodString>;
-            road: z.ZodOptional<z.ZodString>;
-            poi: z.ZodOptional<z.ZodString>;
-            primary: z.ZodOptional<z.ZodString>;
-            country: z.ZodOptional<z.ZodString>;
-            neighborhood: z.ZodOptional<z.ZodString>;
-            halo: z.ZodOptional<z.ZodString>;
-            muted: z.ZodOptional<z.ZodString>;
-            settlement: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        landcover: z.ZodOptional<z.ZodObject<{
-            park: z.ZodOptional<z.ZodString>;
-            grass: z.ZodOptional<z.ZodString>;
-            ice: z.ZodOptional<z.ZodString>;
-            protected: z.ZodOptional<z.ZodString>;
-            sand: z.ZodOptional<z.ZodString>;
-            wood: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        landuse: z.ZodOptional<z.ZodObject<{
-            residential: z.ZodOptional<z.ZodString>;
-            cemetery: z.ZodOptional<z.ZodString>;
-            civic: z.ZodOptional<z.ZodString>;
-            commercial: z.ZodOptional<z.ZodString>;
-            industrial: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        poi: z.ZodOptional<z.ZodObject<{
-            food: z.ZodOptional<z.ZodString>;
-            coffee: z.ZodOptional<z.ZodString>;
-            culture: z.ZodOptional<z.ZodString>;
-            transit: z.ZodOptional<z.ZodString>;
-            shopping: z.ZodOptional<z.ZodString>;
-            lodging: z.ZodOptional<z.ZodString>;
-            health: z.ZodOptional<z.ZodString>;
-            education: z.ZodOptional<z.ZodString>;
-            services: z.ZodOptional<z.ZodString>;
-            halo: z.ZodOptional<z.ZodString>;
-            icon: z.ZodOptional<z.ZodString>;
-            label: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        roads: z.ZodOptional<z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            motorway: z.ZodOptional<z.ZodString>;
-            trunk: z.ZodOptional<z.ZodString>;
-            primary: z.ZodOptional<z.ZodString>;
-            secondary: z.ZodOptional<z.ZodString>;
-            minor: z.ZodOptional<z.ZodString>;
-            bridge: z.ZodOptional<z.ZodString>;
-            tunnel: z.ZodOptional<z.ZodString>;
-            casing: z.ZodOptional<z.ZodString>;
-            ferry: z.ZodOptional<z.ZodString>;
-            rail: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    typography: z.ZodOptional<z.ZodObject<{
-        font: z.ZodOptional<z.ZodString>;
-        weight: z.ZodOptional<z.ZodEnum<{
-            bold: "bold";
-            regular: "regular";
-            medium: "medium";
-            semibold: "semibold";
-        }>>;
-        places: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-        poi: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-        roads: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-        water: z.ZodOptional<z.ZodObject<{
-            font: z.ZodOptional<z.ZodString>;
-            weight: z.ZodOptional<z.ZodEnum<{
-                bold: "bold";
-                regular: "regular";
-                medium: "medium";
-                semibold: "semibold";
-            }>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-declare const tileflowMapSchema: z.ZodType<TileflowConfig>;
-declare const configSchema: z.ZodType<TileflowConfig>;
-declare const tileflowProjectSchema: z.ZodType<TileflowProjectConfig>;
-declare function parseTileflowMap(input: unknown): TileflowConfig;
-declare function parseTileflowProject(input: unknown): TileflowProjectConfig;
-declare function validateConfig(input: unknown): ValidationResult;
-declare const validateTileflowConfig: typeof validateConfig;
+/** 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;
 
-declare function defineTileflow<const TConfig extends TileflowProjectConfig>(config: TConfig): TConfig;
+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;
+/** Preserve the exact inferred type of a compiler-root map. */
+declare function defineRootMap<const TMap extends TileflowRootMap>(map: ExactTileflowMap<TileflowRootMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
+/** Preserve the exact inferred type of a map that extends another map object. */
+declare function defineMap<const TMap extends TileflowDerivedMap>(map: ExactTileflowMap<TileflowDerivedMap, TMap> & ExactTileflowMapScenes<TMap>): TMap;
+
+declare const tileflowMapDefaultMaxDepth = 64;
+/** Resolve an imported map lineage to one standalone authoring map. */
+declare function resolveMap(map: TileflowMap, options?: ResolveMapOptions): ResolvedTileflowMap;
+
+/** 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[]);
+}
+
+type TileflowZoomPerformance = {
+    activeLayers: number;
+    /** @deprecated Use styleLayerFamilies. This is not a count of runtime tile buckets. */
+    estimatedBuckets: number;
+    sourceLayers: Record<string, number>;
+    styleLayerFamilies: number;
+    symbols: number;
+    zoom: number;
+};
+type TileflowStylePerformance = {
+    styleBytes: number;
+    totalLayers: number;
+    zooms: TileflowZoomPerformance[];
+};
+/** A deterministic, network-free structural sweep of a compiled style. */
+declare function analyzeTileflowStylePerformance(style: MapLibreStyle, zooms?: readonly number[]): TileflowStylePerformance;
 
 declare function roads(options?: TileflowRoadsModuleOptions): TileflowRoadsModuleConfig;
 
 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";
+    };
+}>;
 declare function poi(options?: TileflowPoiModuleOptions): TileflowPoiModuleConfig;
 
 declare const tileflowIconPackageFileNames: readonly ["sprite.json", "sprite.png", "sprite@2x.json", "sprite@2x.png"];
 type TileflowIconPackageFileName = (typeof tileflowIconPackageFileNames)[number];
-declare const tileflowHostedIconIdPattern: RegExp;
+/** 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;
@@ -184,10 +151,10 @@ declare const tileflowHostedAlphaCompatibility: {
         readonly maxGeneratedBytesPerProject: number;
         readonly maxRetainedPerProject: 24;
     };
-    readonly maxMapsPerDeploy: 1;
+    readonly maxMapsPerDeploy: 20;
 };
 declare const tileflowIconPackageContentHashSchema: z.ZodString;
-declare const tileflowHostedIconIdSchema: z.ZodString;
+declare const tileflowIconIdSchema: z.ZodString;
 declare const tileflowRenderedIconManifestEntrySchema: z.ZodObject<{
     name: z.ZodString;
     pixelSha256: z.ZodObject<{
@@ -262,6 +229,62 @@ declare function hashTileflowRenderedIconPixels(input: {
     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;
@@ -270,31 +293,6 @@ type TileflowIconManifestDiff = {
     removed: string[];
     unchangedCount: number;
 };
-type TileflowIconMappingChange = {
-    after?: string;
-    before?: string;
-    key: string;
-};
-type TileflowIconMappingDiff = {
-    added: TileflowIconMappingChange[];
-    changed: TileflowIconMappingChange[];
-    removed: TileflowIconMappingChange[];
-};
-type TileflowIconReferenceAnalysis = {
-    analysisComplete: boolean;
-    dangling: Array<{
-        iconName: string;
-        kind: 'mapping' | 'style-override-literal';
-        path: string;
-    }>;
-    unanalyzable: Array<{
-        kind: 'style-override-expression';
-        path: string;
-    }>;
-};
 declare function diffTileflowIconPackageManifests(before: TileflowIconPackageManifest | null, after: TileflowIconPackageManifest | null): TileflowIconManifestDiff;
-declare function diffTileflowIconMappings(before: Record<string, string> | null, after: Record<string, string> | null): TileflowIconMappingDiff;
-declare function inspectTileflowIconReferences(project: TileflowProjectConfig, mapName: string, availableIconNames: readonly string[]): TileflowIconReferenceAnalysis;
-declare function resolveTileflowIconMapping(project: TileflowProjectConfig, mapName: string): Record<string, string>;
 
-export { TileflowBaseColors, TileflowConfig, type TileflowIconManifestDiff, type TileflowIconMappingChange, type TileflowIconMappingDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, type TileflowIconReferenceAnalysis, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, TileflowPoiModuleConfig, TileflowPoiModuleOptions, TileflowProjectConfig, type TileflowRenderedIconManifestEntry, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, ValidationResult, compareCodeUnits, configSchema, defineTileflow, diffTileflowIconMappings, diffTileflowIconPackageManifests, getDefaultColors, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, inspectTileflowIconReferences, labels, parseTileflowMap, parseTileflowProject, poi, resolveTileflowIconMapping, roads, serializeCanonicalJson, serializeTileflowIconPackageManifest, sha256Hex, tileflowHostedAlphaCompatibility, tileflowHostedIconIdPattern, tileflowHostedIconIdSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowMapSchema, tileflowProjectSchema, tileflowRenderedIconManifestEntrySchema, tileflowThemeSchema, validateConfig, validateTileflowConfig };
+export { MapLibreStyle, ResolveMapOptions, ResolvedTileflowMap, TileflowDerivedMap, type TileflowFontBundleFile, type TileflowFontBundleFontFace, type TileflowFontBundleManifest, type TileflowIconManifestDiff, type TileflowIconPackageFileName, type TileflowIconPackageManifest, TileflowLabelsModuleConfig, TileflowLabelsModuleOptions, TileflowMap, TileflowMapScene, TileflowPoiModuleConfig, TileflowPoiModuleOptions, type TileflowRenderedIconManifestEntry, TileflowResolvedMapValidationError, TileflowRoadsModuleConfig, TileflowRoadsModuleOptions, type TileflowStylePerformance, type TileflowZoomPerformance, ValidationMessage, analyzeTileflowStylePerformance, compareCodeUnits, defineMap, defineRootMap, diffTileflowIconPackageManifests, hashTileflowFontBundleManifest, hashTileflowIconPackageManifest, hashTileflowRenderedIconPixels, isTileflowPortableId, isTileflowThemeName, isTileflowWorldReleaseId, labels, poi, resolveMap, roads, serializeCanonicalJson, serializeTileflowFontBundleManifest, serializeTileflowIconPackageManifest, sha256Hex, tileflowFontBundleContentHashSchema, tileflowFontBundleLimits, tileflowFontBundleManifestSchema, tileflowHostedAlphaCompatibility, tileflowIconIdPattern, tileflowIconIdSchema, tileflowIconPackageContentHashSchema, tileflowIconPackageFileNames, tileflowIconPackageLabelSchema, tileflowIconPackageLimits, tileflowIconPackageManifestSchema, tileflowMapDefaultMaxDepth, tileflowPoiImageRoles, tileflowPortableIdMaximumLength, tileflowRenderedIconManifestEntrySchema, tileflowWorldReleaseIdMaximumLength, tileflowWorldReleaseIdMinimumLength, tileflowWorldReleaseIdPattern, tileflowWorldReleaseIdPatternSource, tileflowWorldReleaseIdSchema };