@tileflow/core 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/runtime-Bg--GMWM.d.ts

@@ -0,0 +1,680 @@
+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 TileflowSessionGrantResponse = {
+    billingEnabled?: false;
+    disposition?: 'ordinary' | 'unbilled_fail_open';
+    expiresAt?: string;
+    grant?: string;
+    meterMode?: 'disabled' | 'shadow' | 'enforced';
+    ok: boolean;
+    resourceOrigins?: string[];
+    sessionId: string;
+    usageMode?: 'session';
+    code?: string;
+    retryWithNewSession?: boolean;
+};
+type TileflowSessionController = {
+    readonly sessionId: string;
+    resolveRequestUrl(url: string, analytics: TileflowAnalytics | undefined): Promise<string | undefined>;
+};
+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 createTileflowSessionController(input: {
+    fetch?: typeof fetch;
+    grantTimeoutMs?: number;
+    now?: () => Date;
+    sessionIdFactory?: () => string;
+    source: string;
+}): TileflowSessionController;
+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 TileflowMapMarker as $, type TileflowCaptureScene as A, type TileflowCaptureTarget as B, type TileflowCaptureViewport as C, type TileflowColor as D, type TileflowColorConfig as E, type TileflowColors as F, type TileflowDensity as G, type TileflowFontWeight as H, type TileflowFonts as I, type TileflowHostedNotoSansWeight as J, type TileflowHydroColorConfig as K, type TileflowIconSet as L, type MapLibreSprite as M, type NormalizedTileflowCaptureScene as N, type TileflowIconSetConfig as O, type TileflowLabelColorConfig as P, type TileflowLabelDetail as Q, type ResolvedTileflowTypography as R, type TileflowLabelLanguage as S, type TileflowAnalytics as T, type TileflowLabels as U, type ValidationResult as V, type TileflowLandcoverColorConfig as W, type TileflowLanduseColorConfig as X, type TileflowManifest as Y, type TileflowManifestLoadOptions as Z, type TileflowMapConfig as _, type TileflowSessionController as a, normalizeTileflowCaptureScene as a$, type TileflowMapMode as a0, type TileflowMapModeOptions as a1, type TileflowModuleConfig as a2, type TileflowPoi as a3, type TileflowPoiCategory as a4, type TileflowPoiClassMapping as a5, type TileflowPoiColorConfig as a6, type TileflowPoiColorMode as a7, type TileflowPoiDensity as a8, type TileflowPoiIcons as a9, type TileflowTheme as aA, type TileflowThemeConfig as aB, type TileflowThemeMode as aC, type TileflowThemeModulesConfig as aD, type TileflowThemeName as aE, type TileflowTiles as aF, type TileflowTilesetConfig as aG, type TileflowTypography as aH, type TileflowTypographyDomain as aI, type TileflowTypographyStyle as aJ, type TileflowViewConfig as aK, type ValidationMessage as aL, createManifest as aM, createStyle as aN, createStyleFromProject as aO, createTileflowSessionController as aP, createTileflowSessionId as aQ, defaultTileflowManifestUrl as aR, defaultTileflowStyleBaseUrl as aS, getDefaultColors as aT, getDefaultTileflowStyleBaseUrl as aU, getTileflowAnalyticsApiUrl as aV, inferTileflowAnalyticsFromStyleUrl as aW, isTileflowLocalDevHost as aX, loadTileflowManifest as aY, mergeTileflowAnalytics as aZ, normalizeTileflowCaptureId as a_, type TileflowPoiLabels as aa, type TileflowProjectIconSets as ab, type TileflowProjectThemes as ac, type TileflowRenderer as ad, type TileflowRoadClass as ae, type TileflowRoadColorConfig as af, type TileflowRoadDetail as ag, type TileflowRoadExtras as ah, type TileflowRoadHierarchy as ai, type TileflowRoadLabelDetail as aj, type TileflowRoadOutline as ak, type TileflowRoadWeight as al, type TileflowRoads as am, type TileflowRuntimeManifest as an, type TileflowRuntimeManifestMap as ao, type TileflowRuntimeManifestMapEntry as ap, type TileflowRuntimeStyle as aq, type TileflowRuntimeStyleOptions as ar, type TileflowSessionGrantResponse as as, type TileflowSourceLayers as at, type TileflowStyleLayerOverride as au, type TileflowStyleOptions as av, type TileflowTerrain as aw, type TileflowTerrainConfig as ax, type TileflowTerrainEncoding as ay, type TileflowTerrainMode as az, type TileflowConfig as b, normalizeTileflowStaticImageSize as b0, normalizeTileflowUrl as b1, resolveTileflowAnalyticsRequestUrl as b2, resolveTileflowManifestMap as b3, resolveTileflowMapMode as b4, resolveTileflowRuntimeStyle as b5, resolveTileflowStaticImageUrl as b6, resolveTileflowStyleUrl as b7, shouldLoadTileflowManifest as b8, startTileflowSession as b9, tileflowCaptureApplicationTargetSchema as ba, tileflowCaptureBoundsCameraSchema as bb, tileflowCaptureCameraSchema as bc, tileflowCaptureCenterCameraSchema as bd, tileflowCaptureIdSchema as be, tileflowCaptureMapTargetSchema as bf, tileflowCaptureSceneLimits as bg, tileflowCaptureSceneNameSchema as bh, tileflowCaptureSceneSchema as bi, tileflowCaptureSceneSchemaVersion as bj, tileflowCaptureTargetSchema as bk, tileflowCaptureViewportSchema as bl, tileflowHostedNotoSansWeights as bm, type TileflowProjectConfig as c, type TileflowOsmBasemapOptions as d, type TileflowOsmBasemapConfig as e, type TileflowRoadsModuleOptions as f, type TileflowRoadsModuleConfig as g, type TileflowLabelsModuleOptions as h, type TileflowLabelsModuleConfig as i, type TileflowPoiModuleOptions as j, type TileflowPoiModuleConfig as k, type TileflowStyleOverrideOptions as l, type TileflowStyleOverrideModuleConfig as m, type MapLibreStyle as n, type TileflowAdvancedColorConfig as o, type TileflowBaseColors as p, type TileflowBasemapConfig as q, type TileflowBoundaryColorConfig as r, type TileflowBuildingColorConfig as s, type TileflowBuildingStyleConfig as t, type TileflowBuildings as u, type TileflowCaptureApplicationTarget as v, type TileflowCaptureBoundsCamera as w, type TileflowCaptureCamera as x, type TileflowCaptureCenterCamera as y, type TileflowCaptureMapTarget as z };