/**
 * @license
 *-------------------------------------------------------------------------------------------
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the package root for more information
 *-------------------------------------------------------------------------------------------
 */
import { Align } from '@progress/kendo-react-popup';
import { BubbleLayerOptions } from '@progress/kendo-charts';
import { BubbleLayerSymbol } from '@progress/kendo-charts';
import { BubbleLayerSymbolArgs } from '@progress/kendo-charts';
import { default as default_2 } from 'prop-types';
import { Element as Element_2 } from '@progress/kendo-drawing';
import { Extent } from '@progress/kendo-charts';
import { geometry } from '@progress/kendo-drawing';
import { Group } from '@progress/kendo-drawing';
import { InstanceObserver } from '@progress/kendo-charts';
import { JSX } from 'react/jsx-runtime';
import { Location as Location_2 } from '@progress/kendo-charts';
import { Map as Map_3 } from '@progress/kendo-charts';
import { MapBeforeResetEvent } from '@progress/kendo-charts';
import { MapClickEvent as MapClickEvent_2 } from '@progress/kendo-charts';
import { MapContextType } from '../../MapContext';
import { MapContextType as MapContextType_3 } from '../MapContext';
import { MapControls } from '@progress/kendo-charts';
import { MapControlsPosition } from '@progress/kendo-charts';
import { MapLayer } from '@progress/kendo-charts';
import { MapLayerOptions } from '@progress/kendo-charts';
import { MapMarker } from '@progress/kendo-charts';
import { MapMarkerActivateEvent } from '@progress/kendo-charts';
import { MapMarkerClickEvent } from '@progress/kendo-charts';
import { MapMarkerCreatedEvent } from '@progress/kendo-charts';
import { MapOptions } from '@progress/kendo-charts';
import { MapPanEndEvent } from '@progress/kendo-charts';
import { MapPanEvent } from '@progress/kendo-charts';
import { MapResetEvent } from '@progress/kendo-charts';
import { MapShapeClickEvent } from '@progress/kendo-charts';
import { MapShapeCreatedEvent } from '@progress/kendo-charts';
import { MapShapeFeatureCreatedEvent } from '@progress/kendo-charts';
import { MapShapeMouseEnterEvent } from '@progress/kendo-charts';
import { MapShapeMouseLeaveEvent } from '@progress/kendo-charts';
import { MapZoomEndEvent } from '@progress/kendo-charts';
import { MapZoomStartEvent } from '@progress/kendo-charts';
import { MarkerLayerOptions } from '@progress/kendo-charts';
import { Offset } from '@progress/kendo-react-popup';
import * as React_2 from 'react';
import { ShapeLayerOptions } from '@progress/kendo-charts';
import { Store as Store_2 } from '../../store/store';
import { Store as Store_3 } from './../../store/store';
import { TileLayerOptions } from '@progress/kendo-charts';
import { TileUrlTemplateArgs } from '@progress/kendo-charts';

/**
 * @hidden
 */
declare abstract class BaseEvent {
    /**
     * The `Map` component that triggered the event.
     */
    target: Map_2;
    /**
     * @hidden
     */
    constructor(target: Map_2);
}

/**
 * Fired immediately before the map is reset. This event is typically used for cleanup by layer implementers.
 */
export declare class BeforeResetEvent extends BaseEvent implements MapBeforeResetEvent {
    /**
     * @hidden
     */
    constructor(_: any, target: Map_2);
}

export { BubbleLayerSymbol }

export { BubbleLayerSymbolArgs }

/**
 * Context object for bubble layer tooltips.
 */
export declare interface BubbleTooltipContext {
    /**
     * The original data item used to create the bubble.
     */
    dataItem: any;
    /**
     * The index of the bubble layer in the map.
     */
    layerIndex: number;
    /**
     * The location of the bubble.
     */
    location: Location_2;
    /**
     * The numerical value of the bubble
     */
    value: number;
}

/**
 * @hidden
 */
export declare class CollectionConfigurationComponent extends React_2.Component<CollectionConfigurationProps> {
    static contextType: React_2.Context<MapContextType | null>;
    context: React_2.ContextType<typeof MapContext>;
    get optionsStore(): Store_2 | undefined;
    renderChildren(child: any, index: number): React_2.DetailedReactHTMLElement<any, HTMLElement>;
    render(): any;
}

