@yarrow-uz/yarrow-map-web-sdk 1.0.46 → 1.0.47

package/dist/maps/cache.d.ts

@@ -0,0 +1,17 @@
+import { type RequestParameters, ResourceType } from 'maplibre-gl';
+import { TILE_CACHE_NAME, ICON_CACHE_NAME, CACHE_PROTOCOL, type NormalizedCacheConfig, type CachedArrayBufferResponse } from './types';
+export declare const hasCacheStorage: () => boolean;
+export declare const normalizeCacheConfig: (cache?: {
+    enabled?: boolean;
+    lifespanDays?: number;
+}) => NormalizedCacheConfig;
+export declare const resolveRequestUrl: (url: string, baseUrl?: string) => string;
+export declare const buildProtocolUrl: (url: string, lifespanMs: number) => string;
+export declare const extractCachedAt: (response: Response) => number | null;
+export declare const toCachedArrayBufferResponse: (response: Response) => Promise<CachedArrayBufferResponse>;
+export declare const fetchFromNetwork: (url: string, abortController: AbortController, requestParameters?: RequestParameters) => Promise<CachedArrayBufferResponse>;
+export declare const fetchArrayBufferWithCache: (url: string, cacheName: string, lifespanMs: number, abortController: AbortController, requestParameters?: RequestParameters) => Promise<CachedArrayBufferResponse>;
+export declare const getDefaultLifespanMs: () => number;
+export declare const isCacheableResourceType: (resourceType?: ResourceType) => boolean;
+export { TILE_CACHE_NAME, ICON_CACHE_NAME, CACHE_PROTOCOL };
+//# sourceMappingURL=cache.d.ts.map

package/dist/maps/config.d.ts

