@progress/kendo-angular-map 24.2.2 → 25.0.0-develop.2

package/index.d.ts

@@ -2,16 +2,1509 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { BubbleLayerComponent } from './map/bubble-layer.component';
-export { MapComponent } from './map.component';
-export { MapModule } from './map.module';
-export { MarkerLayerComponent } from './map/marker-layer.component';
-export { ShapeLayerComponent } from './map/shape-layer.component';
-export { TileLayerComponent } from './map/tile-layer.component';
-export { LayersComponent } from './map/layers.component';
-export { LayerTooltipComponent } from './map/layer/tooltip.component';
-export * from './events';
-export * from './tooltip';
-export { bodyFactory } from './tooltip/body-factory';
-export { MapLayer, MapLayerOptions, MapMarker, BubbleLayerSymbolArgs, BubbleLayerSymbol, MapControls, MapControlsPosition, TileUrlTemplateArgs, Location, Extent } from '@progress/kendo-charts';
-export * from './directives';
+import { DomSanitizer } from '@angular/platform-browser';
+import { MapLayerType, Extent, BubbleLayerOptions, BubbleLayerSymbol, InstanceObserver, MapBeforeResetEvent, MapClickEvent as MapClickEvent$1, Location, MapMarkerActivateEvent, MapMarker, MapLayer, MapMarkerClickEvent, MapMarkerCreatedEvent, MapPanEndEvent, MapPanEvent, MapResetEvent, MapShapeClickEvent, MapShapeCreatedEvent, MapShapeFeatureCreatedEvent, MapShapeMouseEnterEvent, MapShapeMouseLeaveEvent, MapZoomEndEvent, MapZoomStartEvent, MapControls, Map, MarkerLayerOptions, ShapeLayerOptions, TileLayerOptions, TileUrlTemplateArgs } from '@progress/kendo-charts';
+export { BubbleLayerSymbol, BubbleLayerSymbolArgs, Extent, Location, MapControls, MapControlsPosition, MapLayer, MapLayerOptions, MapMarker, TileUrlTemplateArgs } from '@progress/kendo-charts';
+import { ShapeOptions, Element, Group, geometry } from '@progress/kendo-drawing';
+import { Observable, BehaviorSubject, Subscription } from 'rxjs';
+import * as i0 from '@angular/core';
+import { NgZone, OnChanges, OnDestroy, SimpleChange, TemplateRef, ViewContainerRef, EventEmitter, AfterViewInit, AfterViewChecked, ElementRef, ChangeDetectorRef, Renderer2, AfterContentChecked, AfterContentInit, QueryList } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { PopupService, PopupSettings as PopupSettings$1 } from '@progress/kendo-angular-popup';
+import { IconsService, IconSettings } from '@progress/kendo-angular-icons';
+
+/**
+ * @hidden
+ */
+interface Item {
+    index: number;
+    options: any;
+}
+/**
+ * @hidden
+ */
+declare class ItemChange {
+    sender: Item;
+    options: any;
+    constructor(sender: Item, options: any);
+}
+/**
+ * @hidden
+ */
+declare class CollectionService {
+    itemChanges: Observable<ItemChange>;
+    private source;
+    constructor();
+    notify(change: ItemChange): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CollectionService>;
+}
+
+/**
+ * @hidden
+ */
+declare class Change {
+    key: string;
+    value: any;
+    constructor(key: string, value: any);
+}
+/**
+ * @hidden
+ */
+declare class ConfigurationService {
+    protected ngZone: NgZone;
+    changes: Observable<any>;
+    store: any;
+    protected source: BehaviorSubject<any>;
+    constructor(ngZone: NgZone);
+    protected initSource(): void;
+    push(store: any): void;
+    notify(change: Change): void;
+    protected set(field: string, value: any): void;
+    protected next(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class CollectionItemComponent implements Item, OnChanges, OnDestroy {
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    protected subscription: Subscription;
+    index: number;
+    options: any;
+    constructor(configurationService: ConfigurationService, collectionService: CollectionService);
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    /**
+     * Updates the component fields with the specified values and refreshes the Chart.
+     *
+     * Use this method when the configuration values cannot be set through the template.
+     *
+     * @example
+     * ```ts-no-run
+     * item.notifyChanges({ visible: true });
+     * ```
+     *
+     * @param changes An object containing the updated input fields.
+     */
+    notifyChanges(changes: any): void;
+    ngOnDestroy(): void;
+    protected notify(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionItemComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CollectionItemComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class SettingsComponent implements OnChanges, OnDestroy {
+    protected configKey: string;
+    configurationService: ConfigurationService;
+    protected store: any;
+    constructor(configKey: string, configurationService: ConfigurationService);
+    ngOnDestroy(): void;
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    /**
+     * Updates the component fields with the specified values and refreshes the component.
+     *
+     * Use this method when the configuration values cannot be set through the template.
+     *
+     * @example
+     * ```ts-no-run
+     * item.notifyChanges({ visible: true });
+     * ```
+     *
+     * @param changes An object containing the updated input fields.
+     */
+    notifyChanges(changes: any): void;
+    protected markAsVisible(): void;
+    private notify;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SettingsComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The configuration options of the Map layer tooltip.
+ *
+ * @hidden
+ */
+declare class LayerTooltipComponent extends SettingsComponent {
+    configurationService: ConfigurationService;
+    layerTooltipTemplate: TemplateRef<any>;
+    constructor(configurationService: ConfigurationService);
+    get layerTooltipTemplateRef(): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerTooltipComponent, "kendo-map-layer-tooltip", never, {}, {}, ["layerTooltipTemplate"], never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class LayerComponent extends CollectionItemComponent {
+    protected type: MapLayerType;
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    protected sanitizer: DomSanitizer;
+    /**
+     * @hidden
+     */
+    attribution: string;
+    /**
+     * @hidden
+     */
+    extent?: Extent | [[number, number], [number, number]];
+    /**
+     * @hidden
+     */
+    maxZoom?: number;
+    /**
+     * @hidden
+     */
+    minZoom?: number;
+    /**
+     * @hidden
+     */
+    opacity?: number;
+    /**
+     * @hidden
+     */
+    zIndex: number;
+    layerTooltip: LayerTooltipComponent;
+    constructor(type: MapLayerType, configurationService: ConfigurationService, collectionService: CollectionService, sanitizer: DomSanitizer);
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    get layerTooltipTemplateRef(): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayerComponent, never, never, { "attribution": { "alias": "attribution"; "required": false; }; "extent": { "alias": "extent"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; }, {}, ["layerTooltip"], never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI BubbleLayer component for Angular. Displays data as bubbles on vector shape layers for bubble maps.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-bubble-layer
+ *         [data]="bubbleData"
+ *         locationField="location"
+ *         valueField="population"
+ *         [maxSize]="50"
+ *         [minSize]="10">
+ *       </kendo-map-bubble-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public bubbleData = [
+ *     { location: [40.7128, -74.0060], population: 8000000 }
+ *   ];
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link BubbleTooltipComponent}.
+ */
+declare class BubbleLayerComponent extends LayerComponent implements BubbleLayerOptions {
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    protected sanitizer: DomSanitizer;
+    /**
+     * Sets the array of data items for this layer.
+     */
+    data?: any[];
+    /**
+     * Sets the data item field which contains the symbol location.
+     * The field should be an array with two numbers &mdash; latitude and longitude in decimal degrees.
+     */
+    locationField?: string;
+    /**
+     * Sets the value field for the symbols used to determine their relative size.
+     * The data item field should be a number.
+     */
+    valueField?: string;
+    /**
+     * Sets the symbol to use for bubble layers.
+     */
+    symbol?: BubbleLayerSymbol;
+    /**
+     * Sets the default style for symbols.
+     */
+    style?: ShapeOptions;
+    /**
+     * Sets the maximum symbol size for bubble layer symbols.
+     *
+     * @default 100
+     */
+    maxSize?: number;
+    /**
+     * Sets the minimum symbol size for bubble layer symbols.
+     * Setting a non-zero value will distort the symbol area to value ratio.
+     *
+     * @default 0
+     */
+    minSize?: number;
+    constructor(configurationService: ConfigurationService, collectionService: CollectionService, sanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BubbleLayerComponent, "kendo-map-bubble-layer", never, { "data": { "alias": "data"; "required": false; }; "locationField": { "alias": "locationField"; "required": false; }; "valueField": { "alias": "valueField"; "required": false; }; "symbol": { "alias": "symbol"; "required": false; }; "style": { "alias": "style"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "minSize": { "alias": "minSize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class MapInstanceObserver extends InstanceObserver {
+    protected handlerMap: any;
+    constructor(instance: any);
+}
+
+/**
+ * @hidden
+ */
+declare abstract class BaseEvent {
+    /**
+     * The `MapComponent` that triggered the event.
+     */
+    sender: MapComponent;
+    /**
+     * @hidden
+     */
+    constructor(sender: MapComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseEvent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseEvent, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Arguments for the `beforeReset` event.
+ * Fires immediately before the map resets. Layer implementers typically use this event for cleanup.
+ */
+declare class BeforeResetEvent extends BaseEvent implements MapBeforeResetEvent {
+    /**
+     * @hidden
+     */
+    constructor(_: any, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `mapClick` event.
+ * Fires when you click on the map.
+ */
+declare class MapClickEvent extends BaseEvent implements MapClickEvent$1 {
+    /**
+     * The location of the clicked point.
+     */
+    location: Location;
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapClickEvent$1, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `markerActivate` event.
+ * Fires when a marker displays and has a DOM element assigned.
+ */
+declare class MarkerActivateEvent extends BaseEvent implements MapMarkerActivateEvent {
+    /**
+     * The marker instance.
+     */
+    marker: MapMarker;
+    /**
+     * The marker layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * @hidden
+     */
+    constructor(e: MapMarkerActivateEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `markerClick` event.
+ * Fires when the user clicks or taps a marker.
+ */
+declare class MarkerClickEvent extends BaseEvent implements MapMarkerClickEvent {
+    /**
+     * The marker instance.
+     */
+    marker: MapMarker;
+    /**
+     * The marker layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * @hidden
+     */
+    constructor(e: MapMarkerClickEvent, sender: MapComponent);
+}
+
+/**
+ * @hidden
+ */
+declare abstract class PreventableEvent extends BaseEvent {
+    private prevented;
+    /**
+     * Prevents the default action for a specified event.
+     * In this way, the source component suppresses
+     * the built-in behavior that follows the event.
+     */
+    preventDefault(): void;
+    /**
+     * Returns `true` if the event was prevented
+     * by any of its subscribers.
+     *
+     * @returns `true` if the default action was prevented.
+     * Otherwise, returns `false`.
+     */
+    isDefaultPrevented(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventableEvent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventableEvent, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Arguments for the `markerCreated` event.
+ * Fires once the map has created a marker, and just before the map displays it.
+ *
+ * Cancelling the event prevents displaying the marker.
+ */
+declare class MarkerCreatedEvent extends PreventableEvent implements MapMarkerCreatedEvent {
+    /**
+     * The marker instance.
+     */
+    marker: MapMarker;
+    /**
+     * The marker layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * @hidden
+     */
+    constructor(e: MapMarkerCreatedEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `panEnd` event.
+ * Fires after the map viewport completes panning.
+ */
+declare class PanEndEvent extends BaseEvent implements MapPanEndEvent {
+    /**
+     * The map origin (top left or NW corner).
+     */
+    origin: Location;
+    /**
+     * The current map center.
+     */
+    center: Location;
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapPanEndEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `pan` event.
+ * Fires while the map viewport is being moved.
+ */
+declare class PanEvent extends BaseEvent implements MapPanEvent {
+    /**
+     * The map origin (top left or NW corner).
+     */
+    origin: Location;
+    /**
+     * The current map center.
+     */
+    center: Location;
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapPanEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `reset` event.
+ * Fires when the map resets.
+ *
+ * This typically occurs on initial load and after a zoom/center change.
+ */
+declare class ResetEvent extends BaseEvent implements MapResetEvent {
+    /**
+     * @hidden
+     */
+    constructor(_: any, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `shapeClick` event.
+ * Fires when a shape is clicked or tapped.
+ */
+declare class ShapeClickEvent extends BaseEvent implements MapShapeClickEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeClickEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `shapeCreated` event.
+ * Fires when a shape is created, but is not rendered yet.
+ */
+declare class ShapeCreatedEvent extends BaseEvent implements MapShapeCreatedEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The original data item for this Shape.
+     */
+    dataItem: any;
+    /**
+     * The shape location.
+     */
+    location: Location;
+    /**
+     * @hidden
+     */
+    constructor(e: any, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `shapeFeatureCreated` event.
+ * Fires when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
+ */
+declare class ShapeFeatureCreatedEvent extends BaseEvent implements MapShapeFeatureCreatedEvent {
+    /**
+     * The original data item for this Feature. Includes `geometries` and `properties` members.
+     */
+    dataItem: any;
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The group that contains feature shape instances.
+     */
+    group: Group;
+    /**
+     * A reference to the `dataItem.properties` object.
+     */
+    properties: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeFeatureCreatedEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `shapeMouseEnter` event.
+ * Fires when the mouse enters a shape.
+ *
+ * > This event fires reliably only for shapes that have a set fill color.
+ * > You can still set the opacity to 0 so the shapes appear to have no fill.
+ */
+declare class ShapeMouseEnterEvent extends BaseEvent implements MapShapeMouseEnterEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeMouseEnterEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `shapeMouseLeave` event.
+ * Fires when the mouse leaves a shape.
+ *
+ * > This event fires reliably only for shapes that have a set fill color.
+ * > You can still set the opacity to 0 so the shapes appear to have no fill.
+ */
+declare class ShapeMouseLeaveEvent extends BaseEvent implements MapShapeMouseLeaveEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeMouseLeaveEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `zoomEnd` event.
+ * Fires when the map zoom level changes.
+ */
+declare class ZoomEndEvent extends BaseEvent implements MapZoomEndEvent {
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapZoomEndEvent, sender: MapComponent);
+}
+
+/**
+ * Arguments for the `zoomStart` event.
+ * Fires when the map zoom level is about to change.
+ * Cancel the event to prevent the user action.
+ */
+declare class ZoomStartEvent extends PreventableEvent implements MapZoomStartEvent {
+    /**
+     * The source DOM event instance.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapZoomStartEvent, sender: MapComponent);
+}
+
+/**
+ * @hidden
+ */
+declare class InstanceEventService {
+    create(name: string, args: any, sender: MapComponent): any;
+}
+
+/**
+ * Defines the settings for the tooltip popup.
+ */
+interface PopupSettings {
+    /**
+     * Sets the container to which you want to append the popup.
+     */
+    appendTo?: ViewContainerRef;
+    /**
+     * Sets the class or classes for the popup.
+     */
+    popupClass?: string | Array<string> | object | Set<string>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class BaseTooltip implements OnDestroy {
+    protected popupService: PopupService;
+    protected localizationService: LocalizationService;
+    animate: boolean;
+    style: any;
+    templateRef: TemplateRef<any>;
+    popupRef: any;
+    popupSettings: PopupSettings;
+    constructor(popupService: PopupService, localizationService: LocalizationService);
+    get active(): boolean;
+    show(e: any): void;
+    hide(): void;
+    protected onInit(): void;
+    ngOnDestroy(): void;
+    protected position(offset: any): any;
+    private scrollOffset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseTooltip, never, never, { "popupSettings": { "alias": "popupSettings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class TooltipTemplateService {
+    private templates;
+    registerTemplate(layerIndex: number, template: TemplateRef<any>): void;
+    getTemplate(layerIndex: number): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipTemplateService>;
+}
+
+/**
+ * @hidden
+ */
+declare class TooltipPopupComponent extends BaseTooltip {
+    protected popupService: PopupService;
+    protected templateService: TooltipTemplateService;
+    protected localizationService: LocalizationService;
+    protected ngZone: NgZone;
+    tooltipTemplateRef: TemplateRef<any>;
+    tooltipContext: any;
+    animate: boolean;
+    classNames: any;
+    wrapperClass: string;
+    leave: EventEmitter<any>;
+    popupClasses: any;
+    private mouseleaveSubscription;
+    constructor(popupService: PopupService, templateService: TooltipTemplateService, localizationService: LocalizationService, ngZone: NgZone);
+    show(e: any): void;
+    containsElement(element: any): boolean;
+    protected onInit(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipPopupComponent, "kendo-map-tooltip-popup", never, { "animate": { "alias": "animate"; "required": false; }; "classNames": { "alias": "classNames"; "required": false; }; "wrapperClass": { "alias": "wrapperClass"; "required": false; }; }, { "leave": "leave"; }, never, never, true, never>;
+}
+
+/**
+ * Represents the [Kendo UI Map component for Angular](https://www.telerik.com/kendo-angular-ui/components/map).
+ *
+ * Use this component to display interactive maps with markers, layers, and controls.
+ * Configure zoom levels, center coordinates, and user interactions like panning and zooming.
+ *
+ * @example
+ * ```ts
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *      <kendo-map [center]="center" [zoom]="15">
+ *          <kendo-map-layers>
+ *          <kendo-map-tile-layer
+ *              [subdomains]="tileSubdomains"
+ *              [urlTemplate]="tileUrl"
+ *              attribution="&copy; <a href='https://osm.org/copyright'>OpenStreetMap contributors</a>"
+ *          >
+ *          </kendo-map-tile-layer>
+ *          <kendo-map-marker-layer
+ *              [data]="markers"
+ *              locationField="latlng"
+ *              titleField="name"
+ *          >
+ *          </kendo-map-marker-layer>
+ *          </kendo-map-layers>
+ *      </kendo-map>
+ *   `
+ * })
+ * class AppComponent {
+ *  tileSubdomains = ["a", "b", "c"];
+ *  tileUrl = (e: TileUrlTemplateArgs): string =>
+ *      `https://${e.subdomain}.tile.openstreetmap.org/${e.zoom}/${e.x}/${e.y}.png`;
+ *
+ *  center = [30.2675, -97.7409];
+ *  markers = [{ latlng: [30.2675, -97.7409], name: "Zevo Toys" }];
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link LayersComponent}.
+ */
+declare class MapComponent implements AfterViewInit, AfterViewChecked, OnChanges, OnDestroy {
+    configurationService: ConfigurationService;
+    protected instanceEventService: InstanceEventService;
+    protected element: ElementRef;
+    protected localizationService: LocalizationService;
+    protected changeDetector: ChangeDetectorRef;
+    protected ngZone: NgZone;
+    protected renderer: Renderer2;
+    protected iconsService: IconsService;
+    /**
+     * Limits the automatic resizing of the Map. Sets the maximum number of times per second
+     * that the component redraws its content when the size of its container changes.
+     * To disable the automatic resizing, set it to `0`.
+     *
+     * @default 10
+     *
+     * @example
+     * ```ts
+     * @Component({
+     *     selector: 'my-app',
+     *     template: `
+     *         <kendo-map [resizeRateLimit]="2">
+     *       </kendo-map>
+     *   `
+     * })
+     * export class AppComponent {
+     * }
+     * ```
+     */
+    resizeRateLimit: number;
+    /**
+     * Specifies the map center coordinates.
+     * Provide coordinates as `[Latitude, Longitude]`.
+     */
+    center: number[];
+    /**
+     * Specifies the configuration for built-in map controls.
+     */
+    controls: MapControls;
+    /**
+     * The minimum zoom level. Typical web maps use zoom levels from 0 (whole world) to 19 (sub-meter features).
+     *
+     * @default 1
+     */
+    minZoom: number;
+    /**
+     * The maximum zoom level. Typical web maps use zoom levels from 0 (whole world) to 19 (sub-meter features).
+     *
+     * @default 19
+     */
+    maxZoom: number;
+    /**
+     * The size of the map in pixels at zoom level 0.
+     *
+     * @default 256
+     */
+    minSize?: number;
+    /**
+     * Controls whether the user can pan the map.
+     *
+     * @default true
+     */
+    pannable: boolean;
+    /**
+     * The settings for the tooltip popup.
+     */
+    popupSettings: PopupSettings$1;
+    /**
+     * Specifies whether the map should wrap around the east-west edges.
+     *
+     * @default true
+     */
+    wraparound: boolean;
+    /**
+     * Specifies the initial zoom level.
+     * Use values from 0 (whole world) to 19 (sub-meter features).
+     * The map size derives from the zoom level and `minScale` options: `size = (2 ^ zoom) * minSize`.
+     * Map zoom rounds floating point numbers to use whole [`zoom levels`](https://wiki.openstreetmap.org/wiki/Zoom_levels) 0 through 19.
+     *
+     * @default 3
+     */
+    zoom: number;
+    /**
+     * Determines whether users can change the map zoom level.
+     *
+     * @default true
+     */
+    zoomable: boolean;
+    /**
+     * Fires immediately before the map resets. This event is typically used for cleanup by layer implementers.
+     */
+    beforeReset: EventEmitter<BeforeResetEvent>;
+    /**
+     * Fires when the user clicks on the map.
+     */
+    mapClick: EventEmitter<MapClickEvent>;
+    /**
+     * Fires when a marker appears on the map and its DOM element becomes available.
+     */
+    markerActivate: EventEmitter<MarkerActivateEvent>;
+    /**
+     * Fires when the user clicks or taps a marker.
+     */
+    markerClick: EventEmitter<MarkerClickEvent>;
+    /**
+     * Fires once the map has created a marker, and just before the map displays it.
+     *
+     * Cancelling the event prevents displaying the marker.
+     */
+    markerCreated: EventEmitter<MarkerCreatedEvent>;
+    /**
+     * Fires after the map viewport completes panning.
+     */
+    panEnd: EventEmitter<PanEndEvent>;
+    /**
+     * Fires while the map viewport is being moved.
+     */
+    pan: EventEmitter<PanEvent>;
+    /**
+     * Fires when the map resets.
+     *
+     * This typically occurs on initial load and after a zoom/center change.
+     */
+    reset: EventEmitter<ResetEvent>;
+    /**
+     * Fires when a shape is clicked or tapped.
+     */
+    shapeClick: EventEmitter<ShapeClickEvent>;
+    /**
+     * Fires when a shape is created, but is not rendered yet.
+     */
+    shapeCreated: EventEmitter<ShapeCreatedEvent>;
+    /**
+     * Fires when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
+     */
+    shapeFeatureCreated: EventEmitter<ShapeFeatureCreatedEvent>;
+    /**
+     * Fires when the mouse enters a shape.
+     *
+     * > This event will fire reliably only for shapes that have set fill color.
+     * > The opacity can still be set to 0 so the shapes appear to have no fill.
+     */
+    shapeMouseEnter: EventEmitter<ShapeMouseEnterEvent>;
+    /**
+     * Fires when the mouse leaves a shape.
+     *
+     * > This event will fire reliably only for shapes that have set fill color.
+     * > The opacity can still be set to 0 so the shapes appear to have no fill.
+     */
+    shapeMouseLeave: EventEmitter<ShapeMouseLeaveEvent>;
+    /**
+     * Fires when the map zoom level is about to change.
+     *
+     * Cancelling the event will prevent the user action.
+     */
+    zoomStart: EventEmitter<ZoomStartEvent>;
+    /**
+     * Fires when the map zoom level changes.
+     */
+    zoomEnd: EventEmitter<ZoomEndEvent>;
+    /**
+     * Fires when the map center has been changed.
+     */
+    centerChange: EventEmitter<number[]>;
+    /**
+     * Fires when the map zoom level has been changed.
+     */
+    zoomChange: EventEmitter<number>;
+    tooltipInstance: TooltipPopupComponent;
+    instance: Map;
+    initResizeSensor: boolean;
+    protected options: any;
+    protected theme: any;
+    protected resizeTimeout: any;
+    protected redrawTimeout: any;
+    protected destroyed: boolean;
+    protected rtl: boolean;
+    protected subscriptions: Subscription;
+    protected optionsChange: Subscription;
+    protected domSubscriptions: () => void;
+    protected iconSettings: IconSettings;
+    constructor(configurationService: ConfigurationService, instanceEventService: InstanceEventService, element: ElementRef, localizationService: LocalizationService, changeDetector: ChangeDetectorRef, ngZone: NgZone, renderer: Renderer2, iconsService: IconsService);
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    ngOnDestroy(): void;
+    /**
+     * Gets the marker layers instances.
+     */
+    get layers(): MapLayer[];
+    /**
+     * Gets the extent (visible area) of the map.
+     */
+    get extent(): Extent;
+    /**
+     * Sets the extent (visible area) of the map.
+     */
+    set extent(extent: Extent);
+    /**
+     * Detects the container size and redraws the Map.
+     * Resizing happens automatically unless you set `resizeRateLimit` to `0`.
+     */
+    resize(): void;
+    /**
+     * Gets the size of the visible map area.
+     *
+     * @returns {Object} The width and height of the visible map area.
+     */
+    viewSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Gets event coordinates relative to the map element.
+     * Offset coordinates do not sync to a specific map location.
+     *
+     * @param {any} e The mouse event.
+     * @returns {geometry.Point} The event coordinates relative to the map element.
+     */
+    eventOffset(e: any): geometry.Point;
+    /**
+     * Gets projected layer coordinates for this mouse event.
+     * Layer coordinates are absolute and change only when zoom level changes.
+     *
+     * @param {any} e The mouse event.
+     * @returns {geometry.Point} The projected layer coordinates for this event.
+     */
+    eventToLayer(e: any): geometry.Point;
+    /**
+     * Gets the geographic location for this mouse event.
+     *
+     * @param {any} e The mouse event.
+     * @returns {geometry.Point} The geographic location for this mouse event.
+     */
+    eventToLocation(e: any): geometry.Point;
+    /**
+     * Gets relative view coordinates for this mouse event.
+     * Layer elements positioned on these coordinates appear under the mouse cursor.
+     * View coordinates become invalid after a map reset.
+     *
+     * @param {any} e The mouse event.
+     * @returns {geometry.Point} The relative view coordinates for this mouse event.
+     */
+    eventToView(e: any): geometry.Point;
+    /**
+     * Converts layer coordinates to geographic location.
+     *
+     * @param {geometry.Point | number[]} point The layer coordinates. Arrays use x, y order.
+     * @param {number} zoom Optional. Zoom level to use. Defaults to current zoom level.
+     * @returns {Location} The geographic location for the layer coordinates.
+     */
+    layerToLocation(point: geometry.Point | number[], zoom?: number): Location;
+    /**
+     * Gets layer coordinates for a geographic location.
+     *
+     * @param {Location | number[]} location The geographic location. Arrays use [Latitude, Longitude] order.
+     * @param {number} zoom Optional. Zoom level to use. Defaults to current zoom level.
+     * @returns {geometry.Point} The layer coordinates.
+     */
+    locationToLayer(location: Location | number[], zoom?: number): geometry.Point;
+    /**
+     * Gets view coordinates for a geographic location.
+     *
+     * @param {Location | number[]} location The geographic location. Arrays use [Latitude, Longitude] order.
+     * @returns {geometry.Point} The view coordinates for the geographic location.
+     */
+    locationToView(location: Location | number[]): geometry.Point;
+    /**
+     * Gets the geographic location for view coordinates.
+     *
+     * @param {geometry.Point | number[]} point The view coordinates. Arrays use x, y order.
+     * @param {number} zoom Optional. Zoom level to use. Defaults to current zoom level.
+     * @returns {Location} The geographic location for the view coordinates.
+     */
+    viewToLocation(point: geometry.Point | number[], zoom?: number): Location;
+    /**
+     * @hidden
+     */
+    onResize(): void;
+    /**
+     * @hidden
+     */
+    get canRender(): boolean;
+    protected get autoResize(): boolean;
+    protected init(): void;
+    protected initConfig(): void;
+    protected createInstance(element: any, observer: MapInstanceObserver): void;
+    protected activeEmitter(name: string): any;
+    protected trigger(name: string, e: any): boolean;
+    protected run(callback: any, inZone?: boolean, detectChanges?: boolean): void;
+    protected detectChanges(): void;
+    protected setDirection(): void;
+    protected get isRTL(): boolean;
+    protected onInit(e: any): void;
+    protected onShowTooltip(e: any): void;
+    protected onHideTooltip(): void;
+    protected onCenterChange(e: any): void;
+    protected onZoomChange(e: any): void;
+    /**
+     * @hidden
+     */
+    tooltipMouseleave(e: any): void;
+    /**
+     * @hidden
+     */
+    mapMouseleave(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapComponent, "kendo-map", ["kendoMap"], { "resizeRateLimit": { "alias": "resizeRateLimit"; "required": false; }; "center": { "alias": "center"; "required": false; }; "controls": { "alias": "controls"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minSize": { "alias": "minSize"; "required": false; }; "pannable": { "alias": "pannable"; "required": false; }; "popupSettings": { "alias": "popupSettings"; "required": false; }; "wraparound": { "alias": "wraparound"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "zoomable": { "alias": "zoomable"; "required": false; }; }, { "beforeReset": "beforeReset"; "mapClick": "mapClick"; "markerActivate": "markerActivate"; "markerClick": "markerClick"; "markerCreated": "markerCreated"; "panEnd": "panEnd"; "pan": "pan"; "reset": "reset"; "shapeClick": "shapeClick"; "shapeCreated": "shapeCreated"; "shapeFeatureCreated": "shapeFeatureCreated"; "shapeMouseEnter": "shapeMouseEnter"; "shapeMouseLeave": "shapeMouseLeave"; "zoomStart": "zoomStart"; "zoomEnd": "zoomEnd"; "centerChange": "centerChange"; "zoomChange": "zoomChange"; }, never, never, true, never>;
+}
+
+/**
+ * A directive that sets a [template](link:site.data.urls.angular['templatesyntax'])
+ * within the `<kendo-map-tooltip>` component for the Map
+ * [Bubble layer tooltip](https://www.telerik.com/kendo-angular-ui/components/map/layers/bubble#tooltips).
+ *
+ * The available inputs for the bubble tooltip template are:
+ *    * `dataItem: any`&mdash;The original data item used to create the bubble.
+ *    * `layerIndex: number`&mdash;The index of the layer for the tooltip.
+ *    * `location: Location`&mdash;The location of the bubble.
+ *    * `value: number`&mdash;The value of the bubble.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-bubble-layer [data]="data">
+ *         <kendo-map-bubble-layer-tooltip>
+ *           <ng-template kendoMapBubbleTooltipTemplate let-dataItem="dataItem" let-value="value">
+ *             <div>{{ dataItem.name }}: {{ value }}</div>
+ *           </ng-template>
+ *         </kendo-map-bubble-layer-tooltip>
+ *       </kendo-map-bubble-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public data = [{ name: 'City', value: 100000 }];
+ * }
+ * ```
+ */
+declare class BubbleTooltipTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleTooltipTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BubbleTooltipTemplateDirective, "[kendoMapBubbleTooltipTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI BubbleTooltip component for Angular.
+ *
+ * Configures the [Bubble Layer Tooltip](https://www.telerik.com/kendo-angular-ui/components/map/layers/bubble#tooltips).
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-layer type="bubble" [data]="bubbleData">
+ *         <kendo-map-bubble-layer-tooltip>
+ *           <ng-template kendoMapBubbleTooltipTemplate let-dataItem="dataItem" let-value="value">
+ *             <div>{{ dataItem.name }}: {{ value }}</div>
+ *           </ng-template>
+ *         </kendo-map-bubble-layer-tooltip>
+ *       </kendo-map-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public bubbleData = [{ name: 'Population', value: 50000 }];
+ * }
+ * ```
+ */
+declare class BubbleTooltipComponent extends SettingsComponent implements AfterContentChecked {
+    configurationService: ConfigurationService;
+    private templateService;
+    private layer;
+    bubbleTooltipTemplate: BubbleTooltipTemplateDirective;
+    constructor(configurationService: ConfigurationService, templateService: TooltipTemplateService, layer: LayerComponent);
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BubbleTooltipComponent, "kendo-map-bubble-layer-tooltip", never, {}, {}, ["bubbleTooltipTemplate"], never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class CollectionComponent implements AfterContentInit, OnDestroy {
+    protected configKey: string;
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    children: QueryList<Item>;
+    private subscription;
+    private items;
+    constructor(configKey: string, configurationService: ConfigurationService, collectionService: CollectionService);
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    private processChanges;
+    private readItems;
+    private change;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CollectionComponent, never, never, {}, {}, ["children"], never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI Layers component for Angular. Contains a collection of one or more map layers.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-layers>
+ *         <kendo-map-tile-layer [urlTemplate]="tileUrl"></kendo-map-tile-layer>
+ *         <kendo-map-shape-layer [data]="shapeData"></kendo-map-shape-layer>
+ *       </kendo-map-layers>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public tileUrl = (args: any) => `https://tile.openstreetmap.org/${args.z}/${args.x}/${args.y}.png`;
+ *   public shapeData = [];
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link TileLayerComponent}, {@link ShapeLayerComponent}, {@link BubbleLayerComponent}, {@link MarkerLayerComponent}.
+ */
+declare class LayersComponent extends CollectionComponent {
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    constructor(configurationService: ConfigurationService, collectionService: CollectionService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayersComponent, "kendo-map-layers", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI MarkerLayer component for Angular. Displays data as markers on vector shape layers for marker maps.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-marker-layer
+ *         [data]="markerData"
+ *         locationField="location"
+ *         titleField="title"
+ *         shape="pin">
+ *       </kendo-map-marker-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public markerData = [
+ *     { location: [40.7128, -74.0060], title: "New York" }
+ *   ];
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link MarkerTooltipComponent}.
+ */
+declare class MarkerLayerComponent extends LayerComponent implements MarkerLayerOptions {
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    protected sanitizer: DomSanitizer;
+    /**
+     * Sets the array of data items for this layer.
+     */
+    data?: any[];
+    /**
+     * Sets the data item field which contains the marker location.
+     * The field should be an array with two numbers &mdash; latitude and longitude in decimal degrees.
+     */
+    locationField?: string;
+    /**
+     * Sets the data item field which contains the marker title.
+     */
+    titleField?: string;
+    /**
+     * Sets the default marker shape for data-bound markers. Supported marker shapes are `pinTarget` and `pin`.
+     * Marker shapes are implemented as CSS classes on the marker element (`span.k-marker`). For example `pinTarget` is rendered as `k-marker-pin-target`.
+     */
+    shape?: string | 'pinTarget' | 'pin';
+    constructor(configurationService: ConfigurationService, collectionService: CollectionService, sanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkerLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkerLayerComponent, "kendo-map-marker-layer", never, { "data": { "alias": "data"; "required": false; }; "locationField": { "alias": "locationField"; "required": false; }; "titleField": { "alias": "titleField"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A directive that sets a [template](link:site.data.urls.angular['templatesyntax'])
+ * within the `<kendo-map-tooltip>` component for the Map
+ * [Marker layer tooltip](https://www.telerik.com/kendo-angular-ui/components/map/layers/marker#tooltips).
+ *
+ * The available inputs for the marker tooltip template are:
+ *    * `title: string`&mdash;The marker title.
+ *    * `layerIndex: number`&mdash;The index of the layer for the tooltip.
+ *    * `location: Location`&mdash;The marker location.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-layer type="marker" [data]="markers">
+ *         <kendo-map-marker-layer-tooltip>
+ *           <ng-template kendoMapMarkerTooltipTemplate let-title="title" let-location="location">
+ *             <div>{{ title }} at {{ location.lat }}, {{ location.lng }}</div>
+ *           </ng-template>
+ *         </kendo-map-marker-layer-tooltip>
+ *       </kendo-map-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public markers = [{ title: 'Office', location: [42.6977, 23.3219] }];
+ * }
+ * ```
+ */
+declare class MarkerTooltipTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkerTooltipTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MarkerTooltipTemplateDirective, "[kendoMapMarkerTooltipTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI MarkerTooltip component for Angular.
+ *
+ * Configures the [Marker Layer Tooltip](https://www.telerik.com/kendo-angular-ui/components/map/layers/marker#tooltips).
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-layer type="marker" [data]="markers">
+ *         <kendo-map-marker-layer-tooltip>
+ *           <ng-template kendoMapMarkerTooltipTemplate let-title="title">
+ *             <div>Marker: {{ title }}</div>
+ *           </ng-template>
+ *         </kendo-map-marker-layer-tooltip>
+ *       </kendo-map-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public markers = [{ title: 'Location A' }];
+ * }
+ * ```
+ */
+declare class MarkerTooltipComponent extends SettingsComponent implements AfterContentChecked {
+    configurationService: ConfigurationService;
+    private templateService;
+    private layer;
+    markerTooltipTemplate: MarkerTooltipTemplateDirective;
+    constructor(configurationService: ConfigurationService, templateService: TooltipTemplateService, layer: LayerComponent);
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkerTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkerTooltipComponent, "kendo-map-marker-layer-tooltip", never, {}, {}, ["markerTooltipTemplate"], never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI ShapeLayer component for Angular. Defines a vector shape layer bound to GeoJSON data.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-shape-layer
+ *         [data]="geoJsonData"
+ *         [style]="shapeStyle">
+ *       </kendo-map-shape-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public geoJsonData = { type: "FeatureCollection", features: [] };
+ *   public shapeStyle = { fill: { color: "#007acc" }, stroke: { color: "#ffffff" } };
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link ShapeTooltipComponent}.
+ */
+declare class ShapeLayerComponent extends LayerComponent implements ShapeLayerOptions {
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    protected sanitizer: DomSanitizer;
+    /**
+     * Sets the array of data items for this layer.
+     */
+    data?: any;
+    /**
+     * Sets the default style for shapes.
+     */
+    style?: ShapeOptions;
+    constructor(configurationService: ConfigurationService, collectionService: CollectionService, sanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShapeLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShapeLayerComponent, "kendo-map-shape-layer", never, { "data": { "alias": "data"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A directive that sets a [template](link:site.data.urls.angular['templatesyntax'])
+ * within the `<kendo-map-tooltip>` component for the Map
+ * [Shape layer tooltip](https://www.telerik.com/kendo-angular-ui/components/map/layers/shape#tooltips).
+ *
+ * The available inputs for the shape tooltip template are:
+ *    * `dataItem: any`&mdash;The original data item used to create the shape.
+ *    * `layerIndex: number`&mdash;The index of the layer for the tooltip.
+ *    * `location: Location`&mdash;The location of the center of the shape.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-layer type="shape" [data]="data">
+ *         <kendo-map-shape-layer-tooltip>
+ *           <ng-template kendoMapShapeTooltipTemplate let-dataItem="dataItem" let-layerIndex="layerIndex">
+ *             <div>Shape: {{ dataItem.properties.name }} (Layer {{ layerIndex }})</div>
+ *           </ng-template>
+ *         </kendo-map-shape-layer-tooltip>
+ *       </kendo-map-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public data = [ ... ]; // GeoJSON data for shapes
+ * }
+ * ```
+ */
+declare class ShapeTooltipTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShapeTooltipTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ShapeTooltipTemplateDirective, "[kendoMapShapeTooltipTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI ShapeTooltip component for Angular.
+ *
+ * Configures the [Shape Layer Tooltip](https://www.telerik.com/kendo-angular-ui/components/map/layers/shape#tooltips).
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-layer type="shape" [data]="shapeData">
+ *         <kendo-map-shape-layer-tooltip>
+ *           <ng-template kendoMapShapeTooltipTemplate let-dataItem="dataItem">
+ *             <div>{{ dataItem.properties.name }}</div>
+ *           </ng-template>
+ *         </kendo-map-shape-layer-tooltip>
+ *       </kendo-map-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public shapeData = [ ... ]; // GeoJSON data for shapes
+ * }
+ * ```
+ */
+declare class ShapeTooltipComponent extends SettingsComponent implements AfterContentChecked {
+    configurationService: ConfigurationService;
+    private templateService;
+    private layer;
+    shapeTooltipTemplate: ShapeTooltipTemplateDirective;
+    constructor(configurationService: ConfigurationService, templateService: TooltipTemplateService, layer: LayerComponent);
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShapeTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShapeTooltipComponent, "kendo-map-shape-layer-tooltip", never, {}, {}, ["shapeTooltipTemplate"], never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI TileLayer component for Angular. Displays raster map tiles from various sources.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-map>
+ *       <kendo-map-tile-layer
+ *         [urlTemplate]="tileUrlTemplate"
+ *         [subdomains]="['a', 'b', 'c']"
+ *         [tileSize]="256">
+ *       </kendo-map-tile-layer>
+ *     </kendo-map>
+ *   `
+ * })
+ * export class AppComponent {
+ *   public tileUrlTemplate = (args: any) => `https://${args.subdomain}.tile.openstreetmap.org/${args.z}/${args.x}/${args.y}.png`;
+ * }
+ * ```
+ */
+declare class TileLayerComponent extends LayerComponent implements TileLayerOptions {
+    protected configurationService: ConfigurationService;
+    protected collectionService: CollectionService;
+    protected sanitizer: DomSanitizer;
+    /**
+     * Sets the size of the image tile in pixels.
+     *
+     * @default 256
+     */
+    tileSize: number;
+    /**
+     * Sets a list of subdomains to use for loading tiles.
+     * Alternating between different subdomains allows more requests to execute in parallel.
+     */
+    subdomains: string[];
+    /**
+     * Sets a function that returns an image URL for each tile position.
+     */
+    urlTemplate: (args: TileUrlTemplateArgs) => string;
+    constructor(configurationService: ConfigurationService, collectionService: CollectionService, sanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TileLayerComponent, "kendo-map-tile-layer", never, { "tileSize": { "alias": "tileSize"; "required": false; }; "subdomains": { "alias": "subdomains"; "required": false; }; "urlTemplate": { "alias": "urlTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi'])
+ * definition for the Map component.
+ *
+ * @example
+ * ```ts
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { NgModule } from '@angular/core';
+ * import { MapModule } from '@progress/kendo-angular-map';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     declarations: [AppComponent],
+ *     imports: [BrowserModule, BrowserAnimationsModule, MapModule],
+ *     bootstrap: [AppComponent]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class MapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MapModule, never, [typeof BubbleLayerComponent, typeof BubbleTooltipComponent, typeof BubbleTooltipTemplateDirective, typeof LayersComponent, typeof MapComponent, typeof MarkerLayerComponent, typeof MarkerTooltipComponent, typeof MarkerTooltipTemplateDirective, typeof ShapeLayerComponent, typeof ShapeTooltipComponent, typeof ShapeTooltipTemplateDirective, typeof TileLayerComponent], [typeof BubbleLayerComponent, typeof BubbleTooltipComponent, typeof BubbleTooltipTemplateDirective, typeof LayersComponent, typeof MapComponent, typeof MarkerLayerComponent, typeof MarkerTooltipComponent, typeof MarkerTooltipTemplateDirective, typeof ShapeLayerComponent, typeof ShapeTooltipComponent, typeof ShapeTooltipTemplateDirective, typeof TileLayerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MapModule>;
+}
+
+/**
+ * @hidden
+ */
+declare function bodyFactory(): ElementRef;
+
+/**
+ * Utility array that contains all `Map` related components and directives.
+ */
+declare const KENDO_MAP: readonly [typeof BubbleLayerComponent, typeof BubbleTooltipComponent, typeof BubbleTooltipTemplateDirective, typeof LayersComponent, typeof MapComponent, typeof MarkerLayerComponent, typeof MarkerTooltipComponent, typeof MarkerTooltipTemplateDirective, typeof ShapeLayerComponent, typeof ShapeTooltipComponent, typeof ShapeTooltipTemplateDirective, typeof TileLayerComponent];
+
+export { BeforeResetEvent, BubbleLayerComponent, BubbleTooltipComponent, BubbleTooltipTemplateDirective, KENDO_MAP, LayerTooltipComponent, LayersComponent, MapClickEvent, MapComponent, MapModule, MarkerActivateEvent, MarkerClickEvent, MarkerCreatedEvent, MarkerLayerComponent, MarkerTooltipComponent, MarkerTooltipTemplateDirective, PanEndEvent, PanEvent, ResetEvent, ShapeClickEvent, ShapeCreatedEvent, ShapeFeatureCreatedEvent, ShapeLayerComponent, ShapeMouseEnterEvent, ShapeMouseLeaveEvent, ShapeTooltipComponent, ShapeTooltipTemplateDirective, TileLayerComponent, TooltipPopupComponent, ZoomEndEvent, ZoomStartEvent, bodyFactory };