/**
 * @hidden
 */
declare interface CollectionConfigurationProps {
    _mapKey: string;
    _parentStore?: any;
    [x: string]: any;
}

/**
 * @hidden
 */
export declare class ConfigurationComponent extends React_2.Component<ConfigurationComponentProps> {
    static contextType: React_2.Context<MapContextType | null>;
    context: React_2.ContextType<typeof MapContext>;
    childStore: any;
    get optionsStore(): Store_3 | undefined;
    constructor(props: any);
    render(): any;
    componentDidMount(): void;
    componentDidUpdate(): void;
    private dispatch;
    private renderChildren;
}

/**
 * @hidden
 */
declare interface ConfigurationComponentProps {
    _mapKey?: string;
    _mapCollectionIdxKey?: string;
    _parentStore?: any;
    [x: string]: any;
}

/**
 * @hidden
 */
declare class DomEvent<T> {
    /**
     * The `Map` component that triggered the event.
     */
    sender: React.Component;
    /**
     * The syntheticEvent
     */
    syntheticEvent: T;
    /**
     * @hidden
     */
    constructor(sender: React.Component, e: T);
}

export { Extent }

export { Location_2 as Location }

/**
 * Represents the [KendoReact Map component]({% slug overview_map %}).
 *
 * @remarks
 * Supported children components are: {@link MapLayers}.
 */
declare class Map_2 extends React_2.Component<MapProps, {}> {
    /**
     * @hidden
     */
    static propTypes: {
        dir: default_2.Requireable<string>;
    };
    /**
     * @hidden
     */
    static defaultProps: {};
    /**
     * @hidden
     */
    mapInstance: Map_3 | null;
    /**
     * @hidden
     */
    get element(): HTMLDivElement;
    protected _element: HTMLDivElement | null;
    protected optionsStore: any;
    protected optionsUnsubscriber: Function;
    protected observersStore: any;
    protected mapObserver: InstanceObserver;
    protected childrenObserver: InstanceObserver;
    protected contextValue: MapContextType_2;
    private readonly showLicenseWatermark;
    constructor(props: MapProps);
    private iconsType;
    private svgIcons;
    /**
     * @hidden
     */
    componentDidMount(): void;
    /**
     * @hidden
     */
    componentWillUnmount(): void;
    /**
     * @hidden
     */
    componentDidUpdate(prevProps: MapProps): void;
    /**
     * @hidden
     */
    render(): any;
    /**
     * @hidden
     */
    getMapOptions(): any;
    /**
     * The marker layers instances.
     */
    get layers(): MapLayer[];
    /**
     * Gets the extent (visible area) of the map.
     */
    get extent(): Extent | undefined;
    /**
     * Sets the extent (visible area) of the map.
     */
    set extent(extent: Extent | undefined);
    /**
     * Detects the size of the container and redraws the Map.
     * Resizing is automatic unless you set the `resizeRateLimit` option to `0`.
     */
    resize(): void;
    /**
     * Retrieves the size of the visible portion of the map.
     *
     * @returns The size (width and height) of the visible portion of the map.
     */
    viewSize(): {
        width: number;
        height: number;
    };
    /**
     * Returns the event coordinates relative to the map element. Offset coordinates are not synchronized to a particular location on the map.
     *
     * @param e The mouse event.
     * @returns The event coordinates relative to the map element.
     */
    eventOffset(e: any): geometry.Point | undefined;
    /**
     * Retrieves projected (layer) coordinates that correspond to this mouse event.
     * Layer coordinates are absolute and change only when the zoom level is changed.
     *
     * @param e The mouse event.
     * @returns The projected (layer) coordinates that correspond to this event.
     */
    eventToLayer(e: any): geometry.Point | undefined;
    /**
     * Retrieves the geographic location that correspond to this mouse event.
     *
     * @param e The mouse event.
     * @returns The geographic location that correspond to this mouse event.
     */
    eventToLocation(e: any): geometry.Point | undefined;
    /**
     * Retrieves relative (view) coordinates that correspond to this mouse event.
     * Layer elements positioned on these coordinates will appear under the mouse cursor.
     * View coordinates are no longer valid after a map reset.
     *
     * @param e The mouse event.
     * @returns The relative (view) coordinates that correspond to this mouse event.
     */
    eventToView(e: any): geometry.Point | undefined;
    /**
     * Transforms layer (projected) coordinates to geographical location.
     *
     * @param point The layer (projected) coordinates. An array argument is assumed to be in x, y order.
     * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
     * @returns The geographic location that corresponds to the layer coordinates.
     */
    layerToLocation(point: geometry.Point | number[], zoom?: number): Location_2 | undefined;
    /**
     * Returns the layer (projected) coordinates that correspond to a geographical location.
     *
     * @param location The geographic location. An array argument is assumed to be in [Latitude, Longitude] order.
     * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
     * @returns The layer (projected) coordinates.
     */
    locationToLayer(location: Location_2 | number[], zoom?: number): geometry.Point | undefined;
    /**
     * Returns the view (relative) coordinates that correspond to a geographical location.
     *
     * @param location The geographic location. An array argument is assumed to be in [Latitude, Longitude] order.
     * @returns The view coordinates that correspond to a geographical location.
     */
    locationToView(location: Location_2 | number[]): geometry.Point | undefined;
    /**
     * Returns the geographical location that correspond to the view (relative) coordinates.
     *
     * @param point The view coordinates. An array argument is assumed to be in x, y order.
     * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
     * @returns The geographic location that corresponds to the view coordinates.
     */
    viewToLocation(point: geometry.Point | number[], zoom?: number): Location_2 | undefined;
    /**
     * Load markers in the Map. This method will clear the current markers and show the new ones.
     *
     * @param newMarkers An array of markers.
     */
    loadMarkers(newMarkers: any[]): void;
    /**
     * @hidden
     */
    refresh(): void;
    /**
     * @hidden
     */
    instantiateCoreMap(): void;
    /**
     * @hidden
     */
    trigger(name: string, e: any): boolean;
    /**
     * @hidden
     */
    requiresHandlers(names: string[]): boolean;
    /**
     * @hidden
     */
    triggerDomEvent<T>(name: string, e: DomEvent<T>): boolean;
    /**
     * @hidden
     */
    onInit: (e: any) => void;
    /**
     * @hidden
     */
    onRender: (e: any) => void;
    /**
     * @hidden
     */
    onMapMouseLeave: (e: React_2.MouseEvent<HTMLDivElement>) => void;
    private setIcons;
}
export { Map_2 as Map }

