import * as i0 from '@angular/core';
import { InjectionToken, OnChanges, OnDestroy, SimpleChanges, AfterViewInit, AfterContentChecked, QueryList, ElementRef, ModuleWithProviders } from '@angular/core';
import * as atlas from 'azure-maps-control';
import { AuthenticationOptions, ControlPosition, Map } from 'azure-maps-control';
import * as atlas$1 from 'azure-maps-rest';
import { IRetryOptions } from 'azure-maps-rest';
import * as atlasdrawing from 'azure-maps-drawing-tools';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

declare const AZUREMAPS_CONFIG: InjectionToken<unknown>;
/**
 * Configuration of the Azure Maps
 */
declare class AzureMapsConfiguration {
    authOptions: AuthenticationOptions;
    pipelineRetryOptions?: IRetryOptions;
    domain?: string;
}

declare abstract class ControlDirective {
    position: ControlPosition;
    abstract initialize(map: Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ControlDirective, never, never, { "position": { "alias": "position"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ZoomControlDirective extends ControlDirective {
    zoomDelta: number;
    controlStyle: atlas.ControlStyle;
    initialize(map: atlas.Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ZoomControlDirective, "[map-zoom-control], map-zoom-control", never, { "zoomDelta": { "alias": "zoomDelta"; "required": false; }; "controlStyle": { "alias": "controlStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PitchControlDirective extends ControlDirective {
    pitchDegreesDelta: number;
    controlStyle: atlas.ControlStyle;
    initialize(map: atlas.Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PitchControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PitchControlDirective, "[map-pitch-control], map-pitch-control", never, { "pitchDegreesDelta": { "alias": "pitchDegreesDelta"; "required": false; }; "controlStyle": { "alias": "controlStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CompassControlDirective extends ControlDirective {
    rotationDegreesDelta: number;
    controlStyle: atlas.ControlStyle;
    initialize(map: atlas.Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CompassControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CompassControlDirective, "[map-compass-control], map-compass-control", never, { "rotationDegreesDelta": { "alias": "rotationDegreesDelta"; "required": false; }; "controlStyle": { "alias": "controlStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StyleControlDirective extends ControlDirective {
    layout: 'icons' | 'list';
    mapStyles: string[] | 'all';
    controlStyle: atlas.ControlStyle;
    initialize(map: atlas.Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StyleControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StyleControlDirective, "[map-style-control], map-style-control", never, { "layout": { "alias": "layout"; "required": false; }; "mapStyles": { "alias": "mapStyles"; "required": false; }; "controlStyle": { "alias": "controlStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HtmlMarkerDirective implements OnChanges, OnDestroy {
    private _map;
    private _marker;
    private readonly _markerEvents;
    anchor: string;
    color: string;
    draggable: boolean;
    htmlContent: string | HTMLElement;
    pixelOffset: atlas.Pixel;
    position: atlas.data.Position;
    secondaryColor: string;
    text: string;
    visible: boolean;
    marker: atlas.HtmlMarker;
    onClick: any;
    onContextMenu: any;
    onDblClick: any;
    onDrag: any;
    onDragStart: any;
    onDragEnd: any;
    onKeyDown: any;
    onKeyPress: any;
    onKeyUp: any;
    onMouseDown: any;
    onMouseEnter: any;
    onMouseLeave: any;
    onMouseMove: any;
    onMouseOut: any;
    onMouseOver: any;
    onMouseUp: any;
    get hasMap(): boolean;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    addToMap(map: atlas.Map): void;
    private toMarkerEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlMarkerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HtmlMarkerDirective, "[map-html-marker], map-html-marker", never, { "anchor": { "alias": "anchor"; "required": false; }; "color": { "alias": "color"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "htmlContent": { "alias": "htmlContent"; "required": false; }; "pixelOffset": { "alias": "pixelOffset"; "required": false; }; "position": { "alias": "position"; "required": false; }; "secondaryColor": { "alias": "secondaryColor"; "required": false; }; "text": { "alias": "text"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "marker": { "alias": "marker"; "required": false; }; }, { "onClick": "onClick"; "onContextMenu": "onContextMenu"; "onDblClick": "onDblClick"; "onDrag": "onDrag"; "onDragStart": "onDragStart"; "onDragEnd": "onDragEnd"; "onKeyDown": "onKeyDown"; "onKeyPress": "onKeyPress"; "onKeyUp": "onKeyUp"; "onMouseDown": "onMouseDown"; "onMouseEnter": "onMouseEnter"; "onMouseLeave": "onMouseLeave"; "onMouseMove": "onMouseMove"; "onMouseOut": "onMouseOut"; "onMouseOver": "onMouseOver"; "onMouseUp": "onMouseUp"; }, never, never, false, never>;
}

declare class DrawingToolbarDirective implements OnChanges, OnDestroy {
    private _drawingManager;
    private _toolbar;
    private _map;
    dragHandleStyle: atlas.HtmlMarkerOptions;
    freehandInterval: number;
    interactionType: atlasdrawing.drawing.DrawingInteractionType;
    mode: atlasdrawing.drawing.DrawingMode;
    secondaryDragHandleStyle: atlas.HtmlMarkerOptions;
    shapeDraggingEnabled: boolean;
    buttons: string[];
    containerId: string;
    numColumns: number;
    position: string;
    toolbarStyle: string;
    visible: boolean;
    drawingChanged: any;
    drawingChanging: any;
    drawingComplete: any;
    drawingModeChanged: any;
    drawingStarted: any;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    initialize(map: atlas.Map): void;
    getDatasource(): atlas.source.DataSource;
    getPreviewSource(): atlas.source.DataSource;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawingToolbarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DrawingToolbarDirective, "[map-drawing-toolbar], map-drawing-toolbar", never, { "dragHandleStyle": { "alias": "dragHandleStyle"; "required": false; }; "freehandInterval": { "alias": "freehandInterval"; "required": false; }; "interactionType": { "alias": "interactionType"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "secondaryDragHandleStyle": { "alias": "secondaryDragHandleStyle"; "required": false; }; "shapeDraggingEnabled": { "alias": "shapeDraggingEnabled"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "containerId": { "alias": "containerId"; "required": false; }; "numColumns": { "alias": "numColumns"; "required": false; }; "position": { "alias": "position"; "required": false; }; "toolbarStyle": { "alias": "toolbarStyle"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, { "drawingChanged": "drawingChanged"; "drawingChanging": "drawingChanging"; "drawingComplete": "drawingComplete"; "drawingModeChanged": "drawingModeChanged"; "drawingStarted": "drawingStarted"; }, never, never, false, never>;
}

declare abstract class LayerDirective<T extends atlas.layer.Layer> implements OnDestroy {
    private readonly _layerEvents;
    protected layer: T;
    id: string;
    before: string;
    onAdded: any;
    onClick: any;
    onContextMenu: any;
    onDblClick: any;
    onMouseDown: any;
    onMouseEnter: any;
    onMouseLeave: any;
    onMouseMove: any;
    onMouseOut: any;
    onMouseOver: any;
    onMouseUp: any;
    onRemoved: any;
    onTouchCancel: any;
    onTouchEnd: any;
    onTouchMove: any;
    onTouchStart: any;
    onWheel: any;
    get hasLayer(): boolean;
    ngOnDestroy(): void;
    protected initializeEvents(map: atlas.Map): void;
    private toLayerEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayerDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LayerDirective<any>, never, never, { "id": { "alias": "id"; "required": false; }; "before": { "alias": "before"; "required": false; }; }, { "onAdded": "onAdded"; "onClick": "onClick"; "onContextMenu": "onContextMenu"; "onDblClick": "onDblClick"; "onMouseDown": "onMouseDown"; "onMouseEnter": "onMouseEnter"; "onMouseLeave": "onMouseLeave"; "onMouseMove": "onMouseMove"; "onMouseOut": "onMouseOut"; "onMouseOver": "onMouseOver"; "onMouseUp": "onMouseUp"; "onRemoved": "onRemoved"; "onTouchCancel": "onTouchCancel"; "onTouchEnd": "onTouchEnd"; "onTouchMove": "onTouchMove"; "onTouchStart": "onTouchStart"; "onWheel": "onWheel"; }, never, never, true, never>;
}

declare abstract class SourceLayerDirective<T extends atlas.layer.Layer> extends LayerDirective<T> implements OnDestroy {
    dataSourceId: string;
    sourceLayer: string;
    initialize(map: atlas.Map, dataSource: atlas.source.Source): void;
    clear(map: atlas.Map): void;
    protected abstract buildLayer(dataSource: atlas.source.Source): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<SourceLayerDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SourceLayerDirective<any>, never, never, { "dataSourceId": { "alias": "dataSourceId"; "required": false; }; "sourceLayer": { "alias": "sourceLayer"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SymbolLayerDirective extends SourceLayerDirective<atlas.layer.SymbolLayer> implements OnChanges {
    filter: atlas.Expression;
    iconOptions: atlas.IconOptions;
    lineSpacing: atlas.Expression | number;
    maxZoom: number;
    minZoom: number;
    placement: 'point' | 'line' | 'line-center';
    textOptions: atlas.TextOptions;
    visible: boolean;
    ngOnChanges(): void;
    protected buildLayer(dataSource: atlas.source.Source): atlas.layer.SymbolLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<SymbolLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SymbolLayerDirective, "[map-symbol-layer], map-symbol-layer", never, { "filter": { "alias": "filter"; "required": false; }; "iconOptions": { "alias": "iconOptions"; "required": false; }; "lineSpacing": { "alias": "lineSpacing"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "textOptions": { "alias": "textOptions"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BubbleLayerDirective extends SourceLayerDirective<atlas.layer.BubbleLayer> implements OnChanges {
    blur: number | atlas.Expression;
    color: string | atlas.Expression;
    filter: atlas.Expression;
    maxZoom: number;
    minZoom: number;
    opacity: number | atlas.Expression;
    pitchAlignment: 'map' | 'viewport';
    radius: number | atlas.Expression;
    strokeColor: string | atlas.Expression;
    strokeOpacity: number | atlas.Expression;
    strokeWidth: number | atlas.Expression;
    visible: boolean;
    ngOnChanges(): void;
    protected buildLayer(dataSource: atlas.source.Source): atlas.layer.BubbleLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BubbleLayerDirective, "[map-bubble-layer], map-bubble-layer", never, { "blur": { "alias": "blur"; "required": false; }; "color": { "alias": "color"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "pitchAlignment": { "alias": "pitchAlignment"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeOpacity": { "alias": "strokeOpacity"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LineLayerDirective extends SourceLayerDirective<atlas.layer.LineLayer> implements OnChanges {
    blur: number | atlas.Expression;
    filter: atlas.Expression;
    lineCap: 'butt' | 'round' | 'square';
    lineJoin: 'bevel' | 'round' | 'miter';
    maxZoom: number;
    minZoom: number;
    offset: number | atlas.Expression;
    strokeColor: string | atlas.Expression;
    strokeDashArray: number[];
    strokeGradient: atlas.Expression;
    strokeOpacity: number | atlas.Expression;
    strokeWidth: number | atlas.Expression;
    translate: atlas.Pixel;
    translateAnchor: 'map' | 'viewport';
    visible: boolean;
    ngOnChanges(): void;
    protected buildLayer(dataSource: atlas.source.Source): atlas.layer.LineLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<LineLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LineLayerDirective, "[map-line-layer], map-line-layer", never, { "blur": { "alias": "blur"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "lineCap": { "alias": "lineCap"; "required": false; }; "lineJoin": { "alias": "lineJoin"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeDashArray": { "alias": "strokeDashArray"; "required": false; }; "strokeGradient": { "alias": "strokeGradient"; "required": false; }; "strokeOpacity": { "alias": "strokeOpacity"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "translateAnchor": { "alias": "translateAnchor"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PolygonLayerDirective extends SourceLayerDirective<atlas.layer.PolygonLayer> implements OnChanges {
    fillColor: string | atlas.Expression;
    fillOpacity: number | atlas.Expression;
    fillPattern: string | atlas.Expression;
    filter: atlas.Expression;
    maxZoom: number;
    minZoom: number;
    visible: boolean;
    ngOnChanges(): void;
    protected buildLayer(dataSource: atlas.source.Source): atlas.layer.PolygonLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PolygonLayerDirective, "[map-polygon-layer], map-polygon-layer", never, { "fillColor": { "alias": "fillColor"; "required": false; }; "fillOpacity": { "alias": "fillOpacity"; "required": false; }; "fillPattern": { "alias": "fillPattern"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PolygonExtrusionLayerDirective extends SourceLayerDirective<atlas.layer.PolygonExtrusionLayer> implements OnChanges {
    base: number | atlas.Expression;
    fillColor: string | atlas.Expression;
    fillOpacity: number;
    fillPattern: string;
    filter: atlas.Expression;
    height: number;
    maxZoom: number;
    minZoom: number;
    translate: atlas.Pixel;
    translateAnchor: 'map' | 'viewport';
    verticalGradient: boolean;
    visible: boolean;
    ngOnChanges(): void;
    protected buildLayer(dataSource: atlas.source.Source): atlas.layer.PolygonExtrusionLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonExtrusionLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PolygonExtrusionLayerDirective, "[map-polygon-extrusion-layer], map-polygon-extrusion-layer", never, { "base": { "alias": "base"; "required": false; }; "fillColor": { "alias": "fillColor"; "required": false; }; "fillOpacity": { "alias": "fillOpacity"; "required": false; }; "fillPattern": { "alias": "fillPattern"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "height": { "alias": "height"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "translateAnchor": { "alias": "translateAnchor"; "required": false; }; "verticalGradient": { "alias": "verticalGradient"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HeatmapLayerDirective extends SourceLayerDirective<atlas.layer.HeatMapLayer> implements OnChanges {
    color: atlas.Expression;
    filter: atlas.Expression;
    intensity: number | atlas.Expression;
    maxZoom: number;
    minZoom: number;
    opacity: number | atlas.Expression;
    radius: number | atlas.Expression;
    visible: boolean;
    weight: number | atlas.Expression;
    ngOnChanges(): void;
    protected buildLayer(dataSource: atlas.source.Source): atlas.layer.HeatMapLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeatmapLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HeatmapLayerDirective, "[map-heatmap-layer], map-heatmap-layer", never, { "color": { "alias": "color"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "weight": { "alias": "weight"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ImageLayerDirective extends LayerDirective<atlas.layer.ImageLayer> implements OnChanges {
    contrast: number;
    coordinates: atlas.data.Position[];
    fadeDuration: number;
    filter: atlas.Expression;
    hueRotation: number;
    maxBrightness: number;
    maxZoom: number;
    minBrightness: number;
    minZoom: number;
    opacity: number;
    saturation: number;
    url: string;
    visible: boolean;
    ngOnChanges(): void;
    initialize(map: atlas.Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageLayerDirective, "[map-image-layer], map-image-layer", never, { "contrast": { "alias": "contrast"; "required": false; }; "coordinates": { "alias": "coordinates"; "required": false; }; "fadeDuration": { "alias": "fadeDuration"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "hueRotation": { "alias": "hueRotation"; "required": false; }; "maxBrightness": { "alias": "maxBrightness"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minBrightness": { "alias": "minBrightness"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "saturation": { "alias": "saturation"; "required": false; }; "url": { "alias": "url"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TileLayerDirective extends LayerDirective<atlas.layer.TileLayer> implements OnChanges {
    bounds: atlas.data.BoundingBox;
    contrast: number;
    fadeDuration: number;
    filter: atlas.Expression;
    hueRotation: number;
    isTMS: boolean;
    maxBrightness: number;
    maxSourceZoom: number;
    maxZoom: number;
    minBrightness: number;
    minSourceZoom: number;
    minZoom: number;
    opacity: number;
    saturation: number;
    subdomains: string[];
    tileSize: number;
    tileUrl: string;
    visible: boolean;
    ngOnChanges(): void;
    initialize(map: atlas.Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileLayerDirective, "[map-tile-layer], map-tile-layer", never, { "bounds": { "alias": "bounds"; "required": false; }; "contrast": { "alias": "contrast"; "required": false; }; "fadeDuration": { "alias": "fadeDuration"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "hueRotation": { "alias": "hueRotation"; "required": false; }; "isTMS": { "alias": "isTMS"; "required": false; }; "maxBrightness": { "alias": "maxBrightness"; "required": false; }; "maxSourceZoom": { "alias": "maxSourceZoom"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minBrightness": { "alias": "minBrightness"; "required": false; }; "minSourceZoom": { "alias": "minSourceZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "saturation": { "alias": "saturation"; "required": false; }; "subdomains": { "alias": "subdomains"; "required": false; }; "tileSize": { "alias": "tileSize"; "required": false; }; "tileUrl": { "alias": "tileUrl"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PopupDirective implements OnChanges, OnDestroy {
    private _map;
    private _popup;
    private readonly _popupEvents;
    opened: boolean;
    closeButton: boolean;
    content: HTMLElement | string;
    draggable: boolean;
    fillColor: string;
    pixelOffset: atlas.Pixel;
    position: atlas.data.Position;
    showPointer: boolean;
    onClose: any;
    onDrag: any;
    onDragEnd: any;
    onDragStart: any;
    onOpen: any;
    get hasMap(): boolean;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    addToMap(map: atlas.Map): void;
    private toPopupEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopupDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PopupDirective, "[map-popup], map-popup", never, { "opened": { "alias": "opened"; "required": false; }; "closeButton": { "alias": "closeButton"; "required": false; }; "content": { "alias": "content"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "fillColor": { "alias": "fillColor"; "required": false; }; "pixelOffset": { "alias": "pixelOffset"; "required": false; }; "position": { "alias": "position"; "required": false; }; "showPointer": { "alias": "showPointer"; "required": false; }; }, { "onClose": "onClose"; "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; "onDragStart": "onDragStart"; "onOpen": "onOpen"; }, never, never, false, never>;
}

declare class AzureMapDirective implements AfterViewInit, AfterContentChecked, OnChanges {
    private readonly elementRef;
    private readonly _mapEvents;
    private _map;
    autoResize: boolean;
    bearing: number;
    bounds: [number, number, number, number];
    boxZoomInteraction: boolean;
    cameraType: 'jump' | 'ease' | 'fly';
    center: [number, number];
    centerOffset: [number, number];
    cursor: string;
    dblclickZoomInteraction: boolean;
    disableTelemetry: boolean;
    duration: number;
    dragPanInteraction: boolean;
    dragRotateInteraction: boolean;
    enableAccessibility: boolean;
    interactive: boolean;
    keyboardInteraction: boolean;
    language: string;
    light: atlas.LightOptions;
    maxBounds: atlas.data.BoundingBox;
    maxZoom: number;
    minZoom: number;
    offset: [number, number];
    padding: {
        top: 0;
        bottom: 0;
        left: 0;
        right: 0;
    };
    preserveDrawingBuffer: boolean;
    pitch: number;
    refreshExpiredTiles: boolean;
    renderWorldCopies: boolean;
    scrollZoomInteraction: boolean;
    mapStyle: string;
    showBuildingModels: boolean;
    showFeedbackLink: boolean;
    showLogo: boolean;
    showTilesBoundary: boolean;
    touchInteraction: boolean;
    view: string;
    wheelZoomRate: number;
    zoom: number;
    dataSources: atlas.source.Source[];
    trafficOptions: atlas.TrafficOptions;
    onBoxZoomEnd: any;
    onBoxZoomStart: any;
    onClick: any;
    onContextMenu: any;
    onData: any;
    onDblClick: any;
    onDrag: any;
    onDragEnd: any;
    onDragStart: any;
    onError: any;
    onIdle: any;
    onLayerAdded: any;
    onLayerRemoved: any;
    onLoad: any;
    onMouseDown: any;
    onMouseLeave: any;
    onMouseMove: any;
    onMouseOut: any;
    onMouseOver: any;
    onMouseUp: any;
    onMove: any;
    onMoveEnd: any;
    onMoveStart: any;
    onPitch: any;
    onPitchEnd: any;
    onPitchStart: any;
    onReady: any;
    onRender: any;
    onResize: any;
    onRotate: any;
    onRotateEnd: any;
    onRotateStart: any;
    onSourceAdded: any;
    onSourceData: any;
    onSourceRemoved: any;
    onStyleData: any;
    onStyleImageMissing: any;
    onTokenAcquired: any;
    onTouchCancel: any;
    onTouchEnd: any;
    onTouchMove: any;
    onTouchStart: any;
    onWheel: any;
    onZoom: any;
    onZoomEnd: any;
    onZoomStart: any;
    zoomControl: ZoomControlDirective;
    pitchControl: PitchControlDirective;
    compassControl: CompassControlDirective;
    styleControl: StyleControlDirective;
    htmlMarkers: QueryList<HtmlMarkerDirective>;
    drawingToolbar: DrawingToolbarDirective;
    symbolLayers: QueryList<SymbolLayerDirective>;
    bubbleLayers: QueryList<BubbleLayerDirective>;
    lineLayers: QueryList<LineLayerDirective>;
    polygonLayers: QueryList<PolygonLayerDirective>;
    polygonExtrusionLayers: QueryList<PolygonExtrusionLayerDirective>;
    heatmapLayers: QueryList<HeatmapLayerDirective>;
    imageLayers: QueryList<ImageLayerDirective>;
    tileLayers: QueryList<TileLayerDirective>;
    popups: QueryList<PopupDirective>;
    private get sourceLayers();
    ngAfterViewInit(): void;
    ngAfterContentChecked(): void;
    ngOnChanges(changes: SimpleChanges): void;
    constructor(elementRef: ElementRef);
    private updateDataSources;
    private setOptions;
    private toMapEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<AzureMapDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AzureMapDirective, "[azure-map], azure-map", never, { "autoResize": { "alias": "autoResize"; "required": false; }; "bearing": { "alias": "bearing"; "required": false; }; "bounds": { "alias": "bounds"; "required": false; }; "boxZoomInteraction": { "alias": "boxZoomInteraction"; "required": false; }; "cameraType": { "alias": "cameraType"; "required": false; }; "center": { "alias": "center"; "required": false; }; "centerOffset": { "alias": "centerOffset"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "dblclickZoomInteraction": { "alias": "dblclickZoomInteraction"; "required": false; }; "disableTelemetry": { "alias": "disableTelemetry"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "dragPanInteraction": { "alias": "dragPanInteraction"; "required": false; }; "dragRotateInteraction": { "alias": "dragRotateInteraction"; "required": false; }; "enableAccessibility": { "alias": "enableAccessibility"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "keyboardInteraction": { "alias": "keyboardInteraction"; "required": false; }; "language": { "alias": "language"; "required": false; }; "light": { "alias": "light"; "required": false; }; "maxBounds": { "alias": "maxBounds"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "preserveDrawingBuffer": { "alias": "preserveDrawingBuffer"; "required": false; }; "pitch": { "alias": "pitch"; "required": false; }; "refreshExpiredTiles": { "alias": "refreshExpiredTiles"; "required": false; }; "renderWorldCopies": { "alias": "renderWorldCopies"; "required": false; }; "scrollZoomInteraction": { "alias": "scrollZoomInteraction"; "required": false; }; "mapStyle": { "alias": "mapStyle"; "required": false; }; "showBuildingModels": { "alias": "showBuildingModels"; "required": false; }; "showFeedbackLink": { "alias": "showFeedbackLink"; "required": false; }; "showLogo": { "alias": "showLogo"; "required": false; }; "showTilesBoundary": { "alias": "showTilesBoundary"; "required": false; }; "touchInteraction": { "alias": "touchInteraction"; "required": false; }; "view": { "alias": "view"; "required": false; }; "wheelZoomRate": { "alias": "wheelZoomRate"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "dataSources": { "alias": "dataSources"; "required": false; }; "trafficOptions": { "alias": "trafficOptions"; "required": false; }; }, { "onBoxZoomEnd": "onBoxZoomEnd"; "onBoxZoomStart": "onBoxZoomStart"; "onClick": "onClick"; "onContextMenu": "onContextMenu"; "onData": "onData"; "onDblClick": "onDblClick"; "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; "onDragStart": "onDragStart"; "onError": "onError"; "onIdle": "onIdle"; "onLayerAdded": "onLayerAdded"; "onLayerRemoved": "onLayerRemoved"; "onLoad": "onLoad"; "onMouseDown": "onMouseDown"; "onMouseLeave": "onMouseLeave"; "onMouseMove": "onMouseMove"; "onMouseOut": "onMouseOut"; "onMouseOver": "onMouseOver"; "onMouseUp": "onMouseUp"; "onMove": "onMove"; "onMoveEnd": "onMoveEnd"; "onMoveStart": "onMoveStart"; "onPitch": "onPitch"; "onPitchEnd": "onPitchEnd"; "onPitchStart": "onPitchStart"; "onReady": "onReady"; "onRender": "onRender"; "onResize": "onResize"; "onRotate": "onRotate"; "onRotateEnd": "onRotateEnd"; "onRotateStart": "onRotateStart"; "onSourceAdded": "onSourceAdded"; "onSourceData": "onSourceData"; "onSourceRemoved": "onSourceRemoved"; "onStyleData": "onStyleData"; "onStyleImageMissing": "onStyleImageMissing"; "onTokenAcquired": "onTokenAcquired"; "onTouchCancel": "onTouchCancel"; "onTouchEnd": "onTouchEnd"; "onTouchMove": "onTouchMove"; "onTouchStart": "onTouchStart"; "onWheel": "onWheel"; "onZoom": "onZoom"; "onZoomEnd": "onZoomEnd"; "onZoomStart": "onZoomStart"; }, ["zoomControl", "pitchControl", "compassControl", "styleControl", "htmlMarkers", "drawingToolbar", "symbolLayers", "bubbleLayers", "lineLayers", "polygonLayers", "polygonExtrusionLayers", "heatmapLayers", "imageLayers", "tileLayers", "popups"], never, false, never>;
}

interface ILayerEvent {
    layer: atlas.layer.Layer | atlas.layer.Layer[];
    event: any;
}

interface IMapEvent {
    map: atlas.Map;
    event: any;
}

interface IMarkerEvent {
    marker: atlas.HtmlMarker;
    event: any;
}

interface IPopupEvent {
    popup: atlas.Popup;
    event: any;
}

type Unit = 'imperial' | 'metric';
/**
 * Quarter of the day.
 */
type Quarter = 0 | 1 | 2 | 3;
interface CurrentConditionsResponse {
    results: CurrentConditions[];
}
interface CurrentConditions {
    /**
     * Perceived outdoor WeatherUnit caused by the combination of air WeatherUnit, relative humidity, and wind speed in specified unit.
     */
    apparentWeatherUnit: WeatherUnit;
    /**
     * Cloud ceiling in specified unit. The ceiling is a measurement of the height of the base of the lowest clouds.
     */
    ceiling: WeatherUnit;
    /**
     * Percent representing cloud cover.
     */
    cloudCover: number;
    /**
     * Date and time of the current observation displayed in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    dateTime: string;
    /**
     * The dewpoint temperature in specified unit. The dewpoint temperature is the temperature that the air must be cooled to in order to reach saturation.
     */
    dewPoint: WeatherUnit;
    /**
     * Indicates the presence or absence of precipitation. True indicates the presence of precipitation, false indicates the absence of precipitation.
     */
    hasPrecipitation: boolean;
    /**
     * Numeric value representing an image that displays the iconPhrase. Please refer to Weather Service Concepts for details.
     */
    iconCode: number;
    /**
     * Indicates the time of the day. True indicates 'day',', false indicates 'night.
     */
    isDayTime: boolean;
    /**
     * Cause of limited visibility.
     */
    obstructionsToVisibility: string;
    /**
     * Departure from the temperature observed 24 hours ago in specified unit.
     */
    past24HourWeatherUnitDeparture: WeatherUnit;
    /**
     * Phrase description of the current weather condition. Displayed in specified language.
     */
    phrase: string;
    /**
     * Summary of precipitation amounts over the past 24 hours.
     */
    precipitationSummary: PrecipitationSummary;
    /**
     * Atmospheric pressure in specified unit.
     */
    pressure: WeatherUnit;
    /**
     * Atmospheric pressure change.
     */
    pressureTendency: PressureTendency;
    /**
     * RealFeel™ Temperature being returned.
     */
    realFeelTemperature: WeatherUnit;
    /**
     * RealFeel™ Temperature being returned. Describes what the temperature really feels like in the shade.
     */
    realFeelTemperatureShade: WeatherUnit;
    /**
     * Relative humidity is the amount of water vapor present in air expressed as a percentage of the amount needed for saturation at the same temperature.
     */
    relativeHumidity: number;
    /**
     * Temperature being returned.
     */
    temperature: WeatherUnit;
    /**
     * Summary of temperature fluctuations over the past 6, 12, and 24 hours.
     */
    temperatureSummary: TemperatureSummary;
    /**
     * Measure of the strength of the ultraviolet radiation from the sun. Supported values are:
      0-2 - Low danger from the sun's UV rays or the average person.
      3-5 - Moderate risk of harm from unprotected sun exposure.
      6-7 - High risk of harm from unprotected sun exposure.
      8-10 - Very high risk of harm from unprotected sun exposure.
      11+ - Extreme risk of harm from unprotected sun exposure.
     */
    uvIndex: number;
    /**
     * Phrase associated with the uvIndex.
     */
    uvIndexPhrase: string;
    /**
     * Visibility in specified unit. A measure of the distance at which an object or light can be clearly discerned.
     */
    visibility: WeatherUnit;
    /**
     * The temperature to which air may be cooled by evaporating water into it at constant pressure until it reaches saturation.
     */
    wetBulbTemperature: WeatherUnit;
    /**
     * Wind details being returned including speed and direction.
     */
    wind: Wind;
    /**
     * Perceived air temperature on exposed skin due to wind.
     */
    windChillTemperature: WeatherUnit;
    /**
     * Wind gust. Wind gust is a sudden, brief increase in speed of the wind.
     */
    windGust: Wind;
}
interface TemperatureSummary {
    /**
     * Summary of temperature fluctuations over the past 6 hours.
     */
    past6Hours: Past6Hours;
    /**
     * Summary of temperature fluctuations over the past 12 hours.
     */
    past12Hours: Past12Hours;
    /**
     * Summary of temperature fluctuations over the past 24 hours.
     */
    past24Hours: Past24Hours;
}
/**
 * Summary of temperature fluctuations over the past 6 hours.
 */
interface Past6Hours {
    /**
     * minimum
     */
    minimum: WeatherUnit;
    /**
     * maximum
     */
    maximum: WeatherUnit;
}
/**
 * Summary of temperature fluctuations over the past 12 hours.
 */
interface Past12Hours {
    /**
     * minimum
     */
    minimum: WeatherUnit;
    /**
     * maximum
     */
    maximum: WeatherUnit;
}
/**
 * Summary of temperature fluctuations over the past 24 hours.
 */
interface Past24Hours {
    /**
     * minimum
     */
    minimum: WeatherUnit;
    /**
     * maximum
     */
    maximum: WeatherUnit;
}
interface PrecipitationSummary {
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past hour.
     */
    pastHour: WeatherUnit;
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past three hours.
     */
    past3Hours: WeatherUnit;
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past six hours. Contains Metric and Imperial Values.
     */
    past6Hours: WeatherUnit;
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past nine hours.
     */
    past9Hours: WeatherUnit;
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past 12 hours.
     */
    past12Hours: WeatherUnit;
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past 18 hours.
     */
    past18Hours: WeatherUnit;
    /**
     * The amount of precipitation (liquid equivalent) that has fallen in the past 24 hours.
     */
    past24Hours: WeatherUnit;
}
interface PressureTendency {
    /**
     * Description of the pressure tendency in specified language
     */
    localizedDescription: string;
    /**
     * Pressure tendency code regardless of language. One of F=Falling, S=Steady, R=Rising.
     */
    code: string;
}
/**
 * Wind details being returned including speed and direction.
 */
interface Wind {
    /**
     * Wind direction
     */
    direction: WindDirection;
    /**
     * Speed of the wind in specified unit.
     */
    speed: WindSpeed;
}
/**
 * Wind direction
 */
interface WindDirection {
    /**
     * Wind direction in Azimuth degrees, starting at true North and continuing in clockwise direction. North is 0 degrees, east is 90 degrees, south is 180 degrees, west is 270 degrees. Possible values 0-359.
     */
    degrees: number;
    /**
     * Direction abbreviation in the specified language.
     */
    localizedDescription: string;
}
/**
 * Speed of wind in specified unit.
 */
interface WindSpeed {
    /**
     * Rounded value of the speed.
     */
    value: number;
    /**
     * Type of unit for the speed value.
     */
    unit: string;
    /**
     * Numeric ID value associated with the type of unit being displayed. Can be used for unit translation.
     */
    unitType: number;
}
interface WeatherUnit {
    /**
     * Rounded value.
     */
    value: number;
    /**
     * Type of unit for the returned value.
     */
    unit: string;
    /**
     * Numeric ID value associated with the type of unit being displayed. Can be used for unit translation.
     */
    unitType: number;
}
interface DailyForecastResponse {
    /**
     * Summary for the main conditions for the requested time period. Notice that summary can cover only part of the time period.
     */
    summary: DailyForecastSummary;
    /**
     * Forecast data for each requested day.
     */
    forecasts: DailyForecast[];
}
interface DailyForecast {
    /**
     * Date and time of the current observation displayed in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    date: string;
    /**
     * Temperature values for the day.
     */
    temperature: WeatherUnitRange;
    /**
     * RealFeel™ Temperature being returned.
     */
    realFeelTemperature: WeatherUnitRange;
    /**
     * RealFeel™ Temperature being returned. Describes what the temperature really feels like in the shade.
     */
    realFeelTemperatureShade: WeatherUnitRange;
    /**
     * Hours of sun.
     */
    hoursOfSun: number;
    /**
     * Summary of Heating Degree Day or Cooling Degree Day information
     */
    degreeDaySummary: DegreeDaySummary;
    /**
     * airAndPollen
     */
    airAndPollen: AirAndPollen[];
    /**
     * Day
     */
    day: DayOrNight;
    /**
     * Night
     */
    night: DayOrNight;
    /**
     * Source(s) of the forecast data.
     */
    sources: string[];
}
interface DayOrNight {
    /**
     * Numeric value representing an image that displays the iconPhrase. Please refer to Weather Service Concepts for details.
     */
    iconCode: number;
    /**
     * Phrase description of the icon. Displayed in specified language. For example, 'Sunny'.
     */
    iconPhrase: string;
    /**
     * Indicates the presence or absence of precipitation. True indicates the presence of precipitation, false indicates the absence of precipitation.
     */
    hasPrecipitation: boolean;
    /**
     * Specifies the type of precipitation ("rain" "snow" "ice" or "mix"). If dbz = zero, precipitationType is not present in the response.
     */
    precipitationType: string;
    /**
     * Description of the intensity.
     */
    precipitationIntensity: string;
    /**
     * Phrase description of the forecast in specified language. Azure Maps attempts to keep this phrase under 30 characters in length, but some languages/weather events may result in a longer phrase length, exceeding 30 characters.
     */
    shortPhrase: string;
    /**
     * Phrase description of the forecast in specified language. Azure Maps attempts to keep this phrase under 100 characters in length, but some languages/weather events may result in a longer phrase length, exceeding 100 characters.
     */
    longPhrase: string;
    /**
     * Percent representing the probability of precipitation. For example, '20'.
     */
    precipitationProbability: number;
    /**
     * Percent representing the probability of a thunderstorm. For example, '80'.
     */
    thunderstormProbability: number;
    /**
     * Percent representing the probability of rain. For example, '40'.
     */
    rainProbability: number;
    /**
     * Percent representing the probability of snow. For example, '30'.
     */
    snowProbability: number;
    /**
     * Percent representing the probability of ice. For example, '30'.
     */
    iceProbability: number;
    /**
     * Wind details being returned including speed and direction.
     */
    wind: Wind;
    /**
     * Wind gust. Wind gust is a sudden, brief increase in speed of the wind.
     */
    windGust: Wind;
    /**
     * Total liquid equivalent of precipitation during the forecast period.
     */
    totalLiquid: WeatherUnit;
    /**
     * Rain
     */
    rain: WeatherUnit;
    /**
     * Snow
     */
    snow: WeatherUnit;
    /**
     * Ice
     */
    ice: WeatherUnit;
    /**
     * Hours of precipitation
     */
    hoursOfPrecipitation: number;
    /**
     * Hours of rain.
     */
    hoursOfRain: number;
    /**
     * Hours of snow.
     */
    hoursOfSnow: number;
    /**
     * Hours of ice.
     */
    hoursOfIce: number;
    /**
     * Percent representing cloud cover.
     */
    cloudCover: number;
    localSource?: LocalSource;
}
interface AirAndPollen {
    /**
     * Name of the pollen or pollutant. For example, grass, mold, weed, air quality, tree and UV index.
     */
    name: string;
    /**
     * Value of the given type above. Values associated with mold, grass, weed and tree are in units of parts per cubic meter. Both air quality and UV are indices, so they are unitless.
     */
    value: number;
    /**
     * Category of the air quality or pollution type. For example, low, high, good, moderate, unhealthy, hazardous.
     */
    category: string;
    /**
     * Value associated with the air quality or pollution category. These values range from 1 to 6. 1 implying good conditions, 6 implying hazardous conditions.
     */
    categoryValue: number;
    /**
     * Only exists for air quality. Examples include ozone and particle pollution.
     */
    type?: string;
}
interface DegreeDaySummary {
    /**
     * Number of degrees that the mean temperature is below 65 degrees F/ 18 degree C.
     */
    heating: WeatherUnit;
    /**
     * Number of degrees that the mean temperature is above 65 degrees F/ 18 degree C.
     */
    cooling: WeatherUnit;
}
/**
 * Returned temperature values.
 */
interface WeatherUnitRange {
    /**
     * Minimum temperature for the time period.
     */
    minimum: WeatherUnit;
    /**
     * Maximum temperature for the time period
     */
    maximum: WeatherUnit;
}
/**
 * Summary for the main conditions for the requested time period. Notice that summary can cover only part of the time period.
 */
interface DailyForecastSummary {
    /**
     * Date and time that the summary is in effect, displayed in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    startDate: string;
    /**
     * Date and time that the summary period ends, displayed in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    endDate: string;
    /**
     * severity
     */
    severity: number;
    /**
     * Summary phrase of the daily forecast. Displayed in specified language.
     */
    phrase: string;
    /**
     * one or 2 word(s) to summarize the phrase.
     */
    category: string;
}
interface LocalSource {
    /**
     * Numeric identifier, unique to the local data provider.
     */
    id: number;
    /**
     * Name of the local data provider. Name is displayed in the language specified by language code in URL, if available. Otherwise, Name is displayed in English or the language in which the name was provided.
     */
    name: string;
    /**
     * Weather code provided by the local data provider. This weather code allows the forecast to be matched to icons provided by the local data provider instead of Azure Maps icons.
     */
    weatherCode: string;
}
interface HourlyForecastResponse {
    forecasts: HourlyForecast[];
}
interface HourlyForecast {
    /**
     * Date and time of the forecast in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    date: string;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
    /**
     * Phrase description of the weather icon.
     */
    iconPhrase: string;
    /**
     * Indicates the presence or absence of precipitation. True indicates the presence of precipitation, false indicates the absence of precipitation.
     */
    hasPrecipitation: boolean;
    /**
     * Specifies whether or not it is daylight. True indicates day light.
     */
    isDaylight: boolean;
    /**
     * Temperature being returned.
     */
    temperature: WeatherUnit;
    /**
     * RealFeel™ Temperature being returned. Describes what the temperature really feels like in the shade.
     */
    realFeelTemperature: WeatherUnit;
    /**
     * The temperature to which air may be cooled by evaporating water into it at constant pressure until it reaches saturation.
     */
    wetBulbTemperature: WeatherUnit;
    /**
     * The dewpoint temperature in specified unit. The dewpoint temperature is the temperature that the air must be cooled to in order to reach saturation.
     */
    dewPoint: WeatherUnit;
    /**
     * Wind details being returned including speed and direction.
     */
    wind: Wind;
    /**
     * Wind gust. Wind gust is a sudden, brief increase in speed of the wind.
     */
    windGust: Wind;
    /**
     * Relative humidity is the amount of water vapor present in air expressed as a percentage of the amount needed for saturation at the same temperature.
     */
    relativeHumidity: number;
    /**
     * Visibility in specified unit. A measure of the distance at which an object or light can be clearly discerned.
     */
    visibility: WeatherUnit;
    /**
     * Percent representing cloud cover.
     */
    cloudCover: number;
    /**
     * Cloud ceiling in specified unit. The ceiling is a measurement of the height of the base of the lowest clouds.
     */
    ceiling: WeatherUnit;
    /**
     * Measure of the strength of the ultraviolet radiation from the sun. Supported values are:
      0-2 - Low danger from the sun's UV rays or the average person.
      3-5 - Moderate risk of harm from unprotected sun exposure.
      6-7 - High risk of harm from unprotected sun exposure.
      8-10 - Very high risk of harm from unprotected sun exposure.
      11+ - Extreme risk of harm from unprotected sun exposure.
     */
    uvIndex: number;
    /**
     * Phrase associated with the uvIndex.
     */
    uvIndexPhrase: string;
    /**
     * Percent representing the probability of precipitation. For example, '20'.
     */
    precipitationProbability: number;
    /**
     * Percent representing the probability of rain. For example, '50'.
     */
    rainProbability: number;
    /**
     * Percent representing the probability of snow. For example, '50'.
     */
    snowProbability: number;
    /**
     * Percent representing the probability of ice. For example, '5'.
     */
    iceProbability: number;
    /**
     * Total liquid equivalent of precipitation during the forecast period.
     */
    totalLiquid: WeatherUnit;
    /**
     * Rain
     */
    rain: WeatherUnit;
    /**
     * Snow
     */
    snow: WeatherUnit;
    /**
     * Ice
     */
    ice: WeatherUnit;
}
interface MinuteForecastResponse {
    /**
     * Phrase summaries for the entire forecast period.
     */
    summary: MinuteForecastSummary;
    /**
     * Summary information for each interval in the forecast. The Summaries breaks down each potential interval where precipitation starts and stops.
     */
    intervalSummaries: IntervalSummary[];
    /**
     * Forecast data for each interval in the forecast.
     */
    intervals: Interval[];
}
interface Interval {
    /**
     * The date and time for the start of the interval in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    startTime: string;
    /**
     * The first minute for the interval.
     */
    minute: number;
    /**
     * A unit that represents forecasted precipitation intensity.
     */
    dbz: number;
    /**
     * A short phrase describing precipitation condition for the interval.
     */
    shortPhrase: string;
    /**
     * Key that specifies the threshold value. Along with precipitationType, can be used to determine the simplifiedColor. If dbz is zero, not present in the response.
     */
    threshold?: string;
    /**
     * The full spectrum color that maps to the dBZ (decibel relative to Z). If dbz is zero, color is not present in the response.
     */
    color?: Color;
    /**
     * The band color that maps to the precipitation type and threshold. If dbz is zero, not present in the response.
     */
    simplifiedColor?: Color;
    /**
     * Specifies the type of precipitation ("rain" "snow" "ice" or "mix"). If dbz is zero, precipitationType is not present in the response.
     */
    precipitationType?: string;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
    /**
     * Percent representing cloud cover.
     */
    cloudCover: number;
}
interface Color {
    /**
     * Red component of the RGB value.
     */
    red: number;
    /**
     * Green component of the RGB value.
     */
    green: number;
    /**
     * Blue component of the RGB value
     */
    blue: number;
    /**
     * Hexadecimal color value.
     */
    hex: string;
}
interface IntervalSummary {
    /**
     * The first minute to which the summary applies.
     */
    startMinute: number;
    /**
     * The last minute to which the summary applies.
     */
    endMinute: number;
    /**
     * The number of minutes for which the summary applies.
     */
    totalMinutes: number;
    /**
     * Short summary phrase. Phrase length is approximately 25 characters.
     */
    shortPhrase: string;
    /**
     * Brief summary phrase. Phrase length is approximately 60 characters.
     */
    briefPhrase: string;
    /**
     * Long summary phrase. Phrase length is 60+ characters.
     */
    longPhrase: string;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
}
/**
 * Phrase summaries for the entire forecast period.
 */
interface MinuteForecastSummary {
    /**
     * Summary phrase for the next 60 minutes. Phrase length is approximately 60 characters.
     */
    briefPhrase60: string;
    /**
     * Short summary phrase for the next 120 minutes. Phrase length is approximately 25 characters.
     */
    shortPhrase: string;
    /**
     * Summary phrase for the next 120 minutes. Phrase length is approximately 60 characters.
     */
    briefPhrase: string;
    /**
     * Long summary phrase for the next 120 minutes. Phrase length is 60+ characters.
     */
    longPhrase: string;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
}
interface QuarterDayForecastResponse {
    /**
     * Forecast data for each quarter in the response.
     */
    forecasts: QuarterDayForecast[];
}
interface QuarterDayForecast {
    /**
     * Date and time of the forecast in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    date: string;
    /**
     * Date and time of the beginning of the forecast quarter displayed in ISO 8601 format, for example, 2019-10-27T19:39:57-08:00.
     */
    effectiveDate: string;
    /**
     * Quarter of the day.
     */
    quarter: Quarter;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
    /**
     * Phrase description of the icon. Displayed in specified language. For example, 'Sunny'.
     */
    iconPhrase: string;
    /**
     * Short summary phrase summary for quarter.
     */
    phrase: string;
    /**
     * Temperature values for the quarter.
     */
    temperature: WeatherUnitRange;
    /**
     * RealFeel™ Temperature values for the quarter.
     */
    realFeelTemperature: WeatherUnitRange;
    /**
     * The dewpoint temperature in specified unit. The dewpoint temperature is the temperature that the air must be cooled to in order to reach saturation.
     */
    dewPoint: WeatherUnit;
    /**
     * Relative humidity is the amount of water vapor present in air expressed as a percentage of the amount needed for saturation at the same temperature.
     */
    relativeHumidity: number;
    /**
     * Wind details being returned including speed and direction.
     */
    wind: Wind;
    /**
     * Wind gust. Wind gust is a sudden, brief increase in speed of the wind.
     */
    windGust: Wind;
    /**
     * Visibility in specified unit. A measure of the distance at which an object or light can be clearly discerned.
     */
    visibility: WeatherUnit;
    /**
     * Percent representing cloud cover.
     */
    cloudCover: number;
    /**
     * Indicates the presence or absence of precipitation. True indicates the presence of precipitation, false indicates the absence of precipitation.
     */
    hasPrecipitation: boolean;
    /**
     * Specifies the type of precipitation ("rain" "snow" "ice" or "mix"). If dbz = zero, precipitationType is not present in the response.
     */
    precipitationType?: string;
    /**
     * Description of the intensity.
     */
    precipitationIntensity?: string;
    /**
     * Percent representing the probability of precipitation. For example, '20'.
     */
    precipitationProbability: number;
    /**
     * Percent representing the probability of a thunderstorm. For example, '10'.
     */
    thunderstormProbability: number;
    /**
     * Total liquid equivalent of precipitation during the forecast period.
     */
    totalLiquid: WeatherUnit;
    /**
     * Rain
     */
    rain: WeatherUnit;
    /**
     * Snow
     */
    snow: WeatherUnit;
    /**
     * Ice
     */
    ice: WeatherUnit;
}
/**
 * A waypoint indicates location, ETA, and optional heading
 */
interface WaypointInput {
    /**
     * Latitude coordinate in decimal degrees.
     */
    latitude: number;
    /**
     * Longitude coordinate in decimal degrees
     */
    longitude: number;
    /**
     * The number of minutes from the present time that it will take for the vehicle to reach the waypoint. Allowed range is from 0.0 to 120.0 minutes.
     */
    eta: number;
    /**
     * An optional value indicating the vehicle heading as it passes the waypoint.
     * Expressed in clockwise degrees relative to true north.
     * This is issued to calculate sun glare as a driving hazard.
     * Allowed range is from 0.0 to 360.0 degrees.
     * If not provided, a heading will automatically be derived based on the position of neighboring waypoints.
     * It is recommended to stay within, or close to, the distance that can be traveled within 120-mins or shortly after.
     * This way a more accurate assessment can be provided for the trip and prevent isolated events not being captured between waypoints.
     * Information can and should be updated along the route (especially for trips greater than 2 hours) to continuously pull new waypoints moving forward, but also to ensure that forecast information for content such as precipitation type and intensity is accurate as storms develop and dissipate over time.
     */
    heading?: number;
}
interface HazardDetail {
    /**
     * A unique identifier (non-displayable) for each type of hazard: LightRain, ModerateRain, HeavyRain, LightMix, ModerateMix, HeavyMix, LightSnow, ModerateSnow, HeavySnow, LightIce, ModerateIce, HeavyIce, Hail, LargeHail, SunGlare, SunGlareHigh, Lightning, SevereLightning, WindModerate, WindHigh, WindExtreme, FloodWarning, FlashFloodWarning, TornadoWarning, TsunamiWarning, SevereThunderstormWarning.
     */
    hazardCode: string;
    /**
     * A severity/hazard index.
      0 - No hazard.
      1 - Be informed, be aware.
      2 - Pay attention, be prepared.
      3 - Take action.
      4 - Life threatening, emergency.
     */
    hazardIndex: number;
    /**
     * A displayable short phrase describing the forecasted conditions and precipitation intensity/type.
     */
    shortPhrase: string;
}
interface Hazards {
    /**
     * Details of the weather hazards affecting the trip.
     */
    hazardDetails: HazardDetail[];
    /**
     * A severity/hazard index.
      0 - No hazard.
      1 - Be informed, be aware.
      2 - Pay attention, be prepared.
      3 - Take action.
      4 - Life threatening, emergency.
     */
    maxHazardIndex: number;
}
interface Notification {
    /**
     * A unique identifier (non-displayable) for each type of hazard: LightRain, ModerateRain, HeavyRain, LightMix, ModerateMix, HeavyMix, LightSnow, ModerateSnow, HeavySnow, LightIce, ModerateIce, HeavyIce, Hail, LargeHail, SunGlare, SunGlareHigh, Lightning, SevereLightning, WindModerate, WindHigh, WindExtreme, FloodWarning, FlashFloodWarning, TornadoWarning, TsunamiWarning, SevereThunderstormWarning.
     */
    hazardCode: string;
    /**
     * A severity/hazard index.
      0 - No hazard.
      1 - Be informed, be aware.
      2 - Pay attention, be prepared.
      3 - Take action.
      4 - Life threatening, emergency.
     */
    hazardIndex: number;
    /**
     * A displayable short phrase describing the forecasted conditions and precipitation intensity/type.
     */
    shortPhrase: string;
    /**
     * A type of notification generated to warn drivers of the onset of a hazard, or increase in intensity of a hazard.
     */
    type: string;
}
/**
 * A rating that indicates how blinding the sun is for the driver.
 */
interface SunGlare {
    /**
     * If the vehicle heading value is not provided for a waypoint, then the service will calculate a heading based upon the location of neighboring waypoints if provided.
     */
    calculatedVehicleHeading: number;
    /**
     * An index from 0 to 100 indicating sun glare intensity for a driver. A value of 50 and above can be considered a hazard for some drivers and a value of 100 signifies the driver is driving straight into the sun and atmospheric conditions are clear allowing for the full intensity of the sun to blind the driver.
     */
    glareIndex: number;
}
interface Waypoint {
    /**
     * Percent representing cloud cover.
     */
    cloudCover: number;
    hazards: Hazards;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
    /**
     * Indicates the time of the day. True indicates 'day',', false indicates 'night.
     */
    isDayTime: boolean;
    /**
     * Estimation of thunderstorm intensity on an open scale. A value of 0 means there is no thunderstorm; values of 1 and higher mean there is a thunderstorm in increasing intensity.
     */
    lightningCount: number;
    notifications: Notification[];
    precipitation: WeatherAlongRoutePrecipitation;
    /**
     * A displayable short phrase describing the forecasted conditions and precipitation intensity/type.
     */
    shortPhrase: string;
    /**
     * A rating that indicates how blinding the sun is for the driver.
     */
    sunGlare: SunGlare;
    temperature: WeatherUnit;
    /**
     * Wind details being returned including speed and direction.
     */
    wind: Wind;
    /**
     * Wind details being returned including speed and direction.
     */
    windGust: Wind;
}
interface WeatherAlongRoutePrecipitation {
    /**
     * The forecasted precipitation intensity in dBZ (decibels relative to Z) from 0.0 to 100.0.
     */
    dbz: number;
    /**
     * Precipitation type. If precipitation should occur, the type that it will be: "RAIN," "HAIL," "SNOW," "ICE," or "MIX."
     */
    type: string;
}
/**
 * This object is returned from a successful Weather Along Route.
 */
interface WeatherAlongRouteResponse {
    summary: WeatherAlongRouteSummary;
    /**
     * Data for each waypoint returned in the same order as specified in the request.
     */
    waypoints: Waypoint[];
}
interface WeatherAlongRouteSummary {
    hazards: Hazards;
    /**
     * Numeric value representing an image that displays the iconPhrase.
     */
    iconCode: number;
}

declare enum ExtendedPostalCodes {
    AddressRanges = "Addr",
    Geographies = "Geo",
    PointAddresses = "PAD",
    PointOfIntereset = "POI",
    Streets = "Str",
    CrossStreets = "XStr"
}

interface SearchAddressOptionalParams {
    /**
     * Bottom right position of the bounding box. E.g. 37.553,-122.453
     */
    btmRight?: atlas.data.Position;
    /**
     * Country codes
     */
    countrySet?: string[];
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Latitude where results should be biased. E.g. 37.337
     */
    lat?: number;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Longitude where results should be biased. E.g. -121.89
     */
    lon?: number;
    /**
     * Starting offset of the returned results within the full result set. Default: 0, minimum: 0 and maximum: 1900
     */
    ofs?: number;
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     * Top left position of the bounding box. E.g. 37.553,-122.453
     */
    topLeft?: atlas.data.Position;
    /**
     * If the typeahead flag is set, the query will be interpreted as a partial input and the search will enter predictive mode
     */
    typeahead?: boolean;
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchAddressReverseOptionalParams {
    /**
     * Format of newlines in the formatted address.
     * If true, the address will contain newlines. If false, newlines will be converted to commas.
     */
    allowFreeformNewline?: boolean;
    /**
     * Specifies the level of filtering performed on geographies. Narrows the search for specified geography entity types, e.g. return only municipality. The resulting response will contain the geography ID as well as the entity type matched. If you provide more than one entity as a comma separated list, endpoint will return the 'smallest entity available'. Returned Geometry ID can be used to get the geometry of that geography via Get Search Polygon API. The following parameters are ignored when entityType is set:
     * heading
     * number
     * returnRoadUse
     * returnSpeedLimit
     * roadUse
     * returnMatchType
     */
    entityType?: atlas$1.Models.EntityType;
    /**
     * The directional heading of the vehicle in degrees, for travel along a segment of roadway. 0 is North, 90 is East and so on, values range from -360 to 360. The precision can include upto one decimal place
     */
    heading?: number;
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * If a number is sent in along with the request, the response may include the side of the street (Left/Right) and also an offset position for that number
     */
    number?: number;
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     * Include information on the type of match the geocoder achieved in the response.
     */
    returnMatchType?: boolean;
    /**
     * To enable return of the road use array for reverse geocodes at street level
     */
    returnRoadUse?: boolean;
    /**
     * To enable return of the posted speed limit
     */
    returnSpeedLimit?: boolean;
    /**
     * To restrict reverse geocodes to a certain type of road use
     */
    roadUse?: RoadUse[];
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}
declare enum RoadUse {
    LimitedAccess = "LimitedAccess",
    Arterial = "Arterial",
    Terminal = "Terminal",
    Ramp = "Ramp",
    Rotary = "Rotary",
    LocalStreet = "LocalStreet"
}

interface SearchAddressReverseCrossStreetOptionalParams {
    /**
     * The directional heading of the vehicle in degrees, for travel along a segment of roadway. 0 is North, 90 is East and so on, values range from -360 to 360. The precision can include upto one decimal place
     */
    heading?: number;
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     *
  The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchAddressStructuredOptionalParams {
    /**
     * The county for the structured address
     */
    countrySecondarySubdivision?: string;
    /**
     * The country subdivision portion of an address
     */
    countrySubdivision?: string;
    /**
     * The named area for the structured address
     */
    countryTertiarySubdivision: string;
    /**
     * The cross street name for the structured address
     */
    crossStreet?: string;
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * The municipality portion of an address
     */
    municipality?: string;
    /**
     * The municipality subdivision (sub/super city) for the structured address
     */
    municipalitySubdivision?: string;
    /**
     * Starting offset of the returned results within the full result set. Default: 0, minimum: 0 and maximum: 1900
     */
    ofs?: number;
    /**
     * The postal code portion of an address
     */
    postalCode?: string;
    /**
     * 	The street name portion of an address
     */
    streetName?: string;
    /**
     * The street number portion of an address
     */
    streetNumber?: string;
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

declare enum ConnectorSet {
    /**
     * These are the standard household connectors for a certain region. They are all AC single phase and the standard Voltage and standard Amperage
     */
    StandardHouseholdCountrySpecific = "StandardHouseholdCountrySpecific",
    /**
     * Type 1 connector as defined in the IEC 62196-2 standard. Also called Yazaki after the original manufacturer or SAE J1772 after the standard that first published it. Mostly used in combination with 120V single phase or up to 240V single phase infrastructure.
     */
    IEC62196Type1 = "IEC62196Type1",
    /**
     * Type 1 based combo connector as defined in the IEC 62196-3 standard. The connector is based on the Type 1 connector – as defined in the IEC 62196-2 standard – with two additional direct current (DC) contacts to allow DC fast charging.
     */
    IEC62196Type1CCS = "IEC62196Type1CCS",
    /**
     * Type 2 connector as defined in the IEC 62196-2 standard. Provided as a cable and plug attached to the charging point.
     */
    IEC62196Type2CableAttached = "IEC62196Type2CableAttached",
    /**
     * Type 2 connector as defined in the IEC 62196-2 standard. Provided as a socket set into the charging point.
     */
    IEC62196Type2Outlet = "IEC62196Type2Outlet",
    /**
     *  Type 2 based combo connector as defined in the IEC 62196-3 standard. The connector is based on the Type 2 connector – as defined in the IEC 62196-2 standard – with two additional direct current (DC) contacts to allow DC fast charging.
     */
    IEC62196Type2CCS = "IEC62196Type2CCS",
    /**
     * Type 3 connector as defined in the IEC 62196-2 standard. Also called Scame after the original manufacturer. Mostly used in combination with up to 240V single phase or up to 420V three phase infrastructure.
     */
    IEC62196Type3 = "IEC62196Type3",
    /**
     * CHAdeMO connector named after an association formed by the Tokyo Electric Power Company and industrial partners. Because of this is is also known as the TEPCO's connector. It supports fast DC charging.
     */
    Chademo = "Chademo",
    /**
     * Industrial Blue connector is a connector defined in the IEC 60309 standard. It is sometime referred to as by some combination of the standard, the color and the fact that is a single phase connector. The connector usually has the "P+N+E, 6h" configuration.
     */
    IEC60309AC1PhaseBlue = "IEC60309AC1PhaseBlue",
    /**
     * Industrial White connector is a DC connector defined in the IEC 60309 standard.
     */
    IEC60309DCWhite = "IEC60309DCWhite",
    /**
     * The Tesla connector is the regionally specific Tesla Supercharger connector. I.e. it refers to either Tesla's proprietary connector, sometimes referred to as Tesla Port mostly limited to North America or the modified Type 2 (DC over Type 2) in Europe.
     */
    Tesla = "Tesla"
}

interface SearchFuzzyOptionalParams {
    /**
     * List of brand names which could be used to restrict the result to specific brands. Item order does not matter. When multiple brands are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    brandSet?: string[];
    /**
     * Bottom right position of the bounding box. E.g. 37.553,-122.453
     */
    btmRight?: string;
    /**
     * List of category set IDs which could be used to restrict the result to specific Points of Interest categories. ID order does not matter. When multiple category identifiers are provided, only POIs that belong to (at least) one of the categories from the provided list will be returned.
     */
    categorySet?: number[];
    /**
     * List of connector types which could be used to restrict the result to Electric Vehicle Station supporting specific connector types. Item order does not matter. When multiple connector types are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    connectorSet?: ConnectorSet[];
    /**
     * Country codes
     */
    countrySet?: string[];
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * List of indexes which should be utilized for the search. Item order does not matter.
     */
    idxSet?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Latitude where results should be biased. E.g. 37.337
     */
    lat?: number;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Longitude where results should be biased. E.g. -121.89
     */
    lon?: number;
    /**
     * Maximum fuzziness level to be used. Default: 2, minimum: 1 and maximum: 4
     * Level 1 has no spell checking.
     * Level 2 uses normal n-gram spell checking. For example, query "restrant" can be matched to "restaurant."
     * Level 3 uses sound-like spell checking, and shingle spell checking. Sound-like spell checking is for "rstrnt" to "restaurant" matching. Shingle spell checking is for "mountainview" to "mountain view" matching.
     * Level 4 doesn’t add any more spell checking functions.
     * The search engine will start looking for a match on the level defined by minFuzzyLevel, and will stop searching at the level specified by maxFuzzyLevel.
     */
    maxFuzzyLevel?: number;
    /**
     * Minimum fuzziness level to be used. Default: 2, minimum: 1 and maximum: 4
     * Level 1 has no spell checking.
     * Level 2 uses normal n-gram spell checking. For example, query "restrant" can be matched to "restaurant."
     * Level 3 uses sound-like spell checking, and shingle spell checking. Sound-like spell checking is for "rstrnt" to "restaurant" matching. Shingle spell checking is for "mountainview" to "mountain view" matching.
     * Level 4 doesn’t add any more spell checking functions.
     * The search engine will start looking for a match on the level defined by minFuzzyLevel, and will stop searching at the level specified by maxFuzzyLevel.
     */
    minFuzzyLevel?: number;
    /**
     * Starting offset of the returned results within the full result set. Default: 0, minimum: 0 and maximum: 1900
     */
    ofs?: number;
    /**
     * Hours of operation for a POI (Points of Interest). The availability of hours of operation will vary based on the data available. Supported value: nextSevenDays
     */
    openingHours?: 'nextSevenDays';
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     * Top left position of the bounding box. E.g. 37.553,-122.453
     */
    topLeft?: string;
    /**
     * If the typeahead flag is set, the query will be interpreted as a partial input and the search will enter predictive mode
     */
    typeahead?: boolean;
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchNearbyOptionalParams {
    /**
     * List of brand names which could be used to restrict the result to specific brands. Item order does not matter. When multiple brands are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    brandSet?: string[];
    /**
     * List of category set IDs which could be used to restrict the result to specific Points of Interest categories. ID order does not matter. When multiple category identifiers are provided, only POIs that belong to (at least) one of the categories from the provided list will be returned.
     */
    categorySet?: number[];
    /**
     * List of connector types which could be used to restrict the result to Electric Vehicle Station supporting specific connector types. Item order does not matter. When multiple connector types are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    connectorSet?: ConnectorSet[];
    /**
     * Country codes
     */
    countrySet?: string[];
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Starting offset of the returned results within the full result set. Default: 0, minimum: 0 and maximum: 1900
     */
    ofs?: number;
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchPOIOptionalParams {
    /**
     * List of brand names which could be used to restrict the result to specific brands. Item order does not matter. When multiple brands are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    brandSet?: string[];
    /**
     * Bottom right position of the bounding box. E.g. 37.553,-122.453
     */
    btmRight?: string;
    /**
     * List of category set IDs which could be used to restrict the result to specific Points of Interest categories. ID order does not matter. When multiple category identifiers are provided, only POIs that belong to (at least) one of the categories from the provided list will be returned.
     */
    categorySet?: number[];
    /**
     * List of connector types which could be used to restrict the result to Electric Vehicle Station supporting specific connector types. Item order does not matter. When multiple connector types are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    connectorSet?: ConnectorSet[];
    /**
     * Country codes
     */
    countrySet?: string[];
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Latitude where results should be biased. E.g. 37.337
     */
    lat?: number;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Longitude where results should be biased. E.g. -121.89
     */
    lon?: number;
    /**
     * Starting offset of the returned results within the full result set. Default: 0, minimum: 0 and maximum: 1900
     */
    ofs?: number;
    /**
     * Hours of operation for a POI (Points of Interest). The availability of hours of operation will vary based on the data available. Supported value: nextSevenDays
     */
    openingHours?: 'nextSevenDays';
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     * Top left position of the bounding box. E.g. 37.553,-122.453
     */
    topLeft?: string;
    /**
     * If the typeahead flag is set, the query will be interpreted as a partial input and the search will enter predictive mode
     */
    typeahead?: boolean;
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchPOICategoryOptionalParams {
    /**
     * List of brand names which could be used to restrict the result to specific brands. Item order does not matter. When multiple brands are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    brandSet?: string[];
    /**
     * Bottom right position of the bounding box. E.g. 37.553,-122.453
     */
    btmRight?: string;
    /**
     * List of category set IDs which could be used to restrict the result to specific Points of Interest categories. ID order does not matter. When multiple category identifiers are provided, only POIs that belong to (at least) one of the categories from the provided list will be returned.
     */
    categorySet?: number[];
    /**
     * List of connector types which could be used to restrict the result to Electric Vehicle Station supporting specific connector types. Item order does not matter. When multiple connector types are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    connectorSet?: ConnectorSet[];
    /**
     * Country codes
     */
    countrySet?: string[];
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Latitude where results should be biased. E.g. 37.337
     */
    lat?: number;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Longitude where results should be biased. E.g. -121.89
     */
    lon?: number;
    /**
     * Starting offset of the returned results within the full result set. Default: 0, minimum: 0 and maximum: 1900
     */
    ofs?: number;
    /**
     * Hours of operation for a POI (Points of Interest). The availability of hours of operation will vary based on the data available. Supported value: nextSevenDays
     */
    openingHours?: 'nextSevenDays';
    /**
     * The radius in meters to for the results to be constrained to the defined area
     */
    radius?: number;
    /**
     * Top left position of the bounding box. E.g. 37.553,-122.453
     */
    topLeft?: string;
    /**
     * If the typeahead flag is set, the query will be interpreted as a partial input and the search will enter predictive mode
     */
    typeahead?: boolean;
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchPOICategoryTreeOptionalParams {
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, except NGT and NGT-Latn. Language tag is case insensitive. When data in specified language is not available for a specific field, default language is used (English).
     */
    language?: string;
}

/**
 * This object is returned from a successful POI Category Tree call
 */
interface SearchPOICategoryTreeResponse {
    /**
     * Categories array
     */
    poiCategories: SearchPOICategoryTreeResult[];
}
/**
 * POI category result
 */
interface SearchPOICategoryTreeResult {
    /**
     * Array of child category ids
     */
    childCategoryIds: number[];
    /**
     * Unique ID for the category. ID can be used to restrict search results to specific categories through other Search Service APIs, like Get Search POI.
     */
    id: string;
    /**
     * Name of the category
     */
    name: string;
    /**
     * Array of alternative names of the category
     */
    synonyms: string[];
}

interface SearchAlongRouteOptionalParams {
    /**
     * List of brand names which could be used to restrict the result to specific brands. Item order does not matter. When multiple brands are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    brandSet?: string[];
    /**
     * List of category set IDs which could be used to restrict the result to specific Points of Interest categories. ID order does not matter. When multiple category identifiers are provided, only POIs that belong to (at least) one of the categories from the provided list will be returned.
     */
    categorySet?: number[];
    /**
     * List of connector types which could be used to restrict the result to Electric Vehicle Station supporting specific connector types. Item order does not matter. When multiple connector types are provided, only results that belong to (at least) one of the provided list will be returned.
     */
    connectorSet?: ConnectorSet[];
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Hours of operation for a POI (Points of Interest). The availability of hours of operation will vary based on the data available. Supported value: nextSevenDays
     */
    openingHours?: 'nextSevenDays';
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

interface SearchInsideGeometryOptionalParams {
    /**
     * List of category set IDs which could be used to restrict the result to specific Points of Interest categories. ID order does not matter. When multiple category identifiers are provided, only POIs that belong to (at least) one of the categories from the provided list will be returned.
     */
    categorySet?: number[];
    /**
     * Indexes for which extended postal codes should be included in the results.
     */
    extendedPostalCodesFor?: ExtendedPostalCodes[];
    /**
     * List of indexes which should be utilized for the search. Item order does not matter.
     */
    idxSet?: ExtendedPostalCodes[];
    /**
     * Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used.
     */
    language?: string;
    /**
     * Maximum number of responses that will be returned. Default: 10, minimum: 1 and maximum: 100
     */
    limit?: number;
    /**
     * Hours of operation for a POI (Points of Interest). The availability of hours of operation will vary based on the data available. Supported value: nextSevenDays
     */
    openingHours?: 'nextSevenDays';
    /**
     * The View parameter specifies which set of geopolitically disputed content is returned via Azure Maps services, including borders and labels displayed on the map. The View parameter (also referred to as “user region parameter”) will show the correct maps for that country/region. By default, the View parameter is set to “Unified” even if you haven’t defined it in the request. It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. Alternatively, you have the option to set ‘View=Auto’, which will return the map data based on the IP address of the request. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country where maps, images and other data and third party content that you are authorized to access via Azure Maps is made available. Example: view=IN.
     */
    view?: string;
}

declare const setAzureMapsConfiguration: (configuration: AzureMapsConfiguration) => void;
declare class AzureMapsModule {
    static forRoot(configuration?: AzureMapsConfiguration): ModuleWithProviders<AzureMapsModule>;
    static forChild(configuration: AzureMapsConfiguration): ModuleWithProviders<AzureMapsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AzureMapsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AzureMapsModule, [typeof AzureMapDirective, typeof ZoomControlDirective, typeof PitchControlDirective, typeof CompassControlDirective, typeof StyleControlDirective, typeof HtmlMarkerDirective, typeof DrawingToolbarDirective, typeof SymbolLayerDirective, typeof BubbleLayerDirective, typeof LineLayerDirective, typeof PolygonLayerDirective, typeof PolygonExtrusionLayerDirective, typeof HeatmapLayerDirective, typeof ImageLayerDirective, typeof TileLayerDirective, typeof PopupDirective], never, [typeof AzureMapDirective, typeof ZoomControlDirective, typeof PitchControlDirective, typeof CompassControlDirective, typeof StyleControlDirective, typeof HtmlMarkerDirective, typeof DrawingToolbarDirective, typeof SymbolLayerDirective, typeof BubbleLayerDirective, typeof LineLayerDirective, typeof PolygonLayerDirective, typeof PolygonExtrusionLayerDirective, typeof HeatmapLayerDirective, typeof ImageLayerDirective, typeof TileLayerDirective, typeof PopupDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AzureMapsModule>;
}

declare class PipelineProvider {
    private readonly azureMapsConfiguration;
    constructor(azureMapsConfiguration: AzureMapsConfiguration);
    getPipeline(): atlas$1.Pipeline;
    static ɵfac: i0.ɵɵFactoryDeclaration<PipelineProvider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PipelineProvider>;
}

declare abstract class AtlasHttpService {
    protected readonly httpClient: HttpClient;
    private readonly _rootUrl;
    private readonly _apiVersion;
    constructor(httpClient: HttpClient);
    protected buildUrl(path: string): string;
}

declare class SearchService extends AtlasHttpService {
    constructor(httpClient: HttpClient);
    /**
     *
     *
     * **Address Geocoding** In many cases, the complete search service might be too much, for
     *
     * instance if you are only interested in traditional geocoding.
     *
     * Search can also be accessed for address look up exclusively.
     *
     * The geocoding is performed by hitting the geocode endpoint with just the address or
     *
     * partial address in question.
     *
     * The geocoding search index will be queried for everything above the street level data.
     *
     * No POIs will be returned.
     *
     * Note that the geocoder is very tolerant of typos and incomplete addresses.
     *
     * It will also handle everything from exact street addresses or street or intersections
     *
     * as well as higher level geographies such as city centers, counties, states etc.
     *
     * Uses the Get Search Address API: https://docs.microsoft.com/rest/api/maps/search/getsearchaddress
     *
     *
     *
     * @param query The address to search for (e.g., "1 Microsoft way, Redmond, WA").
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchAddress(query: string, options?: SearchAddressOptionalParams): Observable<atlas$1.Models.SearchAddressResponse>;
    /**
     *
     *
     * **Reverse Geocode to an Address** There may be times when you need to translate a
     *
     * coordinate (example: -122.3862, 37.786505) into a human understandable street address.
     *
     * Most often this is needed in tracking applications where you receive a GPS feed from the device or
     *
     * asset and wish to know what address where the coordinate is located.
     *
     * This endpoint will return address information for a given coordinate.
     *
     * Uses the Get Search Address Reverse API: https://docs.microsoft.com/rest/api/maps/search/getsearchaddressreverse
     *
     * @param position The position to reverse search,
     * a coordinate array of `[longitude, latitude]` e.g. `[-122.125679, 47.641268]`.
     * @param [options] The optional parameters
     * @param timeout Create a new Aborter instance with the given timeout (in ms).
     * @returns
     * @memberof SearchService
     */
    searchAddressReverse(position: GeoJSON.Position, options?: SearchAddressReverseOptionalParams): Observable<atlas$1.Models.SearchAddressReverseResponse>;
    /**
     *
     *
     * **Reverse Geocode to a Cross Street** There may be times when you need to translate a
     *
     * coordinate (example: -122.3862, 37.786505) into a human understandable cross street.
     *
     * Most often this is needed in tracking applications where you receive a GPS feed from the device or asset
     *
     * and wish to know what address where the coordinate is located.
     *
     * This endpoint will return cross street information for a given coordinate.
     *
     * Uses the Get Search Address Reverse Cross Street API: https://docs.microsoft.com/rest/api/maps/search/getsearchaddressreversecrossstreet
     *
     * @param position The position to reverse search,
     * a coordinate array of `[longitude, latitude]` e.g. `[-122.125679, 47.641268]`.
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchAddressReverseCrossStreet(position: GeoJSON.Position, options?: SearchAddressReverseCrossStreetOptionalParams): Observable<atlas$1.Models.SearchAddressReverseCrossStreetResponse>;
    /**
     *
     *
     * **Structured Address Geocoding** Azure Address Geocoding can also be accessed for
     *
     * structured address look up exclusively.
     *
     * The geocoding search index will be queried for everything above the street level data.
     *
     * No POIs will be returned. Note that the geocoder is very tolerant of typos and incomplete addresses.
     *
     * It will also handle everything from exact street addresses or street or intersections as well as
     *
     * higher level geographies such as city centers, counties, states etc.
     *
     * Uses the Get Search Address Structured API: https://docs.microsoft.com/rest/api/maps/search/getsearchaddressstructured
     *
     *
     *
     * @param countryCode The 2 or 3 letter
     * [ISO3166-1](https://www.iso.org/iso-3166-country-codes.html) country code portion of an address.
     * E.g. US.
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchAddressStructured(countryCode: string, options?: SearchAddressStructuredOptionalParams): Observable<atlas$1.Models.SearchAddressStructuredResponse>;
    /**
     *
     *
     * The Search Along Route endpoint allows you to perform a fuzzy search for POIs along a specified
     *
     * route.
     *
     * This search is constrained by specifying the `maxDetourTime` limiting measure.
     *
     * To send the route-points you will use a `body` which will contain the `route` object represented
     *
     * as a `GeoJSON LineString` type and the `Content-Type` header will be set to `application/json`.
     *
     * Each route-point in `route` is represented as a `GeoJSON Position` type i.e. an array where the
     *
     * _longitude_ value is followed by the _latitude_ value and the _altitude_ value is ignored.
     *
     * The `route` should contain at least 2 route-points.
     *
     * It is possible that original route will be altered, some of it's points may be skipped.
     *
     * If the route that passes through the found point is faster than the original one, the `detourTime` value in
     *
     * the response is negative.
     *
     * Uses the Post Search Along Route API: https://docs.microsoft.com/rest/api/maps/search/postsearchalongroute
     *
     *
     *
     * @param query The POI name to search for (e.g., "statue of liberty", "starbucks", "pizza").
     * @param maxDetourTime Maximum detour time of the point of interest in seconds. Max value is 3600 seconds
     * @param body This represents the route to search along and should be a
     * valid `GeoJSON LineString` type. Please refer to [RFC
     * 7946](https://tools.ietf.org/html/rfc7946#section-3.1.4) for details.
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchAlongRoute(query: string, maxDetourTime: number, body: atlas$1.Models.SearchAlongRouteRequestBody, options?: SearchAlongRouteOptionalParams): Observable<atlas$1.Models.SearchAlongRouteResponse>;
    /**
     *
     *
     * **Free Form Search** The basic default API is Free Form Search which handles the most
     *
     * fuzzy of inputs handling any combination of address or POI tokens.
     *
     * This search API is the canonical 'single line search'.
     *
     * The Free Form Search API is a seamless combination of POI search and geocoding.
     *
     * The API can also be weighted with a contextual position (lat./lon. pair), or
     *
     * fully constrained by a coordinate and radius, or it can be executed more generally without any
     *
     * geo biasing anchor point.
     *
     * We strongly advise you to use the 'countrySet' parameter to specify only the countries for
     *
     * which your application needs coverage, as the default behavior will be to search the entire world,
     *
     * potentially returning unnecessary results. E.g.: `countrySet`=US,FR. Please see [Search Coverage]
     *
     * (https://docs.microsoft.com/azure/location-based-services/geocoding-coverage) for
     *
     * a complete list of all the supported countries.
     *
     * Most Search queries default to `maxFuzzyLevel`=2 to gain performance and also reduce unusual results.
     *
     * This new default can be overridden as needed per request by passing in the query param `maxFuzzyLevel`=3 or 4.
     *
     * Uses the Get Search Fuzzy API: https://docs.microsoft.com/rest/api/maps/search/getsearchfuzzy
     *
     *
     *
     * @param query The applicable query string (e.g., "seattle", "pizza").
     * Can _also_ be specified as a coordinate array of `[longitude, latitude]` (e.g., `[-122.125679, 47.641268]`).
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchFuzzy(query: string | GeoJSON.Position, options?: SearchFuzzyOptionalParams): Observable<atlas$1.Models.SearchFuzzyResponse>;
    /**
     *
     *
     * The Search Geometry endpoint allows you to perform a free form search inside a single geometry
     *
     * or many of them.
     *
     * The search results that fall inside the geometry/geometries will be returned.
     *
     * The geographical features to be searched can be modeled as Polygon and/or Circle geometries
     *
     * represented using any one of the following `GeoJSON` types: **GeoJSON FeatureCollection**,
     *
     * The `geometry` can be represented as a `GeoJSON FeatureCollection` object.
     *
     * This is the recommended option if the geometry contains both Polygons and Circles.
     *
     * The `FeatureCollection` can contain a max of 50 `GeoJSON Feature` objects.
     *
     * Each `Feature` object should represent either a Polygon or a Circle with the following conditions:
     *
     * A `Feature` object for the Polygon geometry can have a max of 50 coordinates and it's properties must be empty.
     *
     * A `Feature` object for the Circle geometry is composed of a _center_ represented using a `GeoJSON Point` type and a _radius_ value
     *
     * (in meters) which must be specified in the object's properties along with the _subType_ property
     *
     * whose value should be 'Circle'.
     *
     * Please see the Examples section below for a sample `FeatureCollection` representation.
     *
     * **GeoJSON GeometryCollection**, The `geometry` can be represented as a `GeoJSON GeometryCollection` object.
     *
     * This is the recommended option if the geometry contains a list of Polygons only.
     *
     * The `GeometryCollection` can contain a max of 50 `GeoJSON Polygon` objects.
     *
     * Each `Polygon` object can have a max of 50 coordinates.
     *
     * Please see the Examples section below for a sample `GeometryCollection` representation.
     *
     * **GeoJSON Polygon**, The `geometry` can be represented as a `GeoJSON Polygon` object.
     *
     * This is the recommended option if the geometry contains a single Polygon.
     *
     * The `Polygon` object can have a max of 50 coordinates.
     *
     * Uses the Post Search Inside Geometry API: https://docs.microsoft.com/rest/api/maps/search/postsearchinsidegeometry
     *
     * @param query The applicable query string (e.g., "seattle", "pizza").
     * @param body This represents the geometry for one or more geographical
     * features (parks, state boundary etc.) to search in and should be a GeoJSON compliant type.
     * Please refer to [RFC 7946](https://tools.ietf.org/html/rfc7946) for details.
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchInsideGeometry(query: string, body: atlas$1.Models.SearchInsideGeometryRequestBody, options?: SearchInsideGeometryOptionalParams): Observable<atlas$1.Models.SearchPostSearchInsideGeometryResponse>;
    /**
     *
     *
     * **Nearby Search** If you have a use case for only retrieving POI results around a
     *
     * specific location, the nearby search method may be the right choice.
     *
     * This endpoint will only return POI results, and does not take in a search query parameter.
     *
     * Uses the Get Search Nearby API: https://docs.microsoft.com/rest/api/maps/search/getsearchnearby
     *
     *
     *
     * @param location Location where results should be biased.
     * Should be an array of `[longitude, latitude]`, E.g. `[-121.89, 37.337]`.
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchNearby(location: GeoJSON.Position, options?: SearchNearbyOptionalParams): Observable<atlas$1.Models.SearchNearbyResponse>;
    /**
     *
     *
     * **Get POI by Name** If your search use case only requires POI results, you may use the
     *
     * POI endpoint for searching.
     *
     * This endpoint will only return POI results.
     *
     * Uses the Get Search POI API: https://docs.microsoft.com/rest/api/maps/search/getsearchpoi
     *
     *
     *
     * @param query The POI name to search for (e.g., "statue of liberty", "starbucks").
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchPOI(query: string, options?: SearchPOIOptionalParams): Observable<atlas$1.Models.SearchPoiResponse>;
    /**
     *
     *
     * **Get POI by Category** If your search use case only requires POI results filtered by
     *
     * category, you may use the category endpoint.
     *
     * This endpoint will only return POI results which are categorized as specified.
     *
     * List of available categories can be found [here](https://docs.microsoft.com/azure/azure-maps/search-categories).
     *
     * Uses the Get Search POI Category API: https://docs.microsoft.com/rest/api/maps/search/getsearchpoicategory
     *
     *
     *
     * @param query The POI category to search for (e.g., "AIRPORT", "BEACH").
     * @param [options] The optional parameters
     * @returns
     * @memberof SearchService
     */
    searchPOICategory(query: string, options?: SearchPOICategoryOptionalParams): Observable<atlas$1.Models.SearchPoiCategoryResponse>;
    /**
     *
     *
     * POI Category API provides a full list of supported Points of Interest (POI) categories and subcategories together with their translations and synonyms. The returned content can be used to provide more meaningful results through other Search Service APIs, like Get Search POI.
     *
     *
     *
     * @param [options] The optional parameters.
     * @returns
     * @memberof SearchService
     */
    searchPOICategoryTree(options?: SearchPOICategoryTreeOptionalParams): Observable<SearchPOICategoryTreeResponse>;
    /**
     *
     *
     * The Search Polygon API allows you to request the geometry data such as a city or country
     *
     * outline for a set of entities, previously retrieved from an Online Search request in GeoJSON
     *
     * format. The geometry  ID is returned in the dataSources object under "geometry" and "id" in
     *
     * either a Search Address or Search Fuzzy call.
     *
     *
     *
     * Please note that any geometry ID retrieved from an Online Search endpoint has a limited
     *
     * lifetime. The client  should not store geometry IDs in persistent storage for later referral, as
     *
     * the stability of these identifiers is  not guaranteed for a long period of time. It is expected
     *
     * that a request to the Polygon method is made within a  few minutes of the request to the Online
     *
     * Search method that provided the ID. The service allows for batch  requests up to 20 identifiers.
     *
     *
     *
     * Uses the Get Search Polygon API: https://docs.microsoft.com/rest/api/maps/search/getsearchpolygon
     *
     *
     *
     * @param geometries List of geometry UUIDs, previously retrieved from an Online
     * Search request.
     * @returns
     * @memberof SearchService
     */
    searchPolygons(geometries: string[]): Observable<atlas$1.Models.SearchPolygonResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
}

declare class RouteService {
    private readonly _routeUrl;
    private readonly _defaultTimeout;
    constructor(pipelineProvider: PipelineProvider);
    /**
     *
     *
     * Returns  a route between an origin and a destination, passing through waypoints if they are
     *
     * specified. The route will take into account factors such as current traffic and the typical road
     *
     * speeds on the requested day of the week and time of day.
     *
     *
     *
     * Information returned includes the distance, estimated travel time, and a representation of the
     *
     * route geometry. Additional routing information such as optimized waypoint order or turn by turn
     *
     * instructions is also available, depending on the options selected.
     *
     *
     *
     * Routing service provides a set of parameters for a detailed description of vehicle-specific
     *
     * Consumption Model. Please check [Consumption
     *
     * Model](https://docs.microsoft.com/azure/azure-maps/consumption-model) for detailed explanation
     *
     * of the concepts and parameters involved.
     *
     *
     *
     * If `options.postBody` is specified uses the Post Route Directions API: https://docs.microsoft.com/rest/api/maps/route/postroutedirections
     *
     *
     *
     * Otherwise uses the Get Route Directions API: https://docs.microsoft.com/rest/api/maps/route/getroutedirections
     *
     *
     *
     * @param aborter Create a new Aborter instance with Aborter.none or Aborter.timeout(),
     * goto documents of Aborter for more examples about request cancellation.
     * @param coordinates An array of coordinates through which the route is calculated.
     * Each coordinate is an array of `[longitude, latitude]`. A minimum of two coordinates is required.
     * The first one is the origin and the last is the destination of the route.
     * Optional coordinates in-between act as WayPoints in the route. You can pass up to 150 WayPoints.
     * @param [options]
     * @returns
     * @memberof RouteURL
     */
    calculateRouteDirections(coordinates: GeoJSON.Position[], options?: atlas$1.CalculateRouteDirectionsOptions, timeout?: number): Promise<atlas$1.CalculateRouteDirectionsResponse>;
    /**
     *
     *
     * Calculate a set of locations that can be reached from the origin point based
     *
     * on fuel, energy,  or time budget that is specified. A polygon boundary (or Isochrone) is
     *
     * returned in a counterclockwise  orientation as well as the precise polygon center which was the
     *
     * result of the origin point.
     *
     *
     *
     * The returned polygon can be used for further processing such as  [Search Inside
     *
     * Geometry](https://docs.microsoft.com/rest/api/maps/search/getsearchinsidegeometry) to
     *
     * search for POIs within the provided Isochrone.
     *
     *
     *
     * Uses the Get Route Range API: https://docs.microsoft.com/rest/api/maps/route/getrouterange
     *
     *
     *
     * @param aborter Create a new Aborter instance with Aborter.none or Aborter.timeout(),
     * goto documents of Aborter for more examples about request cancellation.
     * @param center The coordinate from which the range calculation should start.
     * @param [options] The optional parameters
     * @returns
     * @memberof RouteURL
     */
    calculateRouteMatrix(body: atlas$1.Models.RouteMatrixRequestBody, options?: atlas$1.Models.RoutePostRouteMatrixPreviewOptionalParams, timeout?: number): Promise<atlas$1.CalculateRouteMatrixResponse>;
    /**
     *
     *
     * **Note: This API is currently in preview and may be subject to breaking changes.**
     *
     * Calculates a matrix of route summaries for a set of routes
     *
     * defined by origin and destination locations. For every given origin, this service calculates the
     *
     * cost of routing from that origin to every given destination. The set of origins and the set of
     *
     * destinations can be thought of as the column and row headers of a table and each cell in the
     *
     * table contains the costs of routing from the origin to the destination for that cell. For each
     *
     * route, the travel times and distances are calculated. You can use the computed costs to
     *
     * determine which routes to calculate using the Routing Directions API. If waitForResults
     *
     * parameter in the request is set to false (default value), this API returns a 202 response code
     *
     * along a redirect URL in the Location field of the response header. This URL should be checked
     *
     * periodically until the response data or error information is available.
     *
     *
     *
     * The maximum size of a matrix for this API is 700 (the number of origins  multiplied by the
     *
     * number of destinations). With that constraint in mind,  examples of possible matrix dimensions
     *
     * are: 50x10, 10x10, 28x25. 10x70  (it does not need to be square).
     *
     *
     *
     * Calculating a route matrix is considered a long running operation.
     *
     * A long running operations implies that after the initial request is accepted (HTTP 202)
     *
     * the final result will be polled for until available.
     *
     * Each poll request restarts the aborter's timeout, if one was specified.
     *
     *
     *
     * Uses the Post Route Matrix API: https://docs.microsoft.com/rest/api/maps/route/postroutematrixpreview
     *
     *
     *
     * @param aborter Create a new Aborter instance with Aborter.none or Aborter.timeout(),
     * goto documents of Aborter for more examples about request cancellation.
     * @param body The matrix of origin and destination coordinates to compute the route
     * distance, travel time and other summary for each cell of the matrix based on the input
     * parameters. The minimum and the maximum cell count supported are 1 and 700 respectively. For
     * example, it can be 35 origins and 20 destinations or 25 origins and 25 destinations.
     * @param [options] The optional parameters
     * @returns
     * @memberof RouteURL
     */
    calculateRouteRange(center: GeoJSON.Position, options?: atlas$1.Models.RouteGetRouteRangeOptionalParams, timeout?: number): Promise<atlas$1.Response<atlas$1.Models.RouteRangeResponse, atlas$1.Models.RouteGetRouteRangeResponse, atlas$1.RouteRangeGeojson>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RouteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RouteService>;
}

declare class WeatherService extends AtlasHttpService {
    constructor(httpClient: HttpClient);
    /**
     * Get Current Conditions service returns detailed current weather conditions such as precipitation, temperature and wind for a given coordinate location.
     * Also, observations from the past 6 or 24 hours for a particular location can be retrieved.
     * The basic information returned with the response include details such as observation date and time, brief description of the weather conditions, weather icon, precipitation indicator flags, and temperature.
     * Additional details such as RealFeel™ Temperature and UV index are also returned.
     *
     * @param latitude Latitude
     * @param longitude Longitude
     * @param details Return full details for the current conditions. Available values are
                      - true - Returns full details. By default all details are returned.
                      - false - Returns a truncated version of the current condition data, which includes observation date time, weather phrase, icon code, precipitation indicator flag, and temperature.
     * @param duration Time frame of the returned weather conditions. By default, the most current weather conditions will be returned. Default value is 0. Supported values are:
                      0 - Return the most current weather conditions.
                      6 - Return weather conditions from past 6 hours.
                      24 - Return weather conditions from past 24 hours.
     * @param language Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used. Default value is en-us.
     * @param unit Specifies to return the data in either metric units or imperial units. Default value is metric.
     */
    getCurrentConditions(latitude: number, longitude: number, details?: boolean, duration?: 0 | 6 | 24, language?: string, unit?: Unit): Observable<CurrentConditionsResponse>;
    /**
     * The service returns detailed weather forecast such as temperature and wind by day for the next 1, 5, 10, 15, 25, or 45 days for a given coordinate location. The response include details such as temperature, wind, precipitation, air quality, and UV index.
     *
     * @param latitude Latitude
     * @param longitude Longitude
     * @param duration Specifies for how many days the daily forecast responses are returned. Available values are
                        1 - Return forecast data for the next day. Returned by default.
                        5 - Return forecast data for the next 5 days.
                        10 - Return forecast data for the next 10 days.
                        25 - Return forecast data for the next 25 days. Only available in S1 SKU.
                        45 - Return forecast data for the next 45 days. Only available in S1 SKU.
     * @param language Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used. Default value is en-us.
     * @param unit Specifies to return the data in either metric units or imperial units. Default value is metric.
     */
    getDailyForecast(latitude: number, longitude: number, duration?: 1 | 5 | 10 | 25 | 45, language?: string, unit?: Unit): Observable<DailyForecastResponse>;
    /**
     * Request detailed weather forecast by the hour for the next 1, 12, 24 (1 day), 72 (3 days), 120 (5 days), and 240 hours (10 days) for the given the given coordinate location. The API returns details such as temperature, humidity, wind, precipitation, and ultraviolet (UV) index.
     *
     * @param latitude Latitude
     * @param longitude Longitude
     * @param duration Time frame of the returned weather forecast. By default, the forecast data for next hour will be returned. Available values are
                        1 - Return forecast data for the next hour. Default value.
                        12 - Return hourly forecast for next 12 hours.
                        24 - Return hourly forecast for next 24 hours.
                        72 - Return hourly forecast for next 72 hours (3 days).
                        120 - Return hourly forecast for next 120 hours (5 days). Only available in S1 SKU.
                        240 - Return hourly forecast for next 240 hours (10 days). Only available in S1 SKU.
     * @param language Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used. Default value is en-us.
     * @param unit Specifies to return the data in either metric units or imperial units. Default value is metric.
     */
    getHourlyForecast(latitude: number, longitude: number, duration?: 1 | 12 | 24 | 72 | 120 | 240, language?: string, unit?: Unit): Observable<HourlyForecastResponse>;
    /**
     * Get Minute Forecast service returns minute-by-minute forecasts for a given location for the next 120 minutes. Users can request weather forecasts in the interval of 1, 5 and 15 minutes. The response will include details such as the type of precipitation (including rain, snow, or a mixture of both), start time, and precipitation intensity value (dBZ).
     *
     * @param latitude Latitude
     * @param longitude Longitude
     * @param interval Specifies time interval in minutes for the returned weather forecast. Supported values are
                      1 - Retrieve forecast for 1-minute intervals. Returned by default.
                      5 - Retrieve forecasts for 5-minute intervals.
                      15 - Retrieve forecasts for 15-minute intervals.
     * @param language Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used. Default value is en-us.
     */
    getMinuteForecast(latitude: number, longitude: number, interval?: 1 | 5 | 15, language?: string): Observable<MinuteForecastResponse>;
    /**
     * Service returns detailed weather forecast by quarter-day for the next 1, 5, 10, or 15 days for a given location. Response data is presented by quarters of the day - morning, afternoon, evening, and overnight. Details such as temperature, humidity, wind, precipitation, and UV index are returned.Service returns detailed weather forecast by quarter-day for the next 1, 5, 10, or 15 days for a given location. Response data is presented by quarters of the day - morning, afternoon, evening, and overnight. Details such as temperature, humidity, wind, precipitation, and UV index are returned.
     *
     * @param latitude Latitude
     * @param longitude Longitude
     * @param duration Specifies for how many days the quester-day forecast responses are returned. Supported values are:
                        1 - Return forecast data for the next day. Returned by default.
                        5 - Return forecast data for the next 5 days.
                        10 - Return forecast data for next 10 days.
                        15 - Return forecast data for the next 15 days.
     * @param language Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used. Default value is en-us.
     * @param unit Specifies to return the data in either metric units or imperial units. Default value is metric.
     */
    getQuarterDayForecast(latitude: number, longitude: number, duration?: 1 | 5 | 10 | 15, language?: string, unit?: Unit): Observable<QuarterDayForecastResponse>;
    /**
     * Weather along a route API returns hyper local (one kilometer or less), up-to-the-minute weather nowcasts, weather hazard assessments, and notifications along a route described as a sequence of waypoints. This includes a list of weather hazards affecting the waypoint or route, and the aggregated hazard index for each waypoint might be used to paint each portion of a route according to how safe it is for the driver. When submitting the waypoints, it is recommended to stay within, or close to, the distance that can be traveled within 120-mins or shortly after. Data is updated every five minutes.
      The service supplements Azure Maps Route Service that allows you to first request a route between an origin and a destination and use that as an input for Weather Along Route endpoint.
      In addition, the service supports scenarios to generate weather notifications for waypoints that experience an increase in intensity of a weather hazard. For example, if the vehicle is expected to begin experiencing heavy rain as it reaches a waypoint, a weather notification for heavy rain will be generated for that waypoint allowing the end product to display a heavy rain notification before the driver reaches that waypoint. The trigger for when to display the notification for a waypoint could be based, for example, on a geofence, or selectable distance to the waypoint.
      The API covers all regions of the planet except latitudes above Greenland and Antarctica.
     *
     * @param waypoints Coordinates through which the route is calculated, separated by colon (:) and entered in chronological order. A minimum of two waypoints is required. A single API call may contain up to 60 waypoints. A waypoint indicates location, ETA, and optional heading.
     * @param language Language in which search results should be returned. Should be one of supported IETF language tags, case insensitive. When data in specified language is not available for a specific field, default language is used. Default value is en-us.
     */
    getWeatherAlongRoute(waypoints: WaypointInput[], language?: string): Observable<WeatherAlongRouteResponse>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WeatherService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WeatherService>;
}

export { AZUREMAPS_CONFIG, AzureMapDirective, AzureMapsConfiguration, AzureMapsModule, BubbleLayerDirective, CompassControlDirective, ConnectorSet, DrawingToolbarDirective, ExtendedPostalCodes, HeatmapLayerDirective, HtmlMarkerDirective, ImageLayerDirective, LineLayerDirective, PitchControlDirective, PolygonExtrusionLayerDirective, PolygonLayerDirective, PopupDirective, RoadUse, RouteService, SearchService, StyleControlDirective, SymbolLayerDirective, TileLayerDirective, WeatherService, ZoomControlDirective, setAzureMapsConfiguration };
export type { AirAndPollen, Color, CurrentConditions, CurrentConditionsResponse, DailyForecast, DailyForecastResponse, DailyForecastSummary, DayOrNight, DegreeDaySummary, HazardDetail, Hazards, HourlyForecast, HourlyForecastResponse, ILayerEvent, IMapEvent, IMarkerEvent, IPopupEvent, Interval, IntervalSummary, LocalSource, MinuteForecastResponse, MinuteForecastSummary, Notification, Past12Hours, Past24Hours, Past6Hours, PrecipitationSummary, PressureTendency, Quarter, QuarterDayForecast, QuarterDayForecastResponse, SearchAddressOptionalParams, SearchAddressReverseCrossStreetOptionalParams, SearchAddressReverseOptionalParams, SearchAddressStructuredOptionalParams, SearchAlongRouteOptionalParams, SearchFuzzyOptionalParams, SearchInsideGeometryOptionalParams, SearchNearbyOptionalParams, SearchPOICategoryOptionalParams, SearchPOICategoryTreeOptionalParams, SearchPOICategoryTreeResponse, SearchPOICategoryTreeResult, SearchPOIOptionalParams, SunGlare, TemperatureSummary, Unit, Waypoint, WaypointInput, WeatherAlongRoutePrecipitation, WeatherAlongRouteResponse, WeatherAlongRouteSummary, WeatherUnit, WeatherUnitRange, Wind, WindDirection, WindSpeed };