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

package/dist/requirements-BV77ZVhR.d.ts

@@ -0,0 +1,491 @@
+import * as zod from 'zod';
+import { T as TileflowCaptureScene } from './capture-scene-BK_0J2oR.js';
+import { b as TileflowVisualValueCategory, d as TileflowDataConfig, e as TileflowStreetsModules } from './visual-semantics-DTC-8Hsb.js';
+import { a as TileflowFillStyle, b as TileflowLineStyle, c as TileflowSymbolStyle, d as TileflowTerrainHillshadeStyle, e as TileflowTerrainEncoding, f as TileflowThemeNumberValue, g as TileflowThemeColorValue, h as TileflowThemeFontValue, i as TileflowThemeImageValue, j as TileflowTypographyStyle, k as TileflowLight, R as ResolvedTileflowTypography, l as TileflowProjection, m as TileflowTerrain, T as TileflowViewConfig, M as MapLibreStyle, V as ValidationResult } from './types-DlUGI6LC.js';
+
+declare const tileflowBathymetrySourceId: "tileflow-bathymetry";
+declare const tileflowBathymetryDemSourceId: "tileflow-bathymetry-dem";
+declare const tileflowNauticalSourceId: "tileflow-nautical";
+declare const tileflowBathymetryV1Schema: Readonly<{
+    fields: Readonly<{
+        minDepth: "min_depth";
+        sortKey: "sort_key";
+    }>;
+    layer: "bathymetry";
+    layers: Readonly<{
+        bands: "bathymetry";
+        contours: "bathymetry_contour";
+        coverage: "bathymetry_coverage";
+        landforms: "seafloor_landform";
+        waterNames: "water_name";
+    }>;
+    optionalLayers: readonly ["contours", "coverage", "landforms", "waterNames"];
+    product: "bathymetry-v1";
+    requiredLayers: readonly ["bands"];
+    schemaVersion: 1;
+    sources: Readonly<{
+        dem: Readonly<{
+            encoding: "terrarium";
+            sourceId: "tileflow-bathymetry-dem";
+            tileSize: 512;
+        }>;
+        vector: Readonly<{
+            sourceId: "tileflow-bathymetry";
+        }>;
+    }>;
+}>;
+declare const tileflowNauticalV1Schema: Readonly<{
+    fields: Readonly<{
+        cell: "cell";
+        character: "character";
+        class: "class";
+        color: "color";
+        coverage: "coverage";
+        depth: "depth";
+        direction: "direction";
+        edition: "edition";
+        licence: "licence";
+        name: "name";
+        provider: "provider";
+        provenance: "provenance";
+        quality: "quality";
+        rangeNm: "range_nm";
+        scale: "scale";
+        subclass: "subclass";
+        update: "update";
+    }>;
+    geometryTypes: Readonly<{
+        aids: readonly ["Point"];
+        coverage: readonly ["Polygon"];
+        hazards: readonly ["Point", "Polygon"];
+        lights: readonly ["Point"];
+        navigationAreas: readonly ["Polygon"];
+        reefs: readonly ["Polygon"];
+        soundings: readonly ["Point"];
+        wrecks: readonly ["Point", "Polygon"];
+    }>;
+    layers: Readonly<{
+        aids: "aid";
+        coverage: "coverage";
+        hazards: "hazard";
+        lights: "light";
+        navigationAreas: "navigation_area";
+        reefs: "reef";
+        soundings: "sounding";
+        wrecks: "wreck";
+    }>;
+    product: "nautical-v1";
+    schemaVersion: 1;
+}>;
+type TileflowMarineMode = 'none' | 'bathymetry' | 'nautical' | 'chart';
+/** One schema-compatible vector TileJSON source used by a marine sidecar. */
+type TileflowMarineSourceConfig = {
+    attribution?: string;
+    sourceId?: string;
+    url?: string;
+};
+type TileflowBathymetryDisplay = 'bands' | 'relief' | 'hybrid';
+/**
+ * Styling and physical-source overrides for the optional Bathymetry DEM.
+ * Terrarium and 512 px tiles are the hosted defaults; advanced compatible sources may override
+ * either. `opacity` applies to both the continuous color relief and the hillshade tint.
+ */
+type TileflowBathymetryReliefConfig = TileflowTerrainHillshadeStyle & {
+    attribution?: string;
+    encoding?: TileflowTerrainEncoding;
+    illuminationAltitude?: TileflowThemeNumberValue;
+    multidirectional?: boolean;
+    opacity?: TileflowThemeNumberValue;
+    sourceId?: string;
+    tileSize?: 256 | 512;
+    url?: string;
+};
+/** One logical Bathymetry product backed by vector bands and, when requested, a DEM. */
+type TileflowBathymetryConfig = TileflowMarineSourceConfig & {
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display?: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: false | TileflowBathymetryReliefConfig;
+    type: 'bathymetry';
+};
+type TileflowBathymetryOptions = Omit<TileflowBathymetryConfig, 'type'>;
+/** Configure Bathymetry as one product while loading only the physical sources its display needs. */
+declare function bathymetry(options?: TileflowBathymetryOptions): TileflowBathymetryConfig;
+/**
+ * Advanced marine selection. An omitted member selects Tileflow's current product; `false`
+ * disables only that member. Therefore `{}` is equivalent to `"chart"`.
+ */
+type TileflowMarineConfig = {
+    bathymetry?: false | TileflowBathymetryConfig | TileflowMarineSourceConfig;
+    nautical?: false | TileflowMarineSourceConfig;
+};
+type TileflowMarine = TileflowMarineMode | TileflowMarineConfig;
+type TileflowMarineSourceIdentity = Readonly<{
+    kind: 'tileflow-bathymetry' | 'tileflow-nautical';
+    product: 'bathymetry-v1' | 'nautical-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    url: string;
+}>;
+type TileflowBathymetryDemSourceIdentity = Readonly<{
+    encoding: TileflowTerrainEncoding;
+    kind: 'tileflow-bathymetry-dem';
+    product: 'bathymetry-v1';
+    schemaVersion: 1;
+    sourceId: string;
+    tileSize: 256 | 512;
+    url: string;
+}>;
+type ResolvedMarineSource = Readonly<{
+    identity: TileflowMarineSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        type: 'vector';
+        url: string;
+    }>;
+    sourceId: string;
+}>;
+type ResolvedBathymetryRelief = Readonly<{
+    identity: TileflowBathymetryDemSourceIdentity;
+    source: Readonly<Record<string, unknown> & {
+        encoding: TileflowTerrainEncoding;
+        tileSize: 256 | 512;
+        type: 'raster-dem';
+        url: string;
+    }>;
+    sourceId: string;
+    style: TileflowBathymetryReliefConfig;
+}>;
+type ResolvedBathymetry = Readonly<{
+    bands?: false | TileflowFillStyle;
+    contours?: false | TileflowLineStyle;
+    display: TileflowBathymetryDisplay;
+    labels?: false | TileflowSymbolStyle;
+    relief?: ResolvedBathymetryRelief;
+    vector?: ResolvedMarineSource;
+}>;
+type ResolvedMarine = Readonly<{
+    bathymetry?: ResolvedBathymetry;
+    nautical?: ResolvedMarineSource;
+}>;
+/** Resolve the optional marine sidecars without fetching their TileJSON documents. */
+declare function resolveMarine(marine: TileflowMarine | undefined, apiBaseUrl?: string): ResolvedMarine | undefined;
+
+type TileflowThemeColorScheme = 'dark' | 'light';
+type TileflowThemeName = string;
+type TileflowThemeTokens = {
+    color: Readonly<Record<string, TileflowThemeColorValue>>;
+    font: Readonly<Record<string, TileflowThemeFontValue>>;
+    image: Readonly<Record<string, TileflowThemeImageValue>>;
+    number: Readonly<Record<string, TileflowThemeNumberValue>>;
+};
+type TileflowThemeTypographyStyle = {
+    fallbacks?: readonly TileflowThemeFontValue[];
+    font?: TileflowThemeFontValue;
+    letterSpacing?: TileflowThemeNumberValue;
+    transform?: TileflowTypographyStyle['transform'];
+};
+type TileflowThemeTypography = TileflowThemeTypographyStyle & {
+    places?: TileflowThemeTypographyStyle;
+    poi?: TileflowThemeTypographyStyle;
+    roads?: TileflowThemeTypographyStyle;
+    water?: TileflowThemeTypographyStyle;
+};
+type TileflowThemeLighting = {
+    anchor?: 'map' | 'viewport';
+    color?: TileflowThemeColorValue;
+    intensity?: TileflowThemeNumberValue;
+    position?: readonly [
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue,
+        TileflowThemeNumberValue
+    ];
+};
+/** A complete, inheritance-free appearance document. */
+type TileflowTheme = {
+    colorScheme: TileflowThemeColorScheme;
+    id: string;
+    lighting: TileflowThemeLighting;
+    tokens: TileflowThemeTokens;
+    typography: TileflowThemeTypography;
+    version: number;
+};
+type TileflowThemeTokenOverrides = {
+    [TCategory in keyof TileflowThemeTokens]?: Readonly<Partial<TileflowThemeTokens[TCategory]>>;
+};
+/** Input accepted by defineTheme. The returned theme is always fully materialized. */
+type TileflowThemeDefinition = Pick<TileflowTheme, 'colorScheme' | 'id' | 'version'> & {
+    lighting?: TileflowThemeLighting;
+    tokens?: TileflowThemeTokenOverrides;
+    typography?: TileflowThemeTypography;
+};
+type ResolvedTileflowThemeTokens = {
+    color: Readonly<Record<string, string>>;
+    font: Readonly<Record<string, string>>;
+    image: Readonly<Record<string, string>>;
+    number: Readonly<Record<string, number>>;
+};
+type ResolvedTileflowTheme = Omit<TileflowTheme, 'lighting' | 'tokens' | 'typography'> & {
+    lighting: TileflowLight;
+    tokens: ResolvedTileflowThemeTokens;
+    typography: ResolvedTileflowTypography;
+};
+type TileflowResolvedThemeSelection = {
+    name: TileflowThemeName;
+    theme: TileflowTheme;
+};
+type TileflowThemeAuditScope = 'compiler-effect' | 'module' | 'terrain' | 'value';
+type TileflowThemeAuditEffectKind = 'add' | 'patch';
+type TileflowThemeAuditContext = {
+    effectKind?: TileflowThemeAuditEffectKind;
+    owner?: string;
+    scope: TileflowThemeAuditScope;
+    target?: string;
+};
+type TileflowThemeAuditDiagnostic = {
+    category: TileflowVisualValueCategory;
+    code: 'THEME_IMPLICIT_FIXED';
+    effectKind?: TileflowThemeAuditEffectKind;
+    message: string;
+    owner?: string;
+    path: string;
+    phase: 'theme-audit';
+    scope: TileflowThemeAuditScope;
+    severity: 'error' | 'warning';
+    suggestion: string;
+    target?: string;
+    value: number | string;
+};
+/** A deterministic, machine-readable failure for blocking theme-audit diagnostics. */
+declare class TileflowThemeAuditError extends Error {
+    readonly diagnostics: readonly TileflowThemeAuditDiagnostic[];
+    constructor(diagnostics: readonly TileflowThemeAuditDiagnostic[]);
+}
+declare function defineTheme(definition: TileflowThemeDefinition): TileflowTheme;
+declare function defineTheme(base: TileflowTheme, definition: TileflowThemeDefinition): TileflowTheme;
+declare function resolveTileflowTheme(theme: TileflowTheme): ResolvedTileflowTheme;
+/** Resolve every theme node in modules, effects, zoom values and expression arrays. */
+declare function resolveThemeValues<T>(value: T, theme: TileflowTheme, path?: string): T;
+/** Select an explicit theme or the map's deterministic default. Browser "system" is external. */
+declare function resolveThemeSelection(map: {
+    defaultTheme: string;
+    themes: Readonly<Record<string, TileflowTheme>>;
+}, requested?: string): TileflowResolvedThemeSelection;
+/** Find visual literals whose permanence is otherwise invisible to an agent. */
+declare function auditTileflowThemeValues(value: unknown, path?: string, context?: TileflowThemeAuditContext): TileflowThemeAuditDiagnostic[];
+/** Audit every appearance-bearing branch of a resolved map, including compiler-private effects. */
+declare function auditTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): TileflowThemeAuditDiagnostic[];
+/** Fail closed when a map contains implicit chromatic, font, or image literals. */
+declare function assertTileflowMapThemeValues(map: {
+    modules?: unknown;
+    terrain?: unknown;
+}): void;
+
+/** A directory resolved relative to the selected executable tileflow.config.ts. */
+type TileflowLocalDirectory = `./${string}` | `../${string}`;
+declare const tileflowLocalDirectoryMaximumLength = 512;
+declare const tileflowLocalDirectoryMessage = "Expected a canonical relative directory beginning with ./ or ../; only leading .. segments are allowed and segments must be non-empty, without backslashes or controls";
+/** Exact portable syntax shared by config validation and Node filesystem resolution. */
+declare function isTileflowLocalDirectory(value: unknown): value is TileflowLocalDirectory;
+/**
+ * A package-owned asset directory. Applications normally import one of these
+ * descriptors from the package that owns the assets instead of constructing it.
+ */
+type TileflowPackageDirectory = Readonly<{
+    kind: 'package-directory';
+    package: string;
+    path: string;
+}>;
+/** One icon directory in the ordered map icon search path. */
+type TileflowIconDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/** One font directory in the ordered map font search path. */
+type TileflowFontDirectory = TileflowLocalDirectory | TileflowPackageDirectory;
+/**
+ * An explicit MapLibre glyph provider. `fontStacks` lists the exact comma-joined request keys
+ * produced by each compiled `text-font` array. The map owns the URL; World never supplies fonts.
+ */
+type TileflowGlyphs = Readonly<{
+    fontStacks: readonly string[];
+    kind: 'url';
+    url: string;
+}>;
+
+/** Version of the internal Streets compiler contract understood by map roots. */
+declare const tileflowStreetsCompilerVersion: 1;
+/** Portable, filesystem-safe identity shared by maps and their leaf-owned scenes. */
+declare const tileflowMapIdSchema: zod.ZodString;
+type TileflowStreetsMapRoot = {
+    compiler: 'streets';
+    compilerVersion: typeof tileflowStreetsCompilerVersion;
+};
+/** Compiler root inherited by a complete map lineage. */
+type TileflowMapRoot = TileflowStreetsMapRoot;
+/** Identity is always owned by the map being resolved and never inherited. */
+type TileflowMapIdentity = {
+    id: string;
+    name?: string;
+    /** Editorial version of this map, independent from its compiler version. */
+    version: number;
+};
+/** A capture scene owned by one singular map; its map id is implicit. */
+type TileflowMapScene = Omit<TileflowCaptureScene, 'map'>;
+type TileflowHostedDelivery = {
+    allowedOrigins?: string[];
+};
+type TileflowMapDelivery = {
+    hosted?: TileflowHostedDelivery;
+};
+/** Tooling metadata belongs to the leaf definition and is never inherited. */
+type TileflowMapTooling = {
+    delivery?: TileflowMapDelivery;
+    scenes?: Record<string, TileflowMapScene>;
+};
+type TileflowMapTextAssets = {
+    fonts?: never;
+    glyphs?: never;
+} | {
+    fonts: readonly TileflowFontDirectory[];
+    glyphs?: never;
+} | {
+    fonts?: never;
+    glyphs: TileflowGlyphs;
+};
+/** Cartographic fields supported by the current Streets compiler. */
+type TileflowMapDesign = TileflowMapTextAssets & {
+    data?: TileflowDataConfig;
+    /** Name used whenever a concrete theme is not explicitly requested. */
+    defaultTheme?: TileflowThemeName;
+    /** Ordered icon directories. Omission inherits; declaration replaces; [] means no icons. */
+    icons?: readonly TileflowIconDirectory[];
+    /** Independent Bathymetry and Nautical products composed by the compiler. */
+    marine?: TileflowMarine;
+    modules?: TileflowStreetsModules;
+    projection?: TileflowProjection;
+    /** Browser color-scheme mapping. Runtime resolves "system" to one of these concrete names. */
+    systemThemes?: {
+        dark: TileflowThemeName;
+        light: TileflowThemeName;
+    };
+    terrain?: TileflowTerrain;
+    /** Complete named appearances. Omission inherits; declaration replaces the collection. */
+    themes?: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+    view?: TileflowViewConfig;
+};
+type TileflowRootMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    root: TileflowMapRoot;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type TileflowDerivedMap = TileflowMapIdentity & TileflowMapTooling & TileflowMapDesign & {
+    extends: TileflowMap;
+    root?: never;
+};
+/** Executable authoring definition: exactly one of `root` or `extends`. */
+type TileflowMap = TileflowRootMap | TileflowDerivedMap;
+type ResolvedTileflowMapDesign<TDesign extends TileflowMapDesign = TileflowMapDesign> = TDesign extends TileflowMapDesign ? Omit<TDesign, 'defaultTheme' | 'themes'> : never;
+/** A standalone map definition with inheritance removed. */
+type ResolvedTileflowMap = Omit<TileflowMapIdentity, 'name'> & Pick<TileflowMapTooling, 'delivery'> & ResolvedTileflowMapDesign & {
+    defaultTheme: TileflowThemeName;
+    extends?: never;
+    name: string;
+    root: TileflowMapRoot;
+    themes: Readonly<Record<TileflowThemeName, TileflowTheme>>;
+};
+type ResolveMapOptions = {
+    /** Maximum number of map definitions in a lineage, including the root. */
+    maxDepth?: number;
+};
+
+type TileflowPreparedMapAssets = {
+    icons?: {
+        ids: readonly string[];
+        sprite: string;
+    };
+};
+type TileflowStreetsCompileOptions = {
+    apiBaseUrl?: string;
+    /** Resolved authoring identity. Internal build orchestration supplies this. */
+    map?: {
+        id: string;
+        lineage?: readonly string[];
+        root: TileflowMapRoot;
+        version: number;
+    };
+    /** Build-owned assets prepared from the authoring directories. */
+    preparedAssets?: TileflowPreparedMapAssets;
+    /** Concrete named theme. Omission deterministically selects map.defaultTheme. */
+    theme?: string;
+};
+
+type TileflowStyleOptions = TileflowStreetsCompileOptions;
+declare function createStyle(config: TileflowMap, options?: TileflowStyleOptions): MapLibreStyle;
+declare function collectMapLineage(map: TileflowMap): string[];
+/** Resolve and validate one public authoring map before asset preparation or compilation. */
+declare function parseTileflowMap(map: TileflowMap): ResolvedTileflowMap;
+/** Validate one singular authoring map, including its complete extends lineage. */
+declare function validateTileflowMap(input: unknown): ValidationResult;
+
+type TileflowDataFieldType = 'Boolean' | 'Number' | 'String';
+type TileflowDataFieldRequirement = Readonly<{
+    name: string;
+    type?: TileflowDataFieldType;
+}>;
+type TileflowDataLayerRequirement = Readonly<{
+    fields: readonly TileflowDataFieldRequirement[];
+    id: string;
+}>;
+type TileflowDataRequirementsV1 = Readonly<{
+    complete: boolean;
+    dynamicAccesses: readonly string[];
+    schemaVersion: 1;
+    sourceId: string;
+    sourceLayers: readonly TileflowDataLayerRequirement[];
+}>;
+/** Per-source requirements for styles that compose independent vector and DEM products. */
+type TileflowSourceRequirementsV1 = Readonly<{
+    rasterDemSources?: Readonly<Record<string, TileflowRasterDemSourceRequirementV1>>;
+    schemaVersion: 1;
+    sources: Readonly<Record<string, TileflowDataRequirementsV1>>;
+}>;
+type TileflowRasterDemSourceRequirementV1 = Readonly<{
+    encoding: 'mapbox' | 'terrarium';
+    sourceId: string;
+    tileSize: 256 | 512;
+    type: 'raster-dem';
+}>;
+type TileflowObservedDataContractV1 = Readonly<{
+    sourceLayers: readonly Readonly<{
+        fields: readonly Readonly<{
+            name: string;
+            type: TileflowDataFieldType;
+        }>[];
+        id: string;
+    }>[];
+}>;
+type TileflowDataCompatibilityIssue = Readonly<{
+    code: 'dynamic-field-access' | 'field-missing' | 'field-type-mismatch' | 'source-layer-missing';
+    field?: string;
+    message: string;
+    sourceLayer?: string;
+}>;
+/**
+ * Infer the effective data surface from finalized MapLibre layers. Disabled modules contribute no
+ * requirements, and fields hidden by map inheritance never reach this compiler output.
+ */
+declare function inferTileflowDataRequirements(style: MapLibreStyle, options?: {
+    additional?: readonly TileflowDataLayerRequirement[];
+    sourceId?: string;
+}): TileflowDataRequirementsV1;
+/**
+ * Infer the V1 layer/field contract for every referenced vector source and the physical contract
+ * for each included raster DEM. The singular helper remains unchanged for World-only consumers.
+ */
+declare function inferTileflowSourceRequirements(style: MapLibreStyle): TileflowSourceRequirementsV1;
+/** Compare inferred use with producer-observed layers and fields; no editorial allowlist exists. */
+declare function validateTileflowDataCompatibility(requirements: TileflowDataRequirementsV1, contract: TileflowObservedDataContractV1): readonly TileflowDataCompatibilityIssue[];
+
+export { type TileflowThemeAuditScope as $, type TileflowBathymetryOptions as A, type TileflowBathymetryReliefConfig as B, type TileflowFontDirectory as C, type TileflowGlyphs as D, type TileflowHostedDelivery as E, type TileflowIconDirectory as F, type TileflowLocalDirectory as G, type TileflowMapDelivery as H, type TileflowMapDesign as I, type TileflowMapIdentity as J, type TileflowMapRoot as K, type TileflowMapTooling as L, type TileflowMarine as M, type TileflowMarineConfig as N, type TileflowMarineMode as O, type TileflowMarineSourceConfig as P, type TileflowMarineSourceIdentity as Q, type ResolvedTileflowMap as R, type TileflowPackageDirectory as S, type TileflowMap as T, type TileflowRasterDemSourceRequirementV1 as U, type TileflowResolvedThemeSelection as V, type TileflowTheme as W, type TileflowThemeAuditContext as X, type TileflowThemeAuditDiagnostic as Y, type TileflowThemeAuditEffectKind as Z, TileflowThemeAuditError as _, type TileflowDataRequirementsV1 as a, type TileflowThemeColorScheme as a0, type TileflowThemeDefinition as a1, type TileflowThemeLighting as a2, type TileflowThemeName as a3, type TileflowThemeTokens as a4, type TileflowThemeTypography as a5, type TileflowThemeTypographyStyle as a6, assertTileflowMapThemeValues as a7, auditTileflowMapThemeValues as a8, auditTileflowThemeValues as a9, bathymetry as aa, createStyle as ab, defineTheme as ac, isTileflowLocalDirectory as ad, parseTileflowMap as ae, resolveMarine as af, resolveThemeSelection as ag, resolveThemeValues as ah, resolveTileflowTheme as ai, tileflowBathymetryDemSourceId as aj, tileflowBathymetrySourceId as ak, tileflowBathymetryV1Schema as al, tileflowLocalDirectoryMaximumLength as am, tileflowLocalDirectoryMessage as an, tileflowMapIdSchema as ao, tileflowNauticalSourceId as ap, tileflowNauticalV1Schema as aq, validateTileflowMap as ar, type TileflowSourceRequirementsV1 as b, type TileflowStyleOptions as c, type TileflowPreparedMapAssets as d, type TileflowDataCompatibilityIssue as e, type TileflowDataFieldRequirement as f, type TileflowDataFieldType as g, type TileflowDataLayerRequirement as h, type TileflowObservedDataContractV1 as i, collectMapLineage as j, inferTileflowDataRequirements as k, inferTileflowSourceRequirements as l, type TileflowDerivedMap as m, type TileflowMapScene as n, type TileflowRootMap as o, type ResolveMapOptions as p, type ResolvedBathymetry as q, type ResolvedBathymetryRelief as r, type ResolvedMarine as s, type ResolvedMarineSource as t, type ResolvedTileflowTheme as u, validateTileflowDataCompatibility as v, type ResolvedTileflowThemeTokens as w, type TileflowBathymetryConfig as x, type TileflowBathymetryDemSourceIdentity as y, type TileflowBathymetryDisplay as z };