/**
 * Represents the KendoReact MapBubbleLayer component.
 *
 * @remarks
 * Supported children components are: {@link MapBubbleLayerTooltip}.
 */
export declare const MapBubbleLayer: React_2.FunctionComponent<MapBubbleLayerProps>;

/**
 * Represents the props of the KendoReact MapBubbleLayer component.
 */
export declare interface MapBubbleLayerProps extends BubbleLayerOptions {
    children?: React_2.ReactNode;
}

export declare const MapBubbleLayerTooltip: React_2.FunctionComponent<MapBubbleLayerTooltipProps>;

/**
 * Represents the props of the KendoReact BubbleTooltip component.
 */
export declare interface MapBubbleLayerTooltipProps {
    /**
     * The renderer for the bubble layer tooltip.
     *
     * @return the content of the tooltip.
     */
    render?: (props: BubbleTooltipContext) => React_2.ReactNode;
}

/**
 * Fired when the user clicks on the map.
 */
export declare class MapClickEvent extends BaseEvent implements MapClickEvent_2 {
    /**
     * The location of the clicked point.
     */
    location: Location_2;
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapClickEvent_2, target: Map_2);
}

/**
 * @hidden
 */
declare const MapContext: React_2.Context<MapContextType_2 | null>;

/**
 * @hidden
 */
declare interface MapContextType_2 {
    optionsStore: Store;
    observersStore: Store;
    childrenObserver: InstanceObserver;
}

export { MapControls }

export { MapControlsPosition }

export { MapLayer }

export { MapLayerOptions }

/**
 * Represents the KendoReact MapLayers component.
 *
 * @remarks
 * Supported children components are: {@link MapShapeLayer}, {@link MapBubbleLayer}, {@link MapMarkerLayer}, {@link MapTileLayer}.
 */
