import { ObjectValues } from '../../../utils/ObjectValues';
import { MapUtils } from './mapUtils';
import { EventListenerMap } from './eventHandling';
export type Point = H.geo.Point;
export type NoisePoint = H.clustering.INoisePoint;
export type DataPoint = H.clustering.DataPoint;
export type MapEvent = H.mapevents.Event & {};
export type MapContextMenuEvent = H.mapevents.ContextMenuEvent;
export type MapInfoBubble = H.ui.InfoBubble;
export type MapUtilEvent = H.util.Event;
export type Position = {
    lat: number;
    lng: number;
};
export type BoundingBox = {
    top: number;
    bottom: number;
    left: number;
    right: number;
};
export type MapBoundingBox = {
    topLeft: {
        lng: number | undefined;
        lat: number | undefined;
    };
    bottomRight: {
        lng: number | undefined;
        lat: number | undefined;
    };
};
export declare const MapTypeMap: {
    readonly TYPE_DEFAULT: "DEFAULT";
    readonly TYPE_FLEET_STYLE: "FLEET_STYLE";
    readonly TYPE_SATELLITE: "SATELLITE";
    readonly TYPE_TERRAIN: "TERRAIN";
    readonly TYPE_NIGHT: "NIGHT";
};
export type MapType = ObjectValues<typeof MapTypeMap>;
export declare const MapLayerMap: {
    readonly MAP_LAYER_INCIDENTS: "INCIDENTS";
    readonly MAP_LAYER_TRAFFIC: "TRAFFIC";
    readonly MAP_LAYER_ROAD_RESTRICTIONS: "ROAD_RESTRICTIONS";
};
export type MapLayer = ObjectValues<typeof MapLayerMap>;
export type MapCredentials = {
    app_id?: string;
    app_code?: string;
    apikey?: string;
};
export type MapProps = {
    /**
     * HERE credentials used to initialize the map platform.
     */
    credentials: MapCredentials;
    /**
     * Height of the map container.
     */
    height?: number;
    /**
     * Width of the map container.
     */
    width?: number;
    /**
     * Language used for HERE map labels and controls.
     *
     * @default 'en'
     */
    language?: string;
    /**
     * Initial center position of the map.
     */
    center?: Position;
    /**
     * Initial or controlled zoom level of the map.
     */
    zoom?: number;
    /**
     * Bounding box that should be fitted by the map view.
     */
    boundingBox?: BoundingBox;
    /**
     * Disables HERE map events entirely.
     */
    disableMapEvents?: boolean;
    /**
     * Disables the default HERE map behavior such as pan and zoom interaction.
     *
     * @default false
     */
    disableBehavior?: boolean;
    /**
     * Disables HERE zoom momentum to reduce scroll inertia on zoom.
     *
     * @default true
     */
    disableZoomMomentum?: boolean;
    /**
     * Event listeners attached to the HERE map instance.
     */
    eventListenerMap?: EventListenerMap;
    /**
     * Legacy prop for hiding map settings.
     */
    hideMapSettings?: boolean;
    /**
     * Hides the cluster settings entry in the map settings UI.
     *
     * @default false
     */
    hideClusterSettings?: boolean;
    /**
     * Hides the map layer settings entry in the map settings UI.
     *
     * @default false
     */
    hideMapLayerSettings?: boolean;
    /**
     * Base map type to render.
     *
     * @default Map.TYPE_DEFAULT
     */
    mapType?: MapType;
    /**
     * Active overlay layers such as traffic or incidents.
     *
     * @default []
     */
    mapLayer?: MapLayer[];
    /**
     * Controls whether marker clustering is enabled.
     *
     * @default true
     */
    showCluster?: boolean;
    /**
     * Shows the HERE scale bar.
     *
     * @default false
     */
    showScaleBar?: boolean;
    /**
     * Callback fired when the map type changes.
     */
    onMapTypeChange?: (type: MapType, previousType?: MapType) => void;
    /**
     * Callback fired when the active map layers change.
     */
    onMapLayerChange?: (activeLayer: MapLayer[], previousLayer?: MapLayer[]) => void;
    /**
     * Callback fired when the cluster visibility changes.
     */
    onShowClusterChange?: (show: boolean) => void;
    /**
     * Callback fired when zooming in via the built-in zoom controls.
     */
    onZoomIn?: (zoom: number) => void;
    /**
     * Callback fired when zooming out via the built-in zoom controls.
     */
    onZoomOut?: (zoom: number) => void;
    /**
     * Callback used by incidents overlays to report fetched incidents.
     */
    onIncidentsChange?: (incidentsResult: MapIncidents) => void;
    /**
     * Tooltip content for the map settings entry.
     */
    mapSettingsTooltip?: string | React.ReactNode;
    /**
     * Custom settings UI rendered on top of the map.
     */
    mapSettings?: React.ReactNode;
    /**
     * Enables animation when zoom or center changes are applied programmatically.
     *
     * @default false
     */
    zoomAnimation?: boolean;
    /**
     * Maximum number of previous map viewports stored for viewport history.
     *
     * @default 5
     */
    maxViewportHistoryEntries?: number;
    /**
     * Enables the WebGL/HARP rendering engine where supported.
     *
     * @default true
     */
    enableWebGL?: boolean;
    /**
     * Uses `window.devicePixelRatio` for map rendering.
     *
     * @default true
     */
    enableDevicePixelRatio?: boolean;
    /**
     * Enables caching for generated marker icons.
     *
     * @default true
     */
    enableMarkerIconCache?: boolean;
    /**
     * Keeps HERE fractional zoom enabled for smoother trackpad and wheel zoom interaction.
     *
     * @default false
     */
    enableFractionalZoom?: boolean;
    /**
     * Temporarily disables marker pointer events during zoom interactions to reduce DOM hit-testing overhead.
     *
     * @default false
     */
    disableMarkerPointerEventsWhileZooming?: boolean;
    /**
     * Fallback pixel ratio used when device pixel ratio support is disabled.
     */
    pixelRatio?: number;
    /**
     * Minimum allowed zoom level.
     */
    minZoom?: number;
    /**
     * Maximum allowed zoom level.
     */
    maxZoom?: number;
    /**
     * Map content or a render function receiving the map API.
     */
    children?: React.ReactNode | ((api: MapApi, incidents?: MapIncidents) => React.ReactNode);
};
export type MapApi = {
    credentials?: MapCredentials;
    defaultLayers?: H.service.DefaultLayers;
    map?: H.Map;
    mapEvents?: false | H.mapevents.MapEvents;
    behavior?: false | H.mapevents.Behavior;
    platform?: H.service.Platform;
    ui?: H.ui.UI;
    utils?: MapUtils;
    group?: H.map.Group;
    settings?: {
        enableWebGL?: boolean;
        baseLayer?: MapType;
        activeLayers?: MapLayer[];
        showCluster?: boolean;
        minZoom?: number;
        maxZoom?: number;
    };
};
export type MapIncidents = {
    sourceUpdated: string;
    results: IncidentDataPoint[];
};
export type Incidents = {
    sourceUpdated: string;
    results: Incident[];
};
export type IncidentLocationPoint = {
    length: number;
    points: Position[];
};
export type IncidentLocationShape = {
    links: IncidentLocationPoint[];
};
export type Incident = {
    incidentDetails: IncidentDetails;
    location: {
        length: number;
        shape: IncidentLocationShape;
    };
};
export type IncidentDetails = {
    id: string;
    hrn: string;
    originalId: string;
    originalHrn: string;
    startTime: string;
    endTime: string;
    entryTime: string;
    roadClosed: boolean;
    criticality: 'minor' | 'major' | 'critical';
    type: 'roadClosure' | 'construction' | 'roadHazard' | 'other';
    codes: number[];
    comment: string | undefined;
    description: {
        value: string;
        language?: string;
    };
    summary: {
        value: string;
        language?: string;
    };
    junctionTraversability: string;
};
export type IncidentDataPoint = {
    id: string;
    tooltipContent: string;
    criticality: 'low' | 'minor' | 'major' | 'critical';
    description: {
        value: string;
        language?: string;
    };
    summary: {
        value: string;
        language?: string;
    };
    comment: string | undefined;
    type: 'accident' | 'construction' | 'congestion' | 'roadHazard' | 'roadClosure' | 'disabledVehicle' | 'massTransit' | 'plannedEvent' | 'weather' | 'laneRestriction' | 'other';
    startTime: string;
    endTime: string;
    roadClosed: boolean;
    position: Position;
};
export declare const markerColorOptions: readonly ["bg-map-marker-asset", "bg-map-marker-poi", "bg-map-marker-geofence", "bg-map-marker-route", "bg-map-marker-info", "bg-map-marker-success", "bg-map-marker-warning", "bg-map-marker-danger", "bg-map-marker-restrictions"];
export type MarkerColor = (typeof markerColorOptions)[number];
export declare const markerColorMapping: Record<MarkerColor, string>;