@@ -0,0 +1,18 @@
+import type { BrandBadgePosition } from './brandBadge';
+import { normalizeYarrowControlsConfig } from './yarrowControls';
+import type { YarrowMapConfigOptions, NormalizedCacheConfig } from './types';
+export declare class YarrowMapConfig {
+    readonly container: HTMLElement | string;
+    readonly center: [number, number];
+    readonly zoom: number;
+    readonly minZoom: number;
+    readonly maxZoom: number;
+    theme: 'light' | 'dark';
+    cache: NormalizedCacheConfig;
+    brandBadgePosition: BrandBadgePosition;
+    controls: ReturnType<typeof normalizeYarrowControlsConfig>;
+    excludePoiLayer: boolean;
+    apiKey: string;
+    constructor(config: YarrowMapConfigOptions);
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/maps/events.d.ts

@@ -0,0 +1,13 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { LayerDescriptor } from './types';
+export declare class YarrowEventManager {
+    private getMap;
+    private getLayers;
+    constructor(getMap: () => MaplibreMap | undefined, getLayers: () => LayerDescriptor[]);
+    onMoveEnd(callback: (lat: number, lng: number, zoom: number) => void): void;
+    onMapClick(callback: (lat: number, lng: number) => void): void;
+    onIconClick(layerGroup: 'pois' | 'buildings', callback: (lat: number, lng: number, properties: Record<string, unknown>) => void): void;
+    onLayerClick(layerName: 'buildings' | 'pois', callback: (lat: number, lng: number, properties: Record<string, unknown>) => void): void;
+    changeBackgroundColor(color: string): void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/maps/layers.d.ts

@@ -0,0 +1,21 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { GeoJSONSourceSpecification, LayerSpecification, FeatureIdentifier, MapGeoJSONFeature, QueryRenderedFeaturesOptions, PointLike } from 'maplibre-gl';
+import type { LayerDescriptor, AddLayerOptions } from './types';
+export declare class YarrowLayerManager {
+    private getMap;
+    private setLayers?;
+    private layers;
+    constructor(getMap: () => MaplibreMap | undefined, setLayers?: ((layers: LayerDescriptor[]) => void) | undefined);
+    getLayers(): LayerDescriptor[];
+    setLayersArray(layers: LayerDescriptor[]): void;
+    addSource(sourceId: string, data: GeoJSONSourceSpecification['data']): void;
+    updateSourceData(sourceId: string, data: GeoJSONSourceSpecification['data']): void;
+    addLayer(layerName: string, layerType: LayerSpecification['type'], featureCollection: GeoJSONSourceSpecification['data'], paint?: LayerSpecification['paint'], layout?: LayerSpecification['layout'], iconSettings?: {
+        width?: number;
+        height?: number;
+    }, options?: AddLayerOptions): void;
+    removeLayer(layerName: string): void;
+    setFeatureState(feature: FeatureIdentifier, state: Record<string, unknown>): void;
+    queryRenderedFeatures(geometryOrOptions?: PointLike | [PointLike, PointLike] | QueryRenderedFeaturesOptions, options?: QueryRenderedFeaturesOptions): MapGeoJSONFeature[];
+}
+//# sourceMappingURL=layers.d.ts.map

package/dist/maps/markers.d.ts

@@ -0,0 +1,12 @@
+import { Marker, type Map as MaplibreMap, type MarkerOptions } from 'maplibre-gl';
+interface YarrowMarkerOptions extends MarkerOptions {
+    onClick?: () => void;
+}
+export declare class YarrowMarkerManager {
+    private getMap;
+    constructor(getMap: () => MaplibreMap | undefined);
+    addMarker(coordinates: [number, number], options?: YarrowMarkerOptions): Marker | null;
+    removeMarker(marker: Marker | null): void;
+}
+export {};
+//# sourceMappingURL=markers.d.ts.map

package/dist/maps/navigation.d.ts

@@ -0,0 +1,15 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { BoundsInput } from './types';
+export declare class YarrowNavigationManager {
+    private getMap;
+    constructor(getMap: () => MaplibreMap | undefined);
+    zoomTo(lat: number, lng: number, zoom: number): void;
+    fitBounds(data: BoundsInput): void;
+    getBoundingBox(data: BoundsInput): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+//# sourceMappingURL=navigation.d.ts.map

package/dist/maps/routing/builder.d.ts

@@ -0,0 +1,34 @@
+import type { RouteFeature } from '../types';
+import type { YarrowLayerManager } from '../layers';
+import type { BuildRouteOptions, BuildRouteResult } from './types';
+export declare class YarrowRoutingRenderer {
+    private addLayer;
+    constructor(addLayer: YarrowLayerManager['addLayer']);
+    renderRoutes(routes: RouteFeature[], baseLayerName?: string): void;
+}
+export declare class YarrowRoutingBuilder {
+    private getMap;
+    private addLayer;
+    private removeLayer;
+    private fitBounds;
+    constructor(getMap: () => maplibregl.Map | undefined, addLayer: YarrowLayerManager['addLayer'], removeLayer: YarrowLayerManager['removeLayer'], fitBounds: (data: {
+        type?: string;
+        features: Array<{
+            geometry?: {
+                type?: string;
+                coordinates?: unknown;
+            };
+        }>;
+    }) => void);
+    buildRoute(options: BuildRouteOptions): Promise<BuildRouteResult>;
+    buildRouteWithLabels(startCoordinates: [number, number], endCoordinates: [number, number], profile: string): Promise<{
+        features: RouteFeature[];
+        directions: unknown[];
+    }>;
+    buildMultiSegmentRouteWithLabels(coordinates: [number, number][], profile: string, language?: string): Promise<{
+        features: RouteFeature[];
+        directions: unknown[][];
+    }>;
+    clearAllRoutes(): void;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/maps/routing/helpers.d.ts

@@ -0,0 +1,15 @@
+import type { RouteFeature } from '../types';
+export declare const POPUP_CSS = "position: absolute; padding: 6px 12px; background: #fff; border: 1px solid #ccc; border-radius: 6px; font-size: 13px; font-weight: 500; box-shadow: 0 2px 6px rgba(0,0,0,0.15); pointer-events: none; z-index: 9999;";
+export declare const createPopupElement: (labelText: string, x: number, y: number) => HTMLDivElement;
+export declare const removeAllRoutePopups: () => void;
+export declare const formatDuration: (minutes: number) => string;
+export declare const formatDistance: (meters: number) => string;
+export declare const formatRouteLabel: (duration: number, distance: number, isBest: boolean, bestDuration?: number) => string;
+export declare const getMidpointCoordinates: (coordinates: [number, number][]) => [number, number];
+export declare const createRouteLabelFeature: (coordinates: [number, number], labelText: string) => GeoJSON.Feature;
+export declare const createHoverPopup: (map: maplibregl.Map, e: maplibregl.MapMouseEvent, labelText: string) => HTMLDivElement | null;
+export declare const createClickPopup: (map: maplibregl.Map, coordinates: [number, number], labelText: string) => HTMLDivElement | null;
+export declare const setupMoveListenerForPopup: (map: maplibregl.Map, coordinates: [number, number]) => void;
+export declare const clearOldRouteLayers: (removeLayer: (layerId: string) => void) => void;
+export declare const transformRouteCoordinates: (features: RouteFeature[]) => RouteFeature[];
+//# sourceMappingURL=helpers.d.ts.map

package/dist/maps/routing/renderer.d.ts

@@ -0,0 +1,8 @@
+import type { YarrowLayerManager } from '../layers';
+import type { RouteFeature } from '../types';
+export declare class YarrowRoutingRenderer {
+    private addLayer;
+    constructor(addLayer: YarrowLayerManager['addLayer']);
+    renderRoutes(routes: RouteFeature[], baseLayerName?: string): void;
+}
+//# sourceMappingURL=renderer.d.ts.map

package/dist/maps/routing/types.d.ts

@@ -0,0 +1,41 @@
+import type { RouteFeature } from '../types';
+export declare const ROUTE_LAYER_COLORS: string[];
+export declare const MAX_ROUTE_INDEX = 5;
+export declare const ROUTE_API_URL = "https://api.yarrow.uz/api/routing/route";
+export interface BuildRouteOptions {
+    profile: string;
+    coordinates: [number, number][];
+    routeColor?: string;
+    routeWidth?: number;
+    routeOpacity?: number;
+    alternativeColor?: string;
+    alternativeWidth?: number;
+    alternativeOpacity?: number;
+    showLabels?: boolean;
+    labelFont?: string[];
+    labelSize?: number;
+    labelOffset?: [number, number];
+    labelAnchor?: 'top' | 'bottom' | 'left' | 'right' | 'center';
+    fitBounds?: boolean;
+    clearOldRoutes?: boolean;
+    language?: string;
+    layerPrefix?: string;
+}
+export interface BuildRouteResult {
+    features: RouteFeature[];
+    directions: RouteDirection[][];
+    meta: {
+        profile: string;
+        totalRoutes: number;
+        bestRouteIndex: number;
+        duration: number;
+        distance: number;
+    };
+}
+export type RouteDirection = {
+    distance: number;
+    duration: number;
+    instruction: string;
+    [key: string]: unknown;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/maps/search.d.ts

@@ -0,0 +1,23 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { SearchResult, BoundsInput } from './types';
+import type { YarrowLayerManager } from './layers';
+type SearchOptions = {
+    layerName?: string;
+    iconImage?: string;
+    highlightColor?: string;
+    pulseAnimation?: boolean;
+    zoomToResults?: boolean;
+    onIconClick?: (lat: number, lng: number, properties: Record<string, unknown>) => void;
+    onResultsUpdate?: (results: SearchResult[]) => void;
+    onLoadingStateChange?: (state: 'firstRender' | 'rerender' | false) => void;
+};
+export declare class YarrowSearchManager {
+    private getMap;
+    private fitBounds;
+    private addLayer;
+    private removeLayer;
+    constructor(getMap: () => MaplibreMap | undefined, fitBounds: (data: BoundsInput) => void, addLayer: YarrowLayerManager['addLayer'], removeLayer: YarrowLayerManager['removeLayer']);
+    highlightSearchResults(query: string, highlightOptions?: SearchOptions): () => void;
+}
+export {};
+//# sourceMappingURL=search.d.ts.map

package/dist/maps/styles.d.ts

@@ -0,0 +1,29 @@
+import type { StyleSpecification } from 'maplibre-gl';
+import { type BrandBadgeController } from './brandBadge';
+import type { YarrowMapConfig } from './config';
+import type { BrandBadgePosition, LayerDescriptor } from './types';
+import type { YarrowControlsController } from './yarrowControls';
+export declare class YarrowStylesManager {
+    private getMap;
+    private config;
+    private fetchJson;
+    private fixStyle;
+    private getIconsMap;
+    private addIconsToMap;
+    private badgeController;
+    private controlsController;
+    private syncCollision;
+    private updateLayersArray;
+    private setLayers?;
+    private layers;
+    constructor(getMap: () => maplibregl.Map | undefined, config: YarrowMapConfig, fetchJson: <T>(url: string, cacheName: string) => Promise<T>, fixStyle: (style: StyleSpecification) => void, getIconsMap: () => Promise<Record<string, string>>, addIconsToMap: (icons: Record<string, string>) => Promise<void>, badgeController: BrandBadgeController, controlsController: YarrowControlsController, syncCollision: () => void, updateLayersArray: (style: StyleSpecification) => void, setLayers?: ((layers: LayerDescriptor[]) => void) | undefined);
+    setLayersArray(layers: LayerDescriptor[]): void;
+    changeStyles(styleType?: string): Promise<StyleSpecification>;
+    changeTheme(theme: 'light' | 'dark'): Promise<StyleSpecification>;
+    changeBrandBadgePosition(position: BrandBadgePosition): BrandBadgePosition;
+    getControlsInsetForCollision(controlsPosition: 'left-top' | 'left-bottom' | 'right-top' | 'right-bottom', badgePosition: BrandBadgePosition, badgeHeight: number): {
+        top?: number;
+        bottom?: number;
+    };
+}
+//# sourceMappingURL=styles.d.ts.map

package/dist/maps/types.d.ts

@@ -0,0 +1,111 @@
+import type { GeoJSONSourceSpecification, LayerSpecification, MapGeoJSONFeature, FeatureIdentifier, PointLike, QueryRenderedFeaturesOptions, RequestParameters, StyleSpecification } from 'maplibre-gl';
+import type { FilterSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { BrandBadgePosition } from './brandBadge';
+import type { YarrowControlsConfig, YarrowControlsPosition } from './yarrowControls';
+export type { BrandBadgePosition };
+export type { YarrowControlsConfig, YarrowControlsPosition };
+export type CacheConfig = {
+    enabled?: boolean;
+    lifespanDays?: number;
+};
+export type NormalizedCacheConfig = {
+    enabled: boolean;
+    lifespanDays: number;
+};
+export type CachedArrayBufferResponse = {
+    data: ArrayBuffer;
+    cacheControl: string | null;
+    expires: string | null;
+    contentType: string | null;
+};
+export type LayerDescriptor = {
+    type: string;
+    name: string;
+};
+export type AddLayerOptions = {
+    sourceId?: string;
+    filter?: FilterSpecification;
+};
+export type StyleLayerLike = {
+    id: string;
+    type?: string;
+    source?: string;
+    'source-layer'?: string;
+    layout?: Record<string, unknown>;
+};
+export type BoundsInput = {
+    type?: string;
+    features: Array<{
+        geometry?: {
+            type?: string;
+            coordinates?: unknown;
+        };
+    }>;
+};
+export type GeoJsonDataObject = Exclude<GeoJSONSourceSpecification['data'], string>;
+export type RouteFeature = {
+    type: 'Feature';
+    geometry: {
+        type: 'LineString';
+        coordinates: [number, number][];
+    };
+    properties: {
+        duration: number;
+        distance: number;
+        [key: string]: unknown;
+    };
+};
+export type RouteBuildResult = {
+    features: RouteFeature[];
+    directions: unknown[];
+};
+export type MultiRouteBuildResult = {
+    features: RouteFeature[];
+    directions: unknown[][];
+};
+export type IconListItem = {
+    icon_image_name: string;
+    icon_image_url: string;
+};
+export type SearchResult = {
+    id?: string | number;
+    latitude?: number;
+    longitude?: number;
+    icon_img?: string;
+    name?: string;
+    [key: string]: unknown;
+};
+export type YarrowMapConfigOptions = {
+    container: HTMLElement | string;
+    center: [number, number];
+    zoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    theme?: 'light' | 'dark';
+    cache?: CacheConfig;
+    brandBadgePosition?: BrandBadgePosition;
+    controls?: YarrowControlsConfig;
+    excludePoiLayer?: boolean;
+    apiKey: string;
+};
+export type SearchOptions = {
+    layerName?: string;
+    iconImage?: string;
+    highlightColor?: string;
+    pulseAnimation?: boolean;
+    zoomToResults?: boolean;
+    onIconClick?: (lat: number, lng: number, properties: Record<string, unknown>) => void;
+    onResultsUpdate?: (results: SearchResult[]) => void;
+    onLoadingStateChange?: (state: 'firstRender' | 'rerender' | false) => void;
+};
+export declare const OVERLAY_COLLISION_GAP_PX = 8;
+export declare const ROUTE_COLORS: string[];
+export declare const DEFAULT_CACHE_ENABLED = false;
+export declare const DEFAULT_CACHE_LIFESPAN_DAYS = 30;
+export declare const MILLISECONDS_PER_DAY: number;
+export declare const TILE_CACHE_NAME = "yarrow-cache-v1-tile";
+export declare const ICON_CACHE_NAME = "yarrow-cache-v1-icon";
+export declare const CACHE_PROTOCOL = "yarrowcache";
+export declare const CACHED_AT_HEADER = "x-yarrow-cached-at";
+export type { GeoJSONSourceSpecification, LayerSpecification, MapGeoJSONFeature, FeatureIdentifier, PointLike, QueryRenderedFeaturesOptions, RequestParameters, StyleSpecification, };
+//# sourceMappingURL=types.d.ts.map

package/dist/maps/yarrow.d.ts

@@ -1,99 +1,33 @@
-import { type GeoJSONSourceSpecification, type LayerSpecification, type MapGeoJSONFeature, Map as MaplibreMap, type FeatureIdentifier, type PointLike, type QueryRenderedFeaturesOptions, type StyleSpecification } from 'maplibre-gl';
-import type { FilterSpecification } from '@maplibre/maplibre-gl-style-spec';
-import { type BrandBadgePosition } from './brandBadge';
-import { type NormalizedYarrowControlsConfig, type YarrowControlsConfig, type YarrowControlsPosition } from './yarrowControls';
-type CacheConfig = {
-    enabled?: boolean;
-    lifespanDays?: number;
-};
-type YarrowMapConfigOptions = {
-    container: HTMLElement | string;
-    center: [number, number];
-    zoom?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    theme?: 'light' | 'dark';
-    cache?: CacheConfig;
-    brandBadgePosition?: BrandBadgePosition;
-    controls?: YarrowControlsConfig;
-    apiKey: string;
-};
-type NormalizedCacheConfig = {
-    enabled: boolean;
-    lifespanDays: number;
-};
-type LayerDescriptor = {
-    type: string;
-    name: string;
-};
-type AddLayerOptions = {
-    sourceId?: string;
-    filter?: FilterSpecification;
-};
-type BoundsInput = {
-    type?: string;
-    features: Array<{
-        geometry?: {
-            type?: string;
-            coordinates?: unknown;
-        };
-    }>;
-};
-type RouteFeature = {
-    type: 'Feature';
-    geometry: {
-        type: 'LineString';
-        coordinates: [number, number][];
-    };
-    properties: {
-        duration: number;
-        distance: number;
-        [key: string]: unknown;
-    };
-};
-type RouteBuildResult = {
-    features: RouteFeature[];
-    directions: unknown[];
-};
-type MultiRouteBuildResult = {
-    features: RouteFeature[];
-    directions: unknown[][];
-};
-type SearchResult = {
-    id?: string | number;
-    latitude?: number;
-    longitude?: number;
-    icon_img?: string;
-    name?: string;
-    [key: string]: unknown;
-};
-declare class YarrowMapConfig {
-    container: HTMLElement | string;
-    center: [number, number];
-    zoom: number;
-    minZoom: number;
-    maxZoom: number;
-    theme: 'light' | 'dark';
-    cache: NormalizedCacheConfig;
-    brandBadgePosition: BrandBadgePosition;
-    controls: NormalizedYarrowControlsConfig;
-    apiKey: string;
-    constructor(config: YarrowMapConfigOptions);
-}
-declare class YarrowMap {
+import { type FeatureIdentifier, type GeoJSONSourceSpecification, type LayerSpecification, Map as MaplibreMap, type Marker, type MarkerOptions, type PointLike, type QueryRenderedFeaturesOptions, type StyleSpecification } from 'maplibre-gl';
+import { YarrowMapConfig } from './config';
+import type { BuildRouteOptions, BuildRouteResult } from './routing/types';
+import type { BoundsInput, LayerDescriptor, RouteFeature, SearchOptions } from './types';
+import { type AddLayerOptions } from './types';
+export declare class YarrowMap {
     private static isCacheProtocolRegistered;
     config: YarrowMapConfig;
     map?: MaplibreMap;
     layers: LayerDescriptor[];
-    private brandBadgeController;
-    private yarrowControlsController;
+    private layerManager;
+    private markerManager;
+    private routingBuilder;
+    private routingRenderer;
+    private searchManager;
+    private stylesManager;
+    private navigationManager;
+    private eventManager;
+    private badgeController;
+    private controlsController;
     private badgeResizeObserver?;
+    private poiLayerConfig?;
+    private poiSourceConfig?;
     constructor(config: YarrowMapConfig);
     private ensureCacheProtocol;
     private get cacheLifespanMs();
     private isCacheEnabled;
     private transformRequestForCache;
     private fetchJson;
+    private addApiKeyToUrl;
     private loadImageFromSrc;
     private loadIconImage;
     private getIconsMap;
@@ -103,18 +37,23 @@ declare class YarrowMap {
     private syncOverlayCollisionInset;
     private stopBadgeCollisionObserver;
     private startBadgeCollisionObserver;
-    clearCache(): Promise<void>;
     fixStyle(style: StyleSpecification | null | undefined): void;
+    private updateLayersArray;
+    private storePoiLayerConfig;
+    private removePoiLayerFromStyle;
     init(): Promise<void>;
-    changeStyles(styleType: string | undefined): Promise<StyleSpecification>;
+    clearCache(): Promise<void>;
+    changeStyles(styleType?: string): Promise<StyleSpecification>;
     changeTheme(theme: 'light' | 'dark'): Promise<StyleSpecification>;
-    changeBrandBadgePosition(position: BrandBadgePosition): BrandBadgePosition;
+    changeBrandBadgePosition(position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'): import("./brandBadge").BrandBadgePosition;
+    enablePoiLayer(): void;
+    disablePoiLayer(): void;
     zoomTo(lat: number, lng: number, zoom: number): void;
     fitBounds(data: BoundsInput): void;
     getBoundingBox(data: BoundsInput): {
         xMin: number;
-        yMin: number;
         xMax: number;
+        yMin: number;
         yMax: number;
     };
     onMoveEnd(callback: (lat: number, lng: number, zoom: number) => void): void;
@@ -128,46 +67,26 @@ declare class YarrowMap {
         width?: number;
         height?: number;
     }, options?: AddLayerOptions): void;
-    setFeatureState(feature: FeatureIdentifier, state: Record<string, unknown>): void;
-    queryRenderedFeatures(geometryOrOptions?: PointLike | [PointLike, PointLike] | QueryRenderedFeaturesOptions, options?: QueryRenderedFeaturesOptions): MapGeoJSONFeature[];
-    addMarker(coordinates: [number, number], options?: {
-        element?: HTMLElement;
-        color?: string;
-        draggable?: boolean;
-        anchor?: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
-        onClick?: () => void;
-    }): maplibregl.Marker | null;
-    removeMarker(marker: maplibregl.Marker | null): void;
     removeLayer(layerName: string): void;
+    setFeatureState(feature: FeatureIdentifier, state: Record<string, unknown>): void;
+    queryRenderedFeatures(geometryOrOptions?: PointLike | [PointLike, PointLike] | QueryRenderedFeaturesOptions, options?: QueryRenderedFeaturesOptions): import("maplibre-gl").MapGeoJSONFeature[];
+    addMarker(coordinates: [number, number], options?: MarkerOptions): Marker | null;
+    removeMarker(marker: Marker | null): void;
     renderRoutes(routes: RouteFeature[], baseLayerName?: string): void;
-    buildRouteWithLabels(startCoordinates: [number, number], endCoordinates: [number, number], profile: string): Promise<RouteBuildResult>;
-    buildMultiSegmentRouteWithLabels(coordinates: [number, number][], profile: string, language?: string): Promise<MultiRouteBuildResult>;
+    buildRoute(options: BuildRouteOptions): Promise<BuildRouteResult>;
+    buildRouteWithLabels(startCoordinates: [number, number], endCoordinates: [number, number], profile: string): Promise<{
+        features: RouteFeature[];
+        directions: unknown[];
+    }>;
+    buildMultiSegmentRouteWithLabels(coordinates: [number, number][], profile: string, language?: string): Promise<{
+        features: RouteFeature[];
+        directions: unknown[][];
+    }>;
     clearAllRoutes(): void;
-    highlightSearchResults(query: string, highlightOptions?: {
-        layerName?: string;
-        iconImage?: string;
-        highlightColor?: string;
-        pulseAnimation?: boolean;
-        zoomToResults?: boolean;
-        onIconClick?: (lat: number, lng: number, properties: Record<string, unknown>) => void;
-        onResultsUpdate?: (results: SearchResult[]) => void;
-        onLoadingStateChange?: (state: 'firstRender' | 'rerender' | false) => void;
-    }): () => void;
-    private currentBusRouteInterval?;
-    private currentBusMarkers;
-    private currentRouteLayers;
-    private readonly MAX_BUSES;
-    private svgCache;
-    private mapMoveTimeout?;
-    private busPositions;
-    private animationFrameId?;
-    private animateBusMarkers;
-    private startBusAnimation;
-    private stopBusAnimation;
-    showBusRoute(route_id?: string): Promise<() => void>;
+    highlightSearchResults(query: string, options?: SearchOptions): () => void;
 }
-export { YarrowMap, YarrowMapConfig };
-export type { BrandBadgePosition };
-export type { YarrowControlsConfig, YarrowControlsPosition };
-export type { YarrowMapConfigOptions };
+export { YarrowMapConfig };
+export type { BrandBadgePosition } from './brandBadge';
+export type { YarrowControlsConfig, YarrowControlsPosition, } from './yarrowControls';
+export type { YarrowMapConfigOptions } from './types';
 //# sourceMappingURL=yarrow.d.ts.map

package/dist/maps/yarrowControls.d.ts

@@ -27,7 +27,6 @@ type YarrowControlsState = {
 export declare class YarrowControlsController {
     private map?;
     private host?;
-    private container?;
     private zoomInButton?;
     private zoomOutButton?;
     private compassButton?;