export declare const MapLayers: React_2.FunctionComponent<MapLayersProps>;

/**
 * Represents the props of the KendoReact MapLayers component.
 */
export declare interface MapLayersProps {
    children?: React_2.ReactNode;
}

export { MapMarker }

/**
 * Represents the KendoReact MapMarkerLayer component.
 *
 * @remarks
 * Supported children components are: {@link MapMarkerLayerTooltip}.
 */
export declare const MapMarkerLayer: React_2.FunctionComponent<MapMarkerLayerProps>;

/**
 * Represents the props of the KendoReact MapMarkerLayer component.
 */
export declare interface MapMarkerLayerProps extends MarkerLayerOptions {
    children?: React_2.ReactNode;
}

export declare const MapMarkerLayerTooltip: React_2.FunctionComponent<MapMarkerLayerTooltipProps>;

/**
 * Represents the props of the KendoReact MapMarkerLayerTooltip component.
 */
export declare interface MapMarkerLayerTooltipProps {
    /**
     * The renderer for the marker layer tooltip.
     *
     * @return the content of the tooltip.
     */
    render?: (props: MarkerTooltipContext) => React_2.ReactNode;
}

/**
 * Represents the props of the KendoReact Map component.
 */
export declare interface MapProps extends MapOptions {
    /**
     * Represents the `dir` HTML attribute.
     *
     * @example
     * ```jsx
     * <Map dir="rtl" />
     * ```
     */
    dir?: string;
    /**
     * The styles that are applied to the component.
     *
     * @example
     * ```jsx
     * <Map style={{ height: '500px' }} />
     * ```
     */
    style?: React_2.CSSProperties;
    /**
     * Sets additional CSS classes to the component.
     *
     * @example
     * ```jsx
     * <Map className="custom-map-class" />
     * ```
     */
    className?: string;
    /**
     * @hidden
     */
    children?: any;
    /**
     * Fires when the Map is about to refresh. The event can be used to prevent the refresh of the Map in specific cases.
     */
    onRefresh?: (mapOptions: any, mapInstance: any) => void;
    /**
     * Fired immediately before the map is reset. This event is typically used for cleanup by layer implementers.
     */
    onBeforeReset?: (event: BeforeResetEvent) => void;
    /**
     * Fired when the user clicks on the map.
     */
    onMapClick?: (event: MapClickEvent) => void;
    /**
     * Fired when a marker has been displayed and has a DOM element assigned.
     */
    onMarkerActivate?: (event: MarkerActivateEvent) => void;
    /**
     * Fired when a marker has been clicked or tapped.
     */
    onMarkerClick?: (event: MarkerClickEvent) => void;
    /**
     * Fired when a marker has been created and is about to be displayed.
     *
     * Cancelling the event will prevent the marker from being shown.
     */
    onMarkerCreated?: (event: MarkerCreatedEvent) => void;
    /**
     * Fires after the map viewport has been moved.
     */
    onPanEnd?: (event: PanEndEvent) => void;
    /**
     * Fired while the map viewport is being moved.
     */
    onPan?: (event: PanEvent) => void;
    /**
     * Fired when the map is reset.
     *
     * This typically occurs on initial load and after a zoom/center change.
     */
    onReset?: (event: ResetEvent) => void;
    /**
     * Fired when a shape is clicked or tapped.
     */
    onShapeClick?: (event: ShapeClickEvent) => void;
    /**
     * Fired when a shape is created, but is not rendered yet.
     */
    onShapeCreated?: (event: ShapeCreatedEvent) => void;
    /**
     * Fired when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
     */
    onShapeFeatureCreated?: (event: ShapeFeatureCreatedEvent) => void;
    /**
     * Fired 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.
     */
    onShapeMouseEnter?: (event: ShapeMouseEnterEvent) => void;
    /**
     * Fired 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.
     */
    onShapeMouseLeave?: (event: ShapeMouseLeaveEvent) => void;
    /**
     * Fired when the map zoom level is about to change.
     *
     * Cancelling the event will prevent the user action.
     */
    onZoomStart?: (event: ZoomStartEvent) => void;
    /**
     * Fired when the map zoom level has changed.
     */
    onZoomEnd?: (event: ZoomEndEvent) => void;
}

