@progress/kendo-react-map 7.2.4-develop.3 → 7.2.4-develop.4

package/index.d.ts

@@ -1,13 +1,951 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2024 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the package root for more information
-*-------------------------------------------------------------------------------------------*/
-import CollectionConfigurationComponent from './components/base/CollectionConfigurationComponent';
-import ConfigurationComponent from './components/base/ConfigurationComponent';
-export { CollectionConfigurationComponent, ConfigurationComponent };
-export { Map } from './Map';
-export type { MapProps } from './MapProps';
-export * from './components';
-export * from './common/map-types';
-export * from './common/events';
-export * from './tooltip';
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 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 { 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 as JSX_2 } 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 { 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 PropTypes from 'prop-types';
+import * as React_2 from 'react';
+import { ShapeLayerOptions } from '@progress/kendo-charts';
+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>;
+    optionsStore: any;
+    constructor(props: any, context: any);
+    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>;
+    optionsStore: any;
+    childStore: any;
+    constructor(props: any, context: 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 %}).
+ */
+declare class Map_2 extends React_2.Component<MapProps, {}> {
+    /**
+     * @hidden
+     */
+    static propTypes: {
+        dir: PropTypes.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;
+    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 }
+
+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 | null>;
+
+/**
+ * @hidden
+ */
+declare interface MapContextType {
+    optionsStore: Store;
+    observersStore: Store;
+    childrenObserver: InstanceObserver;
+}
+
+export { MapControls }
+
+export { MapControlsPosition }
+
+export { MapLayer }
+
+export { MapLayerOptions }
+
+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 }
+
+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.
+     */
+    dir?: string;
+    /**
+     * The styles that are applied to the component.
+     */
+    style?: React_2.CSSProperties;
+    /**
+     * Sets additional CSS classes to the component.
+     */
+    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;
+}
+
+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 | null>;
+    context: React_2.ContextType<typeof MapContext>;
+    readonly state: MapTooltipState;
+    mapObserver?: InstanceObserver;
+    componentDidMount(): void;
+    render(): JSX_2.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 { }