import * as React from 'react';
import { IgrSeries } from "igniteui-react-charts";
import { IgrSeriesViewer, IIgrSeriesViewerProps } from "igniteui-react-charts";
import { IgRect } from "igniteui-react-core";
import { IgPoint } from "igniteui-react-core";
import { XamGeographicMap } from './XamGeographicMap';
import { IgrSeriesCollection } from "igniteui-react-charts";
import { IgrNumericXAxis } from "igniteui-react-charts";
import { IgrNumericYAxis } from "igniteui-react-charts";
import { IgrImageTilesReadyEventArgs } from './igr-image-tiles-ready-event-args';
import { IgrGeographicMapImagery } from './igr-geographic-map-imagery';
import { MapResizeBehavior } from './MapResizeBehavior';
import { MapBackgroundTilingMode } from './MapBackgroundTilingMode';
/**
 * Represents the Infragistics IgxGeographicMapComponent control.
*/
export declare class IgrGeographicMap extends IgrSeriesViewer<IIgrGeographicMapProps> {
    contentSeries: IgrSeries[];
    private _height;
    private _width;
    set height(value: string);
    get height(): string;
    /**
     * Gets or sets the legend used for the current chart.
    */
    get legend(): any;
    set legend(v: any);
    private _updateContentChildren;
    private _getMainRef;
    private _elRef;
    render(): React.DetailedReactHTMLElement<{
        className: string;
        ref: (ref: any) => void;
        children: any[];
    }, any>;
    protected _tooltipRef(t: any): void;
    componentDidMount(): void;
    set width(value: string);
    get width(): string;
    /**
     * The series actually present in the chart. Do not directly modify this array.
     * This array's contents can be modified by causing React to reproject the child content.
     * Or adding and removing series from the manual series collection on the series property.
     */
    actualSeries: IgrSeries[];
    private _container;
    private _series;
    /**
     * A collection or manually added series for the chart.
    */
    get series(): IgrSeriesCollection;
    constructor(props: IIgrGeographicMapProps);
    destroy(): void;
    componentWillUnmount(): void;
    private _initialized;
    private _wrapper;
    protected createImplementation(): XamGeographicMap;
    private _chart;
    private _dataSource;
    set dataSource(value: any);
    get dataSource(): any;
    bindData(): void;
    private _seriesAdapter;
    initializeContent(): void;
    private _ensureTooltipCreated;
    private _defaultTooltips;
    private _ensureDefaultTooltip;
    private _onDefaultTooltipsReady;
    private _activeTooltips;
    private _activeTooltipElements;
    private _currentTooltips;
    private _uniqueTooltipId;
    private createTooltip;
    private _updateTooltipState;
    /**
     * An imagery to display behind all series, inside the viewport of the IgrGeographicMapComponent control.
    */
    get backgroundContent(): IgrGeographicMapImagery;
    set backgroundContent(v: IgrGeographicMapImagery);
    /**
                             * @hidden
                             */
    get i(): XamGeographicMap;
    /**
 * Gets or sets zoomability of the current control
*/
    get zoomable(): boolean;
    set zoomable(v: boolean);
    /**
     * Gets or sets the behavior to use during resize.
    */
    get resizeBehavior(): MapResizeBehavior;
    set resizeBehavior(v: MapResizeBehavior);
    /**
     * Gets or sets if the map should horizontally wrap.
    */
    get isHorizontalWrappingEnabled(): boolean;
    set isHorizontalWrappingEnabled(v: boolean);
    /**
     * Gets or sets if the map should horizontally wrap.
    */
    get backgroundTilingMode(): MapBackgroundTilingMode;
    set backgroundTilingMode(v: MapBackgroundTilingMode);
    /**
     * Gets or sets whether to use the uncoerced world rect to constrain the zoom bounds.
    */
    get useWorldRectForZoomBounds(): boolean;
    set useWorldRectForZoomBounds(v: boolean);
    /**
     * Gets or sets whether skip resetting the zoom when the world rect changes.
    */
    get suppressZoomResetOnWorldRectChange(): boolean;
    set suppressZoomResetOnWorldRectChange(v: boolean);
    /**
     * Gets or sets the world bounding rectangle.
    */
    get worldRect(): IgRect;
    set worldRect(v: IgRect);
    /**
     * Gets the actual value of the WorldRect.
    */
    get actualWorldRect(): IgRect;
    set actualWorldRect(v: IgRect);
    /**
     * The X-axis for this IgxGeographicMap.Component
     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
    */
    get xAxis(): IgrNumericXAxis;
    set xAxis(v: IgrNumericXAxis);
    /**
     * The Y-axis for this IgxGeographicMap.Component
     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
    */
    get yAxis(): IgrNumericYAxis;
    set yAxis(v: IgrNumericYAxis);
    /**
     * Indicates if this SeriesViewer is a map.
    */
    get isMap(): boolean;
    /**
     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
     * This property is effectively a shortcut to the Width/Height of the WindowRect property.
    */
    get windowScale(): number;
    set windowScale(v: number);
    /**
     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
     * This property is effectively a shortcut to the Width/Height of the ActualWindowRect property.
    */
    get actualWindowScale(): number;
    set actualWindowScale(v: number);
    /**
     * Gets whether or not the control is ready for zooming
    */
    get zoomIsReady(): boolean;
    findByName(name: string): any;
    protected _styling(container: any, component: any, parent?: any): void;
    /**
 * Gets current world rect in geographic coordinates

*/
    getCurrentActualWorldRect(): IgRect;
    /**
     * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
    
    * @param geographic  * The geographic area.
    */
    getZoomRectFromGeoRect(geographic: IgRect): IgRect;
    /**
     * Updates zoom window using window coordinates
    
    */
    updateZoomWindow(zoomWindow: IgRect): void;
    /**
     * Updates world rect in geographic coordinates
    
    */
    updateWorldRect(worldRect: IgRect): void;
    /**
     * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
    
    * @param geographic  * The geographic area.
    */
    getZoomFromGeographicRect(geographic: IgRect): IgRect;
    convertGeographicToZoom(geographic: IgRect, extraPixelPadding: number): IgRect;
    getZoomFromGeographicPoints(northWest: IgPoint, southEast: IgPoint): IgRect;
    /**
     * Given a WindowRect and the current plot area, get the geographic region represented by that WindowRect.
    
    * @param windowRect  * The zoom area.
    */
    getGeographicFromZoom(windowRect: IgRect): IgRect;
    /**
     * Convert a pixel-based coordinate to a geographic coordinate.
    
    * @param pixelCoordinate  * A pixel-based coordinate
    */
    getGeographicPoint(pixelCoordinate: IgPoint): IgPoint;
    /**
     * Convert a geographic coordinate to a pixel-based coordinate.
    
    * @param geographicCoordinate  * A geographic coordinate
    */
    getPixelPoint(geographicCoordinate: IgPoint): IgPoint;
    /**
     * Convert a geographic coordinate to a pixel-based coordinate.
    
    * @param geographicCoordinate  * A geographic coordinate
    */
    getWindowPoint(geographicCoordinate: IgPoint): IgPoint;
    /**
     * Removes all cached tile images from the map imagery assigned to the map's background content.
    
    */
    clearTileCache(): void;
    /**
     * Notifies the chart that the CSS styles in effect have been updated.
    
    */
    styleUpdated(): void;
    /**
     * Gets actual window scale for horizontal dimension of the control
    
    */
    getActualWindowScaleHorizontal(): number;
    /**
     * Gets actual window scale for vertical dimension of the control
    
    */
    getActualWindowScaleVertical(): number;
    /**
     * Calls for a deferred refresh to the GeographicMap's background.
    
    */
    deferredRefresh(): void;
    /**
     * Returns the chart visuals expressed as a ChartVisualData object.
    
    */
    exportVisualData(): any;
    /**
     * Zoom in to the geographic region specified, when possible (may need to wait for map to be initialized).
    
    * @param geographic  * The geographic region to zoom to.
    */
    zoomToGeographic(geographic: IgRect): void;
    private _imageTilesReady;
    private _imageTilesReady_wrapped;
    /**
     * This event is fired whenever the image tiles transition from a loading state (e.g. some are fading in) to a loaded state.
    */
    get imageTilesReady(): (s: IgrGeographicMap, e: IgrImageTilesReadyEventArgs) => void;
    set imageTilesReady(ev: (s: IgrGeographicMap, e: IgrImageTilesReadyEventArgs) => void);
}
export interface IIgrGeographicMapProps extends IIgrSeriesViewerProps {
    width?: string;
    height?: string;
    /**
    * Gets or sets the data for the chart to use. This can be overriden at the series and axis level.
    */
    dataSource?: any[];
    /**
     * Gets or sets the legend used for the current chart.
    */
    legend?: any[];
    /**
    *  The GeographicMapImagery to display behind all series, inside the viewport of the IgxGeographicMapComponent control.
    */
    backgroundContent?: any;
    /**
 * Gets or sets zoomability of the current control
*/
    zoomable?: boolean | string;
    /**
     * Gets or sets the behavior to use during resize.
    */
    resizeBehavior?: MapResizeBehavior | string;
    /**
     * Gets or sets if the map should horizontally wrap.
    */
    isHorizontalWrappingEnabled?: boolean | string;
    /**
     * Gets or sets if the map should horizontally wrap.
    */
    backgroundTilingMode?: MapBackgroundTilingMode | string;
    /**
     * Gets or sets whether to use the uncoerced world rect to constrain the zoom bounds.
    */
    useWorldRectForZoomBounds?: boolean | string;
    /**
     * Gets or sets whether skip resetting the zoom when the world rect changes.
    */
    suppressZoomResetOnWorldRectChange?: boolean | string;
    /**
     * Gets or sets the world bounding rectangle.
    */
    worldRect?: IgRect | string;
    /**
     * Gets the actual value of the WorldRect.
    */
    actualWorldRect?: IgRect | string;
    /**
     * The X-axis for this IgxGeographicMap.Component
     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
    */
    xAxis?: IgrNumericXAxis;
    /**
     * The Y-axis for this IgxGeographicMap.Component
     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
    */
    yAxis?: IgrNumericYAxis;
    /**
     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
     * This property is effectively a shortcut to the Width/Height of the WindowRect property.
    */
    windowScale?: number | string;
    /**
     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
     * This property is effectively a shortcut to the Width/Height of the ActualWindowRect property.
    */
    actualWindowScale?: number | string;
    /**
 * This event is fired whenever the image tiles transition from a loading state (e.g. some are fading in) to a loaded state.
*/
    imageTilesReady?: (s: IgrGeographicMap, e: IgrImageTilesReadyEventArgs) => void;
}