/**
 * Represents the KendoReact MapShapeLayer component.
 *
 * @remarks
 * Supported children components are: {@link MapShapeLayerTooltip}.
 */
export declare const MapShapeLayer: React_2.FunctionComponent<MapShapeLayerProps>;

/**
 * Represents the props of the KendoReact MapShapeLayer component.
 */
export declare interface MapShapeLayerProps extends ShapeLayerOptions {
    children?: React_2.ReactNode;
}

export declare const MapShapeLayerTooltip: React_2.FunctionComponent<MapShapeLayerTooltipProps>;

/**
 * Represents the props of the KendoReact ShapeTooltip component.
 */
export declare interface MapShapeLayerTooltipProps {
    /**
     * The renderer for the shape layer tooltip.
     *
     * @return the content of the tooltip.
     */
    render?: (props: ShapeTooltipContext) => React_2.ReactNode;
}

export declare const MapTileLayer: React_2.FunctionComponent<MapTileLayerProps>;

/**
 * Represents the props of the KendoReact MapTileLayer component.
 */
export declare interface MapTileLayerProps extends TileLayerOptions {
}

/**
 * @hidden
 */
export declare class MapTooltip extends React_2.Component<{}, MapTooltipState> {
    static contextType: React_2.Context<MapContextType_3 | null>;
    context: React_2.ContextType<typeof MapContext>;
    readonly state: MapTooltipState;
    mapObserver?: InstanceObserver;
    componentDidMount(): void;
    render(): JSX.Element | null;
    componentWillUnmount(): void;
    onShowTooltip(e: any): void;
    onHideTooltip(): void;
    createTooltipContext(e: any): TooltipContext;
    findRenderFunctionByLayer(layerIndex: number): any;
}

/**
 * @hidden
 */
declare interface MapTooltipState {
    className?: string | undefined;
    popupShown: boolean;
    popupAlign?: Align;
    popupOffset?: Offset;
    popupStyles?: any;
    popupContext?: TooltipContext;
    shared?: boolean;
}

/**
 * Fired when a marker has been displayed and has a DOM element assigned.
 */
export declare class MarkerActivateEvent extends BaseEvent implements MapMarkerActivateEvent {
    /**
     * The marker instance.
     */
    marker: MapMarker;
    /**
     * The marker layer instance.
     */
    layer: MapLayer;
    /**
     * @hidden
     */
    constructor(e: MapMarkerActivateEvent, target: Map_2);
}

/**
 * Fired when a marker has been clicked or tapped.
 */
export declare class MarkerClickEvent extends BaseEvent implements MapMarkerClickEvent {
    /**
     * The marker instance.
     */
    marker: MapMarker;
    /**
     * The marker layer instance.
     */
    layer: MapLayer;
    /**
     * @hidden
     */
    constructor(e: MapMarkerClickEvent, target: Map_2);
}

/**
 * Fired when a marker has been created and is about to be displayed.
 *
 * Cancelling the event will prevent the marker from being shown.
 */
export declare class MarkerCreatedEvent extends PreventableEvent implements MapMarkerCreatedEvent {
    /**
     * The marker instance.
     */
    marker: MapMarker;
    /**
     * The marker layer instance.
     */
    layer: MapLayer;
    /**
     * @hidden
     */
    constructor(e: MapMarkerCreatedEvent, target: Map_2);
}

/**
 * Context object for marker tooltips.
 */
export declare interface MarkerTooltipContext {
    /**
     * The original data item used to create the marker.
     */
    dataItem: any;
    /**
     * The index of the marker layer in the map.
     */
    layerIndex: number;
    /**
     * The location of the marker.
     */
    location: Location_2;
    /**
     * The title of the marker.
     */
    title: string;
}

/**
 * Fires after the map viewport has been moved.
 */
export declare class PanEndEvent extends BaseEvent implements MapPanEndEvent {
    /**
     * The map origin (top left or NW corner).
     */
    origin: Location_2;
    /**
     * The current map center.
     */
    center: Location_2;
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapPanEndEvent, target: Map_2);
}

