@tileflow/core 0.1.0-alpha.14 → 0.1.0-alpha.17

package/dist/runtime-BMZ_tuba.d.ts

@@ -0,0 +1,656 @@
+import { z } from 'zod';
+
+declare const tileflowCaptureSceneSchemaVersion: 1;
+declare const tileflowCaptureSceneLimits: Readonly<{
+    applicationPathLength: 2048;
+    boundsPadding: {
+        maximum: number;
+        minimum: number;
+    };
+    captureIdLength: 64;
+    maximumPhysicalPixels: 16777216;
+    pitch: {
+        maximum: number;
+        minimum: number;
+    };
+    selectorLength: 256;
+    viewport: {
+        maximum: number;
+        minimum: number;
+    };
+    zoom: {
+        maximum: number;
+        minimum: number;
+    };
+}>;
+declare const tileflowCaptureCenterCameraSchema: z.ZodObject<{
+    type: z.ZodLiteral<"center">;
+    center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zoom: z.ZodNumber;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const tileflowCaptureBoundsCameraSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bounds">;
+    bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const tileflowCaptureCameraSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"center">;
+    center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    zoom: z.ZodNumber;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"bounds">;
+    bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    pitch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "type">;
+declare const tileflowCaptureViewportSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    dpr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+}, z.core.$strict>;
+declare const tileflowCaptureIdSchema: z.ZodString;
+declare const tileflowCaptureSceneNameSchema: z.ZodString;
+declare const tileflowCaptureMapTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"map">;
+}, z.core.$strict>;
+declare const tileflowCaptureApplicationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"application">;
+    path: z.ZodString;
+    captureId: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    frame: z.ZodOptional<z.ZodEnum<{
+        map: "map";
+        viewport: "viewport";
+    }>>;
+}, z.core.$strict>;
+declare const tileflowCaptureTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"map">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"application">;
+    path: z.ZodString;
+    captureId: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    frame: z.ZodOptional<z.ZodEnum<{
+        map: "map";
+        viewport: "viewport";
+    }>>;
+}, z.core.$strict>], "kind">;
+declare const tileflowCaptureSceneSchema: z.ZodObject<{
+    map: z.ZodString;
+    camera: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"center">;
+        center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        zoom: z.ZodNumber;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"bounds">;
+        bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        padding: z.ZodOptional<z.ZodNumber>;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "type">;
+    viewport: z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        dpr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    }, z.core.$strict>;
+    target: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"map">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"application">;
+        path: z.ZodString;
+        captureId: z.ZodOptional<z.ZodString>;
+        selector: z.ZodOptional<z.ZodString>;
+        frame: z.ZodOptional<z.ZodEnum<{
+            map: "map";
+            viewport: "viewport";
+        }>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+type TileflowCaptureCenterCamera = z.infer<typeof tileflowCaptureCenterCameraSchema>;
+type TileflowCaptureBoundsCamera = z.infer<typeof tileflowCaptureBoundsCameraSchema>;
+type TileflowCaptureCamera = z.infer<typeof tileflowCaptureCameraSchema>;
+type TileflowCaptureViewport = z.infer<typeof tileflowCaptureViewportSchema>;
+type TileflowCaptureMapTarget = z.infer<typeof tileflowCaptureMapTargetSchema>;
+type TileflowCaptureApplicationTarget = z.infer<typeof tileflowCaptureApplicationTargetSchema>;
+type TileflowCaptureTarget = z.infer<typeof tileflowCaptureTargetSchema>;
+type TileflowCaptureScene = z.infer<typeof tileflowCaptureSceneSchema>;
+type NormalizedTileflowCaptureScene = {
+    map: string;
+    camera: {
+        type: 'center';
+        center: [number, number];
+        zoom: number;
+        bearing: number;
+        pitch: number;
+    } | {
+        type: 'bounds';
+        bounds: [number, number, number, number];
+        padding: number;
+        bearing: number;
+        pitch: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+        dpr: 1 | 2;
+    };
+    target: {
+        kind: 'map';
+    } | {
+        kind: 'application';
+        path: string;
+        captureId?: string;
+        selector?: string;
+        frame: 'map' | 'viewport';
+    };
+};
+declare function normalizeTileflowCaptureScene(input: TileflowCaptureScene): NormalizedTileflowCaptureScene;
+declare function normalizeTileflowCaptureId(value: string | undefined): string | undefined;
+
+type TileflowDensity = 'clean' | 'balanced' | 'dense';
+type TileflowRoads = 'hidden' | 'soft' | 'standard' | 'detailed';
+type TileflowLabels = 'none' | 'essential' | 'balanced' | 'full';
+type TileflowPoi = 'none' | 'minimal' | 'balanced' | 'full';
+type TileflowLabelDetail = 'none' | 'major' | 'all';
+type TileflowRoadLabelDetail = TileflowRoadDetail;
+type TileflowLabelLanguage = 'auto' | 'local' | 'en' | (string & {});
+type TileflowPoiCategory = 'food' | 'coffee' | 'culture' | 'transit' | 'shopping' | 'lodging' | 'health' | 'education' | 'services' | (string & {});
+type TileflowPoiIcons = boolean | 'essential' | 'full';
+type TileflowPoiLabels = 'none' | 'minimal' | 'balanced' | 'full';
+type TileflowPoiDensity = 'sparse' | 'balanced' | 'dense';
+type TileflowPoiColorMode = 'uniform' | 'category';
+type TileflowPoiClassMapping = Record<string, readonly string[]>;
+type TileflowTheme = 'standard' | 'light' | 'dark' | 'minimal' | 'osm-bright-2';
+type TileflowBuildings = 'hidden' | 'flat' | '3d';
+type TileflowTerrainMode = 'none' | 'hillshade' | '3d';
+type TileflowTerrainEncoding = 'mapbox' | 'terrarium';
+type TileflowRenderer = 'auto' | 'osm-bright' | 'generated';
+type TileflowThemeName = string;
+type TileflowThemeMode = 'light' | 'dark';
+type TileflowColor = `#${string}`;
+type TileflowBaseColors = {
+    background: TileflowColor;
+    land: TileflowColor;
+    water: TileflowColor;
+    park: TileflowColor;
+    building: TileflowColor;
+    road: TileflowColor;
+    roadMajor: TileflowColor;
+    boundary: TileflowColor;
+    text: TileflowColor;
+    textMuted: TileflowColor;
+    textHalo: TileflowColor;
+};
+type LegacyTileflowColorAliases = {
+    accent?: TileflowColor;
+    canvas?: TileflowColor;
+    background?: TileflowColor;
+    greenspace?: TileflowColor;
+    nature?: TileflowColor;
+    park?: TileflowColor;
+    roadCasing?: TileflowColor;
+};
+type TileflowRoadColorConfig = {
+    bridge?: TileflowColor;
+    casing?: TileflowColor;
+    ferry?: TileflowColor;
+    minor?: TileflowColor;
+    motorway?: TileflowColor;
+    path?: TileflowColor;
+    primary?: TileflowColor;
+    rail?: TileflowColor;
+    secondary?: TileflowColor;
+    trunk?: TileflowColor;
+    tunnel?: TileflowColor;
+};
+type TileflowLabelColorConfig = {
+    country?: TileflowColor;
+    halo?: TileflowColor;
+    muted?: TileflowColor;
+    neighborhood?: TileflowColor;
+    poi?: TileflowColor;
+    primary?: TileflowColor;
+    road?: TileflowColor;
+    settlement?: TileflowColor;
+    water?: TileflowColor;
+};
+type TileflowPoiColorConfig = {
+    coffee?: TileflowColor;
+    culture?: TileflowColor;
+    education?: TileflowColor;
+    food?: TileflowColor;
+    halo?: TileflowColor;
+    health?: TileflowColor;
+    icon?: TileflowColor;
+    label?: TileflowColor;
+    lodging?: TileflowColor;
+    services?: TileflowColor;
+    shopping?: TileflowColor;
+    transit?: TileflowColor;
+};
+type TileflowLanduseColorConfig = {
+    cemetery?: TileflowColor;
+    civic?: TileflowColor;
+    commercial?: TileflowColor;
+    industrial?: TileflowColor;
+    residential?: TileflowColor;
+};
+type TileflowLandcoverColorConfig = {
+    grass?: TileflowColor;
+    ice?: TileflowColor;
+    park?: TileflowColor;
+    protected?: TileflowColor;
+    sand?: TileflowColor;
+    wood?: TileflowColor;
+};
+type TileflowHydroColorConfig = {
+    ferry?: TileflowColor;
+    label?: TileflowColor;
+    water?: TileflowColor;
+    waterway?: TileflowColor;
+};
+type TileflowBuildingColorConfig = {
+    extrusion?: TileflowColor;
+    fill?: TileflowColor;
+    highRise?: TileflowColor;
+    highRiseOutline?: TileflowColor;
+    lowRise?: TileflowColor;
+    lowRiseOutline?: TileflowColor;
+    outline?: TileflowColor;
+};
+type TileflowBuildingStyleConfig = {
+    fillOpacity?: number;
+    heightThreshold?: number;
+    outlineOpacity?: number;
+    outlineWidth?: number;
+};
+type TileflowBoundaryColorConfig = {
+    admin?: TileflowColor;
+    disputed?: TileflowColor;
+    major?: TileflowColor;
+    maritime?: TileflowColor;
+};
+type TileflowAdvancedColorConfig = {
+    boundaries?: TileflowBoundaryColorConfig;
+    buildings?: TileflowBuildingColorConfig;
+    hydro?: TileflowHydroColorConfig;
+    labels?: TileflowLabelColorConfig;
+    landcover?: TileflowLandcoverColorConfig;
+    landuse?: TileflowLanduseColorConfig;
+    poi?: TileflowPoiColorConfig;
+    roads?: TileflowRoadColorConfig;
+};
+type TileflowThemeModulesConfig = TileflowAdvancedColorConfig;
+type TileflowColorConfig = Partial<TileflowBaseColors> & LegacyTileflowColorAliases & TileflowAdvancedColorConfig;
+type TileflowColors = {
+    [K in keyof TileflowBaseColors]: string;
+} & {
+    canvas: string;
+    greenspace: string;
+    nature: string;
+};
+type TileflowFontWeight = 'regular' | 'medium' | 'semibold' | 'bold';
+declare const tileflowHostedNotoSansWeights: readonly ["regular", "bold"];
+type TileflowHostedNotoSansWeight = (typeof tileflowHostedNotoSansWeights)[number];
+type TileflowTypographyStyle = {
+    font?: string;
+    fontFamily?: string;
+    weight?: TileflowFontWeight;
+};
+type TileflowTypographyDomain = 'places' | 'roads' | 'water' | 'poi';
+type TileflowTypography = TileflowTypographyStyle & {
+    places?: TileflowTypographyStyle;
+    roads?: TileflowTypographyStyle;
+    water?: TileflowTypographyStyle;
+    poi?: TileflowTypographyStyle;
+};
+type ResolvedTileflowTypography = Required<TileflowTypographyStyle> & {
+    places: Required<TileflowTypographyStyle>;
+    roads: Required<TileflowTypographyStyle>;
+    water: Required<TileflowTypographyStyle>;
+    poi: Required<TileflowTypographyStyle>;
+};
+type TileflowFonts = {
+    body?: string;
+    labels?: string;
+};
+type TileflowThemeConfig = {
+    colors?: TileflowColorConfig;
+    extends?: string;
+    fonts?: TileflowFonts;
+    layers?: Record<string, TileflowStyleLayerOverride>;
+    mode?: TileflowThemeMode;
+    modules?: TileflowThemeModulesConfig;
+    typography?: TileflowTypography;
+};
+type TileflowSourceLayers = {
+    landcover?: string;
+    landuse?: string;
+    park?: string;
+    water?: string;
+    waterName?: string;
+    waterway?: string;
+    road?: string;
+    roadName?: string;
+    building?: string;
+    boundary?: string;
+    place?: string;
+    poi?: string;
+};
+type TileflowTiles = {
+    sourceId?: string;
+    tileset?: string;
+    url?: string;
+    attribution?: string;
+    sourceLayers?: TileflowSourceLayers;
+    version?: string;
+};
+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;
+    version?: string;
+};
+type TileflowBasemapConfig = TileflowOsmBasemapConfig;
+type TileflowOsmBasemapOptions = Omit<TileflowOsmBasemapConfig, 'type'>;
+type TileflowRoadDetail = 'none' | 'highways' | 'major' | 'streets' | 'all';
+type TileflowRoadClass = 'motorway' | 'trunk' | 'primary' | 'secondary' | 'tertiary' | 'minor' | 'service' | 'track' | 'path';
+type TileflowRoadHierarchy = 'subtle' | 'clear' | 'strong';
+type TileflowRoadWeight = 'thin' | 'regular' | 'bold';
+type TileflowRoadOutline = 'none' | 'subtle' | 'strong';
+type TileflowRoadExtras = {
+    ferry?: boolean;
+    paths?: boolean;
+    rail?: boolean;
+};
+type TileflowRoadsModuleConfig = {
+    type: 'roads';
+    detail?: TileflowRoadDetail;
+    extras?: TileflowRoadExtras;
+    hierarchy?: TileflowRoadHierarchy;
+    oneWayMarkers?: boolean;
+    outline?: TileflowRoadOutline;
+    weight?: TileflowRoadWeight;
+    widthScale?: Partial<Record<TileflowRoadClass, number>>;
+};
+type TileflowRoadsModuleOptions = Omit<TileflowRoadsModuleConfig, 'type'>;
+type TileflowLabelsModuleConfig = {
+    type: 'labels';
+    language?: TileflowLabelLanguage;
+    places?: TileflowLabelDetail;
+    roadClasses?: readonly TileflowRoadClass[];
+    roads?: TileflowRoadLabelDetail;
+    water?: TileflowLabelDetail;
+};
+type TileflowLabelsModuleOptions = Omit<TileflowLabelsModuleConfig, 'type'>;
+type TileflowPoiModuleConfig = {
+    type: 'poi';
+    categories?: readonly TileflowPoiCategory[];
+    classMapping?: TileflowPoiClassMapping;
+    color?: TileflowPoiColorMode;
+    density?: TileflowPoiDensity;
+    icons?: TileflowPoiIcons;
+    labels?: TileflowPoiLabels;
+    minZoom?: number;
+    placement?: {
+        coupleIconAndLabel?: boolean;
+        iconPadding?: number;
+        textPadding?: number;
+    };
+    preset?: TileflowPoi;
+};
+type TileflowPoiModuleOptions = Omit<TileflowPoiModuleConfig, 'type'>;
+type TileflowIconSetConfig = {
+    extends?: string;
+    mapping?: Record<string, string>;
+    source?: string;
+    sprite?: string;
+};
+type TileflowIconSet = string | TileflowIconSetConfig;
+type TileflowProjectIconSets = Record<string, TileflowIconSet>;
+type MapLibreSprite = string | Array<{
+    id: string;
+    url: string;
+}>;
+type TileflowStyleLayerOverride = Record<string, unknown> & {
+    before?: string;
+    filter?: unknown;
+    layout?: Record<string, unknown>;
+    maxzoom?: number;
+    metadata?: Record<string, unknown>;
+    minzoom?: number;
+    paint?: Record<string, unknown>;
+    source?: string;
+    'source-layer'?: string;
+    type?: string;
+};
+type TileflowStyleOverrideModuleConfig = {
+    type: 'styleOverride';
+    layers?: Record<string, TileflowStyleLayerOverride>;
+    removeLayers?: string[];
+};
+type TileflowStyleOverrideOptions = Omit<TileflowStyleOverrideModuleConfig, 'type'>;
+type TileflowModuleConfig = TileflowLabelsModuleConfig | TileflowPoiModuleConfig | TileflowRoadsModuleConfig | TileflowStyleOverrideModuleConfig;
+type TileflowConfig = {
+    basemap?: TileflowBasemapConfig;
+    name?: string;
+    tileset?: string;
+    theme?: TileflowTheme | string | TileflowThemeConfig;
+    modules?: readonly TileflowModuleConfig[];
+    layers?: Record<string, TileflowStyleLayerOverride>;
+    colors?: TileflowColorConfig;
+    typography?: TileflowTypography;
+    density?: TileflowDensity;
+    roads?: TileflowRoads;
+    labels?: TileflowLabels;
+    poi?: TileflowPoi;
+    buildings?: TileflowBuildings;
+    buildingStyle?: TileflowBuildingStyleConfig;
+    terrain?: TileflowTerrain;
+    renderer?: TileflowRenderer;
+    glyphs?: string;
+    icons?: TileflowIconSet;
+    sprite?: string;
+    tiles?: TileflowTiles;
+    view?: TileflowViewConfig;
+    /**
+     * 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.
+     */
+    allowedOrigins?: string[];
+};
+type TileflowMapConfig = TileflowConfig;
+type TileflowTilesetConfig = {
+    id?: string;
+    name?: string;
+    attribution?: string;
+    sourceLayers?: TileflowSourceLayers;
+    version?: string;
+};
+type TileflowProjectThemes = Record<TileflowThemeName, TileflowThemeConfig>;
+type TileflowProjectConfig = {
+    icons?: TileflowProjectIconSets;
+    scenes?: Record<string, TileflowCaptureScene>;
+    themes?: TileflowProjectThemes;
+    tilesets?: Record<string, TileflowTilesetConfig>;
+    maps: Record<string, TileflowMapConfig>;
+};
+type TileflowStyleOptions = {
+    iconSets?: TileflowProjectIconSets;
+    themes?: TileflowProjectThemes;
+    tileBaseUrl?: string;
+    tileset?: string;
+};
+type TileflowManifest = {
+    version: 1;
+    tileBaseUrl: string;
+    styles: Record<string, string>;
+    maps: Record<string, string>;
+};
+type MapLibreStyle = {
+    version: 8;
+    name: string;
+    glyphs?: string;
+    sprite?: MapLibreSprite;
+    sources: Record<string, Record<string, unknown>>;
+    layers: Array<Record<string, unknown>>;
+    terrain?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+type ValidationMessage = {
+    level: 'error' | 'warning';
+    path: string;
+    message: string;
+};
+type ValidationResult = {
+    valid: boolean;
+    messages: ValidationMessage[];
+};
+declare function createStyle(input?: TileflowConfig, options?: TileflowStyleOptions): MapLibreStyle;
+declare function createStyleFromProject<const TProject extends TileflowProjectConfig, const TMapName extends keyof TProject['maps'] & string>(projectConfig: TProject, mapName: TMapName, options?: TileflowStyleOptions): MapLibreStyle;
+declare function createManifest(projectConfig: TileflowProjectConfig, options?: {
+    styleBaseUrl?: string;
+    tileBaseUrl?: string;
+}): TileflowManifest;
+declare function getDefaultColors(): TileflowColors;
+
+declare const defaultTileflowManifestUrl = "/tileflow/manifest.json";
+declare const defaultTileflowStyleBaseUrl = "http://localhost:3333";
+type TileflowAnalytics = {
+    apiUrl?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    mapId?: string;
+    metadata?: Record<string, unknown>;
+    projectId?: string;
+    sdkVersion?: string;
+    source?: string;
+    styleId?: string;
+};
+type TileflowMapMarker = {
+    id: string;
+    coordinates: [number, number];
+    color?: string;
+    label?: string;
+};
+type TileflowMapMode = 'interactive' | 'image';
+type TileflowMapModeOptions = {
+    imageUrl?: string;
+    mode?: TileflowMapMode;
+    preferLocalDev?: boolean;
+};
+type TileflowRuntimeManifestMapEntry = string | {
+    apiUrl?: string;
+    environment?: string;
+    mapId?: string;
+    styleId?: string;
+    styleUrl?: string;
+    tilesetId?: string;
+    url?: string;
+};
+type TileflowRuntimeManifest = {
+    apiUrl?: string;
+    maps?: Record<string, TileflowRuntimeManifestMapEntry>;
+    styles?: Record<string, string>;
+    tileBaseUrl?: string;
+    version?: number;
+};
+type TileflowRuntimeManifestMap = {
+    apiUrl?: string;
+    mapId?: string;
+    styleId?: string;
+    styleUrl?: string;
+};
+type TileflowRuntimeStyle = {
+    analytics?: TileflowAnalytics;
+    style: MapLibreStyle | string;
+};
+type TileflowRuntimeStyleOptions = {
+    config?: TileflowConfig;
+    manifestMap?: TileflowRuntimeManifestMap | null;
+    map?: string;
+    preferLocalDev?: boolean;
+    style?: MapLibreStyle;
+    styleBaseUrl?: string;
+    styleUrl?: string;
+    themes?: TileflowProjectThemes;
+    tileBaseUrl?: string;
+};
+type TileflowManifestLoadOptions = {
+    config?: unknown;
+    imageMode?: boolean;
+    imageUrl?: string;
+    map?: string;
+    style?: unknown;
+    styleBaseUrl?: string;
+    styleUrl?: string;
+};
+declare function shouldLoadTileflowManifest(options: TileflowManifestLoadOptions): boolean;
+declare function resolveTileflowRuntimeStyle(options: TileflowRuntimeStyleOptions): TileflowRuntimeStyle | null;
+declare function resolveTileflowStyleUrl(mapName: string, styleBaseUrl?: string): string;
+declare function getDefaultTileflowStyleBaseUrl(): string;
+declare function normalizeTileflowUrl(value: string): string;
+declare function createTileflowSessionId(): string;
+declare function resolveTileflowAnalyticsRequestUrl(url: string, analytics: TileflowAnalytics | undefined, sessionId: string): string | undefined;
+declare function startTileflowSession(analytics: TileflowAnalytics | undefined, input: {
+    mapId?: string;
+    sessionId: string;
+    source: string;
+    styleId?: string;
+}): void;
+declare function getTileflowAnalyticsApiUrl(analytics: TileflowAnalytics): string;
+declare function mergeTileflowAnalytics(userAnalytics: TileflowAnalytics | undefined, runtimeAnalytics: TileflowAnalytics | undefined): TileflowAnalytics | undefined;
+declare function isTileflowLocalDevHost(): boolean;
+declare function resolveTileflowMapMode(options: TileflowMapModeOptions): TileflowMapMode;
+declare function loadTileflowManifest(url: string): Promise<TileflowRuntimeManifest | null>;
+declare function resolveTileflowManifestMap(manifest: TileflowRuntimeManifest, mapName: string): TileflowRuntimeManifestMap | null;
+declare function resolveTileflowStaticImageUrl(input: {
+    center: [number, number];
+    imageSize: {
+        height: number;
+        width: number;
+    } | null;
+    manifestMap: TileflowRuntimeManifestMap | null;
+    zoom: number;
+}): string | undefined;
+declare function normalizeTileflowStaticImageSize(input: {
+    height: number;
+    width: number;
+}): {
+    height: number;
+    width: number;
+};
+declare function inferTileflowAnalyticsFromStyleUrl(styleUrl: string): TileflowAnalytics | undefined;
+
+export { type TileflowMapMode as $, type TileflowCaptureTarget as A, type TileflowCaptureViewport as B, type TileflowColor as C, type TileflowColorConfig as D, type TileflowColors as E, type TileflowDensity as F, type TileflowFontWeight as G, type TileflowFonts as H, type TileflowHostedNotoSansWeight as I, type TileflowHydroColorConfig as J, type TileflowIconSet as K, type TileflowIconSetConfig as L, type MapLibreSprite as M, type NormalizedTileflowCaptureScene as N, type TileflowLabelColorConfig as O, type TileflowLabelDetail as P, type TileflowLabelLanguage as Q, type ResolvedTileflowTypography as R, type TileflowLabels as S, type TileflowAnalytics as T, type TileflowLandcoverColorConfig as U, type ValidationResult as V, type TileflowLanduseColorConfig as W, type TileflowManifest as X, type TileflowManifestLoadOptions as Y, type TileflowMapConfig as Z, type TileflowMapMarker as _, type TileflowConfig as a, resolveTileflowAnalyticsRequestUrl as a$, type TileflowMapModeOptions as a0, type TileflowModuleConfig as a1, type TileflowPoi as a2, type TileflowPoiCategory as a3, type TileflowPoiClassMapping as a4, type TileflowPoiColorConfig as a5, type TileflowPoiColorMode as a6, type TileflowPoiDensity as a7, type TileflowPoiIcons as a8, type TileflowPoiLabels as a9, type TileflowThemeMode as aA, type TileflowThemeModulesConfig as aB, type TileflowThemeName as aC, type TileflowTiles as aD, type TileflowTilesetConfig as aE, type TileflowTypography as aF, type TileflowTypographyDomain as aG, type TileflowTypographyStyle as aH, type TileflowViewConfig as aI, type ValidationMessage as aJ, createManifest as aK, createStyle as aL, createStyleFromProject as aM, createTileflowSessionId as aN, defaultTileflowManifestUrl as aO, defaultTileflowStyleBaseUrl as aP, getDefaultColors as aQ, getDefaultTileflowStyleBaseUrl as aR, getTileflowAnalyticsApiUrl as aS, inferTileflowAnalyticsFromStyleUrl as aT, isTileflowLocalDevHost as aU, loadTileflowManifest as aV, mergeTileflowAnalytics as aW, normalizeTileflowCaptureId as aX, normalizeTileflowCaptureScene as aY, normalizeTileflowStaticImageSize as aZ, normalizeTileflowUrl as a_, type TileflowProjectIconSets as aa, type TileflowProjectThemes as ab, type TileflowRenderer as ac, type TileflowRoadClass as ad, type TileflowRoadColorConfig as ae, type TileflowRoadDetail as af, type TileflowRoadExtras as ag, type TileflowRoadHierarchy as ah, type TileflowRoadLabelDetail as ai, type TileflowRoadOutline as aj, type TileflowRoadWeight as ak, type TileflowRoads as al, type TileflowRuntimeManifest as am, type TileflowRuntimeManifestMap as an, type TileflowRuntimeManifestMapEntry as ao, type TileflowRuntimeStyle as ap, type TileflowRuntimeStyleOptions as aq, type TileflowSourceLayers as ar, type TileflowStyleLayerOverride as as, type TileflowStyleOptions as at, type TileflowTerrain as au, type TileflowTerrainConfig as av, type TileflowTerrainEncoding as aw, type TileflowTerrainMode as ax, type TileflowTheme as ay, type TileflowThemeConfig as az, type TileflowProjectConfig as b, resolveTileflowManifestMap as b0, resolveTileflowMapMode as b1, resolveTileflowRuntimeStyle as b2, resolveTileflowStaticImageUrl as b3, resolveTileflowStyleUrl as b4, shouldLoadTileflowManifest as b5, startTileflowSession as b6, tileflowCaptureApplicationTargetSchema as b7, tileflowCaptureBoundsCameraSchema as b8, tileflowCaptureCameraSchema as b9, tileflowCaptureCenterCameraSchema as ba, tileflowCaptureIdSchema as bb, tileflowCaptureMapTargetSchema as bc, tileflowCaptureSceneLimits as bd, tileflowCaptureSceneNameSchema as be, tileflowCaptureSceneSchema as bf, tileflowCaptureSceneSchemaVersion as bg, tileflowCaptureTargetSchema as bh, tileflowCaptureViewportSchema as bi, tileflowHostedNotoSansWeights as bj, type TileflowOsmBasemapOptions as c, type TileflowOsmBasemapConfig as d, type TileflowRoadsModuleOptions as e, type TileflowRoadsModuleConfig as f, type TileflowLabelsModuleOptions as g, type TileflowLabelsModuleConfig as h, type TileflowPoiModuleOptions as i, type TileflowPoiModuleConfig as j, type TileflowStyleOverrideOptions as k, type TileflowStyleOverrideModuleConfig as l, type MapLibreStyle as m, type TileflowAdvancedColorConfig as n, type TileflowBaseColors as o, type TileflowBasemapConfig as p, type TileflowBoundaryColorConfig as q, type TileflowBuildingColorConfig as r, type TileflowBuildingStyleConfig as s, type TileflowBuildings as t, type TileflowCaptureApplicationTarget as u, type TileflowCaptureBoundsCamera as v, type TileflowCaptureCamera as w, type TileflowCaptureCenterCamera as x, type TileflowCaptureMapTarget as y, type TileflowCaptureScene as z };