/**
 * Fired while the map viewport is being moved.
 */
export declare class PanEvent extends BaseEvent implements MapPanEvent {
    /**
     * The map origin (top left or NW corner).
     */
    origin: Location_2;
    /**
     * The current map center.
     */
    center: Location_2;
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapPanEvent, target: Map_2);
}

/**
 * @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;
}

/**
 * Fired when the map is reset.
 *
 * This typically occurs on initial load and after a zoom/center change.
 */
export declare class ResetEvent extends BaseEvent implements MapResetEvent {
    /**
     * @hidden
     */
    constructor(_: any, target: Map_2);
}

/**
 * Fired when a shape is clicked or tapped.
 */
export declare class ShapeClickEvent extends BaseEvent implements MapShapeClickEvent {
    /**
     * The shape layer instance.
     */
    layer: MapLayer;
    /**
     * The shape instance.
     */
    shape: Element_2;
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapShapeClickEvent, target: Map_2);
}

/**
 * Fired when a shape is created, but is not rendered yet.
 */
export declare class ShapeCreatedEvent extends BaseEvent implements MapShapeCreatedEvent {
    /**
     * The shape layer instance.
     */
    layer: MapLayer;
    /**
     * The shape instance.
     */
    shape: Element_2;
    /**
     * The original data item for this Shape.
     */
    dataItem: any;
    /**
     * The shape location
     */
    location: Location_2;
    /**
     * @hidden
     */
    constructor(e: any, target: Map_2);
}

/**
 * Fired when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
 */
export declare class ShapeFeatureCreatedEvent extends BaseEvent implements MapShapeFeatureCreatedEvent {
    /**
     * The original data item for this Feature. Members include `geometries` and `properties`.
     */
    dataItem: any;
    /**
     * The shape layer instance.
     */
    layer: MapLayer;
    /**
     * The group containing feature shape instances.
     */
    group: Group;
    /**
     * A reference to the `dataItem.properties` object.
     */
    properties: any;
    /**
     * @hidden
     */
    constructor(e: MapShapeFeatureCreatedEvent, target: Map_2);
}

/**
 * Fired 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.
 */
export declare class ShapeMouseEnterEvent extends BaseEvent implements MapShapeMouseEnterEvent {
    /**
     * The shape layer instance.
     */
    layer: MapLayer;
    /**
     * The shape instance.
     */
    shape: Element_2;
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapShapeMouseEnterEvent, target: Map_2);
}

/**
 * Fired 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.
 */
export declare class ShapeMouseLeaveEvent extends BaseEvent implements MapShapeMouseLeaveEvent {
    /**
     * The shape layer instance.
     */
    layer: MapLayer;
    /**
     * The shape instance.
     */
    shape: Element_2;
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapShapeMouseLeaveEvent, target: Map_2);
}

/**
 * Context object for shape layer tooltips.
 */
export declare interface ShapeTooltipContext {
    /**
     * The original GeoJSON data item used to create the shape.
     */
    dataItem: any;
    /**
     * The index of the shape layer in the map.
     */
    layerIndex: number;
    /**
     * The location (center point) of the shape.
     */
    location: Location_2;
}

/**
 * @hidden
 */
declare interface Store {
    getState(): any;
    dispatch(action: StoreAction | object): void;
    subscribe(f: Function): Function;
}

/**
 * @hidden
 */
declare interface StoreAction {
    mapKey?: string;
    mapCollectionIdxKey?: string;
    type?: string;
    payload: any;
}

export { TileUrlTemplateArgs }

declare type TooltipContext = MarkerTooltipContext | ShapeTooltipContext | BubbleTooltipContext;

/**
 * Fired when the map zoom level has changed.
 */
export declare class ZoomEndEvent extends BaseEvent implements MapZoomEndEvent {
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapZoomEndEvent, target: Map_2);
}

/**
 * Fired when the map zoom level is about to change.
 *
 * Cancelling the event will prevent the user action.
 */
export declare class ZoomStartEvent extends PreventableEvent implements MapZoomStartEvent {
    /**
     * The source DOM event instance
     */
    originalEvent: any;
    /**
     * @hidden
     */
    constructor(e: MapZoomStartEvent, target: Map_2);
}

export { }