import { Align, RObject, IPaddings, AlignBase, VerticalAlign, ChartItemLocation, IPoint as IPoint$1, ISides, IRect, ISize, PercentSize, ColorRange, WritingMode, TextOrientation, TextFormatter, Color, Positions, ConfigObject, ROptionable, Rectangle } from '@realgrid/common';
export { Align, Color, DEG_RAD, Dom, IPercentSize, IRect, ISize, ORG_ANGLE, PI, PI_2, PercentSize, RAD_DEG, Size, Utils, _isIE, absv, assignObj, calcPercent, ceil, copyObj, cos, createRect, floor, incv, isArray, isEmptyRect, isObject, isString, maxv, minv, parsePercentSize, pickNum, pickProp, pickProp3, pixel, rectToSize, sin } from '@realgrid/common';

type Path = string | any[];
declare function fixnum(value: number): number;
/**
 * SVG 스타일 속성.<br/>
 * {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute SVG 속성}을 참조한다.<br/>
 */
interface SVGStyles {
    transform?: string;
    transformBox?: string;
    transformOrigin?: string;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill fill} 스타일 속성.<br/>
     */
    fill?: string;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/filter filter} 스타일 속성.<br/>
     */
    filter?: string;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill-opacity fill-opacity} 스타일 속성.<br/>
     */
    fillOpacity?: string | number;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke stroke} 스타일 속성.<br/>
     */
    stroke?: string;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-width stroke-width} 스타일 속성.<br/>
     */
    strokeWidth?: string | number;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray stroke-dasharray} 스타일 속성.<br/>
     */
    strokeDasharray?: string | number;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/font-family font-family} 스타일 속성.<br/>
     */
    fontFamily?: string;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/font-size font-size} 스타일 속성.<br/>
     */
    fontSize?: string | number;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/font-weight font-weight} 스타일 속성.<br/>
     */
    fontWeight?: string | number;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/font-style font-style} 스타일 속성.<br/>
     */
    fontStyle?: string;
    /**
     * SVG에 적용되는 css {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx rx} 스타일 속성.<br/>
     * {@link https://realmap.co.kr/config/config/seires/bar bar} 시리즈의 데이터포인트 bar의 모서리를 지정하는 데 사용된다.
     */
    rx?: string | number;
    /**
     * 텍스트 정렬을 지정한다.<br/>
     * **SVG에 적용되는 정식 css style 속성이 아니다.**
     * 즉, HTML이나 realmap-style.css 등의 외부 css 파일에서 사용할 수 없고,
     * RealMap 내부에서 {@link https://realmap.co.kr/config/config/title title} 등의 inline 스타일 속성으로 지정할 수 있다.
     *
     * ```js
     * const config = {
     *      subtitle: {
     *          style: {
     *              textAlign: 'left',
     *          },
     *      },
     * };
     * ```
     */
    textAlign?: Align;
    /**
     * **SVG에 적용되는 정식 css style 속성이 아니다.**<br/>
     * 데이터포인트 라벨등 몇 요소의 배경 간격 설정으로 사용할 수 있다.
     */
    padding?: string;
}
/** {@link it.SVGStyles SVGStyles} 또는 class 이름 */
type SVGStyleOrClass = SVGStyles | string;
/**
 * CSS 선언 블록을 나타내는 객체로, 스타일 정보뿐만 아니라 다양한 스타일 관련 메서드와 속성들을 제공한다. <br/>
 * https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration
 */
interface CSSStyles extends Partial<CSSStyleDeclaration> {
}
/**
 * 스와이프 제스처 등의 진행 방향.
 * <br>
 *
 * @see {@link RtListControl.onRowSwipe onRowSwipe}
 */
declare enum RmDirection {
    /**
     * 위쪽으로 진행.
     */
    UP = "up",
    /**
     * 아래쪽으로 진행.
     */
    DOWN = "down",
    /**
     * 왼쪽으로 진행.
     */
    LEFT = "left",
    /**
     * 오른쪽으로 진행.
     */
    RIGHT = "right"
}

type ShapeDrawer = (rd: number, rd2: number) => (string | number)[];
/**
 * 맵 좌표. [경도, 위도]
 */
type MapCoord = [number, number];
type MapRect = {
    h1: number;
    h2: number;
    v1: number;
    v2: number;
};
type MapArc = MapCoord[];
type MapPolygon = MapArc[];
type MapProps = any;
declare function parseCoord(v: any): MapCoord;

interface MapInsetDisplay {
    /**
     * inset area 확대 비율.<br/>
     * 지정하지 않으면 1.
     * 0보다 큰 값이어야 한다.
     */
    readonly scale?: number;
    /**
     * inset area의 [왼쪽, 위쪽] 기준으로, 표시 위치 [경도, 위도]를 도(°) 단위로 지정한다.<br/>
     * [주의] {@link MapInset.children children}으로 적용될 때는 이 값 대신 {@link offset}을 반드시 지정해야 한다.
     */
    readonly coord?: MapCoord;
    /**
     * coord로 지정한 inset 위치에 더 추가되는 [경도, 위도] 값이거나
     * coord가 지정되지 않은 경우 원래 위치에서 떨어진 위치 값.<br/>
     * 라이브러리에서 제공하는 미리 정의된 inset 위치를 조정하는 값으로 사용할 수 있다.
     * [주의] {@link MapInset.children children}으로 적용될 때는 {@link coord} 대신 반드시 이 값을 지정해야 한다.
     */
    readonly offset?: MapCoord;
    /**
     * inset을 구분하는 경계선을 도(°)단위로 지정한다.<br/>
     * 값들은 space나 ','로 분리해서 x, y 순서대로 위치를 지정하고,
     * 닫힌 다각형으로 지정하고 싶은 경우 마지막에 'z'나 'Z'을 추가한다.
     * 또, {@link frame}이 지정되면 이 값은 무시된다.<br/>
     * 값들은 각각 area 전체를 감싸는 가상의 사각형을 기준으로 작성하는데,
     * 아래 값들을 상수로 사용할 수 있고, +,- 연산자로 offset을 지정할 수 있다.
     * x값은 사각형 왼쪽(경도 시작접), y값은 사각형 아래쪽(위도 시작점)이 원점이 된다.
     * w와 h는 각각 사각형의 너비와 높이다.
     * x값은 원점에서 오른쪽으로 증가하고, y값은 원점에서 위쪽으로 증가한다.<br/>
     * ex) '-0.1 h+0.05 +0.1 h+0.1 w+0.2 h' // 제주도 위쪽에 꺽인 line을 표시한다.
     *     '-0.2 -0.1 -0.2 h+0.1' // 울릉도 좌측에 직선으로 표시한다.
     */
    readonly border?: MapCoord[] | string;
    /**
     * inset을 감싸서 구분하는 사각형을 도(°)단위로 지정한다.<br/>
     * 이 값이 지정되면 {@link border}는 무시된다.<br/>
     * css padding이나 margin 지정 방식과 동일하게 지정한댜.
     * 지정된 값은 area의 전체를 포함하는 가상의 사각형과 frame 사이의 간격으로 표시된다.<br/>
     * ex) '0.05'       // 좌위상하 0.05°
     *     '0.05 0.01'     // 상하 0.05°, 좌우 0.01°
     *     '0.05 0.01 0.03'   // 상 0.05°, 우 0.01°, 하 0.03, 좌 0.01°
     *     '0.05 0.01 0.03 0.02' // 상, 우, 하, 좌
     */
    readonly frame?: string;
    /**
     * border나 frame에 적용할 스타일셋.<br/>
     * 기본으로 'rm-map-series-inset' 클래스 선택자가 적용된다.
     */
    readonly style?: SVGStyleOrClass;
    /**
     * 명시적 false로 지정하면 이 inset이 포함하는 영역을 맵에서 제거한다.<br/>
     * 대개 두 번째 map에서 사용된다.
     */
    readonly visible?: boolean;
}
/**
 * 본토에서 멀리 떨어진 영역들을 당겨서 표시하는 설정.<br/>
 * [주의] 아래쪽 계산값들을 제외하곤 모두 readonly로 취급해야 한다.
 *
 * @css 'rm-map-series-inset'
 */
interface MapInset extends MapInsetDisplay {
    /**
     * inset시킬 area id.<br/>
     * 이 area가 존재하지 않고,
     * {@link parent}가 지정되지 않으면
     * 자식들을 모두 함께 이동시킨다.
     */
    readonly area: string;
    readonly name?: string;
    /**
     * 이 area가 존재하지 않고,
     * {@link MapInset.parent parent}가 지정되지 않으면
     * 이 속성에 지정된 자식들을 모두 함께 이동시킨다.<br/>
     * [주의] {@link frame}이나 {@link border}의 기준이 되는 child area의 id를 첫번째 항목으로 설정해야 한다.
     * [주의] parent 하나에 한 번만 지정할 수 있다.
     */
    readonly children?: string[];
    /**
     * {@link area}가 존재하지 않을 때,
     * 이 속성에 해당하는 area를 찾아서 {@link polygons}에 해당하는 영역들을 이동시킨다.<br/>
     * 콤마로 분리해서 둘 이상의 area를 지정할 수 있는데, 순서대로 해당되는 영역이 존재하면 사용한다.
     * [주의] parent 하나에 한 번만 지정할 수 있다.
     */
    readonly parent?: string;
    /**
     * {@link area}가 존재하지 않고, {@link parent}가 지정됐을 때,
     * 이 속성에 지정하는 영역들을 동시에 이동시킨다.<br/>
     * [주의] {@link frame}이나 {@link border}의 기준이 되는 polygon의 index를 첫번째 항목으로 설정해야 한다.
     * [주의] {@link parent}가 복수개로 지정되면 이 속성도 [[], [],..] 형태로 복수 개 지정해야 한다.
     * [주의] parent 하나에 한 번만 지정할 수 있다.
     */
    readonly polygons?: number[] | number[][] | number;
    /**
     * @private
     * 계산된 값들.
     */
    off?: MapCoord;
    box?: MapCoord[];
    pts?: any[];
    bounds?: MapRect;
}
type MapSourceMeta = {
    license?: {
        license?: string;
        author?: string;
        url?: string;
        etc?: "맵차트 최적화를 위해 좌표계 변환 및 Feature Polygon 수정";
    };
    dokdo?: {
        group?: string;
        parent?: number;
        index?: number;
    };
    dummies?: string[];
};
/**
 * 접경선 정보.<br/>
 * 연결된 선으로 표시되므로, 반드시 접경선이 그려지는 순서대로  양쪽 area(들)을 지정해야 한다.
 */
type MapBorderSource = [string | [string], string | [string]];
/**
 * {@link MapSource.unions unions}로 병합할 영역 하나의 설정.<br/>
 * 병합된 영역은 멤버 영역들의 속성을 승계하지 않는다.
 * id와 이름을 포함한 모든 속성은 이 설정에 지정한 값으로 결정된다.
 */
interface MapUnion {
    /**
     * 하나로 병합할 영역들의 id 목록.<br/>
     * 2개 이상 지정해야 한다.
     * {@link MapSource.exclude exclude}된 영역과 찾을 수 없는 id는 제외되고,
     * 남은 영역이 2개 미만이면 병합하지 않는다.
     */
    readonly members: string[];
    /**
     * 병합된 영역의 id.<br/>
     * 지정하지 않으면 {@link members}에서 찾은 첫번째 영역의 id를 사용한다.<br/>
     * 공백을 포함할 수 없고, 병합되지 않는 다른 영역의 id와 겹치지 않아야 한다.
     * 사용할 수 없는 값이면 경고를 출력하고 첫번째 영역의 id를 사용한다.
     */
    readonly id?: string;
    /**
     * 병합된 영역의 속성.<br/>
     * [주의] 멤버 영역들의 속성은 승계되지 않고 이 값으로 대체된다.
     * 따라서 영역 이름을 표시하려면 이름 속성({@link MapSource.nameKey nameKey},
     * 지정하지 않으면 로케일에 따라 'name'이나 'en-name')을 반드시 포함해야 한다.<br/>
     * id 속성({@link MapSource.idKey idKey})은 {@link id}로 설정한 값으로 덮어써지고,
     * 'rm-main-area'는 병합 결과의 polygon 순서와 어긋나므로 지정해도 무시된다.
     */
    readonly properties?: MapProps;
    /**
     * 병합된 영역의 중심 [경도, 위도].<br/>
     * 영역 라벨과 데이터포인트의 기본 위치로 사용되며, 속성의 'ctr-lon', 'ctr-lat'로 설정된다.<br/>
     * 지정하지 않으면 병합된 영역 경계(bounds)의 중심이 사용된다.
     * 무게 중심을 자동으로 계산하지는 않는다.
     */
    readonly center?: MapCoord;
}
/**
 * 맵시리즈에서 사용할 기본 맵을 지정한다.<br/>
 */
interface MapSource {
    /**
     * 맵 이름.<br/>
     * 맵차트에 여러 개 맵이 지정될 수 있으며,
     * 맵차트 시리즈 등에서 맵을 참조할 때 사용된다.
     */
    name?: string;
    /**
     * 명시적 false로 지정하면 맵차트에서 맵으로 사용되지 않는다.<br/>
     *
     * @default true
     */
    enabled?: boolean;
    /**
     * @deprecated use {@link source}
     **/
    map?: any;
    /**
     * 영역들의 정보가 포함된 지도 데이터 소스.<br/>
     */
    source?: any;
    /**
     * 외부 {@link source}를 가져올 위치.<br/>
     */
    url?: string;
    /**
     * 기준 지도({@link source} 또는 {@link url})에 추가할 영역들의 GeoJson 목록.<br/>
     * 문자열로 지정하면 해당 url에서 GeoJson을 가져온다.
     * (문자열 url은 RealMap.createChartAsync()로 생성할 때만 사용할 수 있다.)<br/>
     * 추가된 영역(feature)의 속성에 {@link parentKey}에 해당하는 값이 있으면,
     * 그 값을 id로 갖는 기준 지도 영역에서 추가된 영역의 경계만큼을 빼서(subtract)
     * 두 영역이 겹치지 않게 표시한다.<br/>
     * ex) 시도 지도에 '강릉시'를 추가하면 '강원특별자치도'는 강릉시를 제외한 영역이 된다.
     */
    areas?: (string | object)[];
    /**
     * 병합할 영역들의 설정 목록.<br/>
     * 각 항목의 {@link MapUnion.members members}에 나열된 영역들이 하나의 영역으로 병합된다.
     * 병합된 영역의 id와 속성, 중심 좌표는 멤버에서 승계하지 않고 항목에 지정한 값으로 결정된다.<br/>
     * 병합은 기준 지도에 {@link areas}가 추가되고 subtract가 적용된 다음,
     * 목록에 지정된 순서대로 실행된다.
     * 따라서 앞에서 병합된 영역의 id를 뒤 항목의 멤버로 지정할 수 있다.<br/>
     * ```js
     * unions: [{
     *     members: ['24', '36'],
     *     properties: { name: '광주전남' },
     *     center: [126.9, 34.85]
     * }] // 광주광역시와 전라남도를 '광주전남' 영역 하나로 병합한다.
     *  ```
     */
    unions?: MapUnion[];
    /**
     * {@link areas}로 추가된 영역에서 subtract 대상 부모 영역의 id를 찾을 때 사용할 속성 이름.<br/>
     *
     * @default 'rm-parent'
     */
    parentKey?: string;
    /**
     * 맵 모델의 area를 구성할 때 area id로 사용할 소스의 속성 이름.<br/>
     */
    idKey?: string;
    /**
     * 맵 모델의 area를 구성할 때 area name으로 사용할 소스의 속성 이름.<br/>
     * 지정하지 않으면 차트의 {@link https://realmap.co.kr/docs/api/options/ChartGlobalOptions#locale locale}에 따라 이름 속성이 결정된다.
     */
    nameKey?: string;
    /**
     * 맵차트 맵 모델을 구성할 때 제외시킬 영역들의 id 목록.<br/>
     */
    exclude?: string[];
    /**
     * 맵 인셋 목록을 지정한다.<br/>
     * 이름을 문자열로 지정하면 라이브러기가 기본 제공하는 인셋들이 사용된다.
     * 또, 이름앞에 '-'를 추가하면 visible이 false로 설정된다.
     */
    insets?: (string | MapInset)[];
    /**
     * 맵 상하좌우 주변에 추가할 영역의 크기를  도(°) 단위로 지정한다.<br/>
     * css padding이나 margin 지정 방식과 동일하게 지정한댜.<br/>
     * 상하좌우가 같은 값이면 숫자로 지정할 수 있다.
     */
    padding?: string | number;
    /**
     * 지도에 독도에 대한 meta 정보가 있는 경우,
     * 독도와 울릉도 사이의 거리를 지정한 비율만큼으로 줄이거나 늘여서 표시한다.<br/>
     * 0 ~ 1 사이의 값으로 원래 간격에 대한 상대 거리를 지정한다.
     * 0 이하의 값으로 지정하면 dokdo를 표시하지 않는다.
     * [lon, lat] 형식으로 지정할 수도 있다.
     */
    dokdo?: number | MapCoord;
    /**
     * dummy 영역들을 표시할지 여부.<br/>
     */
    showDummies?: boolean;
    /**
     * @ignore
     * 로컬 지도가 글로벌 투영좌표계 중앙으로 배치할지 여부.<br/>
     * 첫번째 기준 map에만 설절할 수 있다.
     */
    useOffset?: boolean | MapCoord;
    /**
     * 부극 취고위까지 지도에 포함되면 90도까지 그려진 것으로 간주한다.<br/>
     * 명시적 false로 지정하면 계산된 영역까지만 포함한다.
     */
    alignArctic?: boolean;
    /**
     * 내부 경계(internal boundary)선 정보를 별도로 생성할 지 여부.<br/>
     */
    needInternal?: boolean;
    /**
     * {@link needInternal 내부 경계선}에서 제외할 영역 목록.<br/>
     */
    excludeInternal?: string[];
    /**
     * 외부 경계선 정보를 별도로 생성할 지 여부.<br/>
     */
    needExternal?: boolean;
    /**
     * {@link needInternal 내부 경계선}에서 제외할 영역 목록.<br/>
     */
    excludeExternal?: string[];
    /**
     * 접경선 목록.<br/>
     */
    borders?: [{
        name: string;
        border: MapBorderSource;
        closed?: boolean;
    }];
    /**
     * 지도의 표시 경계를 수동으로 지정한다.<br/>
     * [최소 경도, 최소 위도, 최대 경도, 최대 위도] 형태로 지정한다.<br/>
     * - bounds와 지도(url/source) 모두 지정되면 bounds가 경계가 된다. (지도가 작으면 덜 그려지고, 더 크면 clip됨)
     * - bounds만 지정되고 지도가 없으면 bounds가 경계가 된다.
     * - 둘 다 지정하지 않으면 지도 폴리곤에서 자동 계산된 경계를 사용한다.
     *
     * 주의: Orthographic Projection을 사용하는 경우, 해당 옵션은 무시된다.
     */
    bounds?: [number, number, number, number];
}
declare abstract class MapSourceItem {
    id: string;
    constructor(id: string);
}
declare class AreaItem extends MapSourceItem {
    props: MapProps;
    polygon: MapPolygon;
    polygons: MapPolygon[];
    internal?: MapPolygon[];
    internals?: MapPolygon[][];
    external?: MapPolygon[];
    externals?: MapPolygon[][];
    dummy: boolean;
    holes: boolean;
    constructor(id: string, props: MapProps);
}
declare class MapBorderInfo {
    name: string;
    closed: boolean;
    border: [string[], string[]];
    constructor(name: string, source: MapBorderSource, closed: boolean);
}
declare class BorderItem extends MapSourceItem {
    polygon: MapPolygon;
    constructor(id: string, polygon: MapPolygon);
}
declare abstract class MapSourceImpl extends RObject {
    static createStockInset(area?: string, display?: boolean | MapInsetDisplay): MapInset;
    readonly name: string;
    readonly enabled: boolean;
    readonly idKey: string;
    readonly nameKey: string;
    readonly parentKey: string;
    readonly meta: MapSourceMeta;
    readonly dokdo: number;
    readonly dummies: string[];
    readonly useOffset: boolean | MapCoord;
    readonly internals: boolean;
    readonly externals: boolean;
    readonly alignArctic: boolean;
    readonly borders: MapBorderInfo[];
    readonly bounds: [number, number, number, number] | undefined;
    items: MapSourceItem[];
    insets: {
        [area: string]: MapInset;
    };
    paddings: IPaddings;
    private _excludes;
    constructor(options: MapSource, index: number);
    included(area: string): boolean;
    private $_load;
    /**
     * area의 id를 결정한다. MapModel.$_load의 id 결정 규칙(props[idKey] 우선, 없으면 feature id)과 동일해야 한다.
     * feature id가 숫자일 수 있으므로(RFC 7946) 문자열로 정규화해서 비교에 사용한다.
     */
    private $_itemId;
    /**
     * areas/unions 옵션을 items에 적용한다.<br/>
     * 1. areas의 GeoJson feature들을 AreaItem으로 만들어 items에 추가한다.
     * 2. 추가된 영역에 parentKey 속성이 있으면 해당 부모 영역에서 추가 영역을 뺀다(subtract).
     * 3. unions의 각 id 그룹을 하나의 영역으로 병합한다.
     */
    private $_processAreas;
    /**
     * dokdo meta와 inset 설정이 참조하는 영역 id들.<br/>
     * 이 영역들을 병합하면 polygon 인덱스나 id 참조가 깨지므로 병합 대상에서 제외한다.
     */
    private $_reservedAreas;
    /**
     * MapUnion 설정 하나에 해당하는 영역들을 병합해서 items의 첫번째 멤버 자리에 놓고,
     * 나머지 멤버들은 items에서 제거한다.
     */
    private $_mergeAreas;
    /**
     * 병합된 영역의 id를 결정한다.<br/>
     * 지정된 id를 사용할 수 없으면 경고를 출력하고 첫번째 멤버의 id를 사용한다.
     */
    private $_unionAreaId;
    /**
     * 병합된 영역의 속성을 구성한다.<br/>
     * [주의] 멤버 영역의 속성은 승계하지 않고 설정에 지정된 속성으로 대체한다.
     */
    private $_unionProps;
    protected abstract _doLoad(source: object, options: MapSource): MapSourceItem[];
}

/**
 * @enum
 */
declare const _ExportType: {
    /**  */
    readonly PNG: "png";
    /**  */
    readonly JPEG: "jpeg";
    /**  */
    readonly SVG: "svg";
    /**  */
    readonly PDF: "pdf";
    /**  */
    readonly PRINT: "print";
};
/**
 * 내보내기 종류
 */
type ExportType = typeof _ExportType[keyof typeof _ExportType];
/**
 * 내보내기 옵션.
 */
interface ExportOptions {
    /**
     * 내보낸 맵차트에 사용할 확장자.\
     * type을 지정하지 않을 경우 png로 내보내기 된다.\
     * 
     * // @TODO https://github.com/realgrid/realreport-chart/issues/549
     */
    type?: ExportType;
    /**
     * 내보낸 맵차트에 사용할 확장자 없는 파일명.
     * fileName을 지정하지 않을 경우 realmap.type으로 다운로드 된다.
     * 
     */
    fileName?: string;
}
/**
 * 외부 모듈로 구현되는 맵차트 내보내기 기능 명세.
 */
interface ChartExporter {
    exportToImage: (dom: HTMLElement, options: ExportOptions) => void;
    exportToPrint: (dom: HTMLElement, options: ExportOptions) => void;
    isContextMenuVisible: () => boolean;
    toggleContextMenu: () => void;
    contains: (dom: Element) => boolean;
    hideContextMenu: () => void;
    /**
     * @private
     * #565: 차트 파괴 시 document 리스너 등 외부 자원을 정리한다.
     */
    dispose: () => void;
}

/**
 * @enum
 */
declare const _ClickAction: {
    readonly NONE: "none";
    readonly SELECT: "select";
    /**
     * 맵차트가 zoom 가능한 상태일 때 zoom-in 한다.
     */
    readonly ZOOM: "zoom";
    /**
     * 표시된 지도 크기가 표시 영역보다 클 때,
     * 클릭한 위치가 표시 중앙이 되도록 한다.
     */
    readonly CENTER: "center";
    /**
     * 클릭한 영역이 포함된 맵시리즈가 drilldown 가능한 상태일 때,
     * drilldown을 실해하고 클릭한 영역의 상세가 표시되도록 한다.<br/>
     */
    readonly DRILLDOWN: "drilldown";
    /**
     * drilldow이 가능한 상태면 drilldown하거나,
     * 아니면 zoom-in 한다.
     */
    readonly DRILL_OR_ZOOM: "drillOrZoom";
};
/** @dummy */
type ClickAction = typeof _ClickAction[keyof typeof _ClickAction];
/**
 * @enum
 */
declare const _DblClickAction: {
    readonly NONE: "none";
    readonly SELECT: "select";
    /**
     * 맵차트가 zoom 가능한 상태일 때 zoom-in 한다.
     */
    readonly ZOOM: "zoom";
    /**
     * 표시된 지도 크기가 표시 영역보다 클 때,
     * 클릭한 위치가 표시 중앙이 되도록 한다.
     */
    readonly CENTER: "center";
    /**
     * 더블클릭한 영역이 포함된 맵시리즈가 drilldown 가능한 상태일 때,
     * drilldown을 실해하고 클릭한 영역의 상세가 표시되도록 한다.<br/>
     */
    readonly DRILLDOWN: "drilldown";
    /**
     * drilldow이 가능한 상태면 drilldown하거나,
     * 아니면 zoom-in 한다.
     */
    readonly DRILL_OR_ZOOM: "drillOrZoom";
};
/** @dummy */
type DblClickAction = typeof _DblClickAction[keyof typeof _DblClickAction];
/**
 * @enum
 */
declare const _DragAction: {
    /**
     * 구 지도이면 회전하고, 스크롤 가능한 세계지도면 스크롤하고, 아니면 지도를 이동(pan) 시킨다.<br/>
     */
    readonly DEFAULT: "default";
    /**
     * 드래그로 결정된 영역에 포함된 area들을 선택한다.<br/>
     * ctrl/cmd 키가 눌러진 상태가 아니면 기존 선택은 취소된다.
     */
    readonly SELECT: "select";
    /**
     * 드래그로 결정된 영역이 화면을 채우도록 zoom-in 한다.<br/>
     */
    readonly ZOOM: "zoom";
};
/** @dummy */
type DragAction = typeof _DragAction[keyof typeof _DragAction];
interface OnClickArgs extends CommonCallbackArgs {
    x: number;
    y: number;
    coord: MapCoord;
    area?: string;
}
/**
 * 맵차트 전체에 영향을 미치는 옵션들.<br />
 *
 */
interface ChartGeneralOptions extends ChartItemOptions {
    /**
     * theme 이름.<br/>
     * **realmap-style.css**에 기본 theme이 정의되어 있다.
     */
    theme?: string;
    /**
     * 로케일(언어) 설정.<br/>
     * 지도 영역 이름이 로케일에 해당하는 feature 속성으로 표시된다.
     * 'ko'는 'name' 속성을, 'en'은 'en-name'(없으면 'name-en', 'name' 순서) 속성을 사용한다.
     * 맵소스에 {@link https://realmap.co.kr/docs/api/options/MapSourceOptions#nameKey nameKey}가 명시되면 그 속성이 우선한다.<br/>
     * 'en-US'처럼 지역이 포함된 코드는 2자리 언어 코드로 해석되고, 등록되지 않은 언어면 'ko'로 동작한다.<br/>
     * 차트 생성 이후 `updateOptions({ chart: { locale } })`로 이 값을 변경하면
     * 이미 로드된 지도의 영역 이름·데이터포인트 이름·범례 카테고리도 refetch 없이 다시 계산된다.
     * 단, 데이터를 다시 가져오지는 않으므로 소스 feature에 해당 언어 속성이 없으면 'name'으로 폴백하고,
     * nameKey가 명시된 맵소스의 영역 이름은 로케일과 무관하게 유지된다.
     *
     * @default 'ko'
     */
    locale?: string;
    /**
     * false가 아닌 경우 첫번째 시리즈가 'map' 시리즈가 아니면 내부적으로 자동 추가한다.<br/>
     *
     * @default true
     */
    alwaysMap?: boolean;
    /**
     * 차트 전체 수준의 상호작용 여부를 지정한다.<br/>
     * false이면 hover, tooltip, crosshair, 맵 클릭, 선택, drilldown, 범례 클릭, 드래그, 휠 줌, 핀치 줌,
     * 더블클릭이 차단된다. 상호작용은 아니지만 {@link https://realmap.co.kr/config/config/general#animatable 애니메이션}도 함께 차단된다.<br/>
     * 단, 줌 패널은 차트가 그린 UI 컨트롤이므로 이 옵션과 무관하게 표시되고 버튼도 동작한다.
     * 드릴다운 패널은 `type`이 'button'일 때의 뒤로가기 버튼만 동작하며, 기본값인 'text'의 경로 텍스트는 차단된다.<br/>
     * 패널 버튼까지 막으려면 {@link https://realmap.co.kr/config/config/general#clickable clickable}을 false로 지정한다.<br/>
     * true는 끄는 방향으로만 동작하는 이 옵션을 해제할 뿐이며, 각 옵션에 설정한 값이 그대로 적용된다.<br/>
     * {@link https://realmap.co.kr/config/config/series/map#interactive interactive}를 통해 개별 시리즈 수준에서 상호작용 여부를 지정할 수 있다.<br/>
     *
     * @default true
     */
    interactive?: boolean;
    /**
     * 맵 영역 등을 클릭하거나 tap했을 때 실행될 action.<br/>
     *
     * @default 'none'
     */
    clickAction?: ClickAction;
    /**
     * 맵 영역 등을 더블 클릭하거나 더블 tap했을 때 실행될 action.<br/>
     *
     * @default 'zoom'
     */
    dblClickAction?: DblClickAction;
    /**
     * 마우스 드래그 시 실행될 action.<br/>
     *
     * @default 'default'
     */
    dragAction?: DragAction;
    /**
     * 맵차트 컨트롤의 배경 div 속성을 지정한다.<br/>
     * 스타일 속성은 svg가 아니라 html css 속성들로 지정한다.
     */
    backgroundStyle?: CSSStyles;
    /**
     * legend, color scale 등의 위젯들이 표시되는 영역과 body 사이의 간격.<br/>
     * 숫자 값이나 css margin 지정 방식의 문자열로 지정할 수 있다.
     *
     * @default 8
     */
    widgetSectionGap?: number | string;
    /**
     * legend, color scale 등의 위젯들이 표시되는 영역 내에서 위젯 사이의 간격.<br/>
     *
     * @default 8
     */
    widgetGap?: number;
    /**
     * 차트 div 크기가 변경됐을 때 지정한 시간(밀리초) 이후에 다시 그린다.<br>
     * 0 이하면 대기 없이 바로 다시 그리기를 요청한다.<br>
     *
     * @default 50 밀리초
     */
    resizeDelay?: number;
    /**
     * 마우스 휠을 통한 줌인/아웃을 비활성화할지 여부.<br/>
     * true로 설정하면 줌 패널 버튼은 사용할 수 있지만 마우스 휠로는 줌 조절이 불가능하다.<br/>
     * {@link https://realmap.co.kr/config/config/general#interactive interactive}가 false이면 이 옵션과 관계없이 휠 줌은 비활성화된다.<br/>
     *
     * @default false
     */
    wheelDisabled?: boolean;
    /**
     * false로 설정하면 차트 애니메이션이 실행되지 않는다.<br/>
     * {@link https://realmap.co.kr/config/config/general#interactive interactive}가 false이면 이 옵션과 관계없이 애니메이션은 실행되지 않는다.<br/>
     *
     * @default true
     */
    animatable?: boolean;
    /**
     * false로 설정하면 차트에 대한 호버 동작이 비활성화된다.<br/>
     * tooltip, crosshair 등 hover 기반 기능이 모두 작동하지 않는다.<br/>
     * {@link https://realmap.co.kr/config/config/general#interactive interactive}가 false이면 이 옵션과 관계없이 hover 상호작용은 비활성화된다.<br/>
     *
     * @default true
     */
    hoverable?: boolean;
    /**
     * false로 설정하면 차트에 대한 클릭 동작이 비활성화된다.<br/>
     * onClick, 범례 클릭, 선택, 클릭 drilldown, 줌 패널 버튼 등 클릭 기반 기능이 모두 작동하지 않는다.
     * [주의] 더블클릭 action은 이 옵션을 따르지 않는다.<br/>
     * {@link https://realmap.co.kr/config/config/general#interactive interactive}가 false이면 이 옵션과 관계없이 맵 클릭과 범례 클릭이 비활성화된다.
     * 단, 줌 패널 버튼은 이 옵션만 따르므로 `interactive`가 false여도 동작한다.<br/>
     *
     * @default true
     */
    clickable?: boolean;
    /**
     * false로 설정하면 차트 드래그 동작이 비활성화된다.<br/>
     * {@link https://realmap.co.kr/config/config/general#dragAction dragAction}으로 지정한 동작과 Globe 회전, 지도 이동이 모두 작동하지 않는다.<br/>
     * {@link https://realmap.co.kr/config/config/general#interactive interactive}가 false이면 이 옵션과 관계없이 드래그는 비활성화된다.<br/>
     *
     * @default true
     */
    draggable?: boolean;
    /**
     * 마우스 포인터가 클릭됐을 때 호출되는 콜백.<br/>
     */
    onClick?: (args: OnClickArgs) => void;
    /**
     * 선택 변경 시 호출되는 콜백.<br/>
     */
    onSelectionChanged?: (args: OnSelectionChangedArgs) => void;
}
type ChartGlobalOptions = ChartGeneralOptions;
/**
 * 맵차트 제목(title) 설정 모델.<br/>
 * 기본적으로 맵차트 중앙 상단에 표시되지만 {@link align}, {@link verticalAlign} 등으로 위치를 변경할 수 있다.<br/>
 *
 * {@link https://realmap.co.kr/guide/title 타이틀 개요} 페이지를 참조한다.
 */
interface TitleOptions extends ChartItemOptions {
    /**
     * true로 설정되고 {@link text}가 비어 있지 않은 텍스트로 설정된 경우에 표시된다.
     *
     * @default true
     */
    visible?: boolean;
    /**
     * 제목 텍스트.<br/>
     *
     * @default 'Title'
     */
    text?: string;
    /**
     * 정렬 기준.<br/>
     * 시리즈들이 그려지는 plotting 영역이나,
     * 맵차트 전체 영역을 기준으로 할 수 있다.
     * 또, {@link https://realmap.co.kr/config/config/subtitle 부제목}인 경우 제목을 기준으로 위치를 지정할 수 있다.
     *
     * @default 'map'
     */
    alignBase?: AlignBase;
    /**
     * 수평 정렬.<br/>
     *
     * @default 'center'
     */
    align?: Align;
    /**
     * 수직 정렬.<br/>
     *
     * @default 'middle'
     */
    verticalAlign?: VerticalAlign;
    /**
     * 배경 {@link it.SVGStyles 스타일셋} 또는 css {@link https://developer.mozilla.org/ko/docs/Web/CSS/CSS_selectors selector}.
     */
    backgroundStyle?: SVGStyleOrClass;
    /**
     * 주 제목과 부 제목이 표시되는 영역과 맵차트 본체 등 과의 간격을 픽셀 단위로 지정한다.<br/>
     * 주 제목이 표시되면 (부 제목의 값은 무시되고)주 제목의 값을 사용하고,
     * 부 제목만 표시될 때는 부 제목의 값을 사용한다.
     *
     * @default 10
     */
    gap?: number;
}
/**
 * 부제목 표시 위치.
 * @enum
 */
declare const _SubtitlePosition: {
    /**
     * 주제목 아래쪽에 표시.<br/>
     */
    readonly BOTTOM: "bottom";
    /**
     * 주제목 오른쪽에 표시.<br/>
     */
    readonly RIGHT: "right";
    /**
     * 주제목 왼쪽에 표시.<br/>
     */
    readonly LEFT: "left";
    /**
     * 주제목 위쪽에 표시.<br/>
     */
    readonly TOP: "top";
};
/** @dummy */
type SubtitlePosition = typeof _SubtitlePosition[keyof typeof _SubtitlePosition];
/**
 * 맵차트 제목 주위에 표시되는 부제목 옵션.<br/>
 * 기본적으로 주제목(title)의 설정을 따르고, 몇가지 속성들이 추가된다.<br/>
 * 별도 설정이 없으면 표시되지 않는다.
 *
 * ```js
 *  const config = {
 *      title: {},
 *      subtitle: {
 *          visible: true,
 *          text: '출처: UN Data, 2020',
 *      },
 *  };
 * ```
 *
 * {@link https://realmap.co.kr/guide/title 제목 개요} 페이지를 참조한다.
 *
 */
interface SubtitleOptions extends TitleOptions {
    /**
     * 부제목 표시 위치.<br/>
     *
     * @default 'bottom'
     */
    position?: SubtitlePosition;
    /**
     * 주 제목과 사이의 간격을 픽셀 단위로 지정한다.<br/>
     *
     * @default 2
     */
    titleGap?: number;
    /**
     * @default ''
     */
    text?: string;
    /**
     * @default 'bottom'
     */
    verticalAlign?: VerticalAlign;
}
/**
 * 맵차트 개발 제작자 등을 표시하는
 * 크레딧 영역에 대한 설정 모델.
 */
interface CreditsOptions extends ChartItemOptions {
    /**
     * 제작자 이름 등 표시 텍스트.
     */
    text?: string;
    /**
     * 영역을 클릭했을 때 이 속성에 지정한 곳으로 창을 연다.
     */
    url?: string;
    /**
     * credits 표시 위치.<br/>
     * 값을 지정하지 않으면 'bottom'에 표시된다.
     *
     * @default 'bottom'
     */
    location?: ChartItemLocation;
    /**
     * 수평 배치.<br/>
     * 값을 지정하지 않으면, 기본값이 {@link location}이 'body'일 때는 'left',
     * 'top', 'bottom'일 때는 'right'이다.
     * 그 외는 무시된다.
     */
    align?: Align;
    /**
     * 수직 배치.<br/>
     * 값을 지정하지 않으면, 기본값이 {@link location}이 'body'일 때는 'top',
     * 'left', 'right'일 때는 'middle'이다.
     * 그 외는 무시된다.
     */
    verticalAlign?: VerticalAlign;
    /**
     * 설정에 따라 정해진 표시 위치에서 떨어진 수평 간격을 픽셀 단위로 지정한다.<br/>
     * {@link floating}이 true가 아니고,
     * {@link verticalAlign}이 'middle' 이면서 {@link align}이 'center'가 아닌 경우,
     * 이 값만큼 수평 영역을 차지한다.
     *
     * @default 2
     */
    offsetX?: number;
    /**
     * 설정에 따라 정해진 표시 위치에서 떨어진 수직 간격을 픽셀 단위로 지정한다.<br/>
     * {@link floating}이 true가 아니고, {@link verticalAlign}이 'middle'이 아닌 경우,
     * 이 값만큼 수직 영역을 차지한다.
     *
     * @default 1
     */
    offsetY?: number;
    /**
     * {@link floating}이 true가 아니고, 중앙이 아닌 곳에 표시될 때,
     * 맵차트 나머지 영역과의 간격을 픽셀로 지정한다.<br/>
     * {@link verticalAlign}이 'middle'이면 수평 간격, 아니면 수직 간격에 적용된다.
     *
     * @default 4
     */
    gap?: number;
}
/**
 * 툴팁에 표시할 데이터포인트들을 선택하는 방식.<br/>
 *
 * @enum
 */
declare const TooltipScopes: {
    readonly HOVER: "hover";
    readonly POINT: "point";
    readonly GROUP: "group";
    readonly AXIS: "axis";
};
/** @dummy */
type TooltipScope = typeof TooltipScopes[keyof typeof TooltipScopes];
/**
 * @enum
 */
declare const TooltipModes: {
    readonly LINE: "line";
    readonly CIRCLE: "circle";
    readonly HEADER: "header";
};
/**
 * 툴팁 모드
 */
type TooltipMode = typeof TooltipModes[keyof typeof TooltipModes];
/**
 * 데이터포인트 {@link https://realmap.co.kr/guide/tooltip Tooltip} 설정 모델.
 *
 */
interface TooltipOptions extends ChartItemOptions {
    scope?: TooltipScope;
    html?: string;
    /**
     * 툴팁에 표시할 텍스트 형식.<br/>
     * 시리즈에 {@link https://realmap.co.kr/config/config/base/series#tooltiptext tooltipText}가 시리즈 별 tooltip을 제공하지만,
     * 이 속성이 지정된 경우 우선 사용된다.<br/>
     *
     * `${param;default;format}` 형식으로 아래과 같은 변수로 데이터 포인트 및 시리즈 값을 지정할 수 있다.
     * |변수|설명|
     * |---|---|
     * |series|시리즈 이름|
     * |name|포인트 이름. 포인트가 속한 카테고리 이름이거나, 'x' 속성으로 지정한 값|
     * |x|'x' 속성으로 지정한 값|
     * |y|'y' 속성으로 지정한 값|
     * |xValue|계산된 x값|
     * |yValue|계산된 y값|
     *
     */
    text?: string;
    /**
     * 목표 지점과 tooltip 사이의 간격.
     *
     */
    offset?: number;
    /**
     * 툴팁이 점진적으로 닫히는 시간을 밀리초 단위로 지정한다.
     *
     * @default 700
     */
    hideDelay?: number;
    minWidth?: number;
    minHeight?: number;
    /**
     * true이면 툴팁 상자가 마우스 포인터를 따라 다닌다.
     * <br>
     * false, true를 명시적으로 지정하지 않으면 시리즈 종류에 따라 자동 설정된다.
     * ex) pie 시리즈는 true, bar 시리즈는 false가 된다.
     *
     */
    followPointer?: boolean;
    /**
     * 툴팁 텍스트 속 숫자 값이 NaN일 때 대신 표시되는 텍스트.
     *
     */
    nanText?: string;
    /**
     * 툴팁에 표시될 숫자값의 기본 형식.\
     * {@link text}예 표시 문자열을 지정할 때 `${yValue;;#,###.0}`와 같은 식으로 숫자 형식을 지정할 수 있다.
     *
     */
    numberFormat?: string;
    /**
     * 툴팁에 표시될 날짜(시간)값의 기본 형식.\
     * {@link text}예 표시 문자열을 지정할 때 `${x;;yyyy.MM}`와 같은 식으로 날짜(시간) 형식을 지정할 수 있다.
     *
     */
    timeFormat?: string;
    /**
     * 툴팁 모드.<br/>
     *
     * 해당 속성으로 툴팁의 외형을 변경할 수 있다.<br/>
     *
     * @default 'line'
     */
    mode?: TooltipMode;
}
/**
 * 지도 투영 방식.
 */
type ProjectionType = undefined | 'orthographic' | /*'naturealearth' |*/ 'equalearth' | 'miller' | 'mercator';
/**
 * 실제 지도가 차지한 영역의 background에 표시 설정.<br/>
 */
interface MapBackgroundOptions extends ChartItemOptions {
    /**
     * 표시 여부를 지정한다.<br/>
     * boolean 값으로 명시적 지정이 없으면 기본값을 따른다.
     *
     * @default undefined 구형 프로젝션이면 true, 아니면 false.
     */
    visible?: boolean;
    /**
     * 구형 프로젝션일 때 적용할 기본 radial gradient의 색상.<br/>
     * {@link style} 속성으로 다르게 지정할 수 있다.
     *
     * @default 'lightblue'
     */
    globeFill?: string;
}
/**
 * zoom, drilldown 패널 base 모델.<br/>
 */
interface BodyPanelOptions extends ChartItemOptions {
    /**
     * {@link https://realmap.co.kr/config/config/body body} 영역 내에서 panel의 수평 정렬.<br/>
     *
     * @default 'left'
     */
    align?: Align;
    /**
     * {@link https://realmap.co.kr/config/config/body body} 영역 내에서 panel의 수직 정렬.<br/>
     *
     * @default 'top'
     */
    verticalAlign?: VerticalAlign;
    /**
     * {@link https://realmap.co.kr/config/config/body body} 영역 경계와 panel 사이의 수평 간격.<br/>
     *
     * @default 8 픽셀
     */
    offsetX?: number;
    /**
     * {@link https://realmap.co.kr/config/config/body body} 영역 경계와 panel 사이의 수직 간격.<br/>
     *
     * @default 8 픽셀
     */
    offsetY?: number;
    /**
     * 패널에 표시되는 버튼이나 label들 사이의 간격.<br/>
     *
     * @default 3 pixel
     */
    itemGap?: number;
}
interface ZoomButton {
    label?: string;
    icon?: string;
}
/**
 * zoom 버튼들이 표시되는 패널 설정 모델.<br/>
 *
 */
interface ZoomPanelOptions extends BodyPanelOptions {
    /**
     * 패널에 표시되는 zoom 버튼들.<br/>
     */
    buttons?: ZoomButton[];
    /**
     * 버튼 배치 방향.<br/>
     *
     * @default 'vertical'
     */
    direction?: 'vertical' | 'horizontal';
    /**
     * 버튼 클릭 시 증감될 zoom 변화율을 지정한다.<br/>
     * 값이 클수록 작은 변화량이 된다.
     *
     * @default 20
     */
    zoomFactor?: number;
    /**
     * 버튼 너비.<br/>
     * {@link buttonHeight}가 지정되지 않으면 이 속성값과 동일하게 표시된다.
     *
     * @default 28 픽셀
     */
    buttonWidth?: number;
    /**
     * 버튼 높이.<br/>
     * {@link buttonWidth}가 지정되지 않으면 이 속성값과 동일하게 표시된다.
     *
     * @default 28 픽셀
     */
    buttonHeight?: number;
    /**
     * 원래 크기 상태로 변경하는 버튼 표시 여부.<br/>
     *
     * @default true
     */
    showReset?: boolean;
    /**
     * 버튼들에 적용할 스타일셋.<br/>
     */
    buttonStyle?: SVGStyleOrClass;
    /**
     * @default 'left'
     */
    align?: Align;
    /**
     * @default 'bottom'
     */
    verticalAlign?: VerticalAlign;
    /**
     * true로 지정하면 맵이 zoom되지 않은 상태일 때도 표시한다.<br/>
     * 물론 {@link visible}이 false이면 이 속성과 무관하게 표시되지 않는다.
     *
     * @default true
     */
    showAlways?: boolean;
}
/**
 * @enum
 */
declare const _DrilldownPanelType: {
    /**
     * 전후 이동 버튼을 표시한다.
     */
    readonly BUTTON: "button";
    /**
     * 진행된 시리즈들의 이름을 표시한다.
     */
    readonly TEXT: "text";
};
/** @dummy */
type DrilldownPanelType = typeof _DrilldownPanelType[keyof typeof _DrilldownPanelType];
/**
 * drilldown 버튼들이 표시되는 패널 설정 모델.<br/>
 *
 */
interface DrilldownPanelOptions extends BodyPanelOptions {
    /**
     * @default 'text'
     */
    type?: DrilldownPanelType;
    /**
     * @default 'left'
     */
    align?: Align;
    /**
     * @default 'top'
     */
    verticalAlign?: VerticalAlign;
}
/**
 * 콜백 매개변수 타입 base.<br/>
 * 
 */
interface CommonCallbackArgs {
    /**
     * Realmap의 공개 {@link https://realmap.co.kr/docs/api/classes/MapChart MapChart} 모델
     */
    chart: MapChart;
    /**
     * 현재 차트 로케일({@link https://realmap.co.kr/config/config/chart/locale locale}). 콜백에서 로케일별로 텍스트를 분기할 때 사용한다.
     */
    locale?: string;
}
interface OnHoverAreaArgs extends CommonCallbackArgs {
    area: any;
    oldArea: any;
}
interface OnClickAreaArgs extends CommonCallbackArgs {
    area: any;
}
interface OnZoomChangedArgs extends CommonCallbackArgs {
    zoom: number;
    oldZoom: number;
}
/**
 * 맵차트 본체(body) 설정 모델.<br/>
 * 투영 옵션과 지도 제어 옵션들을 설정할 수 있다.<br/>
 */
interface BodyOptions extends ChartItemOptions {
    /**
     * 지도 투영 옵션.<br/>
     * 투영 기법에 따라 지도 표시 방식이 달라진다.<br/>
     */
    projection?: ProjectionType;
    mapBackground?: MapBackgroundOptions;
    /**
     * 사용자가 마우스 wheel이나 zoom panel을 이용해 {@link zoom}을 변경할 수 있는 지 여부.<br/>
     *
     * @default false
     */
    zoomable?: boolean;
    /**
     * zoom 상태를 백분율로 지정한다.<br/>
     * 100이면 원래 크기대로 표시한다.
     *
     * @default 100
     */
    zoom?: number;
    /**
     * 휠·핀치·zoom 패널을 포함해 zoom이 올라갈 수 있는 상한.<br/>
     * 지정하지 않으면 제한하지 않는다.<br/>
     */
    maxZoom?: number;
    /**
     * 마우스 휠로 zooming할 때 이 속성에 지정한 값에 따라 wheel 변화량을 zoom 변화율로 반영한다.<br/>
     * 큰 값을 지정할 수록 작게 변화한다.
     *
     * @default 5
     */
    wheelZoomFactor?: number;
    /**
     * 'orthgraphic' 투영이 아닌 경우 true로 지정하면 좌우 스크롤로 지도 중심점을 변경할 수 있다.<br/>
     * 지도 데이터가 세계 전체 지도일 때만 적용된다.
     *
     * @default false
     */
    scrollable?: boolean;
    /**
     * {@link scrollable}이 true인 경우 도(°) 단위 좌우 스크롤 크기.<br/>
     * 0보다 큰 값이면 중점이 아시아쪽으로 이동한다.
     */
    scroll?: number;
    /**
     * 마우스 드래그로 panX/panY 를 변경할 수 있는 지 여부.<br/>
     * 명시적 false로 지정하면 드래그로 이동시킬 수 없다.
     * 초기 {@link zoom}을 설정하고 그 위치를 유지하려 할 때 사용할 수 있다.
     */
    movable?: boolean;
    /**
     * 지도 중심으로부터 경도상으로 벗어난 지도 단위 크기. 양수이면 왼쪽으로 스크롤 된 상태
     */
    panX?: number;
    /**
     * 지도 중심으로부터 위도상으로 벗어난 지도 단위 크기. 양수이면 아래쪽쪽으로 스크롤 된 상태
     */
    panY?: number;
    rotationX?: number;
    rotationY?: number;
    fit?: any;
    points?: ([string, number, number] | {
        id: string;
        coord?: MapCoord;
        lon?: number;
        lat?: number;
    })[];
    onZoomChanged?: (args: OnZoomChangedArgs) => void;
    onHoverArea?: (args: OnHoverAreaArgs) => void;
    onClickArea?: (args: OnClickAreaArgs) => void;
    /**
     * body 영역 내에 표시되는 어노테이션 옵션.<br/>
     * 옵션 객체 또는 옵션 객체 배열로 여러 어노테이션을 설정할 수 있다.<br/>
     * [주의] 이전 버전의 설정을 로드하기 위해, 이 속성이 지정되지 않고 'annotations' 설정이 존재하면 load 후 이 속성으로 설정한다.
     *
     * @expandable
     */
    annotations?: AnnotationOptionsType | AnnotationOptionsType[];
}
interface BackgroundImageOptions extends ChartItemOptions {
    url?: string;
}

/** @private */
declare class RmTool<T extends RmControl = RmControl> {
    private _control;
    private _touchElement;
    private _moveElement;
    private _draggable;
    private _dragTracker;
    private _clickX;
    private _clickY;
    private _prevX;
    private _prevY;
    protected _touches: {
        x: number;
        y: number;
        t: number;
    }[];
    protected _tapped: number;
    private _firstTime;
    private _secondTime;
    private _longTimer;
    protected _primaryId: number;
    private _distance;
    private _pinching;
    private _pinchRect;
    private _pointerType;
    constructor(control: T);
    get control(): T;
    /**
     * drag tracker
     */
    get dragTracker(): DragTracker;
    setDragTracker(value: DragTracker): void;
    get dragging(): boolean;
    /**
     * 이번 제스처가 손가락 터치인가.
     */
    protected get _isTouch(): boolean;
    pointerDown(ev: PointerEvent): boolean;
    protected _stopEvent(ev: Event): void;
    private $_doDrag;
    private $_startMove;
    pointerMove(ev: PointerEvent): void;
    pointerUp(ev: PointerEvent): void;
    pointerCancel(ev: PointerEvent): void;
    pointerLeave(ev: PointerEvent): void;
    touchStart(ev: TouchEvent): void;
    touchMove(ev: TouchEvent): boolean;
    protected _isPinchTarget(dom: Element): boolean;
    /**
     * @param ratio 이번 이벤트의 두 손가락 거리 배율. 1보다 크면 확대.
     * @param cx 두 손가락 중점 (control 좌표)
     */
    protected _doPinch(ratio: number, cx: number, cy: number): void;
    touchEnd(ev: TouchEvent): void;
    /**
     * 브라우저가 제스처를 가져가거나 전화·알림으로 터치가 끊겼을 때.
     *
     * touchEnd는 다음 touchStart가 초기화해 줄 것을 믿고 _pinching을 남겨두지만,
     * touchcancel 뒤에는 그 touchStart가 오지 않을 수 있다. 그대로 두면 하이브리드 기기에서
     * 이후 마우스 입력이 pointerMove/pointerUp의 _pinching 가드에 조용히 삼켜진다. #585
     */
    touchCancel(ev: TouchEvent): void;
    click(ev: PointerEvent): void;
    dblClick(ev: PointerEvent): void;
    keyPress(ev: KeyboardEvent): void;
    wheel(ev: WheelEvent): void;
    requestDrag(request: DragRequest): void;
    getTrackerFromRequest(request: DragRequest): DragTracker;
    protected _setDraggable(value: boolean): void;
    protected _doClick(ev: PointerEvent): void;
    protected _doDblClick(ev: PointerEvent): void;
    protected _doPointerDown(ev: PointerEvent): boolean;
    protected _doPointerMove(x: number, y: number, ev: PointerEvent): void;
    protected _doPointerUp(ev: PointerEvent): boolean;
    protected _doPointerCancel(ev: PointerEvent): void;
    protected _doPointerLeave(ev: PointerEvent): void;
    protected _doTouchStart(ev: TouchEvent, dom: Element): void;
    protected _doTouchMove(ev: TouchEvent, dom: Element): boolean;
    protected _doTouchEnd(ev: TouchEvent, dom: Element): void;
    protected _doLongPressed(dom: Element, x: number, y: number): void;
    protected _doKeyPress(ev: KeyboardEvent): void;
    protected _doWheel(ev: WheelEvent): boolean;
    protected _doSwipe(dom: Element, prevTracker: DragTracker, dir: RmDirection, duration: number, distance: number): boolean;
    protected _getDragTracker(dom: Element, dx: number, dy: number, shift: any): DragTracker;
    private $_startDrag;
    private $_drag;
    private $_stopDragTracker;
    protected _pointerToPoint(event: PointerEvent): IPoint$1;
    private $_checkSwipe;
    /**
     * 터치 시작 시점에 실행한 설정 등을 이 후 touch 이벤트가 발생하면 초기화한다.
     * ex) touch feedback, ...
     *     iphone 메시지 편집 창에서 touch 하면 행을 선택하고 이 후 다른 이벤트가 발생하면 선택을 해제한다.
     */
    protected _clearTouchEffects(): void;
    private $_getDistance;
    /**
     * 두 터치의 중점을 control 좌표로 돌려준다.
     * 기준 사각형은 핀치 시작 때 한 번만 재둔 값을 쓴다.
     */
    private $_getCenter;
}
declare abstract class DragRequest extends RObject {
}
declare abstract class DragTracker<T extends RmControl = RmControl> extends RObject {
    private _control;
    private _dragging;
    constructor(control: T);
    get control(): T;
    /** dragging */
    get dragging(): boolean;
    /** startWhenCreated */
    get startWhenCreated(): boolean;
    get cursor(): string;
    canSwipe(): boolean;
    start(eventTarget: Element, xStart: number, yStart: number, x: number, y: number): boolean;
    drag(eventTarget: Element, xPrev: number, yPrev: number, x: number, y: number): boolean;
    cancel(): void;
    drop(eventTarget: HTMLElement, x: number, y: number): void;
    swipe(dir: RmDirection, duration: number, distance: number): boolean;
    end(x?: number, y?: number): void;
    protected _doSwipe(dir: RmDirection, duration: number, distance: number): boolean;
    protected _showFeedback(x: number, y: number): void;
    protected _moveFeedback(x: number, y: number): void;
    protected _hideFeedback(): void;
    protected _doStart(eventTarget: Element, xStart: number, yStart: number, x: number, y: number): boolean;
    protected abstract _doDrag(eventTarget: Element, xPrev: number, yPrev: number, x: number, y: number): boolean;
    protected _doCanceled(): void;
    protected _canAccept(eventTarget: Element, x: number, y: number): boolean;
    protected _doCompleted(eventTarget: Element, x: number, y: number): void;
    protected _doEnded(x?: number, y?: number): void;
}

/**
 * @private
 *
 * Control base.
 */
declare abstract class RmControl extends RObject {
    static readonly CLASS_NAME = "rm-control";
    static readonly SHADOW_FILTER = "rm-shadow-filter";
    private _activeTool;
    static _animatable: boolean;
    private _container;
    private _dom;
    private _htmlRoot;
    private _debugger;
    private _svg;
    private _defs;
    private _root;
    private _inited;
    private _testing;
    private _dirty;
    private _requestTimer;
    private _defaultTool;
    private _tool;
    private _toAnimation;
    private _invalidateLock;
    private _lockDirty;
    private _cssVars;
    private _resizeObserver;
    private _wSave;
    private _hSave;
    private _resizeTimer;
    private _resizeDelay;
    /**
     * 드래그를 차단할 지 여부를 나타내는 플래그.
     *
     * 맵 영역 밖에서 드래그가 시작되었을 때 맵이 회전되는 것을 방지하기 위해 사용된다.
     * pointerdown, touchstart 이벤트가 발생했을 때 이벤트 타겟이 맵 영역 안에 있는지 여부를 검사하여 설정된다.
     */
    private _blockDrag;
    loaded: boolean;
    _padding: ISides;
    _scrolling: boolean;
    constructor(doc: Document, container: string | HTMLDivElement, className?: string);
    protected _doDispose(): void;
    isInited(): boolean;
    isTesting(): boolean;
    doc(): Document;
    dom(): HTMLElement;
    setData(data: string, value?: string, container?: boolean): void;
    width(): number;
    height(): number;
    contentWidth(): number;
    contentHeight(): number;
    contentRight(): number;
    clipContainer(): SVGElement;
    activeTool(): RmTool;
    setSctiveTool(value: RmTool): void;
    isLoading(): boolean;
    /**
     * 드래그 가능 여부를 반환한다.
     *
     * 만약 드래그가 맵 영역 밖에서 시작되었다면 드래그가 차단된다.(false 반환)
     */
    isDraggable(): boolean;
    clearDefs(): void;
    appendDom<T extends HTMLElement>(elt: T): T;
    addElement<T extends RmElement>(elt: T): T;
    removeElement(elt: RmElement): void;
    invalidate(force?: boolean): void;
    invalidateLayout(force?: boolean): void;
    setLock(): void;
    releaseLock(validate?: boolean): void;
    lock(func: (control: RmControl) => void): void;
    silentLock(func: (control: RmControl) => void): void;
    setResizeDelay(value: number): void;
    getBounds(): DOMRect;
    setAnimation(to?: number): void;
    fling(distance: number, duration: number): void;
    getCssVar(name: string): string;
    addDef(element: Element): void;
    removeDef(element: Element | string): void;
    hasDef(defId: string): boolean;
    /**
     * defs에 직사각형 clipPath를 등록한다.
     */
    clipBounds(x?: number, y?: number, width?: number, height?: number, rd?: number): ClipRectElement;
    clip<T extends ClipElement>(clip: T): T;
    pointerToPoint(event: PointerEvent): IPoint$1;
    protected _setTesting(): void;
    protected _setSize(w: number, h: number): void;
    private $_addListener;
    protected _registerEventHandlers(dom: HTMLElement): void;
    protected _unresigterEventHandlers(dom: HTMLElement): void;
    protected abstract _creatDefaultTool(): RmTool;
    protected _prepareRenderers(dom: HTMLElement): void;
    protected _initControl(document: Document, container: string | HTMLDivElement, className: string): void;
    protected _initDefs(doc: Document, defs: SVGElement): void;
    protected _render(): void;
    private $_requestRender;
    updateNow(): void;
    private $_render;
    protected _setBackgroundStyle(style: CSSStyles): void;
    setDebug(message: any): void;
    protected abstract _doRender(bounds: IRect): void;
    protected _doBeforeRender(root: RmElement): void;
    protected _doAfterRender(): void;
    /**
     * 렌더링 결과에 맞춰 컨테이너의 touch-action을 다시 지정한다.
     * 소비하지 않는 축을 브라우저에 열어둬야 터치 기기에서 페이지 스크롤이 살아난다.
     */
    protected _updateTouchAction(): void;
    protected _doClick(event: PointerEvent): void;
    protected _doDblClick(event: PointerEvent): void;
    protected _doTouchStart(event: TouchEvent): void;
    protected _doTouchMove(event: TouchEvent): boolean;
    protected _doTouchEnd(event: TouchEvent): void;
    protected _doPointerDown(event: PointerEvent): boolean;
    protected _doPointerMove(event: PointerEvent): void;
    protected _doPointerUp(event: PointerEvent): void;
    protected _doPointerCancel(event: PointerEvent): void;
    protected _doPointerLeave(event: PointerEvent): void;
    protected _doKeyPress(event: KeyboardEvent): void;
    protected _doWheel(event: WheelEvent): boolean;
    protected _windowResizeHandler: (event: Event) => void;
    protected _domResizeHandler: (event: Event) => void;
    protected _domResized(): void;
    private _clickHandler;
    private _dblClickHandler;
    private _touchStartHandler;
    private _touchMoveHandler;
    private _touchEndHandler;
    private _touchCancelHandler;
    private _pointerDownHandler;
    private _pointerMoveHandler;
    private _pointerUpHandler;
    private _pointerCancelHandler;
    private _pointerLeaveHandler;
    private _keyPressHandler;
    private _wheelHandler;
    private $_updateBlockDrag;
}
/**
 * @private
 *
 * RcContainer 구성 요소.
 * SVGElement들로 구현된다.
 */
declare class RmElement extends RObject {
    static TESTING: boolean;
    static DEBUGGING: boolean;
    static ASSET_KEY: string;
    static TEMP_KEY: string;
    static createElement(doc: Document, tag: string): SVGElement;
    static shrink(elts: RmElement[], count: number): void;
    static expand<T extends RmElement>(parent: RmElement, elts: T[], count: number, creator: () => T): void;
    static fit<T extends RmElement>(doc: Document, parent: RmElement, elts: T[], count: number, creator: {
        new (doc: Document, styleName?: string): T;
    }, styleName: string): void;
    private _visible;
    private _x;
    private _y;
    private _width;
    private _height;
    private _zIndex;
    private _tx;
    private _ty;
    private _scaleX;
    private _scaleY;
    private _rotation;
    private _originX;
    private _originY;
    private _matrix;
    protected _styleName: string;
    protected _styles: any;
    protected _styleDirty: boolean;
    private _dom;
    private _parent;
    removing: boolean;
    private _saveStyle;
    private _saveClass;
    constructor(doc: Document, styleName: string, tag?: string);
    protected _doInitStyles(): void;
    protected _doDispose(): void;
    get doc(): Document;
    get dom(): SVGElement;
    get parent(): RmElement;
    get control(): RmControl;
    get zIndex(): number;
    set zIndex(value: number);
    get x(): number;
    set x(value: number);
    get tx(): number;
    get y(): number;
    set y(value: number);
    get ty(): number;
    get width(): number;
    set width(value: number);
    get height(): number;
    set height(value: number);
    /**
     * visible
     */
    get visible(): boolean;
    set visible(value: boolean);
    setVisible(value: boolean): boolean;
    /**
     * rotation
     */
    get rotation(): number;
    set rotation(value: number);
    setRotation(originX: number, originY: number, rotation: number): RmElement;
    getStyle(prop: string): string;
    hasStyle(className: string): boolean;
    containsDom(dom: Element): boolean;
    addDom(dom: SVGElement | HTMLElement): HTMLElement | SVGElement;
    add<T extends RmElement>(child: T): T;
    append<T extends RmElement>(child: T): T;
    addAll(...children: RmElement[]): void;
    insertChild<T extends RmElement>(child: T, before: RmElement): T;
    insertFirst<T extends RmElement>(child: T): T;
    removeChild(child: RmElement): void;
    remove(): RmElement;
    appendElement(doc: Document, tag: string): SVGElement;
    insertElement(doc: Document, tag: string, before: Node): SVGElement;
    moveToLast(child: RmElement): void;
    isValidPathData(d: string): boolean;
    getAttr(attr: string): any;
    setAttr(attr: string, value: any): RmElement;
    hasAttr(attr: string): boolean;
    setAttrEx(attr: string, value: any): RmElement;
    setAttrs(attrs: any): RmElement;
    unsetAttr(attr: string): RmElement;
    getBounds(): DOMRect;
    setBounds(x: number, y: number, width: number, height: number): RmElement;
    setRect(rect: IRect): RmElement;
    getRect(): IRect;
    getSize(): ISize;
    bbox(): IRect;
    move(x: number, y: number): RmElement;
    scale(value: number, yValue?: number): this;
    trans(x: number, y: number): RmElement;
    transp(p: IPoint$1): RmElement;
    transc(p: MapCoord): RmElement;
    transEx(x: number, y: number, duration?: number, invalidate?: boolean): RmElement;
    transX(x: number): RmElement;
    transY(y: number): RmElement;
    transform(s: string): void;
    resize(width: number, height: number, attr?: boolean): boolean;
    appendDom(dom: Node): Node;
    insertDom(dom: Node, before: Node): Node;
    clearDom(): void;
    hasSavedStyles(): boolean;
    saveStyles(): void;
    restoreStyles(): void;
    internalClearStyles(): void;
    clearStyles(): boolean;
    internalSetStyles(styles: any): void;
    internalImportantStylesOrClass(style: any): void;
    resetStyles(styles: any): void;
    protected _resetClass(): void;
    setClass(className: string): void;
    clearStyleAndClass(): void;
    internalClearStyleAndClass(): void;
    setStyleOrClass(style: SVGStyleOrClass): void;
    internalSetStyleOrClass(style: SVGStyleOrClass): void;
    internalResetStyleOrClass(style: SVGStyleOrClass): void;
    protected _setBackgroundBorderRadius(value: number): void;
    setBackStyles(styles: any): boolean;
    internalSetStyle(prop: string, value: any): void;
    internalSetImportantStyle(prop: string, value: string): void;
    setBackStyle(prop: string, value: string): boolean;
    setColor(color: string): this;
    getFill(): any;
    getStroke(): any;
    setFill(color: string): this;
    setStroke(color: string): this;
    setTransparent(important: boolean): void;
    textAlign(): Align;
    setData(data: string, value?: string): void;
    unsetData(data: string): void;
    setBoolData(data: string, value: boolean): void;
    hasData(data: string): boolean;
    removeLater(delay: number, callback?: (v: RmElement) => void): RmElement;
    hide(delay: number): RmElement;
    ignorePointer(): void;
    invalidate(): void;
    rotate(angle: number): RmElement;
    internalRotate(angle: number): void;
    setCursor(cursor: string): void;
    hasClip(): boolean;
    setClip(cr?: ClipElement | string): void;
    clipRect(x: number, y: number, width: number, height: number, rd?: number): ClipRectElement;
    clipPath(path: Path): ClipPathElement;
    private createClipId;
    sort(children: RmElement[]): void;
    getParent<T extends RmElement>(type: {
        new (): T;
    }): T;
    onScrollStart(): void;
    onScrollEnd(): void;
    onRotationStart(): void;
    onRotationEnd(): void;
    protected _testing(): boolean;
    protected _doAttached(parent: RmElement): void;
    protected _doDetached(parent: RmElement): void;
    protected _updateTransform(): void;
}
declare class LayerElement extends RmElement {
    constructor(doc: Document, styleName?: any);
}
declare class PathElement extends RmElement {
    _userData: any;
    private _path;
    constructor(doc: Document, styleName?: string, path?: Path);
    path(): string;
    setPath(path: Path): PathElement;
}
declare class PathElementEx extends RmElement {
    group: boolean;
    _userData: any;
    private _path;
    constructor(doc: Document, styleName: string, group?: boolean);
    path(): string;
    setPath(path: Path): PathElementEx;
}
declare class MaskElement extends RmElement {
    private _id;
    constructor(doc: Document);
    get id(): string;
}
declare class ClipElement extends RmElement {
    private _id;
    constructor(doc: Document);
    get id(): string;
}
declare class ClipRectElement extends ClipElement {
    private _rect;
    constructor(doc: Document, x?: number, y?: number, width?: number, height?: number, rx?: number, ry?: number);
    setBounds(x: number, y: number, w: number, h: number): RmElement;
    resize(width: number, height: number, attr?: boolean): boolean;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get width(): number;
    set width(value: number);
    get height(): number;
    set height(value: number);
}
declare class ClipPathElement extends ClipElement {
    private _path;
    constructor(doc: Document, path?: Path);
    get path(): PathElement;
    setPath(path: Path): this;
}

/**
 * @enum
 */
declare const _Shapes: {
    /**
     * 원
     */
    readonly CIRCLE: "circle";
    /**
     * 다아이몬드
     */
    readonly DIAMOND: "diamond";
    /**
     * 정사각형
     */
    readonly SQUARE: "square";
    /**
     * 삼각형
     */
    readonly TRIANGLE: "triangle";
    /**
     * 별 모양
     */
    readonly STAR: "star";
    /**
     * 역삼각형
     */
    readonly ITRIANGLE: "itriangle";
    /**
     * 사각형
     */
    readonly RECTANGLE: "rectangle";
};
/** @dummy */
type Shape = typeof _Shapes[keyof typeof _Shapes];

/**
 */
type PointHoverCallback = (args: DataPointArgs) => void;
/**
 */
type PointClickCallback = (args: DataPointArgs) => boolean;
/** @dummy */
type PointStyleCallback = (args: DataPointArgs) => SVGStyleOrClass | undefined;
/**
 * @enum
 */
declare const _PointViewPosition: {
    /**
     * 데이터포인트 위치가 이미지 등 아이템의 중앙이 되도록 표시한다.<br/>
     */
    readonly CENTER: "center";
    /**
     * 데이터포인트 위치가 이미지 등 아이템의 아래쪽이 되도록 표시한다.<br/>
     */
    readonly TOP: "top";
    /**
     * 데이터포인트 위치가 이미지 등 아이템의 위쪽이 되도록 표시한다.<br/>
     */
    readonly BOTTOM: "bottom";
    /**
     * 데이터포인트 위치가 이미지 등 아이템의 오른쪽이 되도록 표시한다.<br/>
     */
    readonly LEFT: "left";
    /**
     * 데이터포인트 위치가 이미지 등 아이템의 왼쪽이 되도록 표시한다.<br/>
     */
    readonly RIGHT: "right";
};
/** @dummy */
type PointViewPosition = typeof _PointViewPosition[keyof typeof _PointViewPosition];
/**
 * @enum
 */
declare const _PointLabelPositions: {
    readonly AUTO: "auto";
    readonly CENTER: "center";
    readonly TOP: "top";
    readonly BOTTOM: "bottom";
    readonly LEFT: "left";
    readonly RIGHT: "right";
};
/** @dummy */
type PointLabelPosition = typeof _PointLabelPositions[keyof typeof _PointLabelPositions];
interface PointLabelPositionCallbackArgs extends CommonCallbackArgs {
    point: any;
}
/**
 * 데이터포인트 label 설정 옵션.<br/>
 */
interface DataPointLabelOptions extends IconedTextOptions {
    /**
     * 데이터포인트 위에 마우스가 있을 때 적용되는 스타일셋 혹은 class selector.
     */
    hoverStyle?: SVGStyleOrClass;
    /**
     * @default true
     */
    visible?: boolean;
    /**
     * {@link visible}이 true일 때,
     * 이 속성에 지정한 zoom 이상어야 표시된다.
     * // TODO: level을 배열로 지정하고 level별로 font size를 지정할 수 있게 한다.
     */
    zoomLevel?: number;
    /**
     * 포인트 label 표시 위치.
     *
     * @default 'auto'
     */
    position?: PointLabelPosition;
    /**
     * label과 point view 사이의 기본 간격.<br/>
     * 값을 지정하지 않으면 시리즈 종류에 따라 자동 결정된다.
     */
    offset?: number;
    /**
     * 계산되는 기본 text 대신, data point label로 표시될 field.<br/>
     * {@link textCallback}이 설정되고 콜백에서 null이나 undefined를 리턴하지 않으면 이 속성은 무시된다.
     *
     */
    textField?: string;
    /**
     * 계산되는 기본 text 대신, data point label로 표시될 text 리턴.<br/>
     * undefined나 null을 리턴하면 {@link textField} 등을 사용한 기존에 표시될 텍스트를 사용한다.
     * 빈 문자열 등 정상적인 문자열을 리턴하면 그 문자열대로 표시된다.
     * {@link prefix}나 포맷 속성 등은 적용되지 않는다.
     */
    textCallback?: (point: any) => string;
    /**
     * 데이터 포인트별 label 표시 여부를 리턴하는 콜백.<br/>
     */
    visibleCallback?: (point: any) => boolean;
    /**
     * 데이터 포인트별로 추가 적용되는 스타일을 리턴한다.<br/>
     */
    styleCallback?: (point: any) => SVGStyleOrClass;
    positionCallback?: (args: PointLabelPositionCallbackArgs) => PointLabelPosition;
    /**
     * @ignore 미구현
     * 데이터 포인트 label들이 처음 load될 때 실행될 animation 종류.<br/>
     */
    animation?: 'reveal' | 'fadenin';
}
interface CalloutAnchorPointOptions extends ChartItemOptions {
    /**
     * 모양을 지정한다.<br/>
     *
     * @default 'circle'
     */
    shape?: string;
    /**
     * 반지름 크기를 픽셀 단위로 지정한다.<br/>
     *
     * @default 2.5
     */
    radius?: number;
}
/**
 * 데이터포인트의 원래 표시 위치에서 떨어진 곳에 데이터포인트 뷰를 표시하고,
 * 선을 그어 연결하는 방식에 대한 옵션.<br/>
 * 데이터가 밀집된 지역이나 겹치는 값들 사이에서 분리하여 배치하기 위해 사용한다.<br/>
 * 데이터포인트 생성 데이터의 **'offset'** 속성에 `[경도 변위, 위도 변위]` 형식으로 원래 위치에 대한 변위값들을 지정하거나,
 * **callout** 속성에 직접 표시 위치를 지정할 수도 있다. callout이 지정되면 offset은 무시된다.
 *
 * ex) `[{ offset: [[0, 2], [1, -1]], value: 100 }, ...]`<br/>
 * ex) `[{ callout: [[35.3, 152.1], [36.9, 152.1]], value: 100 }, ...]`
 */
interface DataPointCalloutOptions extends ChartItemOptions {
    mode?: 'point' | 'label';
    /**
     * callout 시작 위치의 모양과 스타일을 설정한다.<br/>
     */
    anchorPoint?: CalloutAnchorPointOptions;
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * true로 지정하면 데이터포인트에 개별적으로 적용된 색상이 있으면 그 색으로 표시한다.<br/>
     *
     * @default true
     */
    usePointColor?: boolean;
    /**
     * true로 지정하면 시리즈 스타일을 먼저 적용한다.<br/>
     *
     * @default false
     */
    useSeriesColor?: boolean;
    /**
     * true로 지정하면 데이터포인트 표시 위치 설정 용도로만 사용한다.<br/>
     *
     * @default false
     */
    layoutOnly?: boolean;
}
/**
 * 시리즈는 {@link data}로 지정된 값들을 데이터포인트로 표시하는 맵차트의 핵심 구성 요소이다.<br/>
 * 맵차트 설정의 다른 부분이나 API에 참조하기 위해서는 {@link name}을 반드시 지정해야 햔다.
 * 맵차트 생성 시 {@link type} 을 지정하지 않으면 {@link https://realmap.co.kr/config/config/series/map map} 시리즈로 생성된다.<br/>
 *
 * 
 */
interface SeriesOptions extends ChartItemOptions {
    /**
     * 시리즈 종류를 지정한다.<br/>
     * 지정하지 않으면 {@link https://realmap.co.kr/config/config/series/map map} 시리즈로 생성된다.
     */
    type?: string;
    /**
     * 시리즈 이름.<br/>
     * 시리즈를 구분하기 위한 이름으로 사용된다.<br/>
     */
    name?: string;
    /**
     * 이 시리즈를 나타내는 텍스트.<br/>
     * 레전드나 툴팁에서 시리즈를 대표한다.
     * 이 속성이 지정되지 않으면 {@link name}이 사용된다.
     */
    label?: string;
    /**
     * 명시적으로 이 속성을 지정하면,
     * 관련된 맵이 맵차트에 활성됐을 때만 시리즈가 표시된다.
     */
    map?: string | number;
    /**
     * 데이터포인트 label 설정 옵션.<br/>
     * boolean으로 지정하면 {@link visible} 속성을,
     * 문자열로 지정하면 {@link text} 속성을 별도로 지정하는 것과 동일하다.
     */
    pointLabel?: DataPointLabelOptions | boolean | string;
    /**
     * 데이터포인트 위치에서 선을 그어 떨어뜨려 표시하는 옵션.<br/>
     * 데이터가 밀집된 지역이나 겹치는 값들 사이에서 분리하여 배치하기 위해 사용한다.<br/>
     * 데이터포인트에 **callout** 속성이 `[경도, 위도]` 형식으로 지정되면 그 위치에 표시하고,
     * **offset** 속성이 지정되면 원래 표시 위치에서 `[경도 변화량, 위도 변화량]`으로 지정한 값들 만큼 이동시킨다.<br/>
     * ex) `{ callout: [[127.2, 35.3], [127.9, 35.3]], ... }`<br/>
     * ex) `{ offset: [[0, 2], [1, -1]], ... }`
     */
    callout?: DataPointCalloutOptions | boolean;
    /**
     * 데이터포인트 목록을 생성하는 데 참조되는 데이터셋.<br/>
     * {@link g.createChartAsync createChartAsync}를 호출해서 비동기로
     * 맵차트를 생성할 때는 {@link dataUrl}로 원격 데이터 소스를 지정할 수 있다.
     * [주의] 처음 load 후 data의 내용을 변경해도 맵차트에 반영되지 않는다.
     */
    data?: any;
    /**
     * 시리즈 데이터의 외부 경로.<br/>
     * {@link g.createChartAsync createChartAsync} 호출 시, 해당 url로 GET 요청을 전송하여 데이터를 다운받고,
     * 해당 시리즈의 data 속성에 저장한다.<br/>
     * {@link data}가 설정되면 이 속성은 무시된다.
     * 또, 비동기 함수가 아닌 {@link g.createChart createChart}로 맵차트를 생성할 때 이 속성으로 data를 설정하려는 경우
     * 콘솔에 경고 메시지가 표시된다.
     */
    dataUrl?: string;
    dataFilter?: (v: any) => boolean;
    /**
     * {@link data}나 {@link dataUrl}로 지정된 데이터소스에서 시리즈 데이터로 가져올 배열의 위치를 지정한다.<br/>
     * "aaa.bbb" 형식으로 지정한다. 배열 항목은 숫자로 지정한다. "aaa.2.bbb".
     * 지정하지 않으면 최상위 JSON 객체를 그대로 사용한다.
     */
    dataPath?: string | number;
    /**
     * {@link data}가 array로 제공되어 datapoint로 생성될 때,
     * array의 각 항목에 해당하는 이름으로 datapoint source의 값을 사용한다.<br/>
     * 좌표는 `coord` 한 항목으로 지정하고, 해당 위치의 값은 `[경도, 위도]` 배열이어야 한다.<br/>
     * ex) `['id', 'coord', 'value', 'name', 'color']`
     */
    fields?: string[];
    /**
     * {@link data}로 전달되는 데이터포인트 생성 객체들의 'id' 속성 값 대신,
     * 이 속성으로 지정된 값을 데이터포인트 **id**로 설정한다.<br/>
     *
     * @default 'id'
     */
    idField?: string | number;
    /**
     * {@link data}로 전달되는 데이터포인트 생성 객체들의 'name' 속성 값 대신,
     * 이 속성으로 지정된 값을 데이터포인트 **이름**으로 설정한다.<br/>
     *
     * @default 'name'
     */
    nameField?: string | number;
    /**
     * {@link data}로 전달되는 데이터포인트 생성 객체들의 'lon' 속성 값 대신,
     * 이 속성으로 지정된 값을 데이터포인트 **경도** 값으로 설정한다.<br/>
     *
     * @default 'lon'
     */
    lonField?: string | number;
    /**
     * {@link data}로 전달되는 데이터포인트 생성 객체들의 'lat' 속성 값 대신,
     * 이 속성으로 지정된 값을 데이터포인트 **위도** 값으로 설정한다.<br/>
     *
     * @default 'lat'
     */
    latField?: string | number;
    /**
     * {@link data}로 전달되는 데이터포인트 생성 객체들의 'color' 속성 값 대신,
     * 이 속성으로 지정된 값을 데이터포인트의 기본 색상으로 적용한다.<br/>
     *
     * @default 'color'
     */
    colorField?: string | number;
    /**
     * 데이터 포인트 기본 색.<br/>
     * 숫자로 지정하면 정수로 변환된 값에 해당하는 팔레트 색상으로 설정된다.
     * 'var(--color-n)'으로 지정한 것과 동일하며, 1 ~ 12 사이의 값으로 설정할 수 있다.
     * {@link style}로 지정된 색상보다는 우선하지만,
     * {@link pointColors}나 {@link styleCallback}으로 설정된 색상이 이 속성으로 설정한 색상보다 우선한다.
     */
    color?: string | number;
    /**
     * color 속성이 명시적으로 지정되지 않은 데이터포인터의 color 속성을 지정한다.<br/>
     * 색 배열로 지정하거나, 'colors' asset으로 등록된 이름을 지정할 수 있다.<br/>
     * 시리즈 {@link style}이나 {@link color}로 지정된 색 보다는 우선하지만,
     * {@link styleCallback}에서 설정된 색상이나 데이터포인트별로 지정한 색상이 이 속성으로 설정된 색상보다 우선한다.
     */
    pointColors?: string[] | string | ((point: DataPointArgs) => string);
    /**
     * 시리즈의 hover, tooltip, click 상호작용 여부를 지정한다.<br/>
     * false로 지정하면 이 시리즈는 포인터 대상에서 제외된다. {@link disabled}를 true로 지정한 것과 동일하게 동작한다.<br/>
     * 차트 {@link https://realmap.co.kr/config/config/general#interactive interactive}가 false이면 이 옵션과 관계없이 모든 시리즈의 상호작용이 비활성화된다.<br/>
     *
     * @default true
     */
    interactive?: boolean;
    /**
     * 데이터포인트 툴팁 텍스트.<br/>
     * true로 지정하면 기본 툴팁이 적용되고, false로 지정하면 tooltip이 표시되지 않는다.
     */
    tooltipText?: string | boolean;
    /**
     * 동적으로 {@link tooltipText}를 리턴하는 콜백.<br/>
     * null이나 undefined를 리턴하면 {@link tooltipText} 설정을 따른다.
     */
    tooltipCallback?: (args: DataPointArgs) => string;
    /**
     * 이 시리즈가 연결된 legend를 legend의 index나 이름으로 지정한다.<br/>
     * 범위를 벗어난 index 등 잘못된 값을 지정하면 legend에 표시되지 않는다.
     * 특별히 지정하지 않으면 첫 번째 index에 표시된다.
     *
     * @default 0
     */
    legend?: number | string;
    /**
     * @ignore 미구현
     *
     * 차트 설정 로드 시 실행되는 animation 종류.
     */
    loadAnimation?: 'default' | 'reveal' | 'grow' | 'spread' | 'fadein';
    /**
     * true로 설정하면 hovering을 포함한 마우스 등의 포인터에 반응하지 않는다.<br/>
     * {@link interactive}를 false로 지정한 것과 동일하게 동작한다.<br/>
     */
    disabled?: boolean;
    /**
     * 데이터 point의 동적 스타일 콜백.<br/>
     * {@link style}, {@link pointColors} 등 다른 스타일 설정들 보다 우선한다.
     */
    styleCallback?: PointStyleCallback;
    /**
     * 데이터포인트들이 로드된 후 호출된다.<br/>
     */
    onPointsLoaded?: (series: object, firstTime: boolean) => void;
    /**
     * {@link https://realmap.co.kr/docs/api/classes/Series#addPoint addPoint}를 호출해서 데이터포인트가 하나 추가된 후 호출된다.<br/>
     */
    onPointAdded?: (args: DataPointArgs) => void;
    /**
     * {@link https://realmap.co.kr/docs/api/classes/Series#removePoint removePoint}를 호출해서 데이터포인트가 하나 제거된 후 호출된다.<br/>
     */
    onPointRemoved?: (args: DataPointArgs) => void;
    onPointUpdated?: (args: DataPointArgs) => void;
    onPointListAdded?: (args: DataPointListkArgs) => void;
    onPointListRemoved?: (args: DataPointListkArgs) => void;
    onPointListUpdated?: (args: DataPointListkArgs) => void;
    /**
     * 데이터 point가 클릭될 때 호출되는 이벤트 콜백.<br/>
     * 명시적 true를 리턴하면 기본 동작이 진행되지 않는다.
     */
    onPointClick?: PointClickCallback;
    /**
     * 마우스가 데이터 point 위에 올라가거나 빠져나갈 때 호출되는 이벤트 콜백.<br/>
     * 빠져나가는 경우 args 매개변수는 null이다.
     */
    onPointHover?: PointHoverCallback;
}
/**
 * 데이터포인트의 **'value'** 속성이나,
 * {@link valueField}로 지정된 속성 값을 기준으로 데이터포인트를 표시하는 시리즈.<br/>
 */
interface ValueSeriesOptions extends SeriesOptions {
    /**
     * {@link data}로 전달되는 데이터포인트 생성 객체들의 'value' 속성 값 대신,
     * 이 속성으로 지정된 값을 데이터포인트 값으로 적용한다.<br/>
     */
    valueField?: string;
}
/**
 * area가 아니라 위치 기준으로 데이터를 표시하는 시리즈.<br/>
 */
interface CoordBaseSeriesOptions extends ValueSeriesOptions {
    /**
     * 데이터포인트를 표시하지 않는 영역(들)을 지정한다.<br/>
     * [왼쪽위, 오른쪽아래, ...] 형태로 두 위치를 연속적으로 지정해서 복수 개의 영역을 설정할 수 있다.
     */
    excludeBounds?: MapCoord[];
}
/**
 * 특정 위치에 연관된 값을 버블이나 shape 등으로 표시한다.<br/>
 */
interface MarkerSeriesOptions extends CoordBaseSeriesOptions {
    /**
     * 데이터포인트 {@link shape 도형} 회전 각도.<br/>
     */
    rotation?: number;
    /**
     * marker가 마우스 아래 있는 지 판단할 때 외부로 추가되는 가상의 두께.<br/>
     * 지정하지 않으면 {@link https://realmap.co.kr/config/config/chart/options/pointHovering/hintDistance hintDistance} 설정을 따른다.
     */
    hintDistance?: number;
}
interface SparkSeriesCategory {
    name?: string;
    /**
     * 로케일이 english일 때 {@link name} 대신 범례에 표시할 이름.<br/>
     * 지정하지 않으면 {@link name}이 그대로 쓰인다.
     */
    nameEn?: string;
    color?: string;
}
/**
 * 특정 위치에 연관된 값들을 단순 차트(spark chart)로 표시한다.<br/>
 * bar, line, pie 차트가 제공된다.
 */
interface SparkSeriesOptions extends CoordBaseSeriesOptions {
    /**
     * 데이터포인트의 값이 복수개일 때 값별 색상을 순서대로 지정한다.<br/>
     * color 항목이 설정되지 않으면 데이터포인트의 기본 색상이 사용된다.
     * 또, {@link legendByCategory}가 true이면 여기에 지정된 색상별로 legend에 표시된다.
     */
    categories?: SparkSeriesCategory[];
    /**
     * 데이터포인트 값들을 가져올 필드 목록.<br/>
     * 이 속성이 지정되면 {@link valueField}는 무시된다.
     */
    valueFields?: (string | number)[];
    /**
     * true로 지정되고 {@link categories}가 지정되면
     * 맵차트 legend에 category별로 항목이 표시된다.
     *
     * @default undefined
     */
    legendByCategory?: boolean;
    /**
     * 이 값을 0보다 크고 1보다 작은 값으로 지정하면,
     * 데이터포인트 최대값을 기준으로 기본 크기에 대한 상대 크기로 표시된다.<br/>
     *
     * @default undefined
     */
    minSize?: number;
    /**
     * 데이터포인트 {@link shape 도형} 회전 각도.<br/>
     */
    rotation?: number;
    /**
     * 데이터포인트 좌표 기준 spark chart 표시 위치.<br/>
     *
     * @default 'top'
     */
    position?: PointViewPosition;
}
interface GaugeOptions extends CoordBaseSeriesOptions {
    /**
     * 데이터포인트 차트 너비를 픽셀 단위로 지정한다.<br/>
     */
    width?: number;
    /**
     * 데이터포인트 차트 높이를 픽셀 단위로 지정한다.<br/>
     */
    height?: number;
    /**
     * {@link width}, {@link height}를 동시에 지정한다.<br/>
     * 이 속성보다 {@link width}, {@link height}가 우선한다.
     *
     * @default 60
     */
    size?: number;
    /**
     * 데이터포인트 좌표 기준 게이지 표시 위치.<br/>
     *
     * @default 'top'
     */
    position?: PointViewPosition;
}
interface ValueGaugeOptions extends GaugeOptions {
    /**
     * {@link valueDomain} 설정에 따라
     * 시리즈의 전체 데이터포인트 값들로 부터 계산된 최소값 보다
     * 이 속성에 지정한 값이 작으면 그 값을 기준 최소값으로 한다.<br/>
     *
     * @default 0
     */
    minValue?: number;
    /**
     * {@link valueDomain} 설정에 따라
     * 시리즈의 전체 데이터포인트 값들로 부터 계산된 최대값 보다
     * 이 속성에 지정한 값이 크면 그 값을 기준 최대값으로 한다.<br/>
     */
    maxValue?: number;
}
interface SparkBaseLineOptions extends ChartItemOptions {
}
/**
 * @enum
 * 데이터포인트 값들을 표시할 때,
 * 크기 기준을 데이터포인트의 값들로 한정할 것인 지 또는,
 * 시리즈 전체 값들의 범위를 기준으로 할 것인 지를 지정한다.<br/>
 */
declare const _DataPointValueDomain: {
    readonly SERIES: "series";
    readonly POINT: "point";
};
/** @dummy */
type DataPointValueDomain = typeof _DataPointValueDomain[keyof typeof _DataPointValueDomain];
interface OrthogonalSparkSeriesOptions extends SparkSeriesOptions {
    /**
     * @ignore 미구현
     * true면 수평 방향으로 표시한다.
     */
    inverted?: boolean;
    /**
     * 기준선 설정 옵션.<br/>
     */
    baseLine?: SparkBaseLineOptions | boolean;
    /**
     * 데이터포인트 차트 너비를 픽셀 단위로 지정한다.<br/>
     */
    width?: number | string;
    /**
     * 데이터포인트 차트 높이를 픽셀 단위로 지정한다.<br/>
     */
    height?: number;
    /**
     * 데이터포인트 차트 양쪽 끝 여백 크기를 픽셀 크기나,
     * '%'로 끝나는 전체 너비에 대한 백분율로 지정한다.<br/>
     *
     * @default undefined
     */
    padding?: PercentSize;
    /**
     * 상/하 값 구분의 기준이 되는 값.\
     * 숫자가 아닌 값으로 지정하면 0으로 간주한다.
     */
    baseValue?: number;
    belowStyle?: SVGStyleOrClass;
    /**
     * 바 높이 계산에 사용할 값 범위(min/max)의 산출 방식을 지정한다.<br/>
     * - `'series'`: 시리즈의 **모든 데이터포인트** 값 전체를 대상으로 min/max를 계산하여,
     *   각 데이터포인트 차트의 스케일이 동일하게 표시된다.
     * - `'point'`: **각 데이터포인트** 자신의 값들만으로 min/max를 계산하여,
     *   데이터포인트마다 스케일이 독립적으로 결정된다.
     *
     * @default 'series'
     */
    valueDomain?: DataPointValueDomain;
    /**
     * {@link valueDomain} 설정에 따라
     * 개별 데이터포인트나 시리즈의 전체 데이터포인트 값들로 부터 계산된 최소값 보다
     * 이 속성에 지정한 값이 작으면 그 값을 기준 최소값으로 한다.<br/>
     */
    minValue?: number;
    /**
     * {@link valueDomain} 설정에 따라
     * 개별 데이터포인트나 시리즈의 전체 데이터포인트 값들로 부터 계산된 최대값 보다
     * 이 속성에 지정한 값이 크면 그 값을 기준 최대값으로 한다.<br/>
     */
    maxValue?: number;
    /**
     * @ignore 미구현
     * 2 이상 값을 지정하면 데이터포인트의 값들을 이 값을 밑수로 하는 log를 취해 계산한다.<br/>
     * 작은 값들과 큰 값의 차이가 아주 클 때 격차의 scale을 줄여서 표시할 수 있다.
     */
    logBase?: number;
}
declare const BarSeriesType = "bar";
interface BarSeriesSubLabelOptions extends DataPointLabelOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
/**
 * 데이터포인트의 **'value'** 속성으로 지정된 값들을 막대 차트로 표시한다.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'bar'이다.<br/>
 *
 * @fiddle series/bar-series2 Bar 시리즈 데모
 *
 */
interface BarSeriesOptions extends OrthogonalSparkSeriesOptions {
    /** @dummy */
    type?: typeof BarSeriesType;
    /**
     * 보조 라벨 설정 모델.<br/>
     * 기본 라벨({@link https://realmap.co.kr/docs/api/options/SeriesOptions#pointLabel pointLabel})과 별도로,
     * position/offset을 다르게 지정해 바를 사이에 두고 위/아래로 나눠 표시할 수 있다.
     * (예: 값은 바 위(pointLabel), 이름은 바 아래(subLabel))
     */
    subLabel?: BarSeriesSubLabelOptions | boolean;
    /**
     * 바 너비.<br/>
     * 차트에 bar 하나가 차지히는 원래 너비에서 실제 표시되는 바 너비의 상대적 크기로 지정한다.
     * 1보다 큰 경우 bar들이 겹치게 되는데 {@link overflow}가 true가 아니면 넘치지 않도록 최대한 차트 안쪽으로 밀어서 표시된다.
     *
     * @default 0.7
     */
    barWidth?: number;
    maxValue?: number;
    /**
     * null인 y값을 {@link baseValue}로 간주한다.<br/>
     */
    nullAsBase?: boolean;
    /**
     * {@link categories}가 지정되지 않고, {@link colorByField}가 true인 경우,
     * bar들의 색상이 이 속성에 지정한 색들로 순환 지정된다.<br/>
     * 이 속성이 지정되지 않으면 데이터포인트 색상을 기준으로 색을 분리해 표시한다.
     */
    fieldColors?: string[];
    /**
     * {@link fieldColors} 속성에 따라 bar들이 다른 색으로 표시되게 한다.<br/>
     * {@link categories}가 지정되면 그 설정을 따른다.
     *
     * @default true
     */
    colorByField?: boolean;
    /**
     * {@link baseValue} 혹은 y축의 baseValue보다 작은 쪽의 point들에 적용되는 스타일.
     */
    belowStyle?: SVGStyleOrClass;
    /**
     * true로 지정하면 {@link barWidth}가 1보다 큰 경우 bar가 차트 너비를 넘어 표시된다.<br/>
     * false면 최대한 차트 영역 내로 밀어서 표시한다.
     *
     * @default false
     */
    overflow?: boolean;
    /**
     * bar 표시 순서.<br/>
     * ex) 'reverse'로 지정하면 첫번째 bar가 두번째 bar 위에 표시된다.
     *
     * @default 'normal'
     */
    barOrder?: 'normal' | 'reverse';
}
/**
 * line 시리즈의 fill 영역 설정.<br/>
 */
interface LineSeriesAreaOptions extends ChartItemOptions {
    /**
     * @default
     */
    visible?: false;
}
declare const LineSeriesType = "line";
/**
 * 데이터포인트의 **'value'** 속성으로 지정된 값들을 선(line) 차트로 표시한다.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'line'이다.<br/>
 *
 * @fiddle series/line-series Line 시리즈 데모
 *
 */
interface LineSeriesOptions extends OrthogonalSparkSeriesOptions {
    /** @dummy */
    type?: typeof LineSeriesType;
    back?: ChartItemOptions;
    /**
     * line 시리즈의 fill 영역 설정.<br/>
     */
    area?: LineSeriesAreaOptions;
    curved?: boolean;
}
/**
 * 파이 섹터 무시 경계 값 및 속성 설정.<br/>
 * 데이터포인트 values의 총 합이 지정된 value보다 작을 때
 * 파이 섹터들을 별도로 표시하지 않고 지정한 크기와 스타일의 원 또는 섹터 하나로 표시한다.<br/>
 */
interface PieSeriesThreshold {
    value?: number;
    /**
     * 지정하지 않으면 원래 크기대로 표시한다.
     */
    radius?: number;
    style?: SVGStyleOrClass;
}
declare const PieSeriesType = "pie";
/**
 * 데이터포인트의 **'value'** 속성으로 지정된 값들을 파이(pie) 차트로 표시한다.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'pie'이다.<br/>
 *
 * @fiddle series/pie-series Pie 시리즈 데모
 *
 */
interface PieSeriesOptions extends SparkSeriesOptions {
    /** @dummy */
    type?: typeof PieSeriesType;
    centerX?: number;
    centerY?: number;
    /**
     * 파이 반지름.<br/>
     * 숫자나 '%'로 끝나는 백분율로 지정할 수 있다.
     * 백분율로 지정하면 {@link body} 영역의 높이/너비 중 작은 크기에 대한 상대 크기로 지정된다.
     * 또, {@link minSize}와 함께 사용하면 데이터포인트 값에 따라 다른 크기로 표시할 수 있다.
     *
     * @default 30
     */
    radius?: PercentSize;
    startAngle?: number;
    totalAngle?: number;
    clockwise?: boolean;
    /**
     * {@link categories}가 지정되지 않고, {@link colorByField}가 true인 경우,
     * bar들의 색상이 이 속성에 지정한 색들로 순환 지정된다.<br/>
     * 이 속성이 지정되지 않으면 데이터포인트 색상을 기준으로 색을 분리해 표시한다.
     */
    fieldColors?: string[];
    /**
     * {@link fieldColors} 속성에 따라 파이 섹터들이 다른 색으로 표시되게 한다.<br/>
     * {@link categories}가 지정되면 각 category에 지정된 색상을 따른다.
     *
     * @default true
     */
    colorByField?: boolean;
    /**
     * 파이 섹터 무시 경계 값 및 속성 설정 목록.<br/>
     * 데이터포인트 values의 총 합이 지정된 값보다 작을 때
     * 파이 섹터들을 별도로 표시하지 않고 지정한 스타일의 원 또는 섹터 하나로 표시한다.<br/>
     */
    threshold?: PieSeriesThreshold | PieSeriesThreshold[];
}
/**
 * @enum
 */
declare const _WaffleDirection: {
    /**
     * 야래쪽 행(row)부터 위로 채워가면서 {@link https://realmap.co.kr/config/config/series/waffle#fillThreshold fillThreshold}에 도달하면
     * 오른쪽으로 채워 나간다.<br/>
     */
    readonly ROW: "row";
    /**
     * 왼쪽 행(column)부터 오른쪽로 채워가면서 {@link https://realmap.co.kr/config/config/series/waffle#fillThreshold fillThreshold}에 도달하면
     * 위쪽으로 채워 나간다.<br/>
     */
    readonly COL: "col";
};
/** @dummy */
type WaffleDirection = typeof _WaffleDirection[keyof typeof _WaffleDirection];
declare const WaffleSeriesType = "waffle";
/**
 * {@link value}로 지정된 연관된 값들을 waffle 차트로 표시한다.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'waffle'이다.<br/>
 *
 * @fiddle series/route-series Route 시리즈 데모
 *
 */
interface WaffleSeriesOptions extends SparkSeriesOptions {
    /** @dummy */
    type?: typeof WaffleSeriesType;
    /**
     * @default 10
     */
    rowCount?: number;
    /**
     * @default 10
     */
    colCount?: number;
    /**
     * @default 'round'
     */
    roundingMethod?: 'round' | 'trunc';
    /**
     * 최소 cell 개수.<br/>
     *
     * @default 1
     */
    minCount?: number;
    shape?: 'sqaure' | 'circle' | 'star' | 'diamond' | 'hexagon';
    cellSize?: 5;
    gap?: 2;
    /**
     * cell 들을 채워나가는 방향을 지정한다.<br/>
     *
     * @default 'col'
     */
    fillDirection?: WaffleDirection;
    /**
     * {@link fillDirection}이 'colFirst'나 'rowFirst'일 때,
     * 방향을 바꾸게 하는 기준 셀 개수.<br/>
     * 1 이상이어야 하고, {@link fillDirection}에 따라 {@link rowCount}나 {@link colCount} 미만 크기로 지정해야 한다.
     *
     * @default 1
     */
    fillThreshold?: number;
    /**
     * @default 'series'
     */
    valueDomain?: DataPointValueDomain;
    /**
     * {@link valueDomain} 설정에 따라
     * 개별 데이터포인트나 시리즈의 전체 데이터포인트 값들로 부터 계산된 최소값 보다
     * 이 속성에 지정한 값이 작으면 그 값을 기준 최소값으로 한다.<br/>
     */
    minValue?: number;
    /**
     * {@link valueDomain} 설정에 따라
     * 개별 데이터포인트나 시리즈의 전체 데이터포인트 값들로 부터 계산된 최대값 보다
     * 이 속성에 지정한 값이 크면 그 값을 기준 최대값으로 한다.<br/>
     */
    maxValue?: number;
    /**
     * true로 지정하면 값에 포함되지 않는 셀들을 {@link nullStyle}을 적용해서 표시한다.<br/>
     *
     * @default false;
     */
    showNull?: boolean;
}
/**
 * @enum
 */
declare const _BubbleSizeMode: {
    /**
     * 최대값의 버블에 대한 지름 비율로 크기를 결정한다.<br/>
     */
    readonly WIDTH: "width";
    /**
     * 최대값의 버블에 대한 면적 비율로 크기를 결정한다.<br/>
     */
    readonly AREA: "area";
};
/** @dummy */
type BubbleSizeMode = typeof _BubbleSizeMode[keyof typeof _BubbleSizeMode];
declare const BubbleSeriesType = "bubble";
/**
 * Bubble 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'bubble'이다.<br/>
 *
 * @fiddle series/bubble-series Bubble 시리즈 데모
 *
 */
interface BubbleSeriesOptions extends MarkerSeriesOptions {
    type?: typeof BubbleSeriesType;
    /**
     * sub label 설정 모델.
     */
    subLabel?: DataPointLabelOptions | boolean;
    /**
     * 데이터포인트 값들로 부터 계산된 최소값 보다
     * 이 속성에 지정한 값이 작으면 그 값을 기준 최소값으로 한다.<br/>
     * 실시간 동적으로 데이터포인트를 추가하는 경우 이 속성과 {@link maxValue}를 명시적으로 지정해야 한다.
     */
    minValue?: number;
    /**
     * 데이터포인트 값들로 부터 계산된 최대값 보다
     * 이 속성에 지정한 값이 크면 그 값을 기준 최대값으로 한다.<br/>
     * 실시간 동적으로 데이터포인트를 추가하는 경우 이 속성과 {@link minValue}를 명시적으로 지정해야 한다.
     */
    maxValue?: number;
    /**
     * 버블 크기를 결정하는 방식.
     *
     * @default 'area'
     */
    sizeMode?: BubbleSizeMode;
    /**
     * 버블 최소 크기.<br/>
     * 백분율(%)로 지정하면 차트 너비/높이 중 작은 크기에 대한 비율로 지정된다.
     *
     * @default 10
     */
    minSize?: PercentSize;
    /**
     * 버블 최대 크기.<br/>
     * 백분율(%)로 지정하면 차트 너비/높이 중 작은 크기에 대한 비율로 지정된다.
     *
     * @default '12%'
     */
    maxSize?: PercentSize;
    /**
     * @default 'center'
     */
    position?: PointViewPosition;
    /**
     * @default 'x: <b>${x}</b><br>y: <b>${y}</b><br>volume: <b>${z}</b>'
     */
    tooltipText?: string;
    /**
     * Orthographic 투영법을 사용할 때, 버블을 구의 표면에 붙여서 그릴지 여부를 지정한다.<br />
     * Orthographic에서만 유효하다.
     *
     * @default false
     */
    alignToSurface?: boolean;
    /**
     * 차트에 설정된 color scale 아이디 혹은 인덱스.<br/>
     * 지정하면 버블의 색이 데이터포인트 값에 해당하는 컬러스케일 색으로 표시된다.
     * 버블 크기 기준({@link minValue}/{@link maxValue})과 무관하게
     * 색은 데이터포인트 값들의 최소/최대값 범위로 결정된다.
     * 단, 컬러스케일이 다른 시리즈나 {@link https://realmap.co.kr/docs/api/options/ColorScaleOptions#minValue minValue}/{@link https://realmap.co.kr/docs/api/options/ColorScaleOptions#maxValue maxValue}를
     * 도메인 기준으로 사용하는 경우에는 그 도메인을 따른다.<br/>
     * 지정하지 않거나 명시적 null을 지정하면 컬러스케일에 연결되지 않는다.
     * 그 외 잘못된 값이면 첫번째 스케일에 연결된다.
     */
    colorScale?: string | number | null;
}
/**
 * @enum
 * 'route' 시리즈 연결 선 종류.<br/>
 */
declare const _RouteLineType: {
    readonly AIR: "air";
    readonly STRAIGHT: "straight";
    readonly CURVED: "curved";
};
/** @dummy */
type RouteLineType = typeof _RouteLineType[keyof typeof _RouteLineType];
/**
 * @enum
 */
declare const _RouteArrowDisplay: {
    readonly ALWAYS: "always";
    readonly MOVING: "moving";
    readonly NONE: "none";
};
/** @dummy */
type RouteArrowDisplay = typeof _RouteArrowDisplay[keyof typeof _RouteArrowDisplay];
/** @enum */
declare const _RouteMode: {
    /**
     * 대권항로를 따르는 경로를 설정한다.<br/>
     */
    readonly GREAT_CIRCLE: "geo";
    /**
     * 대권항로가 아닌 시작점부터 끝점으로 향하는 선을 경로로 설정한다.<br/>
     *
     * 선은 베지어 곡선으로 그려진다.<br/>
     * curveFactor 속성으로 곡률을 설정할 수 있다. <br />
     */
    readonly SIMPLE: "chart";
};
/** @dummy */
type RouteMode = typeof _RouteMode[keyof typeof _RouteMode];
declare const RouteSeriesType = "route";
/**
 * {@link coords}로 지정된 두 지점 사이를 곡선으로 연결하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'route'이다.<br/>
 * 데이터포인트 label을 표시하지 않는다.
 *
 * @fiddle series/route-series Route 시리즈 데모
 *
 */
interface RouteSeriesOptions extends SeriesOptions {
    /** @dummy */
    type?: typeof RouteSeriesType;
    /**
     * 경로를 그리는 방식을 설정하는 옵션  <br />
     *
     * - 'geo' : 지구(구면) 좌표계를 기준으로 경로 계산. great-circle(대권) 경로 생성 <br />
     * - 'chart' : 차트(평면) 좌표계를 기준으로 경로 계산. 직선 또는 곡률 속성에 따른 곡선 생성 <br />
     *
     * 주의: projection이 'orthographic'일 때는 'geo' 모드만 지원한다. <br />
     *
     * @default 'geo'
     */
    routeMode?: RouteMode;
    /**
     * @ignore 미구현
     * @default 'air'
     */
    lineType?: RouteLineType;
    /**
     * 선 두깨를 픽셀단위로 지정한다.<br/>
     * 이 속성을 지정하면 css 설정보다 우선해서 적용된다.
     */
    lineWidth?: number;
    /**
     * 화살표 표시 방식.<br/>
     *
     * @default 'always'
     */
    arrowDisplay?: RouteArrowDisplay;
    /**
     * 화살표의 가로 폭을 지정한다.
     */
    arrowWidth?: number;
    /**
     * 화살표의 길이를 지정한다.
     */
    arrowLength?: number;
    /**
     * 경로의 곡률을 설정한다. <br/>
     * 'routeMode'가 'chart'일 때 유효하다.<br/>
     * 값이 커질수록 휘어짐이 커진다.<br/>
     *
     * - 0: 직선
     * - 양수: 위로 휘는 곡선.
     * - 음수: 아래로 휘는 곡선.
     *
     * @default 0
     */
    curveFactor?: number;
    /**
     * 각 데이터포인트의 imageUrl의 root url.
     */
    imageRootUrl?: string;
    /**
     * 경로 끝점 이미지 URL.<br/>
     *
     * 데이터포인트의 imageUrl을 통해 개별적으로 지정할 수 있으나, 일괄로 적용하고 싶은 경우, 해당 옵션을 사용할 수 있다.<br/>
     * 만약 데이터포인트의 imageUrl이 지정되어 있다면, 이를 우선 적용한다.<br/>
     */
    imageUrl?: string;
    /**
     * @default 'imageUrl'
     */
    imageField?: string;
    /**
     * 경로 끝점 이미지 너비.<br/>
     */
    imageWidth?: number;
    /**
     * 경로 끝점 이미지 높이.<br/>
     */
    imageHeight?: number;
}
interface DrilldownOptions extends ChartItemOptions {
    /**
     * true가 아니면 지정하면 클릭 등으로 사용자가 drilldown할 수 없다.<br/>
     *
     * @default true
     */
    enabled?: boolean;
    /**
     * drilldown 실행 시 detail 시리즈에 연결된 맵이 차트의 base맵이 되도록 한다.<br/>
     *
     * @default true
     */
    autoMapChange?: boolean;
}
/**
 * 맵 시리즈 내외부 접경선 표시 설정 옵션.<br/>
 * [topoJSON](https://github.com/topojson/topojson-specification?tab=readme-ov-file) 소스로
 * 작성된 맵인 경우 내외부 접경선을 별도의 스타일로 구분해서 표시할 수 있다.
 */
interface MapBordersOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
/**
 * 맵 시리즈 내외부 접경선 표시 설정 옵션.<br/>
 * [topoJSON](https://github.com/topojson/topojson-specification?tab=readme-ov-file) 소스로
 * 작성된 맵인 경우 내외부 접경선을 별도의 스타일로 구분해서 표시할 수 있다.
 */
interface MapBorderOptions extends ChartItemOptions {
    /**
     * border 목록일 때, 각 목록을 구분하는 이름.<br/>
     */
    name?: string;
}
interface InsetLabelArgs extends CommonCallbackArgs {
    inset: MapInset;
}
/**
 * map 시리즈 area의 자식 영역들로 구성된 inset에 표시할 label 설정 모델.<br/>
 */
interface InsetLabelOptions extends IconedTextOptions {
    /**
     * 이 속성이 true이거나, undefined이면서 pointLabel이 true일 때 표시된다.<br/>
     *
     * @default undefined
     */
    visible?: boolean;
    /**
     * 계산되는 기본 text 대신, data point label로 표시될 text 리턴.<br/>
     * undefined나 null을 리턴하면 {@link textField} 등을 사용한 기존에 표시될 텍스트를 사용한다.
     * 빈 문자열 등 정상적인 문자열을 리턴하면 그 문자열대로 표시된다.
     * {@link prefix}나 포맷 속성 등은 적용되지 않는다.
     */
    textCallback?: (args: InsetLabelArgs) => string;
    /**
     * 데이터 포인트별 label 표시 여부를 리턴하는 콜백.
     */
    visibleCallback?: (args: InsetLabelArgs) => boolean;
    /**
     * 데이터 포인트별로 추가 적용되는 스타일을 리턴한다.
     */
    styleCallback?: (args: InsetLabelArgs) => SVGStyleOrClass;
}
interface MapSeriesLabelOptions extends DataPointLabelOptions {
    /**
     * @default false
     */
    visible?: boolean;
    hoverColor?: string;
}
declare const MapSeriesType = "map";
/**
 * 맵 소스에서 경계가 설정된 영역들을 표시하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'map'이다.<br/>
 * {@link https://en.wikipedia.org/wiki/Choropleth_map | choropleth map}(단계 구분도. 색상으로 area별 특성을 나타내는 지도)으로 사용된다.
 * 맵차트 설정에서 {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}을 지정하지 않으면 자동으로 생성되는 기본 시리즈이다.
 * 맵차트가 지도처럼 보이려면 반드시 하나 이상의 map 시리즈나 {@link https://realmap.co.kr/config/config/series/tiledweb tiledweb 시리즈}가 포함되어야 한다.<br/>
 *
 */
interface MapSeriesOptions extends ValueSeriesOptions {
    /** @dummy */
    type?: typeof MapSeriesType;
    /**
     * {@link https://realmap.co.kr/config/config/series/map/pointLabel#visible visible} 기본값이 false이다.
     */
    pointLabel?: MapSeriesLabelOptions | boolean;
    /**
     * inset 라벨 설정 옵션.<br/>
     */
    insetLabel?: InsetLabelOptions | boolean;
    /**
     * true로 지정하면 데이터포인트로 지정되지 않은 area들에 대해,
     * map 모델의 속성들을 이용해서 각 area에 해당하는 data point들을 자동 생성한다.<br/>
     */
    useMapData?: boolean;
    /**
     * 맵 area와 연결할 키값들을 지정한다.<br/>
     * 두 값을 배열로 지정하면 첫번째 문자열은 맵소스 "properties"의 속성명,
     * 두번째는 데이터포인트의 속성명이다.
     * 값을 하나만 지정하거나 문자열로 지정하면 양쪽 같은 속성명으로 연결한다.<br/>
     * 이 값이 지정되지 않으면 데이터포인트의 "id" 또는 {@link idField} 속성으로 지정한 속성값과 맵소스의 "rm-id" 또는 "id" 속성값으로 연결한다.
     */
    mapKeys?: string | [string, string];
    /**
     * 데이터포인트가 연결되지 않은 area의 스타일.<br/>
     *
     * @css '.rm-map-series .rm-point[data-null]'
     */
    nullStyle?: SVGStyleOrClass;
    /**
     * dummy area에 설정되는 스타일셋.<br/>
     */
    dummyStyle?: SVGStyleOrClass;
    /**
     * true로 지정하면 data가 연결되지 않은 area도 마우스 hover 효과가 표시된다.<br/>
     *
     * @default false
     */
    nullHovering?: boolean;
    /**
     * 데이터포인트 위에 마우스가 있을 때 적용되는 색상.<br />
     * hoverStyle보다 우선되어 적용된다.
     */
    hoverColor?: string;
    /**
     * 데이터포인트 위에 마우스가 있을 때 적용되는 스타일셋 혹은 class selector.<br />
     * hoverColor와 hoverStyle 둘 다 적용되지 않은 경우, 기본 fill, filter가 적용된다.
     */
    hoverStyle?: SVGStyleOrClass;
    /**
     * true로 지정하면 마우스 클릭 등으로 area를 선택할 수 있다.<br/>
     * {@link https://realmap.co.kr/config/config/general#clickAction clickAction}이 'select'로 지정된 경우에만 적용된다.<br/>
     *
     * @default false
     */
    selectable?: boolean;
    /**
     * @deprecated 대신 {@link selectStyle}을 사용한다.<br/>
     */
    selectedStyle?: SVGStyleOrClass;
    /**
     * 선택된 area에 적용할 스타일셋.<br/>
     */
    selectStyle?: SVGStyleOrClass;
    /**
     * true로 지정하면 data point가 설정되지 않은 area들도 {@link nullStyle}로 표시한다.<br/>
     * 복수 개의 시리즈로 영역들을 그룹핑하려면 반드시 false로 지정해야 한다.
     *
     * @default true
     */
    allAreas?: boolean;
    /**
     * 표시하지 않는 영역들을 지정한다.<br/>
     * {@link mapKeys} 속성으로 지정된 key나 'id' 또는 {@link idField}로 지정된 값(들)로 지정한다.
     */
    hiddenAreas?: string | string[];
    /**
     * 내부 접경선 표시 설정 옵션.<br/>
     */
    internalBorder?: MapBordersOptions;
    /**
     * 외부 접경선 표시 설정 옵션.<br/>
     */
    externalBorder?: MapBordersOptions;
    /**
     * 특정 영역들의 경계선 옵션 목록.<br/>
     */
    mapBorders?: string | MapBorderOptions | (string | MapBorderOptions)[];
    colorRange?: ColorRange;
    /**
     * 차트에 설정된 color scale 아이디 혹은 인덱스.<br/>
     * 명시적 null을 지정하면 컬러스케일에 연결되지 않는다.
     * 다른 잘못된 값이면 첫번째 스케일에 연결된다.
     */
    colorScale?: string | number | null;
    drilldown?: DrilldownOptions;
    /**
     * @ignore
     */
    detail?: MapSeriesOptions;
    detailKey?: string;
    detailZoom?: number;
    /**
     * true로 지정하면 데이터포인트가 설정된 area들이 설정되지 않은 area보다 위에 그려지게 한다.<br/>
     *
     * @default false
     */
    bringToFront?: boolean;
    /**
     * 맵시리즈는 기본값으로 legend에 표시하지 않는다.<br/>
     *
     * @default -1
     */
    legend?: number | string;
}
/**
 * Feature 종류.<br/>
 * @enum
 */
declare const _FeatureType: {
    /**
     * 영역.<br/>
     */
    readonly AREA: "none";
};
/** @dummy */
type FeatureType = typeof _FeatureType[keyof typeof _FeatureType];
interface FeatureSeriesLabelOptions extends DataPointLabelOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
declare const FeatureSeriesType = "feature";
/**
 * Feature area 영역들을 칠하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'feature'이다.<br/>
 *
 */
interface FeatureSeriesOptions extends CoordBaseSeriesOptions {
    /** @dummy */
    type?: typeof FeatureSeriesType;
    featureType?: FeatureType;
    hoverColor?: string;
    hoverStyle?: SVGStyleOrClass;
    colorRange?: ColorRange;
    /**
     * 차트에 설정된 color scale 아이디 혹은 인덱스.<br/>
     * 명시적 null을 지정하면 컬러스케일에 연결되지 않는다.
     * 다른 잘못된 값이면 첫번째 스케일에 연결된다.
     */
    colorScale?: string | number | null;
    /**
     * true로 지정하면 데이터포인트가 설정된 area들이 설정되지 않은 area보다 위에 그려지게 한다.<br/>
     *
     * @default false;
     */
    bringToFront?: boolean;
}
interface PointClusterRange {
    from?: number;
    to?: number;
    radius?: number;
    color?: string;
}
interface PointClusterOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * @default undefined
     */
    algorithm?: 'kmeans' | 'grid';
    /**
     * @default 40 픽셀
     */
    distance?: number;
    /**
     * @default 2
     */
    minDensity?: number;
    /**
     * @default 100
     */
    maxIteration?: number;
    /**
     * @default 50 밀리초
     */
    stepDuration?: number;
    /**
     * @default 300
     */
    zoomLimit?: number;
    /**
     * @default 15
     */
    radius?: number;
    ranges?: PointClusterRange[];
    /**
     * true면 cluster view를 클릭하면 포함된 데이터포인트들이 모두 표시되도록 zoom 시킨다.<br/>
     * 명시적 false로 설정하지 않으면 true로 적용된다.<br/>
     */
    expandable?: boolean;
}
declare const PointSeriesType = "point";
/**
 * Point 시리즈. <br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'point'이다.<br/>
 *
 * @fiddle series/point-series Point 시리즈 데모
 *
 */
interface PointSeriesOptions extends MarkerSeriesOptions {
    /** @dummy */
    type?: typeof PointSeriesType;
    /**
     * 명시적으로 지정하지 않으면 기본 제공되는 shape 목록 중 하나로 자동 설정된다.<br/>
     */
    shape?: Shape;
    /**
     * 데이터포인트 {@link shape 도형}의 반지름.
     *
     * @default 5
     */
    radius?: number;
    /**
     * @default 'center'
     */
    position?: PointViewPosition;
    cluster?: PointClusterOptions;
}
/**
 * Image 시리즈 label 설정 옵션. <br/>
 */
interface ImageSeriesLabelOptions extends DataPointLabelOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
declare const ImageSeriesType = "image";
/**
 * 지정된 지점에 이미지를 표시하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'image'이다.<br/>
 *
 * @fiddle series/image-series Image 시리즈 데모
 *
 */
interface ImageSeriesOptions extends SeriesOptions {
    /** @dummy */
    type?: typeof ImageSeriesType;
    /**
     * {@link https://realmap.co.kr/config/config/series/image/pointLabel#visible visible} 기본값이 false이다.
     */
    pointLabel?: ImageSeriesLabelOptions;
    /**
     * @default 'imageUrl'
     */
    imageField?: string;
    /**
     * 각 데이터포인트의 imageUrl의 root url.
     */
    rootUrl?: string;
    /**
     * 이미지 너비.<br/>
     */
    imageWidth?: number;
    /**
     * 이미지 높이.<br/>
     */
    imageHeight?: number;
    /**
     * 데이터포인트 {@link shape 도형} 회전 각도.<br/>
     */
    rotation?: number;
    /**
     * 이미지 표시 위치.<br/>
     *
     * @default top
     */
    position?: PointViewPosition;
}
declare const PinSeriesType = "pin";
/**
 * Pin 시리즈. <br/>
 * 지정된 위치에 pin의 아래 부분이 위치한다.
 * 내부 원을 특정 스타일로 표시할 수 있다.
 * 또, 도형 안에 text를 표시할 수 있으며,
 * {@link style}에 padding을 지정해서 text 위치를 조정할 수 있다.
 *
 */
interface PinSeriesOptions extends MarkerSeriesOptions {
    /** @dummy */
    type?: typeof PinSeriesType;
    /**
     * 원 반지름.<br/>
     * 이 값을 기준으로 전체 너비와 높이가 결정된다.
     * 전체 높이가 이 값의 3배가 된다.
     *
     * @default 9
     */
    radius?: number;
    /**
     * 내부 원 크기.<br/>
     * {@link radius 외부 원 크기}에 대한 비율을 0 ~ 1 사이의 값으로 지정한다.
     *
     * @default 0
     */
    innerRadius?: number;
    /**
     * 내부 원 스타일셋.<br/>
     */
    innerStyle?: SVGStyleOrClass;
    /**
     * 내부 원에 표시할 label 설정 모델.<br/>
     * 문자열로 지정하면 label 텍스트를 지정한다.
     */
    innerLabel?: ChartTextOptions | string;
    /**
     * spark chart 표시 위치.<br/>
     *
     * @default top
     */
    position?: PointViewPosition;
    /**
     * 차트에 설정된 color scale 아이디 혹은 인덱스.<br/>
     * 명시적 null을 지정하면 컬러스케일에 연결되지 않는다.
     * 다른 잘못된 값이면 첫번째 스케일에 연결된다.
     */
    colorScale?: string | number | null;
}
interface FigureSeriesImageOptions extends ChartItemOptions {
    /**
     * 이미지 경로.<br/>
     */
    url?: string;
    /**
     * 이미지 너비.<br/>
     */
    width?: number;
    /**
     * 이미지 높이.<br/>
     */
    height?: number;
    /**
     * 이 값을 0보다 크고 1보다 작은 값으로 지정하면,
     * 데이터포인트 최대값을 기준으로 기본 크기에 대한 상대 크기로 표시된다.<br/>
     * //시리즈의 minSize가 설정된 경우에만 동작한다.<br/>
     */
    minSize?: number;
}
/**
 * 데이터포인트 figure로 표시할 svg path에 대한 객체. <br/>
 * 'path'와 'style'을 별도로 지정하는 객체로 지정할 수 있다.
 */
interface FigureObject {
    /**
     * svg path 설정.
     */
    path: string;
    /**
     * svg style 또는 class 이름 설정.
     */
    style: SVGStyleOrClass;
}
declare const FigureSeriesType = "figure";
/**
 * Figure 시리즈.<br/>
 * {@link figure} 속성에 표시하려는 사용자 정의 도형의 svg path를 지정한다.
 * 또, 도형 안에 text나 이미지를 표시할 수 있으며,
 * {@link style}에 padding을 지정해서 text나 이미지 위치를 조정할 수 있다.
 *
 * @fiddle series/figure-series Figure 시리즈 데모
 *
 */
interface FigureSeriesOptions extends CoordBaseSeriesOptions {
    /** @dummy */
    type?: typeof FigureSeriesType;
    figures?: {
        [id: string]: {
            path: string;
            box?: [number, number] | number;
            style?: SVGStyleOrClass;
        };
    };
    /**
     * 데이터포인트 figure로 표시할 svg path 'd' 속성 값.<br/>
     * 'path'와 'style'을 별도로 지정하는 객체로 지정할 수도 있다.
     * '#'로 시작하는 문자열은 차트나 {@link figures}에 등록한 figure id를 지정한다.
     * 문자열 배열로 별도로 그려지는 두 path를 지정한다. 각 path에는 별도의 style을 지정할 수 있다.
     */
    figure?: string | (string | FigureObject)[];
    /**
     * {@link figure}의 좌표계를 [너비, 높이]로 지정한다.<br/>
     * 값을 하나만 지정하거나, 애초에 숫자값으로 지정하면 너비, 높이를 같은 값으로 설정한다.
     * 이 속성과 {@link width}나 {@link height}를 같이 지정하면 표시되는 크기를 조정할 수 있다.
     */
    figureBox?: [number, number] | number;
    /**
     * figure 표시 너비.<br/>
     * {@link figureBox}에 figure의 원 크기를 지정하지 않으면 무시된다.
     * 또, height를 지정하지 않으면 이 값과 figureBox의 비율에 맞게 height가 자동 설정된다.
     */
    width?: number;
    /**
     * figure 표시 높이.<br/>
     * {@link figureBox}에 figure의 원 크기를 지정하지 않으면 무시된다.
     * 또, width를 지정하지 않으면 이 값과 figureBox의 비율에 맞게 width가 자동 설정된다.
     */
    height?: number;
    /**
     * 내부 원에 표시할 텍스트.<br/>
     */
    rotation?: number;
    /**
     * figure 내부에 표시할 label 설정 옵션.<br/>
     * 문자열로 지정하면 label 옵션의 text 속성으로 설정된다..
     */
    innerLabel?: IconedTextOptions | string;
    /**
     * figure 내부에 표시할 image 설정 옵션.<br/>
     * 문자열로 지정하면 이미지 옵션의 url 속성으로 지정된다.
     */
    innerImage?: FigureSeriesImageOptions | string;
    /**
     * figure 표시 위치.<br/>
     *
     * @default top
     */
    position?: PointViewPosition;
    /**
     * 이 값을 0보다 크고 1보다 작은 값으로 지정하면,
     * 데이터포인트 최대값을 기준으로 기본 크기에 대한 상대 크기로 표시된다.<br/>
     *
     * @default undefined
     */
    minSize?: number;
}
/**
 * Vector 머리 표시 종류.<br/>
 * @enum
 */
declare const _VectorHeadType: {
    /**
     * 머리를 따로 표시하지 않는다.
     *
     * 
     */
    readonly NONE: "none";
    /**
     * 닫힌 화살표.<br/>
     *
     * 
     */
    readonly CLOSED_ARROW: "closedArrow";
    /**
     * 열린 화살표.<br/>
     *
     * 
     */
    readonly OPEN_ARROW: "openArrow";
};
/** @dummy */
type VectorHeadType = typeof _VectorHeadType[keyof typeof _VectorHeadType];
declare const VectorSeriesType = "vector";
/**
 * Vector 시리즈. <br/>
 *
 */
interface VectorSeriesOptions extends MarkerSeriesOptions {
    /** @dummy */
    type?: typeof VectorSeriesType;
    /**
     * @default 'openArrow'
     */
    headType?: VectorHeadType;
    /**
     * 데이터포인트 생성시 전달되는 정보에서 길이(length) 값을 지정하는 속성 이름.<br/>
     *
     * @default 'length'
     */
    lengthField?: string;
    /**
     * 데이터포인트 생성시 전달되는 정보에서 각도(angle) 값을 지정하는 속성 이름.<br/>
     *
     * @default 'angle'
     */
    angleField?: string;
    /**
     * 시작 각도.
     * 3시 위치가 0도.
     *
     * @default 0
     */
    startAngle?: number;
}
/**
 * 'grid' 모드 'heatmap' 셀에 표시할 기준 값.<br/>
 * @enum
 */
declare const _HeatmapCellAggregation: {
    /**
     * 셀에 포함된 포인트 개수.<br/>
     *
     * 
     */
    readonly COUNT: "count";
    /**
     * 셀에 포함된 포이트 값들의 합.<br/>
     *
     * 
     */
    readonly SUM: "sum";
    /**
     * 셀에 포함된 포이트 값들의 평균.<br/>
     *
     * 
     */
    readonly AVG: "avg";
};
/** @dummy */
type HeatmapCellAggregation = typeof _HeatmapCellAggregation[keyof typeof _HeatmapCellAggregation];
interface HeatmapGridModeOptions {
    origin?: MapCoord;
    /**
     * 초(") 단위로 지정한다.<br/>
     * 1도(°)가 3600초이고, 1분(')은 60초이다.
     * 또, 10초(~30m), 30초(~1km), 60초(~2km) 정도가 된다.<br/>
     * 이 속성을 지정하지 않고 {@link cellHeight}가 지정되면 그 값을 따른다.
     *
     * @default 3600
     */
    cellWidth?: number;
    /**
     * 초(") 단위로 지정한다.<br/>
     * 1도(°)가 3600초이고, 1분(')은 60초이다.
     * 또, 10초(~30m), 30초(~1km), 60초(~2km) 정도가 된다.<br/>
     * 이 속성을 지정하지 않고 {@link cellWidth}가 지정되면 그 값을 따른다.
     *
     * @default 3600
     */
    cellHeight?: number;
    blur?: number;
    /**
     * @default 'sum'
     */
    aggregation?: HeatmapCellAggregation;
}
interface HeatmapPointModeOptions {
}
/**
 * @enum
 * 히트맵 표시 방식<br/>
 */
declare const _HeatmapMode: {
    readonly GRID: "grid";
    readonly POINT: "point";
};
/** @dummy */
type HeatmapMode = typeof _HeatmapMode[keyof typeof _HeatmapMode];
declare const HeatmapSeriesType = "heatmap";
/**
 * @private 미구현
 *
 * 특정 위치를 중심으로 주변 영역을 칠하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'heatmap'이다.<br/>
 *
 */
interface HeatmapSeriesOptions extends MarkerSeriesOptions {
    /** @dummy */
    type?: typeof HeatmapSeriesType;
    /**
     * 히트맵 표시 방식.
     *
     * @default 'grid'
     */
    mode?: HeatmapMode;
    grid?: HeatmapGridModeOptions;
    point?: HeatmapPointModeOptions;
}
declare const RegionSeriesType = "region";
/**
 * @private 미구현
 *
 * Region 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'region'이다.<br/>
 *
 */
interface RegionSeriesOptions extends MarkerSeriesOptions {
    /** @dummy */
    type?: typeof RegionSeriesType;
}
interface PanelSeriesSectionOptions extends ChartItemOptions {
    /**
     * @default '${value}'
     */
    text?: string;
    backgroundStyle?: SVGStyleOrClass | PointStyleCallback;
}
interface PanelSeriesHeaderOptions extends PanelSeriesSectionOptions {
    minSize?: PercentSize;
}
interface PanelSeriesBodyOptions extends PanelSeriesSectionOptions {
}
interface PanelSeriesLabelOptions extends DataPointLabelOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
declare const PanelSeriesType = "panel";
/**
 * 타이틀과 데이터포인트 관련 내용을 표시하는 두 영역을 표시하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'panel'이다.<br/>
 *
 * @fiddle series/panel-series Panel 시리즈 데모
 *
 */
interface PanelSeriesOptions extends CoordBaseSeriesOptions {
    /** @dummy */
    type?: typeof PanelSeriesType;
    /**
     * {@link header}와 본체를 배치하는 방향.<br />
     *
     * @default 'vertical'
     */
    orientation?: 'vertical' | 'horizontal';
    /**
     * {@link https://realmap.co.kr/config/config/series/panel/pointLabel#visible visible} 기본값이 false이다.
     */
    pointLabel?: PanelSeriesLabelOptions;
    header?: PanelSeriesHeaderOptions;
    body?: PanelSeriesBodyOptions;
    divider?: ChartItemOptions;
    /**
     * 데이터포인트 view 전체 최소 너비.<br/>
     */
    minWidth?: number;
    /**
     * 데이터포인트 view 전체 최소 높이.<br/>
     */
    minHeight?: number;
    /**
     * 이미지 표시 위치.<br/>
     *
     * @default top
     */
    position?: PointViewPosition;
}
interface TileWebProvider {
    url: string;
    theme?: string;
    subDomain?: string;
    credit: string;
}
declare const TiledWebSeriesType = "tiledweb";
/**
 * 지도 해상도에 맞는 조각 그림들로 맵 배경을 채우는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'tiledweb'이다.<br/>
 *
 */
interface TiledWebSeriesOptions extends SeriesOptions {
    /** @dummy */
    type?: typeof TiledWebSeriesType;
    /**
     * @default 'osm'
     */
    provider?: TileWebProvider | string;
    /**
     * @default 'Standard'
     */
    theme?: string;
    /**
     * @default 'a'
     */
    subdomain?: string;
}
interface HtmlSeriesLabelOptions extends DataPointLabelOptions {
    /**
     * @append
     * @default false
     */
    visible?: boolean;
}
declare const HtmlSeriesType = "html";
/**
 * 지정된 지점에 html을 표시하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'html'이다.<br/>
 *
 * @fiddle series/html-series Html 시리즈 데모
 *
 */
interface HtmlSeriesOptions extends ValueSeriesOptions {
    type?: typeof HtmlSeriesType;
    /**
     * {@link https://realmap.co.kr/config/config/series/map/pointLabel#visible visible} 기본값이 false이다.
     */
    pointLabel?: HtmlSeriesLabelOptions | boolean;
    htmlField?: string;
    html?: string;
    htmlWidth?: number;
    htmlHeight?: number;
    /**
     * @default 'center'
     */
    position?: PointViewPosition;
    /**
     * {@link html}로 지정된 html 텍스트에 포함된 param 값을 지정하는 객체나 콜백. #311<br/>
     */
    params?: {
        [key: string]: any;
    } | ((param: string) => any);
}
/**
 * track 시리즈 outline 설정 옵션.<br/>
 */
interface TrackSeriesOutlineOptions extends ChartItemOptions {
}
declare const TrackSeriesType = "track";
/**
 * 출발 지점에서 도착 지점까지 복수 지점으로 이어지는 경로를 표시하는 시리즈.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'track'이다.<br/>
 *
 */
interface TrackSeriesOptions extends SeriesOptions {
    /** @dummy */
    type?: typeof TrackSeriesType;
    /**
     * 각 지점을 표시하는 모양.<br/>
     * 명시적으로 지정하지 않으면 기본 제공되는 shape 목록 중 하나로 자동 설정된다.<br/>
     */
    shape?: Shape;
    /**
     * 지점 표시 {@link shape 도형}의 반지름.<br/>
     *
     * @default 3 픽셀
     */
    radius?: number;
    /**
     * track 시리즈 outline 설정 옵션.<br/>
     */
    outline?: TrackSeriesOutlineOptions | boolean;
}
declare const BandSeriesType = "band";
/**
 * @private 미구현
 *
 * Band Series<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'band'이다.<br/>
 *
 */
interface BandSeriesOptions extends SeriesOptions {
    type?: typeof BandSeriesType;
}
declare const TableSeriesType = "table";
/**
 * @private 미구현
 *
 * Table Series<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'table'이다.<br/>
 *
 */
interface TableSeriesOptions extends SeriesOptions {
    type?: typeof TableSeriesType;
}
declare const SankeySeriesType = "sankey";
/**
 * @private 미구현
 *
 * Sankey Series<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'sankey'이다.<br/>
 *
 */
interface SankeySeriesOptions extends SeriesOptions {
    /** @dummy */
    type?: typeof SankeySeriesType;
}
/**
 * @private 미구현
 *
 * WebGL 시리즈 옵션 base.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'table'이다.<br/>
 *
 * @module gl
 */
interface GLSeriesOptions extends ValueSeriesOptions {
}
declare const GLPointSeriesType = "glpoint";
/**
 * @private 미구현
 *
 * WebGL 포인트 시리즈 옵션.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 'glpoint'이다.<br/>
 *
 */
interface GLPointSeriesOptions extends GLSeriesOptions {
    /** @dummy */
    type?: typeof GLPointSeriesType;
    /**
     * 데이터포인트 {@link shape 도형}의 반지름.
     *
     * @default 5
     */
    radius?: number;
    /**
     * @default 'center'
     */
    position?: PointViewPosition;
}
/**
 * Circle 게이지 내부 원 설정 모델.<br/>
 */
interface CircleGaugeFaceOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
/**
 * Circle 게이지 내부 바탕 rim 설정 모델.<br/>
 */
interface CircleGaugeRimOptions extends ChartItemOptions {
}
/**
 * Circle 게이지 내부 값을 표시하는 rim 설정 모델.<br/>
 */
interface CircleGaugeValueRimOptions extends CircleGaugeRimOptions {
    /**
     * 테두리 굵기.
     * 픽셀 단위의 크기나, {@link CircularGaugeOptions.radius radius}와 {@link CircularGaugeOptions.innerRadius innerRadius}로 결정된 원호 굵기에 대한 상대적 크기로 지정할 수 있다.
     * 예) 지정하지 않거나 '100%'로 지정하면 게이지 원호 굵기와 동일하게 표시된다.
     *
     */
    thickness?: PercentSize;
    /**
     * true면 원호 대신 선으로 표시한다.
     * 대시 표현이 가능해진다.
     *
     * @default false
     */
    stroked?: boolean;
}
interface CircleGaugeHandOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * 게이지 중심쪽의 바늘 반지름.\
     * 픽셀 단위 크기나, 게이지 원호 반지름에 대한 상대 크기로 지정할 수 있다.
     *
     * @default 3
     */
    radius?: PercentSize;
    /**
     * 바늘 길이.\
     * 픽셀 단위 크기나, 게이지 원호 반지름에 대한 상대 크기로 지정할 수 있다.
     *
     * @default '100%'
     */
    length?: PercentSize;
    /**
     * 바늘 중심과 게이지 중심 사이의 간격.\
     * 픽셀 단위 크기나, 게이지 원호 반지름에 대한 상대 크기로 지정할 수 있다.
     *
     * @default 0
     */
    offset?: PercentSize;
}
interface CircleGaugePinOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * 핀 반지름.
     * 픽셀 단위 크기나, 게이지 원호 반지름에 대한 상대 크기로 지정할 수 있다.
     *
     * @default 5
     */
    radius?: PercentSize;
}
interface CircleGaugeLabelOptions extends ChartTextOptions {
    /**
     * 게이지 중심 등, label이 표시될 기준 위치에서 x 방향으로 이동한 픽셀 크기.
     * 기준 위치는 게이지 종류에 따라 달라진다.
     *
     * @default 0
     */
    offsetX?: PercentSize;
    /**
     * 게이지 중심 등, label이 표시될 기준 위치에서 y 방향으로 이동한 픽셀 크기.
     * 기준 위치는 게이지 종류에 따라 달라진다.
     *
     * @default 0
     */
    offsetY?: PercentSize;
}
declare const CircleGaugeType = "gauge";
/**
 * 원행 게이지 설정 모델.<br/>
 */
interface CircleGaugeOptions extends ValueGaugeOptions {
    /** @dummy */
    type?: typeof CircleGaugeType;
    /**
     * 게이지 내부 원 설정 모델.<br/>
     */
    face?: CircleGaugeFaceOptions | boolean;
    /**
     * 게이지 배경 원호 테두리 설정 모델.
     */
    rim?: CircleGaugeRimOptions;
    /**
     * 게이지의 값 원호 테두리 설정 모델.
     */
    valueRim?: CircleGaugeValueRimOptions | boolean;
    /**
     * 게이지 바늘 설정 모델.
     */
    hand?: CircleGaugeHandOptions;
    /**
     * 게이지 중앙에 표시되는 핀 설정 모델.
     */
    pin?: CircleGaugePinOptions;
    /**
     * 게이지 중앙에 표시되는 텍스트 설정 모델
     */
    gaugeLabel?: CircleGaugeLabelOptions;
    /**
     * 게이지 중심 수평 위치.
     * 픽셀 단위의 크기나, 데이터포인터 게이지 영역 전체 너비에 대한 상대적 크기로 지정할 수 있다.
     *
     * @default '50%'
     */
    centerX?: PercentSize;
    /**
     * 게이지 중심 수직 위치.
     * 픽셀 단위의 크기나,
     * {@link width}, {@link height}, {@link size} 등으로 지정한
     * 데이터포인터 게이지 영역 전체 높이에 대한 상대적 크기로 지정할 수 있다.
     *
     * @default '50%'
     */
    centerY?: PercentSize;
    /**
     * 게이지 원호의 반지름.
     * 픽셀 단위의 크기나,
     * {@link width}, {@link height}, {@link size} 등으로 지정한
     * 데이터포인터 게이지 영역 전체 크기(너비와 높이 중 작은 값)에 대한 상대적 크기로 지정할 수 있다.
     * '50%'로 지정하면 데이터포인터 게이지 영역의 width나 height중 작은 크기와 동일한 반지름으로 표시된다.
     *
     * @default '50%'
     */
    radius?: PercentSize;
    /**
     * 내부 원호의 반지름.
     * 픽셀 단위의 크기나,
     * {@link width}, {@link height}, {@link size} 등으로 지정한
     * {@link radius}에 대한 상대적 크기로 지정할 수 있다.
     * '100%'이면 게이지 원호의 반지름과 동일하다.
     *
     */
    innerRadius?: PercentSize;
    /**
     * 값을 나타내는 원호의 반지름.
     * 픽셀 단위의 크기나,
     * {@link radius}와 {@link innerRadius}로 결정된 기본 rim의 중점에 대한 상대적 크기로 지정할 수 있다.
     * 지정하지 않거나 '100%'이고 {@link valueRim}의 {@link valueRim.thickness 두께}가
     * 기본 rim의 두께와 동일하면 게이지 원호의 반지름과 동일하게 표시된다.
     */
    valueRadius?: PercentSize;
    /**
     * 게이지 원호 시작 각도.
     * 지정하지 않거나 잘못된 값이면 0으로 계산된다.
     * 0은 시계의 12시 위치다.
     *
     * @default 0
     */
    startAngle?: number;
    /**
     * 게이지 원호 전체 각도.
     * 0 ~ 360 사이의 값으로 지정해야 한다.
     * 범위를 벗어난 값은 범위 안으로 조정된다.
     * 지정하지 않거나 잘못된 값이면 360으로 계산된다.
     * 예) 180 이면 반 원호가 된다.
     *
     * @default 360
     */
    sweepAngle?: number;
    /**
     * true면 시계 방향으로 회전한다.
     *
     * @default true
     */
    clockwise?: boolean;
}
/**
 * Clock 게이지 테두리(rim) 설정 모델.<br/>
 */
interface ClockGaugeRimOptions extends ChartItemOptions {
    /**
     * rim 두께.
     * 픽셀 단위 크기나, 게이지 반지름 대한 상대 크기로 지정할 수 있다.
     *
     * @default 3 pixel
     */
    thickness?: PercentSize;
}
/**
 * Clock 게이지 시/분침(hand) 설정 모델.<br/>
 */
interface ClockGaugeHandOptions extends ChartItemOptions {
    /**
     * 픽셀 단위 바늘 두께.
     * 침 종류에 따라 기본값이 다르다.
     *
     * @default 2 pixel
     */
    thickness?: number;
    /**
     * 바늘 길이.
     * 픽셀 단위로 직접 지정하거나 시계 반지름에 대한 상대 크기로 지정할 수 있다.
     * 침 종류에 따라 기본값이 다르다.
     *
     * @default '55%', '80%', '90%'
     */
    length?: PercentSize;
    /**
     * 오후 시간일 때 표시 색상.<br/>
     */
    pmStyle?: SVGStyleOrClass;
}
/**
 * Clock 게이지 초침(hand) 설정 모델.<br/>
 */
interface ClockGaugeSecondHandOptions extends ClockGaugeHandOptions {
    /**
     * true면 초 이동 시 애니메이션 효과로 표시한다.
     *
     */
    animatable?: boolean;
    /**
     * {@link animatable}이 true일 때 애니메이션 기간.
     * 밀리초 단위로 지정한다.
     *
     */
    duration?: number;
}
/**
 * Clock 게이지 tick 설정 모델.<br/>
 */
interface ClockGaugeTickOptions extends ChartItemOptions {
    /**
     * tick 길이.<br/>
     *
     * @default 5 pixel
     */
    length?: number;
}
/**
 * Clock 게이지 tick 라벨 설정 모델.<br/>
 */
interface ClockGaugeTickLabelOptions extends ChartItemOptions {
    /**
     * 이 속성에 지정한 간격대로 시각 표시를 한다.<br/>
     * ex) 3이면 12,3,6,9시만 표시된다.
     *
     * @default 1
     */
    step?: number;
    /**
     * tick 라인과의 간격.<br/>
     *
     * @default 0
     */
    offset?: number;
}
/**
 * Clock 게이지 중심 pin 설정 모델.<br/>
 */
interface ClockGaugePinOptions extends ChartItemOptions {
    /**
     * 핀 반지름.<br/>
     *
     * @default 2 pixel
     */
    radius?: number;
}
/**
 * @enum
 */
declare const _ClockGaugeLabelPosition: {
    readonly TOP: "top";
    readonly BOTTOM: "bottom";
};
/** @dummy */
type ClockGaugeLabelPosition = typeof _ClockGaugeLabelPosition[keyof typeof _ClockGaugeLabelPosition];
/**
 * Clock 게이지 내부에 표시되는 라벨 설정 모델.<br/>
 */
interface ClockGaugeLabelOptions extends ChartTextOptions {
    /**
     * 라벨 표시 위치.
     *
     */
    position?: ClockGaugeLabelPosition;
}
declare const ClockGaugeType = "clock";
/**
 * 시계 게이지 설정 모델.<br/>
 */
interface ClockGaugeOptions extends GaugeOptions {
    /** @dummy */
    type?: typeof ClockGaugeType;
    /**
     * @default 90
     */
    size?: number;
    /**
     * 게이지 중심 수평 위치.
     * 픽셀 단위의 크기나,
     * {@link width}, {@link height}, {@link size} 등으로 지정한
     * 데이터포인터 게이지 영역 전체 너비에 대한 상대적 크기로 지정할 수 있다.
     *
     * @default '50%'
     */
    centerX?: PercentSize;
    /**
     * 게이지 중심 수직 위치.
     * 픽셀 단위의 크기나,
     * {@link width}, {@link height}, {@link size} 등으로 지정한
     * 데이터포인터 게이지 영역 전체 높이에 대한 상대적 크기로 지정할 수 있다.
     *
     * @default '50%'
     */
    centerY?: PercentSize;
    /**
     * 게이지 원호의 반지름.
     * 픽셀 단위의 크기나,
     * {@link width}, {@link height}, {@link size} 등으로 지정한
     * 데이터포인터 게이지 크기(너비와 높이 중 작은 값)에 대한 상대적 크기로 지정할 수 있다.
     * '50%'로 지정하면 데이터포인터 게이지의 width나 height중 작은 크기와 동일한 반지름으로 표시된다.
     *
     * @default '50%'
     */
    radius?: PercentSize;
    /**
     * 게이지 내부 원 설정 모델.<br/>
     */
    face?: ChartItemOptions | boolean;
    /**
     * rim 설정 모델.
     *
     */
    rim?: ClockGaugeRimOptions | boolean;
    /**
     * 시침 설정 모델.
     *
     */
    hourHand?: ClockGaugeHandOptions | boolean;
    /**
     * 분침 설정 모델.
     *
     */
    minuteHand?: ClockGaugeHandOptions | boolean;
    /**
     * 초침 설정 모델.
     */
    secondHand?: ClockGaugeSecondHandOptions | boolean;
    /**
     * main tick.
     */
    tick?: ClockGaugeTickOptions | boolean;
    /**
     * tick label
     */
    tickLabel?: ClockGaugeTickLabelOptions | boolean;
    /**
     * pin
     */
    pin?: ClockGaugePinOptions | boolean;
    /**
     * label
     *
     */
    gaugeLabel?: ClockGaugeLabelOptions | boolean;
    /**
     * [경도(lon), 위도(lat)] 위치에 해당하는 timezone offset을 분단위로 리턴하는 콜백.<br/>
     * 데이터포인트마다 timezone을 지정하는 대신 이 콜백으로 갈음할 수 있다.
     * 위/경도에 대한 정밀한 offset을 찾아주는 외부 라이브러리을 사용할 수 있다.
     */
    timezoneCallback?: (lon: number, lat: number) => number;
    /**
     * 밤 시간대 시작과 끝을 분단위로 지정한다.<br/>
     * 끝 시각은 포함되지 않는다.
     * 게이지 구성 요소들에 대해 밤시간대 스타일을 별도로 지정할 수 있다.
     */
    nightHours?: [number, number];
    /**
     * 시계 동작 여부.
     *
     * @default true
     */
    active?: boolean;
}
/**
 * @dummy
 */
type SeriesOptionsType = MapSeriesOptions | FeatureSeriesOptions | PointSeriesOptions | PinSeriesOptions | FigureSeriesOptions | VectorSeriesOptions | RouteSeriesOptions | ImageSeriesOptions | BarSeriesOptions | PieSeriesOptions | WaffleSeriesOptions | LineSeriesOptions | BubbleSeriesOptions | HeatmapSeriesOptions | FeatureSeriesOptions | PanelSeriesOptions | TiledWebSeriesOptions | HtmlSeriesOptions | TrackSeriesOptions | SankeySeriesOptions | CircleGaugeOptions | ClockGaugeOptions | RegionSeriesOptions | GLPointSeriesOptions;

/**
 * 컬러, 버블 스케일 등의 스케일 기반 설정.<br/>
 *
 * 
 */
interface ScaleOptions extends MapSimpleWidgetOptions {
    /**
     * {@link minValue}나 {@link maxValue}를 지정하지 않는 경우 범위 기준값을 계산할
     * 시리즈의 {@link https://realmap.co.kr/config/config/base/series#name 이름}이나 {@link Series#index}.<br />
     * 이 속성을 지정하지 않으면 첫 번째 map 시리즈의 범위를 계산한다.
     */
    series?: string | number;
}
/**
 * @enum
 */
declare const _ColorScaleLayout: {
    /**
     * color scale이 맵차트 좌우에 배치되면 item들을 수직으로 배치하고,
     * color scale이 맵차트 상하에 배치되면 item들을 수평으로 배치한다.
     */
    readonly AUTO: "auto";
    /**
     * item들을 수평으로 배치한다.
     */
    readonly HORIZONTAL: "horizontal";
    /**
     * item들을 수직으로 배치한다.
     */
    readonly VERTICAL: "vertical";
};
/** @dummy */
type ColorScaleLayout = typeof _ColorScaleLayout[keyof typeof _ColorScaleLayout];
/**
 * 컬러 스케일 표시 방식.<br/>
 *
 * @enum
 */
declare const ColorScaleDisplays: {
    /**
     * scale bar로 표시한다.<br/>
     */
    readonly SCALE: "scale";
    /**
     * legend 항목들로 표시한다.<br/>
     */
    readonly LEGEND: "legend";
    /**
     * scale bar와 legend에 동시 표시한다.<br/>
     */
    readonly BOTH: "both";
};
/** @dummy */
type ColorScaleDisplay = typeof ColorScaleDisplays[keyof typeof ColorScaleDisplays];
/**
 * 현재 값 위치를 표시하는 color scale 마커 옵션.<br/>
 */
interface ColorScaleMarkerOptions extends ChartItemOptions {
    size?: number;
    label?: ChartTextOptions;
}
/**
 * color scale 내부에서 step을 구분하는 라인 옵션<br/>
 */
interface ColorScaleStepLineOptions extends ChartItemOptions {
}
/**
 * 색상 스텝을 구분하는 color scale 틱 라인 옵션.<br/>
 */
interface ColorScaleTickLineOptions extends ChartItemOptions {
    /**
     * @default 6
     */
    length?: number;
}
/**
 * 색상 스텝을 구분하는 color scale 틱 라벨 옵션.<br/>
 */
interface ColorScaleTickLabelOptions extends IconedTextOptions {
    /**
     * 라벨 표시 위치 및 내용.<br/>
     * - 'between' - step 경게에 맞춰 그 위치의 값을 표시한다.
     * - 'step' - step의 중간에 맟춰 해당 stop의 범위를 표시한다.
     *
     * @default 'between'
     */
    position?: 'between' | 'step';
    /**
     * @default 4
     */
    offset?: number;
    /**
     * 첫번째 label의 텍스트.<br/>
     * 빈 문자열이나 null로 지정하면 label이 표시되지 않는다.
     */
    startText?: string;
    /**
     * 마지막 label의 텍스트.<br/>
     * 빈 문자열이나 null로 지정하면 label이 표시되지 않는다.
     */
    endText?: string;
}
/**
 * 색상 스텝을 구분하는 color scale 틱 라인 및 라벨 옵션.<br/>
 * marker 반대편에 표시된다.
 */
interface ColorScaleTickOptions extends ChartItemOptions {
    /**
     * tick 선 설정 옵션.<br/>
     */
    line?: ColorScaleTickLineOptions;
    /**
     * tick 라벨 설정 옵션.<br/>
     */
    label?: ColorScaleTickLabelOptions;
    /**
     * 명시적 false로 지정하면 최소값 tick 선과 라벨을 표시하지 않는다.<br/>
     *
     * @default undefined
     */
    minVisible?: boolean;
    /**
     * 명시적 false로 지정하면 최대값 tick 선과 라벨을 표시하지 않는다.<br/>
     *
     * @default undefined
     */
    maxVisible?: boolean;
}
interface ColorScaleStep {
    /**
     * 첫 step인 경우 설정하지 않으면 {@link steps.minValue minValue}로 지정된다.<br />
     * 숫자나 '%'로 끝나는 백분율로 지정할 수 있다.
     */
    from?: number | string;
    /**
     * 마지막 step인 경우 설정하지 않으면 {@link steps.maxValue maxValue}로 지정된다.<br />
     * 숫자나 '%'로 끝나는 백분율로 지정할 수 있다.
     */
    to?: number | string;
    /**
     * 구간 label.<br/>
     */
    label?: string;
    /**
     * 로케일이 english일 때 {@link label} 대신 사용할 구간 label.<br/>
     * 지정하지 않으면 {@link label}이 그대로 쓰인다.
     */
    labelEn?: string;
    /**
     * 구간 색상.<br/>
     * {@link fromColor}를 지정하면 이 step에 포함된 영역의 값에 따라 두 색상 사이의 중간 색상으로 표시된다.<br/>
     * '%'로 끝나는 백분율을 지정하면 {@link minColor}와 {@link maxColor} 사이의 중간 색상으로 설정할 수 있다.
     */
    color: string;
    /**
     * 이 속성 값이 지정되면 {@link toColor}나 {@link color} 값 사이의 색상으로 데이터포인트의 색상이 결정된다.<br/>
     * '%'로 끝나는 백분율을 지정하면 {@link minColor}와 {@link maxColor} 사이의 중간 색상으로 설정할 수 있다.
     */
    fromColor?: string;
    /**
     * {@link fromColor}가 지정된 경우 이 속성 값이 {@link color}보다 우선적으로 사용된다.
     * '%'로 끝나는 백분율을 지정하면 {@link minColor}와 {@link maxColor} 사이의 중간 색상으로 설정할 수 있다.
     */
    toColor?: string;
}
interface ColorStop {
    stop: number;
    color: string;
}
interface ColorScaleNullOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * 기본 step들과 사이의 간격.<br/>
     *
     * @default 0
     */
    gap?: number;
    /**
     * 지정되지 않은 값 표시 색.<br/>
     *
     * @default 'white'
     */
    color?: string;
    /**
     * @default 'No Data'
     */
    label?: string;
}
/**
 * 맵 area 등에 표시되는 색상 범위를 표시한다.<br/>
 *
 */
interface ColorScaleOptions extends ScaleOptions {
    /**
     * 현재 선택된 데이터포인트의 색상의 위치를 표시하는 marker 설정 옵션.<br/>
     */
    marker?: ColorScaleMarkerOptions;
    /**
     * Step 상자 옆에 표시되는 label 설정 옵션.<br/>
     */
    tick?: ColorScaleTickOptions;
    /**
     * Step 상자와 label 사이의 연결선 설정 옵션.<br/>
     */
    stepLine?: ColorScaleStepLineOptions;
    /**
     * 지정되지 않은 값들을 표시하는 데 적용되는 색상을 지시하는 별도의 step 설정 옵션.<br/>
     */
    nullStep?: ColorScaleNullOptions;
    /**
     * true로 지정하면 scale view 대신, color step들을 legend view의 항목들로 표시한다.<br/>
     */
    display?: ColorScaleDisplay;
    /**
     * Step 상자들과 tick lable들의 위치를 바꿔 표시한다.<br/>
     * true면 label이 step 상자 왼쪽이나 위쪽에 표시된다.
     */
    reversed?: boolean;
    /**
     * step의 방향을 바꿔 표시한다.<br/>
     * true면 오른쪽에 왼쪽으로, 또는 위쪽에서 아래쪽으로 최소에서 최대값으로 흐르게 표시한다.
     */
    inverted?: boolean;
    /**
     * 기준 최소값.<br/>
     * 이 값을 지정하지 않고 {@link series}가 설정되면 그 시리즈의 최소값을 사용한다.<br/>
     */
    minValue?: number;
    /**
     * 기준 최대값.<br/>
     * 이 값을 지정하지 않고 {@link series}가 설정되면 그 시리즈의 최대값을 사용한다.<br/>
     */
    maxValue?: number;
    /**
     * {@link minValue}, {@link maxValue}로 지정한 값이나, 계산된 최소/최대 값을 기준으로
     * {@link stepCount} 속성 등에 따라 정수 배수로 분리한다.<br/>
     * {@link steps}가 지정되면 이 속성은 무시된다.
     *
     * @default undefined
     */
    integralSteps?: boolean;
    /**
     * 1 이상 지정한 값으로 scale을 구분해서 표시한다.<br/>
     * {@link steps}가 지정되면 이 속성은 무시된다.
     */
    stepCount?: number;
    /**
     * 명시적으로 색상 스텝들을 지정한다.<br/>
     * 이 속성이 지정되면 {@link stepMode}를 포함, step 관련된 속성들이 모두 무시된다.
     * 가능한 연속된 값 배치로 지정해야 한다.
     * 겹치는 경우 나중에 지정된 step이 우선하고,
     * 어느 step에도 포함되지 않는 값일 경우 series 기본 색상이 적용된다.
     */
    steps?: ColorScaleStep[];
    /**
     * 2 이상의 값으로 지정하면 이 속성값을 base로 하는 log 값을 기준으로 step을 생성한다.<br/>
     * step label은 log를 취하지 않은 원 값을 표시한다.
     * {@link steps}가 지정된 경우 각 step의 from/to 값이 log로 계산된 값으로
     *
     * @default undefined
     */
    logBase?: number;
    /**
     * 최소값 쪽 color.<br/>
     * {@link colors}를 지정하면 이 속성은 무시된다.
     * 또, {@link steps}가 지정되면 각 step에 지정된 색 범위가 우선 적용된다.
     * 지정하지 않으면 'white'로 적용된다.
     *
     * @default '#fff'
     */
    minColor?: string;
    /**
     * 최대값 쪽 color.<br/>
     * {@link colors}를 지정하면 이 속성은 무시된다.
     * 또, {@link steps}가 지정되면 각 step에 지정된 색 범위가 우선 적용된다.
     * 지정하지 않으면 'black'로 적용된다.
     */
    maxColor?: string;
    /**
     * @ignore 미구현
     * 단계별 색상 분포를 지정한다.<br/>
     * 둘 이상의 색상으로 이 속성이 지정되면 {@link minColor}, {@link maxColor} 속성은 무시된다.
     * 또, {@link steps}가 지정되면 각 step에 지정된 색 범위가 우선 적용된다.
     */
    colors?: ColorStop[];
    /**
     */
    layout?: ColorScaleLayout;
    /**
     * scale bar 폭.<br/>
     * 수평으로 표시될 때 bar의 높이, 수직일 때는 너비가 된다.
     *
     * @default 12
     */
    barWidth?: number;
    /**
     * bar 길이.<br/>
     * 수평으로 표시될 때 bar의 너비, 수직일 때는 높이가 된다.
     * 숫자로 지정하면 pixel 수, '%'로 지정하면 scale이 표시될 수 있는 최대 크기에 대한 백분율로 설정된다.
     */
    barLength?: PercentSize;
    /**
     * 각 step의 색상을 gradient 없이 단일 색상으로 표시한다.<br/>
     * 스텝별로 fromColor, toColor가 지정된 경우에는 이 속성과 상관없이 gradient로 표시된다.
     */
    solidFill?: boolean;
}
/**
 * bubble 스텝을 구분하는 bubble scale 틱 라인 옵션.<br/>
 */
interface BubbleScaleTickLineOptions extends ChartItemOptions {
    /**
     * 가장 큰 원에서 tick label 표시까지의 간격.<br/>
     * {@link visible}이 false이면 무시된다.
     *
     * @default 10
     */
    length?: number;
}
/**
 * bubble 스텝을 구분하는 bubble scale 틱 라벨 옵션.<br/>
 */
interface BubbleScaleTickLabelOptions extends IconedTextOptions {
    /**
     * tick label과 scale 본체 혹은 tick line 사이의 간격.<br/>
     *
     * @default 4
     */
    offset?: number;
}
/**
 * bubble 스텝을 구분하는 bubble scale 틱 라인 및 라벨 옵션.<br/>
 */
interface BubbleScaleTickOptions extends ChartItemOptions {
    line?: BubbleScaleTickLineOptions;
    label?: BubbleScaleTickLabelOptions;
}
interface BubbleScaleStep {
    value: number;
    label: string;
}
/**
 * 버블,파이 시리즈의 데이터포인트 값에 따라 설정되는
 * 원 크기를 몇 단계로 나누어 원 크기와 값 사이의 관계를 개략적으로 표시한다.<br/>

 */
interface BubbleScaleOptions extends ScaleOptions {
    tick?: BubbleScaleTickOptions;
    steps?: (BubbleScaleStep | number)[];
    stepCount?: number;
    minRadius?: number;
    maxRadius?: number;
}
/**
 * 맵 scale 옆에 표시되는 거리 표시 설정.<br/>
 */
interface MapScaleLabelOptions extends IconedTextOptions {
    /**
     * label과 scale 본체 사이의 간격.<br/>
     *
     * @default 4
     */
    offset?: number;
}
/**
 * 지도 축척자.<br/>
 * 다른 scale과 달리 하나만 표시할 수 있다.
 */
interface MapScaleOptions extends ScaleOptions {
    /**
     * @default false
     */
    visible?: boolean;
    label?: MapScaleLabelOptions;
}

/**
 * 기본 설정. <br/>
 */
interface ChartItemOptions {
    /**
     * 표시 여부.
     *
     * @default true
     */
    visible?: boolean;
    /**
     * 스타일셋 혹은 class selector.
     *
     */
    style?: SVGStyleOrClass;
}
/**
 * 텍스트 표시 효과.
 *
 * @enum
 */
declare const ChartTextEffects: {
    /**
     * 효과 없음.
     */
    readonly NONE: "none";
    /**
     * 텍스트 색상과 대조되는 색상으로 텍스트 외곽을 구분 표시한다.
     */
    readonly OUTLINE: "outline";
    /**
     * 텍스트 배경 상자를 표시한다.<br/>
     * 배경 상자에 {@link backgroundStyle}이 적용된다.
     * 스타일이 적용되지 않으면 기본 'rm-text-background'이 적용된다.
     */
    readonly BACKGROUND: "background";
};
/** @dummy */
type ChartTextEffect = typeof ChartTextEffects[keyof typeof ChartTextEffects];
interface ChartTextOptions extends ChartItemOptions {
    /**
     * 텍스트 표시 효과.<br/>
     *
     * @default 'none'
     */
    effect?: ChartTextEffect;
    /**
     * {@link autoContrast}가 true이고 밝게 표시할 때 적용되는
     * {@link it.SVGStyles 스타일셋} 또는 css {@link https://developer.mozilla.org/ko/docs/Web/CSS/CSS_selectors selector}.<br/>
     */
    lightStyle?: SVGStyleOrClass;
    /**
     * {@link autoContrast}가 true이고 어둡게 표시할 때 적용되는
     * {@link it.SVGStyles 스타일셋} 또는 css {@link https://developer.mozilla.org/ko/docs/Web/CSS/CSS_selectors selector}.<br/>
     */
    darkStyle?: SVGStyleOrClass;
    /**
     * {@link effect}가 'background'일 때 배경에 적용되는
     * {@link it.SVGStyles 스타일셋} 또는 css {@link https://developer.mozilla.org/ko/docs/Web/CSS/CSS_selectors selector}.<br/>
     */
    backgroundStyle?: SVGStyleOrClass;
    /**
     * 텍스트가 data point 내부에 표시되는 경우 포인트 색상과 대조되도록 표시한다.<br/>
     * 밝게 표시할 때는 {@link lightStyle}을 적용하고,
     * 어둡게 표시할 때는 {@link darkStyle}이 적용된다.
     * lightStyle이 지정되지 않으면 'rm-text-light'이,
     * darkStyle이 지정되지 않으면 'rm-text-dark'가 기본 적용된다.
     *
     */
    autoContrast?: boolean;
    /**
     * {@link effect}가 'outline'일 때 외곽 택스트의 외곽선 두께.<br/>
     *
     * @default 2
     */
    outlineThickness?: number;
    /**
     * label 문자열 앞에 추가되는 문자열.<br/>
     */
    prefix?: string;
    /**
     * label 문자열 끝에 추가되는 문자열.<br/>
     */
    suffix?: string;
    /**
     * 축의 tick 간격이 1000 이상인 큰 수를 표시할 때
     * 이 속성에 지정한 symbol을 이용해서 축약형으로 표시한다.<br/>
     *
     * @default 'k,M,G,T,P,E'
     */
    numberSymbols?: string;
    /**
     * label이 숫자일 때 표시 형식.
     *
     * @default '#,##0.#'
     */
    numberFormat?: string;
    /**
     * rich text format을 지정할 수 있다.<br/>
     */
    text?: string;
    /**
     * 로케일이 english일 때 {@link text} 대신 사용할 텍스트.<br/>
     * 지정하지 않으면 {@link text}가 그대로 쓰인다. (현재 pointLabel에서 소비된다)
     */
    textEn?: string;
    lineHeight?: number;
}
/**
 * @enum
 */
declare const IconPostions: {
    readonly DEFAULT: "default";
    readonly LEFT: "left";
    readonly RIGHT: "right";
    readonly TOP: "top";
    readonly BOTTOM: "bottom";
};
/** @dummy */
type IconPosition = typeof IconPostions[keyof typeof IconPostions];
interface IconedTextOptions extends ChartTextOptions {
    /**
     * @default 'default'
     */
    iconPosition?: IconPosition;
    imageList?: string;
    iconRoot?: string;
    /**
     * @default 2
     */
    iconGap?: number;
    width?: number;
    height?: number;
}
/**
 * 범례나 scale의 타이틀이나 footer의 위치.<br/>
 *
 * @enum
 */
declare const MapWidgetCaptionDisplays: {
    /**
     * 범례나 scale 항목들의 배치에 따라 자동 배치한다.<br/>
     * 항목들이 수직 배치이면 'stack', 수평 배치이면 'inline'이 적용된다.
     */
    readonly AUTO: "auto";
    /**
     * 타이틀이나 footer를 항목들의 위/아래에 배치한다.
     */
    readonly STACK: "stack";
    /**
     * 타이틀이나 footer를 항목들의 좌/우에 배치한다.
     */
    readonly INLINE: "inline";
};
/** @dummy */
type MapWidgetCaptionDisplay = typeof MapWidgetCaptionDisplays[keyof typeof MapWidgetCaptionDisplays];
/**
 * 범례나 scale의 title 설정 옵션.<br/>
 */
interface MapWidgetCaptionOptions extends IconedTextOptions {
    /**
     * 타이틀 표시 위치.<br/>
     */
    display?: MapWidgetCaptionDisplay;
    /**
     * 타이틀과 범례 아이템들 사이의 간격.<br/>
     * 타당한 값으로 지정하지 않으면 {@link display}가 'linine'이 될 때 10, 아니면 5 픽셀로 적용된다.
     */
    gap?: number;
    /**
     * {@link display}가 'stack'가 될 때 수평 배치.<br/>
     * 지정하지 않거나 잘못 지정하면 'left'로 적용된다.
     */
    align?: Align;
    /**
     * {@link display}가 'inline'이 될 때 수직 배치.<br/>
     * 지정하지 않거나 잘못 지정하면 'middle'로 적용된다.
     */
    verticalAlign?: VerticalAlign;
}
/**
 * 범례나 scale의 배경 설정 옵션.<br/>
 */
interface MapWidgetBackgroundOptions extends ChartItemOptions {
}
interface MapWidgetOptions extends ChartItemOptions {
    /**
     * 시리즈에서 참조하는 범례나 스케일 이름.<br/>
     */
    name?: string;
    /**
     * 그룹 내에서 배치 순서.<br/>
     * 값을 지정하지 않거나 잘못 지정하면 마자믹에 배치된다.
     */
    order?: number;
    /**
     * 범례나 scale의 타이틀 설정 옵션.<br/>
     */
    title?: MapWidgetCaptionOptions;
    /**
     * 범례나 scale의 footer 설정 옵션.<br/>
     */
    footer?: MapWidgetCaptionOptions;
    /**
     * 범례나 scale의 배경 설정 옵션.<br/>
     */
    background?: MapWidgetBackgroundOptions;
    /**
     * 범례나 scale 표시 위치.<br/>
     *
     * @default 'bottom'
     */
    location?: ChartItemLocation;
    /**
     * 범례 또는 scale과 (location이 body일 때)body 또는 맵차트 경계 사이의 수평 간격.<br/>
     *
     * @default 0
     */
    offsetX?: number;
    /**
     * 범례 또는 scale과 (location이 body일 때)body 또는 맵차트 경계 사이의 수직 간격.<br/>
     *
     * @default 0
     */
    offsetY?: number;
    /**
     * 수평 배치.<br/>
     * 값을 지정하지 않으면, 기본값이 {@link location}이 'body'일 때는 'left',
     * 'left', 'right'일 때는 'center'이다.
     */
    align?: Align;
    /**
     * 수직 배치.<br/>
     * 값을 지정하지 않으면, 기본값이 {@link location}이 'body'일 때는 'top',
     * 'top', 'bottom'일 때는 'middle'이다.
     */
    verticalAlign?: VerticalAlign;
}
interface MapSimpleWidgetOptions extends MapWidgetOptions {
    /**
     * 이 위젯이 표시될 위젯 그룹 이름.<br/>
     * 그룹에 포함되지 않은 위젯은 {@link location} 설정에 따라 위젯 섹션이나 body 영역에 표시된다.
     */
    group?: string;
}
/**
 * 범례 및 scale 등의 위젯들을 한 방향으로 배치하는 그룹 설정 옵션.<br/>
 * 위젯의 order 속성으로 배치 순서를 결정한다.
 */
interface MapWidgetGroupOptions extends MapWidgetOptions {
    /**
     * 포함된 위젯들 배치 방향.<br/>
     *
     * @default 'vertical'
     */
    direction?: 'vertical' | 'horizontal';
}
/**
 * 어노테이션 배치 기준.<br/>
 * [주의]body에 설정된 annoation에는 적용되지 않는다.
 * @enum
 */
declare const _PositionalScope: {
    /**
     * container에서 padding을 적용한 영역을 기준으로 표시한다.
     *
     * 
     */
    readonly CHART: "chart";
    /**
     * container 전체 영역을 기준으로 표시한다.
     *
     * 
     */
    readonly CONTAINER: "container";
};
/** @dummy */
type PositionalScope = typeof _PositionalScope[keyof typeof _PositionalScope];
interface PositionableItemOptions extends ChartItemOptions {
    /**
     * 아이템 이름.<br/>
     * 동적으로 아이템을 다루기 위해서는 반드시 지정해야 한다.
     */
    name?: string;
    /**
     * 수평 배치.<br/>
     *
     * @default 'left'
     */
    align?: Align;
    /**
     * 수직 배치.<br/>
     *
     * @default top
     */
    verticalAlign?: VerticalAlign;
    /**
     * {@link align}과 {@link verticalAlign}으로 지정된 위치에서 실제 표시될 위치의 수평 간격.<br/>
     *
     * @default 0
     */
    offsetX?: number | string;
    /**
     * {@link align}과 {@link verticalAlign}으로 지정된 위치에서 실제 표시될 위치의 수직 간격.<br/>
     *
     * @default 0
     */
    offsetY?: number | string;
    /**
     * 아이템 배치 기준.<br/>
     *
     * @default 'chart'
     */
    scope?: PositionalScope;
    /**
     * 배경 스타일.<br/>
     * 경계 및 배경 색, padding 스타일을 지정할 수 있다.
     * [주의] padding을 style이 아니라 여기서 지정하는 이유: background가 표시되지 않으면 사용자가 padding여부를 알 수 없다.
     */
    backgroundStyle?: SVGStyleOrClass;
    /**
     * 아이템 너비.<br/>
     * 픽셀 단위의 고정 값이나, plot 영역에 대한 상태 크기롤 지정할 수 있다.
     */
    width?: PercentSize;
    /**
     * 아이템 높이.<br/>
     * 픽셀 단위의 고정 값이나, plot 영역에 대한 상태 크기롤 지정할 수 있다.
     */
    height?: PercentSize;
}
/**
 * DataPoint 관련 callback 매개변수 타입.<br/>
 */
interface DataPointArgs extends CommonCallbackArgs {
    /**
     * 시리즈 객체.
     */
    series: object;
    count: number;
    id: string;
    index: number;
    name?: string;
    color?: string;
    className?: string;
    value?: any;
    labelIndex?: number;
    coord?: MapCoord;
    source: any;
}
interface DataPointListkArgs extends CommonCallbackArgs {
    /**
     * 데이터포인트 개수.
     */
    count: number;
    /**
     * 해당 위치의 데이터포인트 정보를 리턴한다.<br/
     * 리턴되는 객체는 재사용되므로 보관할 수 없다.
     */
    get(index: number): DataPointArgs;
}
interface AnimationOptions {
    duration: number;
    end: () => void;
}
interface ZoomToAreaOptions {
    /**
     * 최소 확대 비율.
     */
    minimumZoom?: number;
    /**
     * 최대 확대 비율.
     */
    maximumZoom?: number;
}
interface OnSelectionChangedArgs extends CommonCallbackArgs {
}

/**
 * 어노테이션 배치 기준.<br/>
 * [주의]body에 설정된 annoation에는 적용되지 않는다.
 * @enum
 */
declare const _AnnotationScope: {
    /**
     * container에서 padding을 적용한 영역을 기준으로 표시한다.
     *
     * 
     */
    readonly CHART: "chart";
    /**
     * container 전체 영역을 기준으로 표시한다.
     *
     * 
     */
    readonly CONTAINER: "container";
};
/** @dummy */
type AnnotationScope = typeof _AnnotationScope[keyof typeof _AnnotationScope];
interface AnnotationAnimationOptions {
    type: string;
    duration?: number;
}
type AnnotationType = 'image' | 'shape' | 'text' | 'html' | 'chart';
/**
 * Annotation 모델.<br/>
 *
 * 
 */
interface AnnotationOptions extends PositionableItemOptions {
    type?: AnnotationType;
    /**
     * true로 지정하면 시리즈들 위에 표시된다.<br/>
     * 명시적으로 false로 지정해야 시리즈들 아래 표시된다.
     *
     * @default false
     */
    front?: boolean;
    /**
     * 어노테이션 배치 기준이 되는 맵차트 구성 요소.<br/>
     * 현재, 같은 영역(body 혹은 chart)에 포함된 다른 어노테이션의 {@link name 이름}을 지정할 수 있다.
     *
     */
    anchor?: string;
    /**
     * 수평 배치.<br/>
     *
     * @default 'left' anchor가 지정되면 'center', 아니면 'left'
     */
    align?: Align;
    /**
     * {@link align}과 {@link verticalAlign}으로 지정된 위치에서 실제 표시될 위치의 수평 간격.<br/>
     * 값이 양수일 때, {@link anchor}가 지정된 경우 anchor 아이템의 밖으로 멀어지고, 아니면 영역 경계 안쪽으로 멀어진다.
     * 또, {@link anchor}가 지정된 경우 **'0.5w'** 등으로 이 어노테이션의 너비를 기준으로 한 크기로 지정할 수 있다.
     *
     * @default 0
     */
    offsetX?: number | string;
    /**
     * {@link align}과 {@link verticalAlign}으로 지정된 위치에서 실제 표시될 위치의 수직 간격.<br/>
     * 값이 양수일 때, {@link anchor}가 지정된 경우 anchor 아이템의 밖으로 멀어지고, 아니면 영역 경계 안쪽으로 멀어진다.
     * 또, {@link anchor}가 지정된 경우 **'0.5h'**처럼 이 어노테이션의 너비를 기준으로 한 크기로 지정할 수 있다.
     *
     * @default 0
     */
    offsetY?: number | string;
    /**
     * 회전 각도.<br/>
     * 0 ~ 360 사이의 값으로 지정한다.
     *
     */
    rotation?: number;
    /**
     * 어노테이션 배치 기준.<br/>
     * [주의]body에 설정된 annoation에는 적용되지 않는다.
     *
     * @default 'chart'
     */
    scope?: AnnotationScope;
    /**
     * true로 지정하면 상위 영역을 벗어난 부분도 표시되게 한다.<br/>
     * body에 포함된 경우 body 영역,
     * chart에 포함되고 scope이 'chart'일 때 chart 영역.
     *
     */
    noClip?: boolean;
}
declare const ImageAnnotationType = "image";
/**
 * 이미지 어노테이션.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 'image'이다.<br/>
 *
 * // TODO #fiddle annotation/image-annotation Image Annotation
 * @css 'rm-image-annotation'
 */
interface ImageAnnotationOptions extends AnnotationOptions {
    /** @dummy */
    type?: typeof ImageAnnotationType;
    /**
     * true로 설정되고 {@link url}이 설정된 경우에만 표시된다.
     *
     * @default true
     */
    visible?: boolean;
    /**
     * 이미지 경로.
     *
     */
    imageUrl?: string;
}
declare const ShapeAnnotationType = "shape";
/**
 * Shape Annotation 모델.
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 'shape'이다.<br/>
 * {@link shape} 속성에 표시할 도형 모양을 지정하거나,
 * {@link path}에 SVG path를 직접 지정할 수 있다.
 *
 * // TODO #fiddle annotation/shape-annotation Shape Annotation
 * @css 'rm-shape-annotation'
 */
interface ShapeAnnotationOptions extends AnnotationOptions {
    /** @dummy */
    type?: typeof ShapeAnnotationType;
    /**
     * @default 64
     */
    width?: number;
    /**
     * @default 64
     */
    height?: number;
    /**
     * Shape 종류.
     *
     * circle: 원
     * diamond: 다아이몬드
     * square: 정사각형
     * triangle: 삼각형
     * star: 별 모양
     * itriangle:
     * rectangle: 사각형
     *
     * @default 'square'
     */
    shape?: 'circle' | 'diamond' | 'square' | 'triangle' | 'star' | 'itriangle' | 'rectangle';
    /**
     * Shape path.
     * 이 속성이 지정되면 {@link shape}는 무시된다.
     */
    path?: string;
    series?: string;
    xRange?: number[];
    yRange?: number[];
}
declare const TextAnnotationType = "text";
/**
 * 텍스트 어노테이션.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 'text'이다.<br/>
 *
 * // TODO #fiddle annotation/text-annotation Text Annotation
 * @css 'rm-text-annotation'
 */
interface TextAnnotationOptions extends AnnotationOptions {
    /** @dummy */
    type?: typeof TextAnnotationType;
    /**
     * true로 설정되고 {@link text}가 설정된 경우에만 표시된다.
     *
     * @default true
     */
    visible?: boolean;
    /**
     * 표시할 텍스트.
     *
     * @default 'Text'
     */
    text?: string;
    /**
     * {@link text}에 동적으로 전달되는 값이 숫자일 때 사용되는 표시 형식.
     *
     */
    numberFormat?: string;
    /**
     * {@link text}에 동적으로 전달되는 값이 Date일 때 사용되는 표시 형식.
     *
     */
    timeFormat?: string;
    /**
     * 텍스트를 가로 또는 세로로 배치할지 여부와 블록이 진행되는 방향을 지정한다.
     *
     * 
     */
    writingMode?: WritingMode;
    /**
     * 텍스트 문자 방향을 지정한다.
     * 세로 모드의 텍스트에만 적용된다.
     *
     * 
     */
    textOrientation?: TextOrientation;
}
declare const HtmlAnnotationType = "html";
/**
 * HTML 어노테이션.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 'html'이다.<br/>
 *
 * // TODO #fiddle annotation/html-annotation Html Annotation
 * @css 'rm-html-annotation'
 */
interface HtmlAnnotationOptions extends AnnotationOptions {
    /** @dummy */
    type?: typeof HtmlAnnotationType;
    /**
     * true로 설정되고 {@link text}가 설정된 경우에만 표시된다.
     *
     * @default true
     */
    visible?: boolean;
    /**
     * 이 속성으로 지정한 html 내용을 표시한다.<br/>
     * '.'나 '#'으로 시작되는 html selector로 지정하면 해당하는 dom의 {@link https://developer.mozilla.org/ko/docs/Web/API/Element/innerHTML innerHTML}을 가져와 표시한다.<br/>
     * 예를 들어 id가 'abc'인 dom인 경우 '#abc'로 지정한다.
     * 즉, document.{@link https://developer.mozilla.org/ko/docs/Web/API/Document/querySelector querySelector}(htmlFrom)로 리턴되는 dom의 내용을 표시한다.<br/>
     * 생성되는 dom의 스타일은 {@link htmlStyle}로 지정한다.
     */
    html?: string;
    /**
     * 이 속성으로 지정한 selector에 해당하는 dom의 {@link https://developer.mozilla.org/ko/docs/Web/API/Element/innerHTML innerHTML}을 가져와 표시한다.<br/>
     * 예를 들어 id가 'abc'인 dom인 경우 '#abc'로 지정한다.
     * 즉, document.{@link https://developer.mozilla.org/ko/docs/Web/API/Document/querySelector querySelector}(htmlFrom)로 리턴되는 dom의 내용을 표시한다.<br/>
     * 이 속성이 {@link html}보다 우선한다. 다만, 존재하지 않은 dom을 지정한 경우 {@link html}에 지정한 내용을 대신 표시한다.
     * 생성되는 dom의 스타일은 {@link htmlStyle}로 지정한다.
     */
    htmlFrom?: string;
    /**
     * {@link html}로 생성되는 최상위 dom에 적용되는 스타일셋.<br/>
     */
    htmlStyle?: CSSStyleDeclaration;
    /**
     * @append
     * 너비를 반드시 지정해야 한다.<br/>
     * 지정하지 않으면 100 픽셀 너비로 표시한다.
     * {@link height 높이}를 지정하지 않으면 생성된 dom의 높이에 맞춰진다.
     *
     * @default 100
     */
    width?: PercentSize;
    /**
     * {@link html}로 지정된 html 텍스트에 포함된 param 값을 지정하는 객체나 콜백. #311<br/>
     */
    params?: {
        [key: string]: any;
    } | ((param: string) => any);
}
declare const ChartAnnotationType = "chart";
/**
 * Chart 어노테이션.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 'chart'이다.<br/>
 *
 * @css 'rm-chart-annotation'
 */
interface ChartAnnotationOptions extends AnnotationOptions {
    /** @dummy */
    type?: typeof ChartAnnotationType;
    config?: any;
    /**
     * false로 설정하면 차트 애니메이션이 실행되지 않는다.<br/>
     *
     * @default true
     */
    animatable?: boolean;
}
/** @dummy */
type AnnotationOptionsType = ImageAnnotationOptions | ShapeAnnotationOptions | TextAnnotationOptions | HtmlAnnotationOptions | ChartAnnotationOptions;

/**
 * @private
 *
 * //TODO: Intl.DateTimeFormat 사용할 것.
 */
declare class DatetimeFormatter {
    private static readonly Formatters;
    static getFormatter(format: string): DatetimeFormatter;
    static get Default(): DatetimeFormatter;
    private _format;
    private _baseYear;
    private _preserveTime;
    private _tokens;
    private _hasAmPm;
    private _formatString;
    constructor(format: string);
    /** format */
    get format(): string;
    /** formatString */
    get formatString(): string;
    set formatString(value: string);
    toStr(date: Date, startOfWeek: number): string;
    private parseDateFormatTokens;
    private parse;
}

/**
 * @private
 *
 * 'as,0.0#'
 * NOTE: 'a'는 bigint에 사용할 수 없다.
 */
declare class NumberFormatter {
    static readonly DEFAULT_FORMAT = "";
    private static readonly Formatters;
    static getFormatter(format: string): NumberFormatter;
    static get Default(): NumberFormatter;
    private _format;
    private _options;
    constructor(format: string);
    get format(): string;
    toStr(value: number | bigint): string;
    toStrEx(value: number | bigint, roundingMode: 'trunc' | 'ceil'): string;
    private $_parse;
}

/** @private */
declare class Sides {
    top: number;
    bottom: number;
    left: number;
    right: number;
    static readonly Empty: Readonly<Sides>;
    static Temp: Sides;
    static create(top: number, bottom?: number, left?: number, right?: number): Sides;
    static createFrom(value: string): Sides;
    constructor(top?: number, bottom?: number, left?: number, right?: number);
    clone(): Sides;
    set(...values: number[]): void;
    applyPadding(cs: CSSStyleDeclaration): Sides;
    applyMargin(cs: CSSStyleDeclaration): Sides;
    shrink(r: IRect): IRect;
    toString(): string;
}

/**
 * @private
 */
declare enum TextAnchor {
    START = "start",
    MIDDLE = "middle",
    END = "end"
}
/**
 * @private
 */
declare enum TextLayout {
    TOP = "top",
    MIDDLE = "middle",
    BOTTOM = "bottom"
}
/**
 * Background, padding 등을 이용하려면 HtmlTextElement를 사용한다.
 */
declare class TextElement extends RmElement {
    private _layout;
    private _dirty;
    private _text;
    private _bounds;
    _lineCount: number;
    constructor(doc: Document, styleName?: string);
    /** text */
    get text(): string;
    set text(value: string);
    /** anchor */
    get anchor(): TextAnchor;
    set anchor(value: TextAnchor);
    /** layout */
    get layout(): TextLayout;
    set layout(value: TextLayout);
    /** svg */
    get svg(): string;
    set svg(value: string);
    get opacity(): number;
    set opacity(value: number);
    getAscent(height: number): number;
    layoutText(lineHeight?: number): void;
    isFitIn(bounds: number): boolean;
    calcWidth(): number;
    calcRangeWidth(start?: number, end?: number): number;
    truncate(bounds: number, ellipsis: boolean): void;
    setContrast(target: Element, darkStyle: SVGStyleOrClass, brightStyle: SVGStyleOrClass): TextElement;
    setStyle(prop: string, value: any): boolean;
    setStyles(styles: SVGStyles): boolean;
    clearDom(): void;
    bbox(): IRect;
    getBBoundsTest(): IRect;
    stain(): void;
}

type RichTextParamCallback = (target: any, param: string) => any;
interface IRichTextDomain {
    callback?: RichTextParamCallback;
    numberFormatter?: NumberFormatter;
    timeFormatter?: DatetimeFormatter;
    textFormatter?: TextFormatter;
    startOfWeek?: number;
}
/**
 * '${name;default;format}',
 * [주의] default에는 format이 적용되지 않는다. 즉, format이 적용된 문자열을 설정해야 한다.
 */
declare class Word {
    text: string;
    private _literals;
    tag(): string;
    parse(str: string): Word;
    getText(target: any, domain: IRichTextDomain): string;
    prepareSpan(span: SVGTSpanElement, target: any, domain: IRichTextDomain): SVGTSpanElement;
    protected _doParse(str: string): Word;
}
declare class SvgLine {
    private _words;
    get words(): Word[];
    parse(s: string): SvgLine;
}
/**
 * <t>, <b>, <i>, <br>,
 * <b>${label}</b><br><t style="fill:#c00;">${endValue}</t>
 * <a href='...'>...</a>
 */
declare class SvgRichText {
    _format: string;
    lineHeight: number;
    private _lines;
    constructor(format?: string);
    setFormat(value: string): void;
    lines(): SvgLine[];
    build(view: TextElement, maxWidth: number, maxHeight: number, target: any, domain: IRichTextDomain, prefixSuffixEnabled?: boolean): void;
    layout(tv: TextElement, align: Align, width: number, height: number, pad: Sides): void;
    $_parse(fmt: string): void;
}

type RmAnimationEndHandler = (ani: RmAnimation) => void;
declare abstract class RmAnimation {
    static readonly DURATION = 700;
    static readonly SHORT_DURATION = 300;
    delay: number;
    duration: number;
    easing: string;
    endHandler: RmAnimationEndHandler;
    private _easing;
    private _started;
    private _timer;
    private _ani;
    private _handler;
    setDuration(value: number): RmAnimation;
    start(endHandler?: RmAnimationEndHandler): RmAnimation;
    stop(): void;
    protected _start(duration: number, delay?: number, easing?: string): void;
    protected _stop(): void;
    protected _doStart(): void;
    protected _doStop(): void;
    protected _canUpdate(): boolean;
    protected abstract _doUpdate(rate: number): boolean;
}

/**
 * 시리즈 load animation 타입.
 * @enum
 */
declare const _SeriesLoadAnimation: {
    readonly DEFAULT: "default";
    readonly REVEAL: "reveal";
    readonly GROW: "grow";
    /**
     * 화면 밖에서 제자리로 돌아온다.
     */
    readonly SLIDEIN: "slidein";
    readonly SPREAD: "spread";
    readonly FADEIN: "fadein";
};
/** @dummy */
type SeriesLoadAnimation = typeof _SeriesLoadAnimation[keyof typeof _SeriesLoadAnimation];

/**
 * @enum
 */
declare const _LegendItemsAligns: {
    /**
     * 수평일 때 왼쪽, 수직일 때는 위쪽으로 몰아서 배치한다.
     */
    readonly START: "start";
    /**
     * center: 수평 혹은 수직의 중앙으로 몰아서 배치한다.
     */
    readonly CENTER: "center";
    /**
     * end: 수평일 때 오른쪽, 수직일 때는 아래쪽으로 몰아서 배치한다.
     */
    readonly END: "end";
};
/** @dummy */
type LegendItemsAlign = typeof _LegendItemsAligns[keyof typeof _LegendItemsAligns];
/**
 * @enum
 */
declare const _LegendLayout: {
    /**
     * legend가 맵차트 좌우에 배치되면 item들을 수직으로 배치하고,
     * legend가 맵차트 상하에 배치되면 item들을 수평으로 배치한다.
     */
    readonly AUTO: "auto";
    /**
     * item들을 수평으로 배치한다.
     */
    readonly HORIZONTAL: "horizontal";
    /**
     * item들을 수직으로 배치한다.
     */
    readonly VERTICAL: "vertical";
};
/** @dummy */
type LegendLayout = typeof _LegendLayout[keyof typeof _LegendLayout];
/**
 * 맵차트 시리즈 구성을 직관적으로 이해할 수 있도록 도와주는 범례 설정 모델.<br/>
 * visible 기본값이 undefined이고,
 * 따로 지정하지 않으면 시리즈가 둘 이상 포함돼야 legend가 표시된다.<br/>
 * {@link https://realmap.co.kr/guide/legend 범례 개요} 페이지를 참조한다.
 *
 */
interface LegendOptions extends MapSimpleWidgetOptions {
    /**
     * 명시적으로 true로 설정되거나, 명시적 false가 아니면서 표시 항목 수가 1보다 클 때 표시된다.<br/>
     *
     * @default undefined
     */
    visible?: boolean;
    /**
     * true면 나중에 배치되는 시리즈가 먼저 표시된다.<br/>
     */
    reversed?: boolean;
    /**
     * item 배치 방향.<br/>
     *
     * @default 'auto'
     */
    layout?: LegendLayout;
    /**
     * legend 정렬 기준.<br/>
     */
    alignBase?: AlignBase;
    /**
     * legend 아이템들 사이의 간격.<br/>
     *
     * @default 8
     */
    itemGap?: number;
    /**
     * marker 표시 여부.<br/>
     *
     * @default true
     */
    markerVisible?: boolean;
    /**
     * marker 크기.<br/>
     *
     * @default 10 픽셀.
     */
    markerSize?: number;
    /**
     * marker와 text사이의 간격.<br/>
     *
     * @default 4
     */
    markerGap?: number;
    /**
     * 한 줄 당 표시할 최대 legend 항목 수.<br/>
     */
    itemsPerLine?: number;
    /**
     * 라인 사이의 간격.<br/>
     *
     * @default 0
     */
    lineGap?: number;
    /**
     * 수평 {@link layout 배치}일 때,
     * 최대 너비를 픽셀 단위의 크기 혹은 body 너비에 대한 상대 길이를 '%'로 지정한다.<br/>
     */
    maxWidth?: PercentSize;
    /**
     * 수직 {@link layout 배치}일 때,
     * 최대 높이를 픽셀 단위의 크기 혹은 body 높이에 대한 상대 길이를 '%'로 지정한다.<br/>
     */
    maxHeight?: PercentSize;
    /**
     * 한 라인의 item들이 배치되는 위치.<br/>
     *
     * @default 'center'
     */
    itemsAlign?: LegendItemsAlign;
    /**
     * 범례 항목의 텍스트에도 marker와 동일한 색상을 적용한다.<br/>
     */
    sameTextColor?: boolean;
    /**
     * 시리즈가 연결된 범례 아이템에 마우스가 올라가면 나머지 시리즈들을 반투명 처리해서 연결된 시리즈를 강조한다.<br/>
     *
     * @default true
     */
    seriesHovering?: boolean;
}

/**
 * @private
 */
interface ILegendSource {
    visible: boolean;
    canHide(): boolean;
    legendMarker(doc: Document, size: number): RmElement;
    legendColor(): string;
    legendLabel(): string;
    setLegendMarkerStyle?(marker: RmElement): void;
}
/**
 * @private
 */
declare class LegendItem extends ChartItem<ChartItemOptions> {
    legend: Legend;
    source: ILegendSource;
    static readonly MARKER_SIZE = 10;
    constructor(legend: Legend, source: ILegendSource);
    text(): string;
}
/**
 * 맵차트 시리즈 구성을 직관적으로 이해할 수 있도록 도와주는 범례 설정 모델.<br/>
 * visible 기본값이 undefined이고,
 * 따로 지정하지 않으면 시리즈가 둘 이상 포함돼야 legend가 표시된다.<br/>
 * {@link https://realmap.co.kr/guide/legend 범례 개요} 페이지를 참조한다.
 *
 */
declare class Legend extends MapSimpleWidget<LegendOptions> {
    static defaults: LegendOptions;
    private _maxWidth;
    private _maxHeight;
    private _items;
    private _maxWidthDim;
    private _maxHeightDim;
    items(): LegendItem[];
    isEmpty(): boolean;
    isInner(): boolean;
    getLayout(): LegendLayout;
    getMaxWidth(domain: number): number;
    getMaxHeight(domain: number): number;
    _type(): string;
    isVertical(): boolean;
    isVisible(): boolean;
    protected _doInit(op: LegendOptions): void;
    protected _doApply(options: LegendOptions): void;
    protected _doPrepareRender(chart: IChart, op: LegendOptions): void;
}
declare class LegendCollection extends MapWidgetCollection<Legend> {
    protected _collectionProp(): string;
    protected _canEmpty(): boolean;
    protected _createWidget(chart: IChart): Legend;
    prepareRender(): void;
}

/**
 * https://map-projections.net/index.php
 */
interface MapProjection {
    second?: MapProjection;
    scroll: number;
    offset?: MapCoord;
    bounds?: {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
    };
    isGlobe: boolean;
    lonElliptic: boolean;
    latElliptic: boolean;
    getYRange(latFrom: number, latTo: number): MapCoord;
    project(coord: MapCoord): MapCoord;
    backward(coord: MapCoord): MapCoord;
    projectCoord(coord: MapCoord): MapCoord;
    clip(pts: MapCoord[]): MapCoord[];
    isVisible(coord: MapCoord): boolean;
    getVisible(coord: MapCoord): MapCoord;
    getClipBounds(lonInterval: number, latInterval: number): MapCoord[];
    isClipping(): boolean;
    getScrolledLon(lon: number): number;
    inSecond(lon: number): boolean;
}
declare class MapArea extends RObject implements ISelectionSource {
    source?: AreaItem;
    inset?: MapInset;
    _insetChilds: number[];
    private _info;
    private _path;
    private _internal;
    private _external;
    h1: number;
    h2: number;
    v1: number;
    v2: number;
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    mainLandBounds: {
        x1: number;
        x2: number;
        y1: number;
        y2: number;
    };
    center: MapCoord;
    visible: boolean;
    dummy: boolean;
    private _selected;
    constructor(source?: AreaItem, inset?: MapInset);
    setSelected(selected: boolean): void;
    id: string;
    name: string;
    get path(): string;
    get internal(): string;
    get external(): string;
    get selected(): boolean;
    displayText(): string;
    /**
     * event param으로 사용. MapView.onHoverArea 참조.
     */
    getInfo(): any;
    reset(): void;
    private $_readBound;
    private $_readInset;
    private $_toPath;
    private $_ringToPath;
    readBounds(polys?: number[]): {
        h1: number;
        v1: number;
        h2: number;
        v2: number;
    };
    /**
     * 주어진 polygon들의 경계값을 계산한다.
     */
    readPolygonBounds(polygons: MapPolygon): {
        x1: number;
        x2: number;
        y1: number;
        y2: number;
    };
    readPath(prj: MapProjection, info: {
        internals: boolean;
        externals: boolean;
    }): string;
    private $_readInternal;
    private $_readExternal;
    getCenter(): MapCoord;
    _clone(): MapArea;
}
declare class MapBorder extends RObject {
    source: BorderItem;
    private _path;
    constructor(source: BorderItem);
    get path(): string;
    reset(): void;
    readPath(prj: MapProjection): void;
}
interface IMapOwner {
    getProjection(second: boolean): MapProjection;
    projectionChanged(): void;
    mapChanged(map: MapModel): void;
}
/**
 * @private
 *
 * Map area 정보들을 포함하는 model.<br/>
 *
 * [Note] 'Map'이 javascript 예약어 수준이므로 부득기 'MapModel'로 名한다.
 */
declare class MapModel extends RObject {
    owner: IChart & IMapOwner;
    source: MapSourceImpl | MapModel;
    private _second;
    private _areas;
    private _areaMap;
    private _borders;
    _insets: MapInset[];
    _useOffset: boolean | MapCoord;
    private _mapAreaFinder;
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    cx: number;
    cy: number;
    h1: number;
    v1: number;
    h2: number;
    v2: number;
    sibling: MapModel;
    private _enabled;
    private _hiddenAreas;
    private _index;
    private _name;
    private _hiddens;
    private _world;
    constructor(owner: IChart & IMapOwner, source: MapSourceImpl | MapModel, index: number);
    get index(): number;
    get name(): string;
    get areaCount(): number;
    /**
     * hidden areas
     */
    get hiddenAreas(): string[];
    set hiddenAreas(value: string[]);
    get alignArctic(): any;
    get hasInternals(): boolean;
    get hasExternals(): boolean;
    get hasBorders(): MapBorderInfo[];
    get isWorld(): boolean;
    get(index: number): MapArea;
    areaOf(id: any): MapArea;
    getAreaMap(prop: string): {
        [key: string]: MapArea;
    };
    findByCoord(coord: MapCoord): MapArea | null;
    /**
     * area들의 path를 갱신한다.<br/>
     * 처음 load될 때, projection이 변경됐을 때 호출된다.
     */
    reset(): void;
    isVisible(area: string): boolean;
    insetAt(coord: MapCoord): MapInset;
    getBorder(name: string): MapBorder;
    /**
     * 투영전에 지도 bounds를 계산한다.
     * projection offset을 설정하려면 투영하기 전에 지도 경계값이 필요하다.
     * @TODO readPath 중복 로직 제거
     */
    private $_preflight;
    private $_resetAreas;
    private $_hasArea;
    /**
     * 전 세계 범위(-180~180)로 경계 설정
     */
    private $_setBoundaryByWorld;
    /**
     * map.bounds 옵션으로 지도 경계를 설정하는 메서드
     */
    private $_setBoundsByOption;
    private $_updateMainAreaBounds;
    /**
     * 로케일 이름 후보(nameKeys)를 순서대로 찾아 먼저 발견되는 값을 area 이름으로 결정한다.
     * ($_load과 _relocalizeAreas가 공유한다.)
     */
    private $_resolveAreaName;
    /**
     * 로케일 런타임 변경 시, 보존된 area.source.props에서 이름만 다시 계산한다. (맵 refetch 없음)
     */
    _relocalizeAreas(): void;
    private $_load;
    private $_copy;
    _prepareSecond(): this;
    _internalAreas(): MapArea[];
}

interface ITooltipContext {
    getTooltipText(series: ISeries, point: DataPoint): string;
    getTooltipParam(series: ISeries, point: DataPoint, param: string): string;
}
interface ITooltipOwner {
    chart: IChart;
    getTooltipContext(level: TooltipScope, series: ISeries, point: DataPoint): ITooltipContext;
}
/**
 */
declare class Tooltip extends ChartItem<TooltipOptions> {
    owner: ITooltipOwner;
    static defaults: TooltipOptions;
    private _numberFormat;
    private _timeFormat;
    _op: TooltipOptions;
    private _ctx;
    private _series;
    private _point;
    private _siblings;
    private _domain;
    constructor(owner: ITooltipOwner);
    protected _doInit(): void;
    setTarget(series: ISeries, point: DataPoint): ITooltipContext;
    getTextDomain(): IRichTextDomain;
    isFollowPointer(series: ISeries): boolean;
    protected _doSetSimple(op: TooltipOptions, source: any): boolean;
    protected _doApply(options: TooltipOptions): void;
}

interface IPoint {
    px: number;
    py: number;
    moves?: number;
    cluster?: any;
}
interface ICluster {
    cx: number;
    cy: number;
    points: IPoint[];
    prevs: IPoint[];
}
/**
 * Point custering 모델.<br/>
 */
declare class PointCluster extends ChartItem<PointClusterOptions> {
    static defaults: PointClusterOptions;
    private _runner;
    private _ranges;
    get acitve(): boolean;
    get clusters(): ICluster[];
    run(points: IPoint[], width: number, height: number, onPrepare: (clusters: ICluster[]) => void, onStep: (step: number, clusters: ICluster[]) => void, onComplete?: (clusters: ICluster[]) => void): void;
    stop(): void;
    updateClusters(): void;
    clear(): void;
    isVisible(cluster: ICluster): boolean;
    getRange(cluster: ICluster): PointClusterRange;
    isExpandable(): boolean;
    protected _doApply(op: PointClusterOptions): void;
    private $_parseRanges;
}

type GetLabelPositionFn = (p: DataPoint) => PointLabelPosition;
/**
 * Series data point label options.
 */
declare class DataPointLabel<OP extends DataPointLabelOptions = DataPointLabelOptions> extends IconedText<OP> {
    private static readonly DEFAULT_POSITION;
    static defaults: DataPointLabelOptions;
    private _point;
    _domain: IRichTextDomain;
    private _getPosition;
    get getPosition(): GetLabelPositionFn;
    getValue(p: DataPoint, index: number): any;
    getTextDomain(p: DataPoint): IRichTextDomain;
    getText(value: any): string;
    isVisible(): boolean;
    getDefaultIconPos(): IconPosition;
    protected _doSetSimple(op: OP, src: any): boolean;
    protected _doPrepareRender(chart: IChart, op: OP): void;
    protected _doApply(op: OP): void;
}
declare class DataPointAnchorPoint<OP extends CalloutAnchorPointOptions = CalloutAnchorPointOptions> extends ChartItem<OP> {
    static defaults: CalloutAnchorPointOptions;
}
declare class DataPointCallout<OP extends DataPointCalloutOptions = DataPointCalloutOptions> extends ChartItem<OP> {
    series: Series;
    static defaults: DataPointCalloutOptions;
    constructor(series: Series);
    private _anchorPoint;
    protected _doInit(op: OP): void;
    get anchorPoint(): DataPointAnchorPoint<CalloutAnchorPointOptions>;
}
interface SeriesInspection {
    name: string;
    type: string;
    points: number;
    rendered: number;
    hasData: boolean;
    unpositioned?: number;
    bound?: number;
    unbound?: string[];
}
interface ISeries<T extends DataPoint = DataPoint> {
    chart: IChart;
    color?: Color;
    getProp(key: string): any;
    _idFielder: (src: any) => any;
    _nameFielder?: (src: any) => string;
    _valueFielder?: (src: any) => any;
    _lonFielder?: (src: any) => number;
    _latFielder?: (src: any) => number;
    _colorFielder: (src: any) => string;
    getColorScale(): string | number;
    initPoints(source: any[]): T[];
    followTooltipPointer(): boolean;
    getValueRange?(): {
        min: number;
        max: number;
    };
    select(p: ISelectionSource, clear?: boolean): void;
    unselect(p: ISelectionSource): void;
    selectList(p: ISelectionSource[]): void;
    unselectList(p: ISelectionSource[]): void;
}
/**
 * MapChart series base.
 */
declare abstract class Series<OP extends SeriesOptions = SeriesOptions> extends ChartItem<OP> implements ILegendSource, ITooltipContext {
    static readonly type: string;
    static readonly defaultTooltipText = "<b>${name}</b><br>${series}:<b> ${value}</b>";
    static register(...clses: typeof Series<SeriesOptions>[]): void;
    static defaults: SeriesOptions;
    static getPointTooltipParam(series: Series, point: DataPoint, param: string): any;
    private _data;
    private _dataPath;
    private _name;
    private _index;
    _seriesIndex: number;
    protected _map: MapModel;
    protected _mapChanged: boolean;
    protected _points: DataPointCollection;
    private _pointLabel;
    private _callout;
    _optionsDirty: boolean;
    _dataSourceDirty: boolean;
    _dataDirty: boolean;
    _zindexDirty: boolean;
    _maxZindex: number;
    _runPoints: DataPoint[];
    _visPoints: DataPoint[];
    _idFielder: (src: any) => any;
    _lonFielder: (src: any) => any;
    _latFielder: (src: any) => any;
    _nameFielder: (src: any) => string;
    _valueFielder: (src: any) => any;
    _colorFielder: (src: any) => string;
    _runColor: string;
    _calcedColor: string;
    protected _legend: object;
    private _legendMarker;
    private _pointLabelCallback;
    private _pointLabelVisCallback;
    private _pointArgs;
    private _pointListArgs;
    private _argsPoint;
    private _loaded;
    private _dataLoaded;
    private _needAnimate;
    ani: RmAnimation;
    getProp(key: string): any;
    constructor(chart: IChart);
    protected _doInit(op: SeriesOptions): void;
    protected _createLabel(chart: IChart): DataPointLabel;
    getTooltipText(series: ISeries, point: DataPoint): string;
    getTooltipParam(series: ISeries, point: DataPoint, param: string): any;
    canHide(): boolean;
    legendMarker(doc: Document, size: number): RmElement;
    legendColor(): string;
    legendLabel(): string;
    _type(): string;
    /**
     * 이 시리즈가 실제로 무엇을 그렸는지 요약한다. MapChart.inspect()가 모아서 리턴한다.
     *
     * config가 잘못돼도 예외가 발생하지 않는 경우가 많아, 화면을 보기 전에는
     * 데이터가 붙었는지 알 수 없다. 그 상태를 데이터로 확인할 수 있게 한다.
     * 시리즈 종류별로 더 알릴 것이 있으면 재정의한다(MapSeries의 area 연결 등).
     */
    _inspect(): SeriesInspection;
    /**
     * 데이터포인트의 coord로 위치가 정해지는 시리즈인지.
     *
     * 좌표를 못 구하면 coord가 [0, 0]으로 남는데, 그것을 "좌표 해소 실패"로 볼 수 있는 건
     * coord로 그리는 시리즈뿐이다. 맵 시리즈는 지도 area로, route 시리즈는 coords로 위치가
     * 정해지므로 coord가 [0, 0]이어도 정상이다.
     */
    protected _positionsByCoord(): boolean;
    /**
     * 차트 시리즈 목록에서 위치.<br/>
     */
    get index(): number;
    /**
     * 시리즈 이름.<br/>
     * 시리즈 생성시 지정된 후 변경할 수 없다.
     * 맵차트의 다른 구성 요소에서 이 시리즈를 참조할 때 사용되며,
     * 레전드나 툴팁에서 시리즈를 나타내는 텍스트로도 사용된다.
     *
     * 
     */
    get name(): string;
    /**
     * 데이터포인트 label 설정 모델.
     *
     * 
     */
    get pointLabel(): DataPointLabel<DataPointLabelOptions>;
    get map(): MapModel;
    get callout(): DataPointCallout<DataPointCalloutOptions>;
    get cluster(): PointCluster;
    displayName(): string;
    /**
     * 데이터포인터들을 생성하는 데 사용되는 값 목록.
     *
     * 
     */
    get data(): any;
    private $_setData;
    get pointCount(): number;
    followTooltipPointer(): boolean;
    isEmpty(visibleOnly: boolean): boolean;
    get needAnimate(): boolean;
    set needAnimate(value: boolean);
    get dataLoaded(): boolean;
    set dataLoaded(value: boolean);
    isDataSeries(): boolean;
    isMapSeries(): boolean;
    getDetailed(): Series;
    getValueRange(): {
        min: number;
        max: number;
    };
    /**
     * 시리즈 수준의 포인터 상호작용 허용 여부.
     * disabled와 interactive는 같은 의미이므로 둘 중 하나라도 차단이면 false다.
     * 차트 수준 interactive는 여기서 판정하지 않는다. (ChartObject의 hoverable/clickable 게이트가 앞단에서 막는다)
     */
    isInteractive(): boolean;
    needMapScale(): boolean;
    needTranslate(): boolean;
    contains(p: DataPoint): boolean;
    isExcluded(p: DataPoint): boolean;
    initPoints(source: any[]): DataPoint[];
    getPoint(index: number): DataPoint;
    find(condition: {
        [key: string]: any;
    }): DataPoint;
    findAll(condition: {
        [key: string]: any;
    }): DataPoint[];
    getPointText(p: DataPoint, index: number, label: any): {
        label: string;
        isCallbackExecuted: boolean;
    };
    getPointArgs(p: DataPoint): DataPointArgs;
    /**
     * 로케일 런타임 변경 시 각 데이터포인트의 이름을 재계산한다.<br/>
     * 데이터를 재파싱하지 않고 기존 포인트의 이름만 갱신하므로 선택/애니메이션 상태가 보존된다.
     */
    _relocalize(): void;
    getPointStyle(p: DataPoint): SVGStyleOrClass;
    getPointLabelStyle(p: DataPoint): SVGStyleOrClass;
    getRangedColor(p: DataPoint): string;
    isPointLabelsVisible(): boolean;
    isPointLabelVisible(p: DataPoint): boolean;
    pointLabelCount(): number;
    getLabeledPoints(): DataPoint[];
    getCallout(): DataPointCallout<DataPointCalloutOptions>;
    isPointCalloutVisible(): boolean;
    getLegendSources(legend: object, list: ILegendSource[]): void;
    getLabelOff(): number;
    protected _defLabelOff(): number;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    pointById(id: string): DataPoint;
    canAddAnimation(): boolean;
    canRemoveAnimation(): boolean;
    private $_dataPointsChanged;
    loadData(data: any, animate?: boolean): this;
    /**
     * 데이터포인트를 하나 추가한다.<br/>
     * 데이터포인트 하나를 제거하라면 {@link removePoint}를 사용한다.
     *
     * @param source 데이터포인트 정보
     * @param index 추가 위치. 0보다 적으면 마지막에 추가된다.
     * @param duration 0보다 큰값을 지정하면 애니메이션이 표시된다.
     * @returns 생성된 데이터포인트 객체
     */
    addPoint(source: any, index?: number, duration?: number): DataPoint;
    /**
     * 데이터포인트를 하나 이상 추가한다.<br/>
     * 여러 데이터포인트 한꺼번에 제거하라면 {@link removePointList}를 사용한다.
     *
     * @param source 데이터포인트 정보 목록
     * @param index 추가 위치. 0보다 적으면 마지막에 추가된다.
     * @param duration 0보다 큰값을 지정하면 애니메이션이 표시된다.
     * @returns 생성된 데이터포인트 객체 목록
     */
    addPointList(source: any[], index?: number, duration?: number): DataPoint[];
    /**
     * 지정한 데이터포인트를 제거한다.<br/>
     * 데이터포인트 하나를 추가하라면 {@link addPoint}를 사용한다.
     *
     * @param p 삭제할 데이터포인트 객체나 인덱스 또는 문자열 id
     * @param duration 0보다 크면 삭제 애니메이션 표시
     */
    removePoint(p: DataPoint | number | string, duration?: number): void;
    private $_points;
    private $_remove;
    /**
     * 복수 개 데이터포인트를 제거한다.<br/>
     * 데이터포인트를 여러개 동시에 추가하라면 {@link addPointList}를 사용한다.
     *
     * @param p 삭제할 데이터포인트 객체나 인덱스 또는 문자열 id 목록.
     * @param duration 0보다 크면 삭제 애니메이션 표시
     */
    removePointList(points: (DataPoint | number | string)[], duration?: number): DataPoint[];
    clearPoints(duration?: number): void;
    removeFirst(duration?: number): void;
    removeLast(duration?: number): void;
    updatePoint(p: DataPoint | string | number, props: any, duration?: number): boolean;
    updatePointList(points: (DataPoint | string | number)[], props: any[], duration?: number): void;
    getPointLabels(): DataPointLabel[];
    getColorScale(): string | number;
    setOptionsDirty(value: boolean): Series;
    pointClicked(p: DataPoint): boolean;
    show(force?: boolean, animate?: boolean): void;
    hide(animate?: boolean): void;
    getCalloutShape(p: DataPoint): string;
    /**
     * @private
     * 사용자가 마우스 클릭 등으로 데이터포인트(들)을 선택할 수 있는 시리즈인 지 여부.<br/>
     */
    canSelect(): boolean;
    select(p: ISelectionSource): void;
    unselect(p: ISelectionSource): void;
    selectList(list: ISelectionSource[]): void;
    unselectList(list: ISelectionSource[]): void;
    private $_bringToFront;
    /**
     * rendering lock.<br/>
     */
    lock(): void;
    unlock(): void;
    _setLegend(legend: object): void;
    protected _doApply(op: OP): void;
    protected _isPointsDirty(): boolean;
    _prepareRender(): void;
    protected _doAfterRender(): void;
    protected _doMapChanged(): void;
    protected _doPrepareRender(chart: IChart, op: OP): void;
    protected abstract _createPoint(source: any): DataPoint;
    _setIndex(index: number, seriesIndex?: number): void;
    protected $_addPoint(source: any, i: number): DataPoint;
    /**
     * 매개변수로 받은게 함수면 그 함수를 사용하고,
     * 문자열이면 그 문자열을 필드명으로 사용하는 펑션을 생성한다.
     * 필더가 호출될 때 전달되는 값은 데이터포인트의 소스 객체이다.
     */
    protected _createFielder(f: any): (v: any) => any;
    protected _createFielders(op: SeriesOptions): void;
    protected _createLegendMarker(doc: Document, size: number): RmElement;
    protected _defaultLoadAnimation(): SeriesLoadAnimation;
    protected _doLoad(op: OP, source: any): void;
    protected _doLoadData(src: any): any[];
    private $_loadPoints;
    protected _doLoadPoints(src: any): void;
    private $_createPointArgs;
    protected _getPointArgs(args: DataPointArgs, p: DataPoint): DataPointArgs;
    protected _getPointListArgs(points: DataPoint[]): DataPointListkArgs;
    protected _preparePointArgs(args: DataPointArgs): void;
    protected _calcMinMax(pts: DataPoint[]): {
        min: number;
        max: number;
    };
}
declare abstract class ValuePoint extends DataPoint {
    value: number;
    protected _readObject(series: ISeries, v: any): void;
    protected _readArray(series: ISeries, v: any[]): void;
    protected _assignTo(proxy: any): any;
    getValue(): number;
    getBaseValue(): number;
    protected _valuesChanged(prev: any): boolean;
}
/**
 */
declare abstract class ValueSeries<OP extends ValueSeriesOptions = ValueSeriesOptions> extends Series<OP> {
    static defaults: ValueSeriesOptions;
    protected _createFielders(op: ValueSeriesOptions): void;
    protected _createValueFielder(op: ValueSeriesOptions): (v: any) => any;
}
declare abstract class CoordBaseSeries<OP extends CoordBaseSeriesOptions = CoordBaseSeriesOptions> extends ValueSeries<OP> {
    static defaults: CoordBaseSeriesOptions;
    private _excludes;
    isExcludedCoord(coord: MapCoord): boolean;
    isExcluded(p: DataPoint): boolean;
    protected _doApply(op: OP): void;
}
declare abstract class MarkerSeriesPoint extends ValuePoint {
}
/**
 */
declare abstract class MarkerSeries<OP extends MarkerSeriesOptions = MarkerSeriesOptions> extends CoordBaseSeries<OP> {
    static defaults: MarkerSeriesOptions;
}
declare class SparkSeriesPoint extends ValuePoint {
    values: number[];
    _sum: number;
    position: PointViewPosition;
    getPoints(values: number[], minimum: number, maximum: number): number[];
    getBasePoint(minimum: number, maximum: number, base: number): number;
    getSum(): number;
    protected _readArray(series: ISeries, v: any[]): void;
    protected _readObject(series: ISeries, v: any): void;
    private $_initValues;
    getParam(param: string): any;
}
declare class SparkCategoryImpl implements ILegendSource {
    name: string;
    color: string;
    constructor(name: string, color: string);
    visible: boolean;
    canHide(): boolean;
    legendMarker(doc: Document, size: number): RmElement;
    legendColor(): string;
    legendLabel(): string;
}
/**
 * 복수 개의 관련된 값들을 표시하는 시리즈 기반 클래스.<br/>
 */
declare abstract class SparkSeries<OP extends SparkSeriesOptions = SparkSeriesOptions> extends CoordBaseSeries<OP> {
    static defaults: SparkSeriesOptions;
    _categories: SparkCategoryImpl[];
    getMinMax(points: SparkSeriesPoint[]): {
        min: number;
        max: number;
    };
    protected _doApply(op: OP): void;
    _relocalize(): void;
    protected _createValueFielder(op: SparkSeriesOptions): (v: any) => any;
    getLegendSources(legend: object, list: ILegendSource[]): void;
    private $_parseCategories;
    protected _splitColors(): string[];
}
declare abstract class OrthogonalSparkSeriesPoint extends SparkSeriesPoint {
}
/**
 * 직교 좌표 spark 시리즌 기반 모델.<br/>
 */
declare abstract class OrthogonalSparkSeries<OP extends OrthogonalSparkSeriesOptions = OrthogonalSparkSeriesOptions> extends SparkSeries<OP> {
    static readonly DEF_WIDTH = 80;
    static readonly DEF_HEIGHT = 50;
    static defaults: OrthogonalSparkSeriesOptions;
    private _baseLine;
    _width: number;
    _height: number;
    private _paddingDim;
    _minValue: number;
    _maxValue: number;
    _pointDomain: boolean;
    protected _doInit(op: OrthogonalSparkSeriesOptions): void;
    get baseLine(): ChartItem<ChartItemOptions>;
    getPointExtents(values: number[], seriesExt: {
        min: number;
        max: number;
    }): {
        min: number;
        max: number;
        base: number;
    };
    getPadding(domain: number): number;
    protected _doApply(op: OP): void;
}
declare abstract class GaugePoint extends ValuePoint {
    position: PointViewPosition;
}
declare abstract class Gauge<OP extends GaugeOptions = GaugeOptions> extends CoordBaseSeries<OP> {
    static readonly DEF_SIZE = 60;
    static defaults: GaugeOptions;
    _width: number;
    _height: number;
    protected _doApply(op: OP): void;
}
declare abstract class ValueGauge<OP extends ValueGaugeOptions = ValueGaugeOptions> extends Gauge<OP> {
    static defaults: ValueGaugeOptions;
    private _minValue;
    private _maxValue;
    private _min;
    private _max;
    getValueRate(value: number): number;
    protected _doApply(op: OP): void;
    protected _doPrepareRender(chart: IChart): void;
}

interface ISelectionSource {
    setSelected(selected: boolean): void;
}
interface ISelectionOwner {
    selectionChanged(selection: MapSelection[]): void;
    selectionItemAdded(item: ISelectionSource[]): void;
    selectionItemRemoved(item: ISelectionSource[]): void;
    selectionCleared(): void;
}
declare class MapSelection extends RObject {
    private _owner;
    private _items;
    constructor(owner: ISelectionOwner);
    get count(): number;
    get first(): ISelectionSource;
    get last(): ISelectionSource;
    get(index: number): ISelectionSource;
    contains(source: ISelectionSource): boolean;
    clear(): boolean;
    add(series: ISeries, _list: ISelectionSource[], clear?: boolean): boolean;
    remove(series: ISeries, source: ISelectionSource): boolean;
    toggle(series: ISeries, source: ISelectionSource): boolean;
    protected _changed(): void;
}

/**
 * Series data point base.<br/>
 */
declare class DataPoint implements ISelectionSource {
    source?: any;
    /**
     * 데이터포인트 표시 위치.<br/>
     */
    coord: MapCoord;
    /**
     * @private
     *
     * 인셋에 포함된 경우 인셋의 offset.<br/>
     */
    inset: MapCoord;
    /**
     * 본래 위치와 다른 곳에 데이터포인트 정보를 표시할 때,
     * 해당하는 위치까지의 경로를 표시한다.<br/>
     *
     * 1. [[lon, lat], [lon, lat], ...]
     * 2. [lon, lat]
     * 3. "lon lat, lon lat, ..."
     */
    callout: MapCoord[];
    /**
     * 본래 위치와 다른 곳에 데이터포인트 정보를 표시할 때,
     * 해당하는 위치까지의 경로를 상대적 변위로 표시한다.<br/>
     * callout이 지정되면 이 값은 무시된다.
     */
    offset: MapCoord[];
    readonly pid: number;
    id: string;
    index: number;
    isNull: boolean;
    name: string;
    color: string;
    className: string;
    visible: boolean;
    xPos: number;
    yPos: number;
    _excluded: boolean;
    _runColor: string;
    _zindex: number;
    private _selected;
    _prev: any;
    _vr: number;
    cluster: any;
    px: number;
    py: number;
    moves: number;
    constructor(source?: any);
    setSelected(selected: boolean): void;
    isSelected(): boolean;
    get lon(): number;
    get lat(): number;
    ariaHint(): string;
    labelCount(): number;
    copy(): any;
    proxy(): any;
    assignTo(proxy?: any): any;
    getProp(fld: string | number): any;
    parse(series: ISeries): void;
    protected _doInitValues(): void;
    getValue(): number;
    getLabel(index: number): any;
    vrate(): number;
    _setVrate(vr: number): void;
    _aniRate(): number;
    updateValues(series: ISeries, values: any): any;
    protected _valuesChanged(prev: any): boolean;
    getBaseValue(): number;
    getParam(param: string): any;
    getCallout(coord: MapCoord): MapCoord[];
    _setState(state: string): void;
    _isAdding(): boolean;
    _isUpdating(): boolean;
    _isDeleting(): boolean;
    _isStatic(): boolean;
    protected _assignTo(proxy: any): any;
    protected _readArray(series: ISeries, v: any[]): void;
    /**
     * 차트 로케일에 정의된 이름 속성 후보(nameKeys)를 순서대로 찾아, 먼저 발견되는 값을 이름으로 사용한다.
     * ko는 'name'만, en은 'en-name' → 'name-en' → 'name' 순서다.
     */
    private $_localeName;
    /**
     * 현재 차트 로케일에 맞춰 이름(this.name)을 다시 결정한다.<br/>
     * nameField가 지정되면 그 값이 우선(로케일 무관)하고, 없으면 로케일 nameKeys를 따른다.
     * 로케일 런타임 변경 시 데이터 재파싱 없이 이름만 갱신하는 데 재사용된다.
     */
    _relocalizeName(series: ISeries): void;
    protected _readObject(series: ISeries, v: any): void;
    private $_parseCallout;
    protected _readSingle(v: any): void;
}
declare class DataPointCollection {
    protected _owner: ISeries<DataPoint>;
    private _points;
    constructor(owner: ISeries<DataPoint>);
    get count(): number;
    get first(): DataPoint;
    get last(): DataPoint;
    isEmpty(): boolean;
    getPoints(): DataPoint[];
    get(index: number): DataPoint;
    pointById(id: string): DataPoint;
    contains(p: DataPoint): boolean;
    load(source: any): void;
    clear(): void;
    insert(index: number, p: DataPoint): void;
    insertAll(index: number, points: DataPoint[]): void;
    add(p: DataPoint): void;
    addAll(points: DataPoint[]): void;
    remove(p: DataPoint): boolean;
    removeAll(points: DataPoint[]): number;
    sort(callback: (p1: DataPoint, p2: DataPoint) => number): void;
    forEach(callback: (p: DataPoint, i?: number) => any): void;
    find(condition: {
        [key: string]: any;
    }): DataPoint;
    findAll(condition: {
        [key: string]: any;
    }): DataPoint[];
}

declare const ColorsAssetType = "colors";
declare const ImagesAssetType = "images";
declare const LinearGradientAssetType = "lineargradient";
declare const RadialGradientAssetType = "radialgradient";
declare const PatternAssetType = "pattern";
declare const ShapeAssetType = "shape";
declare const ImageAssetType = "image";
declare const _AssetType: {
    readonly ColorsAssetType: "colors";
    readonly ImagesAssetType: "images";
    readonly LinearGradientAssetType: "lineargradient";
    readonly RadialGradientAssetType: "radialgradient";
    readonly PatternAssetType: "pattern";
    readonly ShapeAssetType: "shape";
    readonly ImageAssetType: "image";
};
/** @dummy */
type AssetType = typeof _AssetType[keyof typeof _AssetType];
interface AssetItemOptions {
    /** @dummy */
    type?: AssetType;
    /**
     * 에셋 id.<br/>
     * 시리즈나 축에서 이 에셋 항목을 참조할 때 사용하는 키로서
     * 맵차트 내에서 유일한 문자열로 반드시 지정해야 한다.
     *
     */
    id: string;
}
/** @dummy */
interface ShapeAssetOptions extends AssetItemOptions {
    /** @dummy */
    type?: typeof ShapeAssetType;
    /** @dummy */
    path?: string;
}
/** @dummy */
interface ImageAssetOptions extends AssetItemOptions {
    type?: typeof ImageAssetType;
    /** 이미지 url */
    url?: string;
}
interface GradientOptions extends AssetItemOptions {
    /**
     * 색을 배열로 지정하거나,
     * 끝 값을 'white'로 전제하고 시작 색 값 하나만 지정할 수 있다.
     *
     */
    color: string[] | string;
    /**
     * 0에서 1사이의 불투명도.<br/>
     * 지정하지 않거나 타당한 값이 아니면 1(완전 불투명)로 적용한다.
     * 또는, 불투명도를 배열로 지정할 수도 있다.
     *
     */
    opacity?: number[] | number;
}
/**
 * 시작점과 끝점 사이에 색상이 서서히 변경되는 효과를 표시한다.<br/>
 * 채우기 색이나 선 색으로 사용될 수 있다.
 *
 */
interface LinearGradientOptions extends GradientOptions {
    /** @dummy */
    type?: typeof LinearGradientAssetType;
    /**
     *
     * @default 'down'
     */
    dir?: 'down' | 'up' | 'right' | 'left';
}
/**
 * 원 중심에서 바깥으로 색상이 변해가는 효과를 표시한다.<br/>
 * 채우기 색이나 선 색으로 사용될 수 있다.
 *
 */
interface RadialGradientOptions extends GradientOptions {
    /** @dummy */
    type?: typeof RadialGradientAssetType;
    /**
     * gradient가 끝나는 원의 x 좌표.
     */
    cx?: number | string;
    /**
     * gradient가 끝나는 원의 y 좌표.
     */
    cy?: number | string;
    /**
     * gradient가 끝나는 원의 반지름.
     */
    r?: number | string;
}
/**
 * 도형 패턴을 지정해서 채우기(fill) 색상 대신 사용할 수 있다.<br/>
 */
interface PatternOptions extends AssetItemOptions {
    /** @dummy */
    type?: typeof PatternAssetType;
    /**
     * 문자열로 지정하면 path 'd', 숫자로 지정하면 stock pattern index.
     */
    pattern: string | number;
    /**
     * 지정하지 않으면 {@link height}나 20 pixels.
     */
    width?: number;
    /**
     * 지정하지 않으면 {@link widths}나 20 pixels.
     */
    height?: number;
    style?: SVGStyles;
    backgroundStyle?: SVGStyles;
    transform?: string;
}
interface Image {
    name?: string;
    url: string;
}
/** @dummy */
interface ImageListOptions extends AssetItemOptions {
    /** @dummy */
    type?: typeof ImagesAssetType;
    /** @dummy */
    rootUrl?: string;
    /** @dummy */
    width?: number;
    /** @dummy */
    height?: number;
    /** @dummy */
    images: (Image | string)[];
}
/**
 * normal: 순서대로 가져오고 끝에 도달하면 처음으로 돌아간다.
 *
 * shuffle: 첫 색상을 가져오기 전 항목들을 섞는다.
 *
 * random: 임의 위치의 색상을 가져온다.
 *
 */
type PaletteMode = 'normal' | 'shuffle' | 'random';
/**
 * 색상 목록을 미리 지정하고 {@link https://realmap.co.kr/config/config/base/series#pointcolors pointcolors} 등에 적용할 수 있다.<br/>
 * 목록에서 색상을 꺼내오는 방식은 {@link mode} 속성으로 지정한다.
 *
 */
interface ColorListOptions extends AssetItemOptions {
    /** @dummy */
    type?: typeof ColorsAssetType;
    /**
     * 색상 목록에서 색을 꺼내오는 방식.
     *
     * @default PaletteMode.NORMAL
     */
    mode?: PaletteMode;
    /**
     * 색상 목록.
     *
     */
    colors?: string[];
}
/** @dummy */
type AssetOptionsType = ShapeAssetOptions | ImageAssetOptions | LinearGradientOptions | RadialGradientOptions | PatternOptions | ColorListOptions | ImageListOptions;

declare abstract class AssetItem<T extends AssetItemOptions> {
    source: T;
    constructor(source: T);
    hasDef(): boolean;
    abstract getElement(doc: Document, source: T): Element;
}
interface IAssetOwner {
    addDef(element: Element): void;
    removeDef(element: string): void;
}
/**
 * 종류 구분없이 id는 유일하게 반드시 지정해야 한다.
 */
declare class AssetCollection {
    private _items;
    private _selectedFill;
    private _map;
    load(source: any): AssetOptionsType | AssetOptionsType[];
    register(doc: Document, owner: IAssetOwner): void;
    unregister(owner: IAssetOwner): void;
    get(id: string): AssetItem<AssetItemOptions>;
    updateOptions(source: any, render: boolean): void;
    private $_loadItem;
}

declare abstract class RmEventProvider<T> extends RObject {
    private _listeners;
    _addListener(listener: T): void;
    _removeListener(listener: T): void;
    /**
     * event로 지정한 함수가 정의된 모든 리스너에 대해 실행한다.
     * 리스너 scope으로 실행하고, 첫번째 매개변수로 이 객체가 전달된다.
     * 다만, 리스너들 중 하나라도 undefined가 아닌 값을 리턴하면,
     * 그 값을 리턴하면서 멈춘다.
     */
    protected _fireEvent(event: string, ...args: any[]): any;
}

/**
 * 맵차트 제작 주체 등을 표시하는 영역에 대한 모델.<br/>
 * 기본적으로 맵차트 오른쪽 아래에 표시되지만, {@link align}, {@link verticalAlign} 등으로 위치를 지정할 수 있다.
 * {@link url}을 설정하면 마우스 클릭 시 새창을 열고 해당 위치로 이동시킨다.
 */
declare class Credits extends ChartItem<CreditsOptions> {
    static defaults: CreditsOptions;
    protected _doSetSimple(op: CreditsOptions, src: any): boolean;
}

/**
 * 경위도선에 대한 옵션
 */
interface MapAxisGridLineOptions extends ChartItemOptions {
    /**
     * 경위도 선의 간격을 도(°) 단위로 지정한다.<br/>
     * 지정하지 않거나 잘못된 값을 않으면 10도로 적용된다.
     */
    step?: number;
}
declare const _MapAxisGridFitTo: {
    /**
     * 그리드를 지도 영역에 맞춰서 그린다.
     */
    readonly Map: "map";
    /**
     * 그리드를 Body 영역에 맞춰서 그린다. 단, 경위도 최대값을 벗어난 그리드는 그리지 않는다.
     */
    readonly Body: "body";
};
type MapAxisGridFitTo = typeof _MapAxisGridFitTo[keyof typeof _MapAxisGridFitTo];
/**
 * 경위도선 표시 설정.<br/>
 */
interface MapAxisGridOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * 그리드를 어떤 영역에 맞춰서 채울지를 지정한다. <br />
     * @default 'map'
     */
    fitTo?: MapAxisGridFitTo;
    /**
     * 숫자로 지정하면 {@link https://realmap.co.kr/config/config/axis/grid/line#step step}으로 설정된다.<br/>
     */
    line?: MapAxisGridLineOptions | number;
    /**
     * 숫자로 지정하면 {@link https://realmap.co.kr/config/config/axis/grid/line#step step}으로 설정된다.<br/>
     */
    lonLine?: MapAxisGridLineOptions | number;
    /**
     * 숫자로 지정하면 {@link https://realmap.co.kr/config/config/axis/grid/line#step step}으로 설정된다.<br/>
     */
    latLine?: MapAxisGridLineOptions | number;
}
interface MapAxisLineOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
interface MapAxisTickLineOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
}
interface MapAxisTickLabelOptions extends ChartTextOptions {
    /**
     * 방위 구분자를 '북남동서' 순서대로 지정한다.<br/>
     *
     * @default 'NSEW'
     */
    dirSymbols?: string;
    /**
     * '°°'로 지정하면 두 번째 자리에 방위에 해당하는 {@link position} 문자 표시.
     *
     * @default '°°'
     */
    suffix?: string;
}
interface MapAxisTickOptions extends ChartItemOptions {
    /**
     * @default false
     */
    visible?: boolean;
    /**
     * @private
     *
     * tick 선 설정 옵션.<br/>
     */
    line?: MapAxisTickLineOptions;
    /**
     * tick 라벨 설정 옵션.<br/>
     */
    label?: MapAxisTickLabelOptions;
    /**
     * @default ['top','right']
     */
    positions?: Positions[];
    /**
     * 위경도 그리드 선 배치를 기준으로 tick 라인과 라벨을 표시하는 간격.<br/>
     * {@link latInterval}, {@link lonInterval}로 위경도 간격을 별도로 지정할 수도 있다.
     *
     * @default 1
     */
    interval?: number;
    /**
     * 경도 그리드 선 배치를 기준으로 tick 라인과 라벨을 표시하는 간격.<br/>
     * {@link interval}로 지정한 값보다 우선한다.
     */
    lonInterval?: number;
    /**
     * 위도 그리드 선 배치를 기준으로 tick 라인과 라벨을 표시하는 간격.<br/>
     * {@link interval}로 지정한 값보다 우선한다.
     */
    latInterval?: number;
}
/**
 * @enum
 */
declare const _MapAxisGuideLabelPosition: {
    /**
     * body 영역 안에 label을 배치한다.
     */
    readonly INSIDE: "inside";
    /**
     * body 영역 밖에 label을 배치한다.
     */
    readonly OUTSIDE: "outside";
};
/** @dummy */
type MapAxisGuideLabelPosition = typeof _MapAxisGuideLabelPosition[keyof typeof _MapAxisGuideLabelPosition];
/**
 * 가이드 label 설정 모델.<br/>
 */
interface MapAxisGuideLabelOptions extends IconedTextOptions {
    /**
     * body 영역 기준, 표시 위치.
     *
     * @default 'inside'
     */
    position?: MapAxisGuideLabelPosition;
    /**
     * 수평 정렬.
     *
     * @default 'left'
     */
    align?: Align;
    /**
     * 수직 정렬.
     *
     * @default 'top'
     */
    verticalAlign?: VerticalAlign;
    /**
     * label과 가이드 사이의 수평 간격.
     *
     * @default 3
     */
    offsetX?: number;
    /**
     * label과 가이드 사이의 수직 간격.
     *
     * @default 3
     */
    offsetY?: number;
}
type MapAxisGuideType = 'line' | 'band' | 'range';
/**
 * 선분이나 영역으로 지도 위의 특정 지점이나 영역을 구분 표시한다.<br/>
 */
interface MapAxisGuideOptions extends ChartItemOptions {
    /**
     * 가이드 종류.<br/>
     * //이 속성을 지정하지 않은 경우,
     * //{@link https://realmap.co.kr/config/config/base/axis/guide guide}
     */
    type?: MapAxisGuideType;
    /**
     * label 모델.
     */
    label?: MapAxisGuideLabelOptions;
    /**
     * true면 시리즈들보다 위에 표시된다.
     *
     * @default true
     */
    front?: boolean;
    /**
     * 모든 guide들 중에서 값이 클수록 나중에 그려진다.
     *
     * @default 0
     */
    zindex?: number;
}
declare const MapAxisLineGuideType = "line";
/**
 * 축 위의 특정한 값에 선분을 표시한다.<br/>
 */
interface MapAxisLineGuideOptions extends MapAxisGuideOptions {
    type?: typeof MapAxisLineGuideType;
    /**
     * @default 'lon'
     */
    axis?: 'lon' | 'lat';
    position?: number;
}
declare const MapAxisBandGuideType = "band";
/**
 * 축 위 특정한 두 값 사이의 영역을 구분 표시한다.<br/>
 * 반대 축은 처음부터 끝까지 포함된다.
 * [주의] realmap-style.css에 fill-opacity가 0.2로 설정되어 있다.
 */
interface MapAxisBandGuideOptions extends MapAxisGuideOptions {
    type?: typeof MapAxisBandGuideType;
    /**
     * @default 'lon'
     */
    axis?: 'lon' | 'lat';
    from?: number;
    to?: number;
}
declare const MapAxisRangeGuideType = "range";
/**
 * 축 위 특정한 두 좌표로 결정되는 영역을 구분 표시한다.<br/>
 * [주의] realmap-style.css에 fill-opacity가 0.2로 설정되어 있다.
 */
interface MapAxisRangeGuideOptions extends MapAxisGuideOptions {
    type?: typeof MapAxisRangeGuideType;
    from?: MapCoord;
    to?: MapCoord;
    elliptic?: boolean;
}
/**
 * 축 line에 crosshair의 정보를 표시하는 view 설정 모델.
 */
interface CrosshairFlagOptions extends ChartItemOptions {
    prefix?: string;
    /**
     * @default '˚'
     */
    suffix?: string;
    /**
     * @default '#0.000'
     */
    numberFormat?: string;
    /**
     * flag에 표시되는 text의 스타일.
     */
    backgroundStyle?: SVGStyleOrClass;
    /**
     * @default 50 pixel
     */
    minWidth?: number;
}
interface CrosshairCallbackArgs extends CommonCallbackArgs {
    axis: object;
    coord: MapCoord;
    flag: string;
    points: DataPoint[];
}
type CrosshairChangeCallback = (args: CrosshairCallbackArgs) => void;
/**
 * 직선 형태로 축 위의 마우스 위치를 표시하는 구성 요소 옵션.<br/>
 */
interface MapCrosshairOptions extends ChartItemOptions {
    /**
     * 축 상에 crosshair의 정보를 표시하는 view.
     *
     */
    flag?: CrosshairFlagOptions;
    /**
     * @override
     * @default false
     */
    visible?: boolean;
    onChange?: CrosshairChangeCallback;
}
/**
 * @dummy
 */
interface MapAxisOptions extends ChartItemOptions {
    /**
     * 축 line 기본 설정 옵션.<br/>
     */
    line?: MapAxisLineOptions | boolean;
    /**
     * Orthographic 투영에서는 표시되지 않는다.
     */
    leftLine?: MapAxisLineOptions | boolean;
    /**
     * Orthographic 투영에서는 표시되지 않는다.
     */
    rightLine?: MapAxisLineOptions | boolean;
    /**
     * Orthographic 투영에서는 표시되지 않는다.
     */
    topLine?: MapAxisLineOptions | boolean;
    /**
     * Orthographic 투영에서는 표시되지 않는다.
     */
    bottomLine?: MapAxisLineOptions | boolean;
    /**
     * 적도선 설정.<br/>
     */
    equatorLine?: MapAxisLineOptions | boolean;
    /**
     * 본초자오선(prime meridian) 설정.<br/>
     */
    meridianLine?: MapAxisLineOptions | boolean;
    /**
     * 경위도선 표시 설정.<br/>
     */
    grid?: MapAxisGridOptions | boolean;
    /**
     * 경위도선 좌표 표서 설정.<br/>
     */
    tick?: MapAxisTickOptions | boolean;
    /**
     * 마우스 현재 위치를 표시하는 crosshair 설정.<br/>
     */
    crosshair?: MapCrosshairOptions | boolean;
    /**
     * 축 가이드 목록.<br/>
     * 하나만 지정할 때는 배열로 지정하지 않아도 된다.
     */
    guide?: MapAxisGuideOptions | MapAxisGuideOptions[];
    /**
     * @default 5
     */
    interval?: number;
    lonInterval?: number;
    latInterval?: number;
}

declare class MapScaleLabel extends IconedText<MapScaleLabelOptions> {
    static defaults: MapScaleLabelOptions;
    getText(value: any): string;
    getDefaultIconPos(): IconPosition;
}
/**
 * 지도 축척자.<br/>
 */
declare class MapScale extends ScaleBase<MapScaleOptions> {
    static defaults: MapScaleOptions;
    private _label;
    private _scale;
    protected _doInit(op: MapScaleOptions): void;
    get label(): MapScaleLabel;
    isVertical(): boolean;
    _type(): string;
    protected _getScaledSeries(chart: IChart): ISeries;
    protected _doApply(options: MapScaleOptions): void;
    protected _doPrepareRender(chart: IChart, op: MapScaleOptions): void;
    private $_calcScale;
}

/**
 * 맵차트 내보내기 설정 모델
 */
interface ExporterOptions extends ChartItemOptions {
    /**
     * 내보내기 버튼 표시 여부 지정
     */
    visible?: boolean;
    /**
     * 내보내기 버튼을 사용해 내보낸 맵차트에 사용할 확장자 없는 파일 이름.\
     * 'export' 함수를 호출할 때 fileName을 지정하지 않을 경우 이 속성이 적용된다.
     * fileName을 지정하지 않을 경우 realmap.type으로 다운로드 된다.
     *
     */
    fileName?: string;
    /**
     * 내보내기를 라이브러리를 사용하여 진행할지 여부 지정
     */
    useLibrary?: boolean;
    /**
     * 내보내기 메뉴에 포함할 export types
     */
    menus?: ExportType[];
    /**
     * 너비, 지정한 너비에 맞춰 높이가 결정된다.
     */
    width?: number;
    /**
     * 이미지의 scale
     */
    scale?: number;
    /**
     * 내보내기 도중 에러가 발생했을 때 처리할 서버 URL. <br />
     * 지정하지 않을경우 realmap 서버에서 처리한다.
     */
    url?: string;
}

interface MapRegionTargetOptions extends ChartItemOptions {
}
interface MapRegionConnectorOptions extends ChartItemOptions {
}
interface MapRegionOptions extends PositionableItemOptions {
    /**
     * 원본 위치 표시 욥션.<br/>
     */
    target?: MapRegionTargetOptions;
    /**
     * {@link target}과의 연결 표시 옵션.<br/>
     */
    connector?: MapRegionConnectorOptions;
    /**
     * 이 맵리전에 표시될 {@link series}로 지정한 맵시리즈의 일부 영역을 지정한다.<br/>
     */
    bounds?: [MapCoord, MapCoord];
    /**
     * 원본 맵시리즈 이름.<br/>
     */
    series?: string;
    /**
     * region 뷰의 너비.<br/>
     *
     * @default 200
     */
    width?: number;
}

/**
 * @dummy
 */
interface MapSourceOptions extends MapSource {
}
/**
 * 맵차트의 기준이 되는 맵과 관련 속성 및 시리즈와 게이지의 기본 타입을 결정하는 중요한 몇가지 속성들과
 * 하위 구성 요소들에 대한 옵션들을 설정한다.<br/>
 * 맵차트 생성 시 이 옵션 객체를 구성해서 전달해야 한다.
 *
 * ```js
 * const chart = RealMap.createChart(doc, 'div', {
 *      .... // 여기에 설정한다.
 * });
 * ```
 *
 * {@link https://www.typescriptlang.org/ typescript} 환경에서는 타입을 명시적으로 지정하여
 * 개발 편집기의 typescript 지원을 받을 수 있으므로
 * 설정 객체를 별도로 정의할 수 있다.
 *
 * ```ts
 * const config: ChartConfiguration = {
 *      ...
 * };
 * const chart = RealMap.createChart(doc, 'div', config);
 * ```
 *
 * 
 */
interface ChartConfiguration {
    templates?: ConfigObject;
    /**
     * 기본 {@link https://realmap.co.kr/guide/series 시리즈} type.<br/>
     * 시리즈에 type을 지정하지 않으면 이 값으로 지정된 type의 시리즈가 생성된다.
     *
     * @default 'map'
     */
    type?: 'map' | 'feature' | 'point' | 'pin' | 'vector' | 'bar' | 'pie' | 'figure' | 'bubble' | 'route' | 'image' | 'line' | 'heatmap' | 'panel' | 'waffle' | 'gauge' | 'clock';
    /**
     * 한 주의 시작 요일.<br/>
     * ex) 0: 일요일, 1: 월요일
     *
     * [주의] 맵차트 로딩 후 변경할 수 없다.
     *
     */
    startOfWeek?: number;
    /**
     * @deprecated {@link general}를 대신 사용해야한다.
     * 맵차트 영역 전체에 연관되는 속성들을 설정한다.<br/>
     */
    chart?: ChartGlobalOptions;
    /**
     * 맵차트 영역 전체에 연관되는 속성들을 설정한다.<br/>
     */
    general?: ChartGeneralOptions;
    /**
     * Asset 목록.<br/>
     * @expandable
     */
    asset?: AssetOptionsType | AssetOptionsType[];
    /**
     * {@link asset}과 동일하고, 이 항목이 우선한다.<br/>
     * @ignore
     */
    assets?: AssetOptionsType | AssetOptionsType[];
    /**
     * {@link https://realmap.co.kr/guide/title 맵차트 타이틀} 표시 영역.<br/>
     * 문자열로 지정하면 제목 텍스트가 되고, boolean으로 지정하면 표시 여부가 된다.
     */
    title?: TitleOptions | string | boolean;
    /**
     * {@link https://realmap.co.kr/guide/title 맵차트 타이틀} 주변에 추가롤 표시되는 부제목 영역.<br/>
     * 문자열로 지정하면 부제목 텍스트가 된다.
     * boolean으로 지정하면 visible이 설정되는데, 부제목은 기본 text가 비어 있어
     * true로 지정해도 표시되지 않는다. false로 숨기는 용도로만 의미가 있다.
     */
    subtitle?: SubtitleOptions | string | boolean;
    /**
     * 맵차트의 기준이 될 지도 소스 및 관련 옵션.<br/>
     * 배열로 둘 이상의 맵을 지정할 수 있다.
     */
    map?: MapSourceOptions | MapSourceOptions[];
    /**
     * {@link https://realmap.co.kr/guide/axis 축} 관련 설정.<br/>
     */
    axis?: MapAxisOptions;
    /**
     * 맵과 시리즈들이 그려지는 영역.<br/>
     */
    body?: BodyOptions;
    /**
     * 범례(legend)나 스케일(color/bubble scale) 등의 위젯들을 한 방향으로 배치하는 그룹을 하나 이상 설정한다.<br/>
     */
    widgetGroup?: MapWidgetGroupOptions | MapWidgetGroupOptions[];
    /**
     * 시리즈 구성을 직관적으로 이해할 수 있도록 도와주는 {@link https://realmap.co.kr/guide/legend 범례}.<br/>
     */
    legend?: LegendOptions | LegendOptions[] | boolean;
    /**
     * {@link https://realmap.co.kr/guide/colorscale 색상자}를 하나 이상 설정한다.
     */
    colorScale?: ColorScaleOptions | ColorScaleOptions[];
    /**
     * @ignore
     * {@link colorScale}과 동일하고, 이 속성이 우선한다.<br/>
     */
    colorScales?: ColorScaleOptions | ColorScaleOptions[];
    /**
     * {@link https://realmap.co.kr/guide/bubblescale 색상자}를 하나 이상 설정한다.
     */
    bubbleScale?: BubbleScaleOptions | BubbleScaleOptions[];
    /**
     * @ignore
     * {@link bubbleScale}과 동일하고, 이 속성이 우선한다.<br/>
     */
    bubbleScales?: BubbleScaleOptions | BubbleScaleOptions[];
    mapScale?: MapScale;
    /**
     * 맵차트가 {@link https://realmap.co.kr/guide/zoom zoom} 가능할 때 zoom 버튼들이 표시되는 패널.<br/>
     */
    zoomPanel?: ZoomPanelOptions | boolean;
    /**
     * 맵차트가 {@link https://realmap.co.kr/guide/drilldown 드릴다운} 상태일 때 뒤로 가기 버튼(들)이 표시되는 패널.<br/>
     */
    drilldownPanel?: DrilldownPanelOptions | boolean;
    /**
     * 데이터포인트 뷰에 마우스 올라갈 때 표시되는 {@link https://realmap.co.kr/guide/tooltip 툴팁} 상자.<br/>
     */
    tooltip?: TooltipOptions | boolean;
    /**
     * 지도나 데이터 원작자 정보 등을 표시하는 {@link https://realmap.co.kr/guide/credits 서명} 영역.<br/>
     */
    credits?: CreditsOptions | boolean;
    /**
     * {@link https://realmap.co.kr/guide/series 시리즈}나 {@link https://realmap.co.kr/guide/gauge 게이지}들을 하나 이상 설정한다.
     *
     * @expandable
     */
    series?: SeriesOptionsType | SeriesOptionsType[];
    /**
     * {@link https://realmap.co.kr/guide/annotations 어노테이션} 또는 어노테이션 목록.<br/>
     * 이 항목이 지정되지 않고 'annotations'가 지정되면 그 항목에 지정된 설정들로 부터 어노테이션들을 생성한다.
     *
     * @expandable
     */
    annotation?: AnnotationOptionsType | AnnotationOptionsType[];
    /**
     * @ignore
     * {@link annotation}과 동일하고, 이 속성이 우선한다.<br/>
     */
    annotations?: AnnotationOptionsType | AnnotationOptionsType[];
    /**
     * @ignore
     * {@link https://realmap.co.kr/guide/mapregion 멥리젼} 또는 맵리젼 목록.<br/>
     */
    mapRegion?: MapRegionOptions | MapRegionOptions[];
    /**
     * @ignore
     * {@link mapRegion}과 동일하고, 이 속성이 우선한다.<br/>
     */
    mapRegions?: MapRegionOptions | MapRegionOptions[];
    /**
     * 내보내기 설정.<br/>
     * false로 지정하면 내보내기 버튼이 표시되지 않는다.
     */
    exporting?: ExporterOptions | boolean;
}

interface IBubbleScaleStep {
    value: number;
    label: string;
    rd: number;
}
declare class BubbleScaleTickLine extends ChartItem<BubbleScaleTickLineOptions> {
    static defaults: BubbleScaleTickLineOptions;
}
declare class BubbleScaleTickLabel extends IconedText<BubbleScaleTickLabelOptions> {
    static defaults: BubbleScaleTickLabelOptions;
    getText(value: any): string;
    getDefaultIconPos(): IconPosition;
}
declare class BubbleScaleTick extends ChartItem<BubbleScaleTickOptions> {
    static defaults: BubbleScaleTickOptions;
    private _line;
    private _label;
    protected _doInit(op: BubbleScaleTickOptions): void;
    get line(): BubbleScaleTickLine;
    get label(): BubbleScaleTickLabel;
}
/**
 * Bubble series 값 범위를 표시한다.<br/>
 */
declare class BubbleScale extends ScaleBase<BubbleScaleOptions> {
    static defaults: BubbleScaleOptions;
    private _tick;
    private _steps;
    protected _doInit(op: BubbleScaleOptions): void;
    get tick(): BubbleScaleTick;
    getSteps(wBody: number, hBody: number): IBubbleScaleStep[];
    _type(): string;
    isVertical(): boolean;
    protected _getScaledSeries(chart: IChart): ISeries;
    protected _doApply(options: BubbleScaleOptions): void;
    protected _doPrepareRender(chart: IChart, op: BubbleScaleOptions): void;
    private $_buildSteps;
}
declare class BubbleScaleCollection extends MapWidgetCollection<BubbleScale> {
    protected _collectionProp(): string;
    protected _createWidget(chart: IChart): BubbleScale;
    beforeRender(): void;
}

interface IColorRanger {
    getColor(min: number, max: number, value: number, color: Color): string;
}
/**
 * @private
 */
declare class ColorRanger implements IColorRanger {
    private _color1;
    private _color2;
    private _logger;
    constructor(range: ColorRange);
    getColor(min: number, max: number, value: number, color: Color): string;
}
declare class ColorScaleMarker extends ChartItem<ColorScaleMarkerOptions> {
    static defaults: ColorScaleMarkerOptions;
    private _label;
    protected _doInit(op: ColorScaleMarkerOptions): void;
    get label(): ChartText<ChartTextOptions>;
    getMarkerSize(): number;
}
declare class ColorScaleTickLine extends ChartItem<ColorScaleTickLineOptions> {
    static defaults: ColorScaleTickLineOptions;
}
declare class ColorScaleTickLabel extends IconedText<ColorScaleTickLabelOptions> {
    static defaults: ColorScaleTickLabelOptions;
    getDefaultIconPos(): IconPosition;
}
declare class ColorScaleTick extends ChartItem<ColorScaleTickOptions> {
    static defaults: ColorScaleTickOptions;
    private _line;
    private _label;
    protected _doInit(op: ColorScaleTickOptions): void;
    get line(): ColorScaleTickLine;
    get label(): ColorScaleTickLabel;
}
interface IColorScaleTick {
    pos: number;
    label?: string;
}
declare class ColorScaleStepLine extends ChartItem<ColorScaleStepLineOptions> {
    static defaults: ColorScaleStepLineOptions;
}
declare class ColorScaleNull extends ChartItem<ColorScaleNullOptions> {
    static defaults: ColorScaleNullOptions;
    getLabel(): string;
    getGap(): number;
}
/**
 * 색상 범위를 표시한다.<br/>
 */
declare class ColorScale extends ScaleBase<ColorScaleOptions> implements IColorRanger {
    static defaults: ColorScaleOptions;
    private _barLength;
    private _marker;
    private _stepLine;
    private _tick;
    private _nullStep;
    private _min;
    private _max;
    private _minColor;
    private _maxColor;
    private _endColor;
    private _colors;
    private _barLengthDim;
    private _logBase;
    private _logger;
    private _steps;
    private _valueSteps;
    protected _doInit(op: ColorScaleOptions): void;
    getColor(min: number, max: number, value: number, color: Color): string;
    get marker(): ColorScaleMarker;
    get stepLine(): ColorScaleStepLine;
    get tick(): ColorScaleTick;
    get nullStep(): ColorScaleNull;
    get minColor(): Color;
    get endColor(): Color;
    getRanger(): IColorRanger;
    getLayout(): ColorScaleLayout;
    getBarSize(wDomain: number, hDomain: number, vertical: boolean): ISize;
    getSplitPoints(len: number, nullStep: boolean, nullGap: number): number[];
    getPosition(value: number): number;
    getTicks(): IColorScaleTick[];
    getSteps(): ColorScaleStep[];
    getLegendSources(target: ILegendSource[]): void;
    _buildSteps(): void;
    _type(): string;
    isVertical(): boolean;
    getDefaultDisplay(caption: MapWidgetCaption): MapWidgetCaptionDisplay;
    protected _doApply(options: ColorScaleOptions): void;
    protected _getScaledSeries(chart: IChart): ISeries;
    private $_parseColorStops;
    protected _doPrepareRender(chart: IChart, op: ColorScaleOptions): void;
    private $_parseValue;
    private $_parseColor;
    private $_buildSteps;
}
declare class ColorScaleCollection extends MapWidgetCollection<ColorScale> {
    getVisibles(loc: ChartItemLocation): ColorScale[];
    getLegendSources(): ILegendSource[];
    protected _collectionProp(): string;
    protected _createWidget(chart: IChart): ColorScale;
    beforeRender(): void;
}

/**
 * 맵차트 내보내기 관련 설정 모델.
 */
declare class Exporter extends ChartItem<ExporterOptions> {
    static defaults: ExporterOptions;
    private _module;
    private _isCompose;
    isCompose(): boolean;
    compose(exporter: ChartExporter): void;
    isContextMenuVisible(): boolean;
    toggleContextMenu(): void;
    contains(dom: Element): boolean;
    hideContextMenu(): void;
    exportToImage(dom: HTMLElement, options: ExportOptions): void;
    /**
     * @private
     * #565: 외부 export 모듈의 자원(document 리스너, 버튼 DOM 등)을 정리한다.
     * RealMap 코어의 destroy()에서 자동 호출되며, 사용자가 직접 호출하지 않는다.
     */
    dispose(): null;
}

/**
 * @private
 */
declare class MapAxisGridLine extends ChartItem<MapAxisGridLineOptions> {
    static defaults: MapAxisGridLineOptions;
    protected _doSetSimple(op: MapAxisGridLineOptions, src: any): boolean;
}
/**
 * @dummy
 */
declare class MapAxisGrid extends ChartItem<MapAxisGridOptions> {
    static defaults: MapAxisGridOptions;
    private _line;
    private _lonLine;
    private _latLine;
    protected _doInit(op: MapAxisGridOptions): void;
    get line(): MapAxisGridLine;
    get lonLine(): MapAxisGridLine;
    get latLine(): MapAxisGridLine;
    get fitTo(): MapAxisGridFitTo;
    getLonStep(): number;
    getLatStep(): number;
    protected _doApply(options: MapAxisGridOptions): void;
    private $_defaultStep;
}
/**
 * @private
 */
declare class MapAxisLine extends ChartItem<MapAxisLineOptions> {
    static defaults: MapAxisLineOptions;
}
/**
 * @private
 */
declare class MapAxisTickLine extends ChartItem<MapAxisTickLineOptions> {
    static defaults: MapAxisTickLineOptions;
}
/**
 * @private
 */
declare class MapAxisTickLabel extends ChartText<MapAxisTickLabelOptions> {
    static defaults: MapAxisTickLabelOptions;
    private _symbolPos;
    private _symbols;
    getText(lat: boolean, dir: number): string;
    protected _doApply(op: MapAxisTickLabelOptions): void;
}
/**
 * @private
 */
declare class MapAxisTick extends ChartItem<MapAxisTickOptions> {
    static defaults: MapAxisTickOptions;
    private _line;
    private _label;
    private _positions;
    protected _doInit(op: MapAxisTickOptions): void;
    get line(): MapAxisTickLine;
    get label(): MapAxisTickLabel;
    visibleAt(pos: Positions): boolean;
    getLonInterval(): number;
    getLatInterval(): number;
    protected _doApply(op: MapAxisTickOptions): void;
}
/**
 * 가이드 label 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/MapAxisGuideLabelOptions MapAxisGuideLabelOptions}이다.
 */
declare class MapAxisGuideLabel extends IconedText<MapAxisGuideLabelOptions> {
    static defaults: MapAxisGuideLabelOptions;
    getDefaultIconPos(): IconPosition;
}
/**
 * 축 가이드 설정 기반 모델.<br/>
 *
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/AxisGuideOptions AxisGuideOptions}이다.
 */
declare abstract class MapAxisGuide<OP extends MapAxisGuideOptions = MapAxisGuideOptions> extends ChartItem<OP> {
    static defaults: MapAxisGuideOptions;
    private _label;
    protected _doInit(op: OP): void;
    /**
     * label 모델.
     */
    get label(): MapAxisGuideLabel;
}
/**
 * 축 위의 특정한 값에 수평 혹은 수직 선분을 표시한다.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/MapAxisLineGuideOptions MapAxisLineGuideOptions}이다.
 */
declare class MapAxisLineGuide extends MapAxisGuide<MapAxisLineGuideOptions> {
    static defaults: MapAxisLineGuideOptions;
}
/**
 * 특정 범위를 수평 혹은 수직 밴드 영역으로 표시한다.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/MapAxisBandGuideOptions MapAxisBandGuideOptions}이다.
 */
declare class MapAxisBandGuide extends MapAxisGuide<MapAxisBandGuideOptions> {
    static defaults: MapAxisBandGuideOptions;
}
/**
 * 특정 영역 두 값 사이의 영역을 구분 표시한다.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/MapAxisBandGuideOptions MapAxisBandGuideOptions}이다.
 */
declare class MapAxisRangeGuide extends MapAxisGuide<MapAxisRangeGuideOptions> {
    static defaults: MapAxisRangeGuideOptions;
}
/**
 * 축 상에 crosshair의 정보를 표시하는 view 설정 모델.
 */
declare class CrosshairFlag extends ChartItem<CrosshairFlagOptions> {
    static defaults: CrosshairFlagOptions;
}
/**
 * 직선 또는 bar 형태로 축 위의 마우스 위치를 표시하는 구성 요소 모델.<br/>
 */
declare class MapCrosshair extends ChartItem<MapCrosshairOptions> {
    axis: MapAxis;
    static defaults: MapCrosshairOptions;
    private _flag;
    private _args;
    constructor(axis: MapAxis);
    protected _doInit(op: MapCrosshairOptions): void;
    /**
     * 축 상에 crosshair의 정보를 표시하는 view.
     */
    get flag(): CrosshairFlag;
    getFlag(pos: number): string;
    moved(pos: IPoint$1, flag: string, points: DataPoint[]): void;
    protected _doSetSimple(op: MapCrosshairOptions, source: any): boolean;
}
declare class MapAxis extends ChartItem<MapAxisOptions> {
    static defaults: MapAxisOptions;
    private _line;
    private _leftLine;
    private _rightLine;
    private _topLine;
    private _bottomLine;
    private _equatorLine;
    private _meridianLine;
    private _grid;
    private _tick;
    private _crosshair;
    private _guides;
    private _lonInterval;
    private _latInterval;
    private _saveGuide;
    protected _doInit(op: MapAxisOptions): void;
    get line(): MapAxisLine;
    get leftLine(): MapAxisLine;
    get rightLine(): MapAxisLine;
    get topLine(): MapAxisLine;
    get bottomLine(): MapAxisLine;
    get equatorLine(): MapAxisLine;
    get meridianLine(): MapAxisLine;
    get grid(): MapAxisGrid;
    get tick(): MapAxisTick;
    get crosshair(): MapCrosshair;
    get guides(): MapAxisGuide<MapAxisGuideOptions>[];
    get lonInterval(): number;
    get latInterval(): number;
    protected _doApply(options: MapAxisOptions): void;
    private $_loadGuides;
}

declare abstract class BodyPanel<OP extends BodyPanelOptions = BodyPanelOptions> extends ChartItem<OP> {
    static readonly ITEM_GAP = 4;
    static defaults: BodyPanelOptions;
    getItemGap(): 4 | OP["itemGap"];
}
declare class ZoomPanel extends BodyPanel<ZoomPanelOptions> {
    static readonly BUTTON_SIZE = 24;
    static defaults: ZoomPanelOptions;
    get vertical(): boolean;
    getButtonSize(): ISize;
    getZoomFactor(): number;
    protected _isVisible(): boolean;
}
declare class DrilldownPanel extends BodyPanel<DrilldownPanelOptions> {
    static defaults: DrilldownPanelOptions;
    protected _isVisible(): boolean;
}

/**
 * 맵차트 제목(title) 설정 모델.<br/>
 * 기본적으로 맵차트 중앙 상단에 표시되지만 {@link align}, {@link verticalAlign} 등으로 위치를 변경할 수 있다.<br/>
 * {@link https://realmap.co.kr/guide/title 타이틀 개요} 페이지를 참조한다.
 *
 */
declare class Title<OP extends TitleOptions = TitleOptions> extends ChartItem<OP> {
    static defaults: TitleOptions;
    isVisible(): boolean;
    protected _doSetSimple(op: OP, src: any): boolean;
}
/**
 * 맵차트 부제목(subtitle) 설정 모델.<br/>
 * 기본적으로 주 제목(title)의 설정을 따르고, 몇가지 속성들이 추가된다.
 */
declare class Subtitle extends Title<SubtitleOptions> {
    static defaults: SubtitleOptions;
}

declare class MapSeriesPoint extends ValuePoint {
    area: MapArea;
    center: MapCoord;
    protected _readObject(series: MapSeries, v: any): void;
    getLabel(index: number): string;
    getParam(param: string): any;
    setSelected(selected: boolean): void;
}
declare class MapSeriesDrilldown extends ChartItem<DrilldownOptions> {
    static defaults: DrilldownOptions;
}
declare class MapSeriesBorder extends ChartItem<MapBorderOptions> {
    name: string;
    series: MapSeries;
    static defaults: MapBorderOptions;
    border: MapBorder;
    constructor(name: string, series: MapSeries);
    getPath(): string;
    protected _doSetSimple(op: MapBorderOptions, src: any): boolean;
}
declare class MapSeriesBorders extends ChartItem<MapBordersOptions> {
    name: string;
    series: MapSeries;
    static defaults: MapBordersOptions;
    constructor(name: string, series: MapSeries);
}
declare class InsetLabel extends IconedText<InsetLabelOptions> {
    static defaults: InsetLabelOptions;
    private _args;
    constructor(chart: IChart);
    getInsetText(inset: MapInset): string;
    getInsetLabelStyle(inset: MapInset): SVGStyleOrClass;
    hideInsetLabel(inset: MapInset): boolean;
    isVisible(): boolean;
    getDefaultIconPos(): IconPosition;
}
/**
 * Map 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/map map}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/MapSeriesOptions MapSeriesOptions}이다.
 */
declare class MapSeries extends ValueSeries<MapSeriesOptions> {
    static type: string;
    static defaults: MapSeriesOptions;
    protected _doInit(op: MapSeriesOptions): void;
    private _parent;
    private _detail;
    private _detailed;
    private _drilldown;
    private _insetLabel;
    private _internalBorder;
    private _externalBorder;
    private _areaPts;
    private _minValue;
    private _maxValue;
    private _colorObj;
    private _colorRanger;
    private _useMapData;
    private _areaMap;
    private _hiddenAreas;
    private _mapBorders;
    private _saveBorders;
    get areaCount(): number;
    get parent(): MapSeries;
    get detail(): MapSeries;
    get drilldown(): MapSeriesDrilldown;
    get insetLabel(): InsetLabel;
    get internalBorder(): MapSeriesBorders;
    get externalBorder(): MapSeriesBorders;
    get color(): Color;
    getMapBorders(): MapSeriesBorder[];
    isHiddenArea(areaId: string): MapArea;
    getHistory(): MapSeries[];
    get(index: number): MapArea;
    pointOf(area: MapArea): MapSeriesPoint;
    protected _positionsByCoord(): boolean;
    /**
     * 기본 정보에 지도 area 연결 결과를 덧붙인다.
     *
     * 데이터포인트가 area와 연결되지 않아도 예외가 발생하지 않고 그냥 화면에서 빠진다
     * (_doLoadPoints에서 대응 area를 못 찾으면 point.area가 undefined로 남는다).
     * 식별자 체계가 어긋나거나 지역명이 개편된 경우가 대표적이라, 무엇이 안 붙었는지 함께 알린다.
     */
    _inspect(): SeriesInspection;
    pointByProp(prop: string, value: any): MapSeriesPoint;
    getBounds(projection: ProjectionType): IRect;
    getCenter(p: MapSeriesPoint | string): MapCoord;
    getValueRange(): {
        min: number;
        max: number;
    };
    getDetailed(): MapSeries;
    showDetail(): void;
    showParent(): void;
    isMapSeries(): boolean;
    protected _createLabel(chart: IChart): DataPointLabel;
    private $_createDetail;
    protected _doLoad(options: ChartItemOptions, source: any): void;
    protected _doApply(op: MapSeriesOptions): void;
    needMapScale(): boolean;
    canAddAnimation(): boolean;
    canRemoveAnimation(): boolean;
    getRangedColor(p: MapSeriesPoint): string;
    followTooltipPointer(): boolean;
    getLegendSources(legend: object, list: ILegendSource[]): void;
    protected _createPoint(source: any): MapSeriesPoint;
    protected _getPointArgs(args: DataPointArgs, p: MapSeriesPoint): DataPointArgs;
    _prepareRender(): void;
    protected _doPrepareRender(chart: IChart, op: MapSeriesOptions): void;
    protected _doLoadPoints(src: any): void;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    getColorScale(): string | number;
    canSelect(): boolean;
    select(p: ISelectionSource, clear?: boolean): void;
    selectList(list: ISelectionSource[]): void;
    isEmpty(visibleOnly: boolean): boolean;
    private $_loadBorders;
}

declare class MapRegionTarget extends ChartItem<MapRegionTargetOptions> {
}
declare class MapRegionConnector extends ChartItem<MapRegionConnectorOptions> {
}
/**
 * 맵리젼 모델.<br/>
 * {@link options 옵션} 모델은 {@link https://realmap.co.kr/docs/api/options/MapRegionOptions MapRegionOptions}이고,
 * {@link https://realmap.co.kr/config 맵차트 설정}에서 {@link https://realmap.co.kr/config/config/mapregion mapRegion} 항목으로 설정한다.
 * ```js
 * const config = {
 *      mapRegion: [{
 *          name: 'region1',
 *          bounds: [[lon1, lat1], [lon2, lat2]],
 *      }],
 * };
 * ```
 * 또, Chart.{@link https://realmap.co.kr/docs/api/classes/Chart#getmapregion getMapRegion}으로
 * 모델 객체를 가져올 수 있다.
 * ```js
 * const region = chart.getMapRegion('region1');
 * region.visible = false;
 * ```
 * {@link https://realmap.co.kr/guide/mapregions MapRegion 개요} 페이지를 참조한다.
 *
 */
declare class MapRegion extends PositioanbleItem<MapRegionOptions> {
    inBody: boolean;
    static defaults: MapRegionOptions;
    private _target;
    private _connector;
    private _map;
    private _zoom;
    private _panX;
    private _panY;
    scroll: number;
    private _scale;
    private _vRect;
    private _wMap;
    constructor(chart: IChart, inBody: boolean);
    protected _doInit(op: MapRegionOptions): void;
    get target(): MapRegionTarget;
    get connector(): MapRegionConnector;
    prepareLayout(width: number, height: number): {
        scale: number;
        wMap: number;
        hMap: number;
        tx: number;
        ty: number;
    };
    refresh(): void;
    protected _getNamePrefix(): string;
    protected _doPrepareRender(chart: IChart, op: MapRegionOptions): void;
    private $_calcPan;
    private $_prepareLayout;
}
/**
 * @private
 */
declare class MapRegionCollection extends PositionalItemCollection<MapRegion> {
    getRegion(name: string): MapRegion;
    protected _loadItem(chart: IChart, src: any, index: number, inBody: boolean): MapRegion;
}

declare class MapBackground extends ChartItem<MapBackgroundOptions> {
    static defaults: MapBackgroundOptions;
    isVisible(): boolean;
}
interface IBodyTransform {
    tx: number;
    ty: number;
    scale: number;
    vx: number;
    vy: number;
}
/**
 * 시리즈, annotation, axis grid 및 guide 등이 표시되는 맵차트 주 영역 모델.<br/>
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/BodyOptions BodyOptions}이다.
 */
declare class Body extends ChartItem<BodyOptions> implements IAnnotationOwner {
    static defaults: BodyOptions;
    private _projection;
    private _mapBackground;
    private _anns;
    _annotations: AnnotationCollection;
    _prj: MapProjection;
    _points: {
        [id: string]: MapCoord;
    };
    private _map;
    private _zoom;
    private _zoomAni;
    private _panX;
    private _panY;
    private _scale;
    private _vRect;
    private _wMap;
    private _hMap;
    private _wLayout;
    private _hLayout;
    private _rawScroll;
    constructor(chart: IChart);
    protected _doInit(op: BodyOptions): void;
    anchorByName(name: string): ChartItem;
    get projection(): MapProjection;
    get mapBackground(): MapBackground;
    get isFlatWorld(): boolean;
    /**
     * rotation x of globe.
     */
    get rotationX(): number;
    set rotationX(value: number);
    /**
     * rotation y of globe.
     */
    get rotationY(): number;
    set rotationY(value: number);
    /**
     * scroll
     */
    get scroll(): number;
    set scroll(value: number);
    /**
     * movable
     */
    get movable(): boolean;
    /**
     * pan x
     */
    get panX(): number;
    set panX(value: number);
    /**
     * pan y
     */
    get panY(): number;
    set panY(value: number);
    /**
     * zoom
     */
    get zoom(): number;
    set zoom(value: number);
    get isZoomed(): boolean;
    /**
     * map scale
     */
    get scale(): number;
    /**
     * 현재 표시된 상태의 맵 중앙 좌표.
     */
    get center(): MapCoord;
    /**
     * map
     */
    get map(): MapModel;
    get calcedMapWidth(): number;
    isDrilldowned(): boolean;
    /**
     * 주어진 panX를 현재 배율에서 실제로 갈 수 있는 범위로 자른다.
     *
     * $_calcPan은 레이아웃 때만 돌고 그 결과(_panX/_panY)는 getter로만 나간다. 반면 setter는
     * 자르지 않은 값을 그대로 저장한다. 그래서 가장자리를 200px 넘겨 끌었다가 50px 되돌리면
     * 저장값이 아직 범위 밖이라 화면이 꿈쩍도 하지 않는다. 손가락은 오버슈트가 상시라
     * 고장으로 느껴지므로, 드래그 중에는 저장 전에 잘라둔다. #585
     */
    clampPanX(value: number): number;
    /** clampPanX의 세로축 판. */
    clampPanY(value: number): number;
    /**
     * 현재 배율에서 가로로 움직일 여지가 있는가.
     * 지도가 body보다 넓어야 $_calcPan의 클램프 여유가 생긴다.
     * scrollable 월드맵은 pan 대신 scroll로 무한히 도므로 항상 여지가 있다.
     */
    canPanX(): boolean;
    /**
     * 현재 배율에서 세로로 움직일 여지가 있는가.
     */
    canPanY(): boolean;
    /**
     * zoom 값을 유효 범위로 자른다. 최소는 100이고, maxZoom을 지정했으면 그 이하로 제한한다.
     * maxZoom은 지금까지 선언만 있고 읽는 곳이 없어서 상한이 아예 없었다. #585
     */
    private $_clampZoom;
    private $_calcPan;
    prepare(map: MapModel): void;
    prepareLayout(width: number, height: number): {
        scale: number;
        wMap: number;
        hMap: number;
        tx: number;
        ty: number;
    };
    /**
     * @private
     *
     * x1 ~ x2 대신 h1 ~ h2 로 계산한다.
     * 현재 globe가 아닌 세계 지도에만 적용하고 있다.
     * TODO: $_prepareLayout_world, $_prepareLayout 합칠 것!
     */
    private $_prepareLayout_world;
    private $_prepareLayout;
    private $_calculateRate;
    getPoint(id: string): MapCoord;
    /**
     * coord는 projection 하지 않은 값.
     */
    toVisible(coord: MapCoord): MapCoord;
    isScrollable(): boolean;
    setZoom(value: number, duration?: number | AnimationOptions | (() => void)): void;
    incZoom(delta: number): void;
    zoomByFactor(factor: number, animate?: boolean): void;
    /**
     * (px, py) 지점이 화면에서 제자리에 남도록 pan을 보정하면서 zoom을 바꾼다.
     * 핀치처럼 확대 기준점이 화면 중앙이 아닐 때 쓴다. #585
     *
     * scale = (zoom / 100) * rate이고 rate는 body 크기가 같으면 상수이므로
     * s1 = s0 * (z1 / z0)이 정확히 성립한다. 그래서 재레이아웃 없이 보정량을 구할 수 있다.
     *   pan += (p - 중앙) * (1 / s0 - 1 / s1)
     * tx = W/2 - C*s - panX*s, ty = H/2 + D*s - panY*s 이므로 두 축의 부호가 같다.
     *
     * @param zoom 목표 zoom
     * @param px 기준점 x (body 좌표)
     * @param py 기준점 y (body 좌표)
     */
    zoomAt(zoom: number, px: number, py: number): void;
    _canSetZoom(value: number): boolean;
    /**
     * 지정한 좌표로 zoom하고 area center로 이동한다.
     *
     * @param zoom 줌 배율
     * @param target 지정한 좌표
     * @param duration animation duration
     */
    zoomTo(zoom: number, target: MapCoord, duration?: number): void;
    /**
     * 지정한 area가 모두 표시되는 정도로 zoom하고 area center로 이동한다.<br/>
     *
     * @param area area id
     * @param ratio 지정한 area를 ratio만큼 확대한다. ratio는 0보다 크고 1 이하. 기본값은 0.7
     * @param duration animation duration
     */
    zoomToArea(areaId: string, ratio?: number, duration?: number, _option?: ZoomToAreaOptions): void;
    /**
     * 떨어진 두 위치로 정해지는 영역이 모두 표시되도록 zoom(in/out)하고 영역 중앙으로 이동한다.<br/>
     */
    zoomToBounds(from: MapCoord, to: MapCoord, duration?: number, ratio?: number): void;
    calcZoomInfo(from: MapCoord, to: MapCoord, ratio: number): {
        center: MapCoord;
        zoom: number;
    };
    /**
     * 지정한 지점이나 area의 center가 중앙이 되도록 이동한다.
     *
     * @param target 지점 좌표 또는 area id.
     */
    focusTo(target: MapCoord, duration?: number): void;
    $_moveTo(coords: MapCoord): void;
    getAnnotations(): Annotation[];
    getAnnotation(name: string): Annotation;
    updateOption(prop: keyof BodyOptions, value: any, render?: boolean): this;
    updateOptions(source?: BodyOptions, render?: boolean): this;
    protected _doApply(op: BodyOptions): void;
    protected _doPrepareRender(chart: IChart): void;
    _getZoom(): number;
}
interface IMapChartEvents {
    onModelChanged(chart: ChartObject, item: ChartItem, tag: any): void;
    onDataChanged(chart: ChartObject, series: Series): void;
    onMapChanged(chart: ChartObject, map: MapModel): void;
    onProjectionChanged(chart: ChartObject, projection: MapProjection): void;
    onZoomChanged(chart: ChartObject, zoom: number, oldZoom: number): void;
    onRequestRender(chart: ChartObject, now: boolean): void;
    onRequestShowSeries(chart: ChartObject, series: Series, visible: boolean): void;
}
declare class ChartGeneral extends ChartItem<ChartGlobalOptions> {
    static defaults: ChartGeneralOptions;
    protected _widgetGaps: Sides;
    getWidgetSectionGap(loc: ChartItemLocation): any;
    protected _doApply(options: ChartGlobalOptions): void;
}
/**
 * @ignore
 *
 * 내부 chart model.<br/>
 * 시리즈가 하나도 설정되지 않으면(visible과 상관없이) data가 연결되지 않은 빈 'map' 시리즈를 표시한다.
 */
declare class ChartObject extends RmEventProvider<IMapChartEvents> implements IChart, IMapOwner, IAnnotationOwner, ITooltipOwner, ISelectionOwner {
    /**
     * map.bounds로 경계를 설정하는 경우 자동으로 격자(AxisGrid)를 표시하는데,
     * 이 때 경계의 크기 차이인 diff를 기준으로 격자의 간격(step)을 결정한다.
     */
    private static readonly ZOOM_STEP_MAP;
    /**
     * 지도 영역이 너무 넓어 ZOOM_STEP_MAP의 최대치를 초과하는 경우
     * (예: 전 세계 지도) 또는 투영법이 orthographic일 때 기본으로 적용할 격자 간격
     */
    private static readonly DEFAULT_GRID_STEP;
    private static defaults;
    _wrapper: any;
    _op: ChartConfiguration;
    private _bases;
    _templates: {
        [key: string]: any;
    };
    _assets: AssetCollection;
    private _general;
    private _axis;
    private _body;
    _title: Title;
    _subtitle: Subtitle;
    _zoomPanel: ZoomPanel;
    _drilldownPanel: DrilldownPanel;
    _credits: Credits;
    _tooltip: Tooltip;
    private _maps;
    private _baseMap;
    private _series;
    _annotations: AnnotationCollection;
    _mapRegions: MapRegionCollection;
    _widgetGroups: MapWidgetGroupCollection;
    _legends: LegendCollection;
    _colorScales: ColorScaleCollection;
    _bubbleScales: BubbleScaleCollection;
    _mapScale: MapScale;
    private _selection;
    _exporter: Exporter;
    _loading: boolean;
    _widgetGroupDirty: boolean;
    private _point_shaes;
    private _params;
    _seriesIndex: number;
    assignTemplates: (target: any) => any;
    _dataDirty: boolean;
    private _optionsLock;
    _optionsDirty: boolean;
    _loadAnimatable: boolean;
    width: number;
    height: number;
    _globalMapBound: MapBounds;
    lockOptionsDirty(): void;
    freeOptionsDirty(): void;
    constructor(config?: ChartConfiguration, wrapper?: any);
    private _initOptions;
    get wrapper(): any;
    get exporter(): any;
    get options(): ChartConfiguration;
    get general(): ChartGeneral;
    /**
     * @deprecated use {@link general} instead.
     */
    get global(): ChartGeneral;
    get isGlobe(): boolean;
    get selection(): MapSelection;
    getFirstSeries(type: string): Series;
    findSeries(finder: (series: ISeries) => boolean): Series;
    _getSeriesType(type: string): any;
    _getAnnotationType(type: string): any;
    _modelChanged(): void;
    _optionChanged(item: ChartItem, tag?: any): void;
    /**
     * 차트 전체 수준의 상호작용 허용 여부.
     * false이면 hover, tooltip, crosshair, 맵 클릭, 선택, drilldown, 범례 클릭,
     * 드래그, 휠 줌, 핀치 줌, 더블클릭과 애니메이션이 차단된다.
     * 줌 패널처럼 차트가 그린 UI 컨트롤은 차단 대상이 아니다.
     */
    interactive(): boolean;
    /**
     * 애니메이션 허용 여부.
     * @param withInteractive false이면 interactive를 무시하고 animatable 옵션만 확인한다.
     */
    animatable(withInteractive?: boolean): boolean;
    /**
     * 호버 효과와 툴팁·크로스헤어 허용 여부.
     * @param withInteractive false이면 interactive를 무시하고 hoverable 옵션만 확인한다.
     */
    hoverable(withInteractive?: boolean): boolean;
    /**
     * 클릭(맵 클릭·선택·drilldown·범례 클릭·패널 버튼) 허용 여부.
     * @param withInteractive false이면 interactive를 무시하고 clickable 옵션만 확인한다.
     *        줌·드릴다운 패널 버튼은 상호작용 차단과 무관하게 동작해야 하므로 MapTool._doClick이 이 형태를 쓴다.
     */
    clickable(withInteractive?: boolean): boolean;
    /**
     * 드래그(dragAction, Globe 회전, 지도 이동) 허용 여부.
     * @param withInteractive false이면 interactive를 무시하고 draggable 옵션만 확인한다.
     */
    draggable(withInteractive?: boolean): boolean;
    /**
     * 드래그가 실제로 소비하는 축.
     *
     * MapTool의 드래그 트래커 선택과 ChartControl의 touch-action 계산이 같은 판정을 써야 한다.
     * 어긋나면 지도가 제스처를 가져가면서 페이지 스크롤도 막거나, 그 반대가 된다. #585
     */
    dragAxes(): {
        x: boolean;
        y: boolean;
    };
    /**
     * 줌 허용 여부.
     * @param withInteractive false이면 interactive를 무시하고 body.zoomable 옵션만 확인한다.
     *        줌 패널은 상호작용이 차단돼도 표시되어야 하므로 ZoomPanel._isVisible이 이 형태를 쓴다.
     */
    zoomable(withInteractive?: boolean): boolean;
    /**
     * 휠 이벤트 허용 여부.
     * @param withInteractive false이면 interactive를 무시하고 wheelDisabled 옵션만 확인한다.
     */
    wheelable(withInteractive?: boolean): boolean;
    loadAnimatable(): boolean;
    requestShowSeries(series: Series, visible: boolean): void;
    _selectionChanged(series: ISeries, points: DataPoint[]): void;
    getNextPointShape(): Shape;
    getProjection(): MapProjection;
    projectionChanged(): void;
    zoomChanged(zoom: number, oldZoom: number): void;
    mapChanged(map: MapModel): void;
    anchorByName(name: string): ChartItem<ChartItemOptions>;
    get chart(): IChart;
    getTooltipContext(scope: TooltipScope, series: ISeries, point: DataPoint): ITooltipContext;
    selectionChanged(selection: MapSelection[]): void;
    selectionItemAdded(item: ISelectionSource[]): void;
    selectionItemRemoved(item: ISelectionSource[]): void;
    selectionCleared(): void;
    get type(): "map" | "figure" | "point" | "line" | "image" | "bar" | "pie" | "waffle" | "bubble" | "route" | "feature" | "pin" | "vector" | "heatmap" | "panel" | "gauge" | "clock";
    get legend(): Legend;
    get credits(): Credits;
    /**
     * 전체 map의 통합 경계 정보
     */
    get globalMapBound(): MapBounds;
    /**
     * map model.
     */
    get map(): MapModel;
    setBaseMap(indexOrName: number | string | MapModel): void;
    get axis(): MapAxis;
    get title(): Title;
    /**
     * body.
     */
    get body(): Body;
    get visibleSeries(): Series[];
    get firstVisible(): Series;
    get firstMapSeries(): MapSeries;
    get colorScale(): ColorScale;
    get bubbleScale(): BubbleScale;
    get mapScale(): MapScale;
    get widgetGroup(): MapWidgetGroup;
    get zoomPanel(): ZoomPanel;
    get drilldownPanel(): DrilldownPanel;
    get isDirty(): boolean;
    get isDrilldowned(): boolean;
    getAnnotations(): Annotation[];
    getMapRegions(): MapRegion[];
    isEmpty(): boolean;
    coordOfArea(id: string): MapCoord;
    requestRender(now: boolean): void;
    mapByName(name: string): MapModel;
    mapAt(index: number): MapModel;
    getMap(nameOrIndex: string | number): MapModel;
    getSeries(series: string | number): Series<SeriesOptions>;
    seriesByName(series: string): Series;
    seriesByType(type: string): Series;
    seriesAt(index: number): Series;
    seriesByPoint(point: DataPoint): Series;
    annotationByName(name: string): Annotation;
    mapRegionByName(name: string): MapRegion;
    _collectWidgets(): {
        [dir: string]: MapWidget<MapWidgetOptions>[];
    };
    loadBase(source: any, model: string, type: string): any;
    private _setProperties;
    _load(config: ChartConfiguration): this;
    /**
     * 설정된 지도가 없어서 더미 MapModel이 설정되었거나, 지도에 지역 정보가 하나도 없는 경우, 자동으로 격자선을 그리도록 설정을 수정하는 메서드.
     * 사용자가 매우 좁은 경계(map.bounds)를 설정한 경우(예: 폭 1도 미만), 기본 격자 단위인 10도(step=10)로는 선이 1개도 보이지 않음
     * 경계에 맞는 간격으로 격자 설정. normalizedMap이 단일 객체로 변환된 경우도 포함한다
     */
    private $_resolveGrid;
    private $_loadTemplates;
    prepareRender(): void;
    afterRender(): void;
    /**
     * 데이터 및 속성 변경 후 다시 그리게 한다.
     */
    update(options: ChartConfiguration, render: boolean): void;
    /**
     * 로케일 런타임 변경 시, 로드 시점에 확정·캐시된 이름을 재계산한다. (차트 재생성/데이터 refetch 없음)<br/>
     * area 이름/데이터포인트 이름/범례 카테고리를 다시 계산하고, 렌더 시점에 로케일을 직접 읽는
     * 나머지(콜백 args.locale, pointLabel textEn, colorScale labelEn, 툴팁)는 이어지는 재렌더에서 자동 갱신된다.
     */
    private $_relocalize;
    export(options: ExportOptions): void;
    _getLegendSources(legend: object): ILegendSource[];
    getParam(target: any, param: string): any;
    setParam(param: string, value: any, redraw?: boolean): ChartObject;
    addSeries(source: any, animate: boolean): Series;
    removeSeries(series: string | Series, animate: boolean): Series<SeriesOptions>;
    /** @private */
    _dataChanged(series: Series): void;
    /** @private */
    _isDataChanged(): boolean;
    getColorScale(scale: string | number): ColorScale;
    getBubbleScale(scale: string | number): BubbleScale;
    drilldown(series: MapSeries, area: string): Promise<void>;
    drillup(series?: MapSeries): Promise<void>;
    canClick(): boolean;
    click(info: any): void;
    pointToMap(x: number, y: number): MapCoord;
    private $_buildWidgetGroups;
    /**
     * 모든 MapModel의 경계좌표를 합쳐서 전체 지도의 좌표 범위를 구한다.
     */
    private $_resetGlobalMapBound;
    _visibleChanged(item: ChartItem): void;
    _hoverAreaChanged(series: Series, newArea: MapArea, oldArea: MapArea): void;
    _areaClicked(series: Series, area: MapArea): void;
}

interface MapBounds {
    x1: number;
    x2: number;
    y1: number;
    y2: number;
    h1: number;
    h2: number;
    v1: number;
    v2: number;
}
interface IChart {
    wrapper: any;
    options: ChartConfiguration;
    general: ChartGeneral;
    /**
     * @deprecated use {@link general} instead.
     */
    global?: ChartGeneral;
    type?: string;
    _loading: boolean;
    map: MapModel;
    axis: MapAxis;
    body: Body;
    _tooltip: Tooltip;
    _exporter: Exporter;
    _assets: AssetCollection;
    _seriesIndex: number;
    selection: MapSelection;
    width: number;
    height: number;
    isGlobe: boolean;
    firstVisible: Series;
    firstMapSeries: Series;
    isDirty: boolean;
    globalMapBound: MapBounds;
    mapAt(index: number): MapModel;
    mapByName(name: string): MapModel;
    getMap(nameOrIndex: string | number): MapModel;
    getFirstSeries(type: string): Series;
    findSeries(finder: (series: ISeries) => boolean): Series;
    interactive(): boolean;
    animatable(withInteractive?: boolean): boolean;
    hoverable(withInteractive?: boolean): boolean;
    clickable(withInteractive?: boolean): boolean;
    zoomable(withInteractive?: boolean): boolean;
    loadAnimatable(): boolean;
    loadBase(source: any, model: string, type: string): any;
    assignTemplates(target: any): any;
    projectionChanged(): void;
    zoomChanged(zoom: number, oldZoom: number): void;
    coordOfArea(id: string): MapCoord;
    seriesByName(series: string): Series;
    seriesAt(index: number): Series;
    getSeries(series: string | number): Series;
    getColorScale(scale: string | number): ColorScale;
    requestShowSeries(series: Series, visible: boolean): void;
    isDrilldowned: boolean;
    drilldown(series: Series, area: string): void;
    drillup(series?: Series): void;
    _getSeriesType(type: string): any;
    _getAnnotationType(type: string): any;
    getProjection(): MapProjection;
    _visibleChanged(item: ChartItem): void;
    _optionChanged(item: ChartItem, tag?: any): void;
    _getLegendSources(legend: object): ILegendSource[];
    _hoverAreaChanged(series: Series, newArea: MapArea, oldArea: MapArea): void;
    _areaClicked(series: Series, newArea: MapArea): void;
    getParam(target: any, param: string): any;
    setParam(param: string, value: any, redraw?: boolean): void;
    _dataChanged(series: Series): void;
    _isDataChanged(): boolean;
    lockOptionsDirty(): void;
    freeOptionsDirty(): void;
    _selectionChanged(series: ISeries, p: ISelectionSource[]): void;
    getNextPointShape(): Shape;
    isEmpty(): boolean;
}
declare const extend: <O extends ChartItemOptions>(base: any, source: O) => O;
/**
 * 맵차트 구성 요소 모델들의 기반 클래스.<br/>
 */
declare class ChartItem<OP extends ChartItemOptions = ChartItemOptions> extends ROptionable<OP> {
    static readonly REFRESHED = "refreshed";
    static defaults: ChartItemOptions;
    readonly chart: IChart;
    _style: SVGStyleOrClass;
    constructor(chart: IChart);
    /**
     * 표시 여부.<br/>
     * options.visible 값을 그대로 return하는 것이 아니라,
     * undefined나 null 등으로 지정하는 경우 모델의 상태에 따라 true나 false로 해석될 수 있다.<br/>
     * 설정의 경우 {@link updateOptions}(`{visible: value}`)로 지정하는 것과 동일하다.
     *
     * @default true
     */
    get visible(): boolean;
    set visible(value: boolean);
    protected _isVisible(): boolean;
    protected _doSetSimple(op: OP, src: any): boolean;
    protected _addChild<T extends ROptionable>(name: string & keyof OP, child: T): T;
    protected _doLoad(op: OP, source: any): void;
    /**
     * 명시적으로 모델에 설정된 모든 style 값들을 제거한다.<br/>
     *
     * @param render true로 지정하면 옵션 변경 시 맵차트를 다시 그린다. 기본값 false
     * @returns
     */
    clearStyle(render?: boolean): this;
    /**
     * 모델 css style 값을 변경한다.<br/>
     * value에 undefined나 null, ''을 지정하면 기존에 설정됐던 스타일 항목이 제거된다.<br/>
     *
     * @param prop css 스타일 항목 이름.
     * @param value 적용할 스타일 값.
     * @param render true로 지정하면 옵션 변경 시 맵차트를 다시 그린다. 기본값 true
     * @returns
     */
    setStyle(prop: string, value: any, render?: boolean): this;
    /**
     * 여러 항목의 모델 css style 값들을 json 객체로 지정해서 동시에 변경한다.<br/>
     * value에 undefined나 null, ''을 지정하면 기존에 설정됐던 스타일 항목이 제거된다.<br/>
     *
     * @param props 스타일 항목들과 값들이 설정된 json 객체
     * @param clear true로 지정하면 기존 스타일 값을 모두 제거한다. 기본값 false
     * @param render true로 지정하면 옵션 변경 시 맵차트를 다시 그린다. 기본값 true
     */
    setStyles(props: object, clear?: boolean, render?: boolean): this;
    _prepareRender(): void;
    _afterRender(): void;
    _optionChanged(tag?: any): void;
    protected _doLoadProp(prop: string, value: any): boolean;
    private $_applyOptions;
    protected _setDim(_op: OP, prop: string): void;
    protected _setDims(op: OP, ...props: string[]): void;
    protected _doApply(op: OP): void;
    protected _doPrepareRender(chart: IChart, op: OP): void;
    protected _doAfterRender(): void;
}
declare abstract class ChartItemCollection<T extends ChartItem> {
    readonly chart: IChart;
    protected _items: T[];
    constructor(chart: IChart);
    get count(): number;
    get first(): T;
    items(): T[];
    _internalItems(): T[];
    abstract load(src: any, tag?: any): void;
    updateOptions(source: any, render: boolean): void;
}
declare class ChartText<OP extends ChartTextOptions = ChartTextOptions> extends ChartItem<OP> {
    static defaults: ChartTextOptions;
    private _outlineThickness;
    private _numberSymbols;
    private _numberFormat;
    private _text;
    _outlineWidth: string;
    private _numSymbols;
    protected _numberFormatter: NumberFormatter;
    protected _richTextImpl: SvgRichText;
    private _setOutlineThickness;
    private _setNumberSymbols;
    private _setNumberFormat;
    private _setText;
    isVisible(): boolean;
    setText(value: string): void;
    buildSvg(view: TextElement, outline: TextElement, maxWidth: number, maxHeight: number, target: any, domain: IRichTextDomain, preSuffixEnabled?: boolean): void;
    prepareRich(text: string): void;
    protected _doSetSimple(op: OP, src: any): boolean;
    protected _doApply(op: OP): void;
    private $_getNumberText;
    protected _getText(text: any, value: any, useSymbols: boolean, forceSymbols: boolean): string;
    getNumberText(value: any, useSymbols: boolean, forceSymbols: boolean, roundingMode: 'trunc' | 'ceil'): string;
}
declare abstract class IconedText<OP extends IconedTextOptions = IconedTextOptions> extends ChartText<OP> {
    static defaults: IconedTextOptions;
    private _images;
    private _root;
    abstract getDefaultIconPos(): IconPosition;
    getIconPos(): IconPosition;
    protected _doPrepareRender(chart: IChart, op: IconedTextOptions): void;
    getUrl(url: string): string;
}
declare class MapWidgetBackground extends ChartItem<MapWidgetBackgroundOptions> {
    static defaults: MapWidgetBackgroundOptions;
}
declare class MapWidgetCaption extends IconedText<MapWidgetCaptionOptions> {
    static defaults: MapWidgetCaptionOptions;
    getDisplay(widget: MapWidget): MapWidgetCaptionDisplay;
    getGap(inline: boolean): number;
    protected _isVisible(): boolean;
    protected _doSetSimple(op: MapWidgetCaptionOptions, src: any): boolean;
    getDefaultIconPos(): IconPosition;
}
declare abstract class MapWidget<OP extends MapWidgetOptions = MapWidgetOptions> extends ChartItem<OP> {
    static defaults: MapWidgetOptions;
    private _group;
    private _index;
    private _background;
    private _title;
    private _footer;
    private _location;
    get index(): number;
    get background(): MapWidgetBackground;
    get title(): MapWidgetCaption;
    get footer(): MapWidgetCaption;
    abstract _type(): string;
    abstract isVertical(): boolean;
    isVisible(): boolean;
    getOrder(): number;
    _setGroup(g: MapWidgetGroup): void;
    getGroup(): MapWidgetGroup;
    getLocation(): ChartItemLocation;
    _setIndex(value: number): void;
    getDefaultDisplay(caption: MapWidgetCaption): MapWidgetCaptionDisplay;
    protected _doInit(op: MapWidgetOptions): void;
    protected _doPrepareRender(chart: IChart, op: OP): void;
}
declare abstract class MapSimpleWidget<OP extends MapSimpleWidgetOptions = MapSimpleWidgetOptions> extends MapWidget<OP> {
}
declare class MapWidgetGroup extends MapWidget<MapWidgetGroupOptions> {
    static defaults: MapWidgetGroupOptions;
    private _widgets;
    _clean(): void;
    _add(w: MapSimpleWidget): void;
    _sort(): void;
    getWidget(index: number): MapSimpleWidget<MapSimpleWidgetOptions>;
    _internalWidgets(): MapSimpleWidget<MapSimpleWidgetOptions>[];
    _type(): string;
    isVertical(): boolean;
}
declare abstract class MapWidgetCollection<T extends MapWidget = MapWidget> extends ChartItemCollection<T> {
    private _dic;
    protected _visibles: T[];
    getVisibles(loc: ChartItemLocation): T[];
    get(name: string | number, loc: ChartItemLocation): T;
    find(name: string | number, force: boolean): T;
    beforeRender(): void;
    prepareRender(): void;
    load(src: any): void;
    protected abstract _collectionProp(): string;
    protected abstract _createWidget(chart: IChart): T;
    protected _canEmpty(): boolean;
    private $_loadItem;
    protected _collectVisibles(): void;
}
declare class MapWidgetGroupCollection extends MapWidgetCollection<MapWidgetGroup> {
    protected _collectionProp(): string;
    protected _createWidget(chart: IChart): MapWidgetGroup;
    beforeRender(): void;
}
declare abstract class PositioanbleItem<OP extends PositionableItemOptions = PositionableItemOptions> extends ChartItem<OP> {
    static defaults: PositionableItemOptions;
    index: number;
    private _name;
    private _widthDim;
    private _heightDim;
    private _offsetXDim;
    private _offsetYDim;
    private _offsetX;
    private _offsetY;
    /**
     * 아이템 이름.<br/>
     * 동적으로 아이템을 다루기 위해서는 반드시 지정해야 한다.
     */
    get name(): string;
    getOffset(w: number, h: number): IPoint$1;
    getSize(wDomain: number, hDomain: number): ISize;
    getPosition(left: number, top: number, wDomain: number, hDomain: number, width: number, height: number): IPoint$1;
    protected _doApply(op: OP): void;
    protected abstract _getNamePrefix(): string;
    protected _getDefaultAlign(): string;
}
/**
 * @private
 */
declare abstract class PositionalItemCollection<T extends PositioanbleItem> extends ChartItemCollection<T> {
    protected _map: {
        [name: string]: T;
    };
    protected _visibles: T[];
    getVisibles(): T[];
    get(name: string | number): T;
    load(src: any, inBody: boolean): void;
    prepareRender(): void;
    protected abstract _loadItem(chart: IChart, src: any, index: number, inBody: boolean): T;
}
/**
 * color, bubble 스케일 base.<br/>
 */
declare abstract class ScaleBase<OP extends ScaleOptions = ScaleOptions> extends MapSimpleWidget<OP> {
    static defaults: ScaleOptions;
    protected _series: ISeries;
    get series(): ISeries<DataPoint>;
    protected _doPrepareRender(chart: IChart, op: OP): void;
    protected abstract _getScaledSeries(chart: IChart): ISeries;
}

/**
 * Annotation 모델들의 기반 클래스.<br/>
 * {@link options 옵션} 모델은 {@link https://realmap.co.kr/docs/api/options/AnnotationOptions AnnotationOptions}이고,
 * {@link https://realmap.co.kr/config 맵차트 설정}에서 {@link https://realmap.co.kr/config/config/annotation annotation} 항목으로 설정한다.
 * ```js
 * const config = {
 *      annotation: [{
 *          type: 'image',
 *          name: 'image1',
 *      }],
 * };
 * ```
 * 또, Chart.{@link https://realmap.co.kr/docs/api/classes/MapChart#getannotation getAnnotation}으로
 * 모델 객체를 가져올 수 있다.
 * ```js
 * const annotation = chart.getAnnotation('image1');
 * annotation.visible = false;
 * ```
 * {@link https://realmap.co.kr/guide/annotations Annotation 개요} 페이지를 참조한다.
 *
 */
declare abstract class Annotation<OP extends AnnotationOptions = AnnotationOptions> extends PositioanbleItem<OP> {
    inBody: boolean;
    static register(...clses: typeof Annotation<AnnotationOptions>[]): void;
    static readonly type: string;
    static defaults: AnnotationOptions;
    _anchorObj: ChartItem;
    constructor(chart: IChart, inBody: boolean);
    _type(): string;
    /**
     * 처음 표시될 때 실행될 에니메이션 설정 정보.
     */
    refresh(): void;
    protected _getNamePrefix(): string;
    protected _doLoad(op: OP, source: any): void;
    protected _doPrepareRender(chart: IChart, op: AnnotationOptions): void;
    protected _getDefaultAlign(): string;
}
/**
 * @private
 */
interface IAnnotationOwner {
    chart: IChart;
    anchorByName(name: string): ChartItem;
}
/**
 * @private
 */
declare class AnnotationCollection extends PositionalItemCollection<Annotation> {
    owner: IAnnotationOwner;
    constructor(owner: IAnnotationOwner);
    getAnnotation(name: string): Annotation;
    load(src: any, inBody: boolean): void;
    prepareRender(): void;
    protected _loadItem(chart: IChart, src: any, index: number, inBody: boolean): Annotation;
}

/**
 * 맵차트 로드 이후 호출되는 콜백의 매개변수로 사용된다.
 */
interface LoadCallbackArgs extends CommonCallbackArgs {
}
interface ChartInspection {
    series: SeriesInspection[];
}
/**
 * RealMap 라이브러리의 맵차트 모델.<br/>
 */
declare class MapChart {
    _obj: ChartObject;
    private _modelCallback;
    _loadCallback: (args: LoadCallbackArgs) => void;
    private _loaded;
    constructor(config?: ChartConfiguration, callback?: (model: ChartObject, oldModel: ChartObject) => void);
    /**
     *
     * 기본 시리즈 종류.\
     * 시리즈에 type을 지정하지 않으면 이 속성 type의 시리즈로 생성된다.
     *
     * @default 'bar'
     * @readonly
     */
    get type(): string;
    get body(): Body;
    get assets(): AssetCollection;
    /**
     * {@link setBaseMap}으로 지정되거나,
     * 기본적으로 첫번째 enabled인 맵 모델.<br />
     */
    get map(): MapModel;
    /**
     * 맵차트 타이틀 모델.
     */
    get title(): Title;
    /**
     * 맵차트 부제목 모델.
     */
    get subtitle(): Subtitle;
    /**
     * 맵차트에 설정된 첫번째 시리즈.<br/>
     * {@link https://realmap.co.kr/guide/series 시리즈 개요} 및
     * {@link https://realmap.co.kr/config/config/base/series 시리즈 설정}을 참조한다.
     */
    get series(): Series;
    /**
     * 맵차트에 설정된 첫번째 맵시리즈.<br/>
     * {@link https://realmap.co.kr/guide/series 시리즈 개요} 및
     * {@link https://realmap.co.kr/config/config/base/series 시리즈 설정}을 참조한다.
     */
    get firstMapSeries(): MapSeries;
    /**
     * 첫번째 legend.
     */
    get legend(): Legend;
    /**
     * Credits.
     */
    get credits(): Credits;
    /**
     * 첫번째 color scale.
     */
    get colorScale(): ColorScale;
    /**
     * 첫번째 bubble scale.
     */
    get bubbleScale(): BubbleScale;
    /**
     * 첫번째 widget group.
     */
    get widgetGroup(): MapWidgetGroup;
    /**
     * zoom panel.
     */
    get zoomPanel(): ZoomPanel;
    /**
     * drilldown panel.
     */
    get drilldownPanel(): DrilldownPanel;
    /**
     * 툴팁 모델.
     */
    get tooltip(): Tooltip;
    /**
     * 선택 모델.
     */
    get selection(): MapSelection;
    /**
     * 맵차트 내보내기 관련 설정 모델.
     */
    get exporter(): Exporter;
    /**
     * @deprecated use {@link general} instead.
     */
    get global(): ChartGeneral;
    get general(): ChartGeneral;
    /**
     * 맵차트 축의 기준이 되는 맵 모델을 지정한다.<br/>
     * 매개변수를 지정하지 않거나 잘못된 값을 넘기면 첫번째 enabled인 맵으로 설정된다.
     */
    setBaseMap(indexOrName?: number | string): void;
    /**
     * 이름이나 index에 해당하는 맵 객체를 리턴한다.<br/>
     *
     * @param name 맵 이름 또는 index.
     * @returns 맵 객체
     */
    getMap(name: string | number): MapModel;
    /**
     * 이름이나 index에 해당하는 시리즈 객체를 리턴한다.<br/>
     *
     * @param name 시리즈 이름 또는 index.
     * @returns 시리즈 객체
     */
    getSeries(name: string | number): Series;
    /**
     * 지정한 type에 해당하는 첫번째 시리즈 객체를 리턴한다.<br/>
     *
     * @param type 시리즈 타입
     * @returns 시리즈 객체
     */
    seriesByType(type: string): Series;
    /**
     * Annotation 이름에 해당하는 Annotation 객체를 리턴한다.<br/>
     *
     * @param name Annotation 이름
     * @returns Annotation 객체
     */
    getAnnotation(name: string): Annotation;
    /**
     * 기존 모델 설정을 모두 제거하고 초기화 한 후,
     * config로 전달된 설정에 따라 맵차트를 새로 구성한다.<br/>
     * 기존에 생성되었던 시리즈나 게이지들과 축들이 모두 제거되고 새로 생성된다.
     *
     * @param config 맵차트 설정 정보
     */
    load(config: ChartConfiguration, loadAnimation?: boolean, callback?: (args: LoadCallbackArgs) => void): MapChart;
    /**
     * load 메서드의 async 버전. <br/>
     *
     * 기존 모델 설정을 모두 제거하고 초기화 한 후,
     * config로 전달된 설정에 따라 맵차트를 새로 구성한다.<br/>
     * 기존에 생성되었던 시리즈나 게이지들과 축들이 모두 제거되고 새로 생성된다.
     *
     * 또한 map과 series 옵션에 url 속성이 있는 경우, 해당 url에서 데이터를 가져온 다음, <br/>
     * 각 옵션의 map 또는 data 속성을 채운다.
     *
     * @param config 맵차트 설정 정보
     */
    loadAsync(config: ChartConfiguration, loadAnimation?: boolean, callback?: () => void): Promise<MapChart>;
    /**
     * {@link load}와 달리 기존 모델을 유지하면서 맵차트 설정 일부를 반영한다.<br/>
     *
     * @param options 설정 객체
     * @param render true로 지정하면 다시 그리도록 요청한다.
     */
    updateOptions(options: ChartConfiguration, render?: boolean): void;
    /**
     * 현재 표시 중인 맵차트를 PNG, JPG 또는 SVG 벡터 이미지로 다운로드한다.
     *
     * ```js
     * chart.export({
     *      type: 'png',
     *      fileName: 'realmap'
     * })
     * ```
     *
     * @param options 내보내기 설정 객체
     */
    export(options: ExportOptions): void;
    /**
     * 다음 rendering frame을 기다리지 않고, 맵차트를 즉시 다시 그린다.<br/>
     * 맵차트 rendering 작업은 자원 소모가 많고 소용 시간도 적지 않으므로,
     * data나 여러 모델을 수정하는 경우 모든 작업이 완료된 후 한 번 호출해야 한다.
     * 가능하면 이 함수는 호출하지 않고
     * 맵차트 기본 동작(다음 frame에 이전 변경 사항들을 모아서 한 번 rendering)으로 실행되게 해야 한다.
     */
    render(now?: boolean): void;
    setParam(param: string, value: any, redraw?: boolean): void;
    /**
     * 시리즈를 추가한다.
     *
     * @param source 시리즈 설정 json.
     * @param animate 애니메이션 실행 여부.
     * @returns 생성된 시리즈 객체.
     */
    addSeries(source: any, animate?: boolean): Series;
    /**
     * 기존 시리즈를 제거한다.
     *
     * @param series 시리즈 이름이나 시리즈 객체.
     * @param animate 애니메이션 실행 여부.
     */
    removeSeries(series: string | Series, animate?: boolean): void;
    /**
     * 맵차트 설정의 map.points로 지정한 위치를 리턴한다.
     *
     * @param id 포인트 키.
     * @returns [lon, lat]
     */
    getPoint(id: string): MapCoord;
    seriesAt(index: number): Series;
    seriesByName(name: string): Series;
    inspect(): ChartInspection;
    /**
     * 픽셀 좌표를 경위도 좌표로 변환한다. <br/>
     * 픽셀 좌표는 맵차트 영역의 왼쪽 위 모서리를 (0,0)으로 하는 좌표계이다. <br/>
     * 차트가 아직 그려지지 않은 상태에서는 NaN이 담긴 배열을 반환하는 점에 주의.<br/>
     * LoadCallback이 호출된 시점부터 이용할 수 있다.
     *
     * @param x 픽셀 X 좌표
     * @param y 픽셀 Y 좌표
     * @returns 경위도 좌표 [lon, lat]
     */
    pointToMap(x: number, y: number): MapCoord;
    drilldown(series?: number | string | MapSeries, area?: string): Promise<void>;
    drillup(series?: number | string | MapSeries): Promise<void>;
    destroy(): void;
    isDestroying(): any;
}

/**
 */
declare class Globals {
    /**
     * RealMap 라이브러리의 버전 정보를 리턴한다.<br/>
     *
     * ```js
     * console.log(RealMap.getVersion()); // ex) '1.1.2'
     * ```
     *
     * @returns 버전 문자열
     */
    static getVersion(): string;
    /**
     * RealMap 라이브러리의 license key를 등록한다.
     */
    static setLicenseKey(key: string): void;
    /**
     * true로 지정하면 맵차트 요소별 디버그 경계를 표시한다.<br/>
     * 기본은 false 상태다.
     *
     * ```js
     * RealMap.setDebugging(true);
     * ```
     *
     * @param debug 디버깅 상태 표시 여부
     */
    static setDebugging(debug: boolean): void;
    /**
     * true로 지정하면 라이브러리 내부 메시지를 출력한다.<br/>
     *
     * @param logging 로그 메시지 표시 여부
     */
    static setLogging(logging: boolean): void;
    /**
     * 지도 위 두 지점간의 거리를 km 단위로 리턴한다.<br/>
     *
     * @param p1 지점 좌표 [위도, 경도]
     * @param p2 지점 좌표 [위도, 경도]
     * @returns km 단위의 거리
     */
    static getDistance(p1: [number, number], p2: [number, number]): number;
    /**
     * @private
     */
    static setGlobals(globals: any): void;
    /**
     * 맵차트 설정 모델을 기반으로 svg를 생성한 후,
     * 지정된 div 엘리먼트의 유일한 자식으로 포함시킨다.
     * div 전체 영역의 크기로 표시된다.
     *
     * ```js
     * const chart = RealMap.createChart(document, 'realmap', config);
     * ```
     *
     * @param doc
     * @param container 컨트롤이 생성되는 div 엘리먼트나 id
     * @param config 맵차트 모델 설정 JSON
     * @param animate 첫 로딩 animation을 실행한다.
     * @param callback 맵차트가 모두 로드되고 첫 렌더링이 완료된 후 호출되는 콜백 함수.
     * @returns 생성된 맵차트 객체
     */
    static createChart(doc: Document, container: string | HTMLDivElement, config: ChartConfiguration, animate?: boolean, callback?: (param: LoadCallbackArgs) => void): MapChart;
    /**
     * 지도 파일이나 데이터가 URL을 통해 제공되는 경우, 데이터를 모두 로드한 뒤 맵차트를 생성하도록 비동기 처리할 수 있다.
     *
     * ```js
     * const config = {
     *     map: [
     *         { url: '../map.json', }
     *     ],
     *     series: [{
     *         dataUrl: '../data.json',
     *     }]
     * };
     * const chart = await RealMap.createChartAsync(document, 'realmap', config);
     * ```
     *
     * @param doc
     * @param container 컨트롤이 생성되는 div 엘리먼트나 id
     * @param config 맵차트 모델 설정 JSON
     * @param animate 첫 로딩 animation을 실행한다.
     * @param callback 맵차트가 모두 로드되고 첫 렌더링이 완료된 후 호출되는 콜백 함수.
     * @returns 생성된 맵차트 객체
     */
    static createChartAsync(doc: Document, container: string | HTMLDivElement, config: ChartConfiguration, animate?: boolean, callback?: (param: LoadCallbackArgs) => void): Promise<MapChart>;
    /**
     * name에 해당하는 기본 제공 객체를 리턴한다.<br/>
     */
    static preset(name: string, info?: boolean | MapInsetDisplay): MapInset;
    private static loadChart;
}

/**
 * Default map chart tool.
 *
 * 1. map 바탕을 더블클릭하면 기본 scale로 되돌아간다.
 */
declare class MapTool extends RmTool<ChartControl> {
    private _clickElement;
    protected _doPointerDown(ev: PointerEvent): boolean;
    protected _doPointerMove(x: number, y: number, ev: PointerEvent): void;
    /**
     * 터치는 차트 밖을 탭해도 pointerMove가 발생하지 않아 툴팁·지역 강조가 그대로 남는다.
     * pointerup은 document에 걸려 있으므로 여기서 차트 바깥 탭을 잡는다. #585
     *
     * 데스크톱에서 마우스가 차트 밖으로 나갈 때와 같은 호출(pointerMoved에 바깥 요소를 넘김)을 쓴다.
     * 시리즈에 걸리지 않으므로 툴팁이 닫히고 hoverArea도 null이 돼 강조가 함께 풀린다.
     * hideTooltip()만 부르면 툴팁 없이 강조만 남는다.
     */
    protected _doPointerUp(ev: PointerEvent): boolean;
    protected _doClick(ev: PointerEvent): void;
    /**
     * 줌·드릴다운 패널의 버튼을 클릭했으면 실행하고 true를 리턴한다.
     */
    private $_clickPanelButton;
    /**
     * 범례 항목을 클릭했으면 표시 여부를 토글하고 true를 리턴한다.
     */
    private $_clickLegend;
    /**
     * 맵 영역 클릭을 처리한다. 시리즈·credits·드릴다운 패널을 순서대로 확인한 뒤 clickAction을 실행한다.
     */
    private $_clickBody;
    protected _doDblClick(ev: PointerEvent): void;
    protected _doWheel(ev: WheelEvent): boolean;
    protected _isPinchTarget(dom: Element): boolean;
    protected _doPinch(ratio: number, cx: number, cy: number): void;
    protected _getDragTracker(dom: Element, dx: number, dy: number, shift: boolean): DragTracker;
    private $_chart;
    private $_chartView;
    private $_drildown;
}

declare abstract class GroupElement extends RmElement {
    private static IGNORE_ATTRS;
    constructor(doc: Document, styleName?: string);
    protected _movable(): boolean;
    setAttr(attr: string, value: any): GroupElement;
    protected _doInitChildren(doc: Document): void;
}

interface IRectShape extends IRect {
    r?: number;
    rx?: number;
    ry?: number;
    rLeft?: number;
    rTop?: number;
    rRight?: number;
    rBottom?: number;
}
declare class RectElement extends RmElement {
    static create(doc: Document, styleName: string, x: number, y: number, width: number, height: number, r?: number): RectElement;
    private _rect;
    constructor(doc: Document, styleName?: string, rect?: IRectShape);
    /** rect */
    get rect(): IRectShape;
    set rect(value: IRectShape);
    setBounds(x: number, y: number, width: number, height: number, r?: number): RectElement;
    setRadius(value: number): void;
    protected _setBackgroundBorderRadius(value: number): void;
}

declare class ImageElement extends RmElement {
    private _dirty;
    private _bounds;
    /**
     * @IE11 not support SVGImageElement onload
     * 사이즈를 알기위해서 이벤트만 사용한다.
     */
    private _proxy;
    /**
     * @IE11 image proxy onload event
     */
    onloadProxy: () => void;
    constructor(doc: Document, styleName?: string, full?: boolean);
    /** image url */
    get url(): string;
    set url(value: string);
    setImage(url: string, width: number, height: number): boolean;
    bbox(): IRect;
}

/**
 * ChartText를 표시하는 텍스트 view.
 */
declare class LabelElement extends GroupElement {
    private _back;
    _outline: TextElement;
    _text: TextElement;
    _icon: ImageElement;
    private _model;
    private _box;
    constructor(doc: Document, styleName: string);
    setText(s: string): LabelElement;
    setModel(doc: Document, model: IconedText, icon: string, contrastTarget: Element): LabelElement;
    setContrast(target: Element): LabelElement;
    layout(): LabelElement;
    bbox(): IRect;
}

declare abstract class ChartElement<T extends ChartItem = ChartItem> extends RmElement {
    model: T;
    protected _op: ChartItemOptions;
    mw: number;
    mh: number;
    _debugRect: RectElement;
    constructor(doc: Document, styleName?: any);
    chart(): IChart;
    protected _prepareStyleOrClass(model: T): void;
    setModel(model: T): void;
    measure(doc: Document, model: T, hintWidth: number, hintHeight: number): ISize;
    layout(param?: any): ChartElement<ChartItem>;
    resizeByMeasured(): ChartElement<ChartItem>;
    protected _getDebugRect(): IRect;
    protected _doMeasure(doc: Document, model: T, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(param: any): void;
    protected _invalidate(): void;
}
declare abstract class BoundableElement<T extends ChartItem = ChartItem> extends ChartElement<T> {
    protected _background: RectElement;
    protected _margins: Sides;
    protected _paddings: Sides;
    constructor(doc: Document, styleName: string, backStyle: string);
    protected _getDebugRect(): IRect;
    measure(doc: Document, model: T, hintWidth: number, hintHeight: number): ISize;
    layout(param?: any): ChartElement<ChartItem>;
    protected abstract _setBackgroundStyle(back: RectElement): void;
    protected _marginable(): boolean;
    protected _resetBackBounds(): boolean;
    protected _getBackOffset(): number;
    protected _deflatePaddings(size: ISize): void;
}
/**
 * @private
 */
declare abstract class SectionView extends GroupElement {
    protected _inverted: boolean;
    mw: number;
    mh: number;
    measure(doc: Document, chart: IChart, hintWidth: number, hintHeight: number): ISize;
    resizeByMeasured(): SectionView;
    layout(param?: any): SectionView;
    locateInner(width: number, height: number, param?: any): SectionView;
    protected abstract _doMeasure(doc: Document, chart: IChart, hintWidth: number, hintHeight: number): ISize;
    protected abstract _doLayout(param?: any): void;
    protected abstract _doLocateInner(width: number, height: number, param?: any): void;
}
declare class MapWidgetTitleView extends LabelElement {
    constructor(doc: Document);
}
declare class MapWidgetFooterView extends LabelElement {
    constructor(doc: Document);
}
declare abstract class MapWidgetView<T extends MapWidget = MapWidget> extends BoundableElement<T> {
    protected _titleView: MapWidgetTitleView;
    protected _footerView: MapWidgetFooterView;
    protected _inTitle: boolean;
    protected _inFooter: boolean;
    protected _rTitle: IRect;
    protected _rFooter: IRect;
    protected _gapFooter: number;
    constructor(doc: Document, styleName: string, backStyle: string);
    protected _setBackgroundStyle(back: RectElement): void;
    private $_layoutCaption;
    protected _checkTitle(doc: Document): boolean;
    protected _checkFooter(doc: Document): boolean;
}

interface IAnnotationAnchorOwner {
    getAnnotationAnchor(model: any): RmElement;
}
/**
 * [주의] clipping하기 위해 translate를 background와 내부 view에 설정한다.
 */
declare abstract class AnnotationView<T extends Annotation = Annotation> extends BoundableElement<T> {
    static readonly CLASS_NAME: string;
    static register(...clses: [typeof Annotation<AnnotationOptions>, typeof AnnotationView<Annotation>][]): void;
    protected _op: AnnotationOptions;
    constructor(doc: Document, styleName: string);
    update(owner: IAnnotationAnchorOwner, hintWidth: number, hintHeight: number): void;
    _layoutView(owner: IAnnotationAnchorOwner, x: number, y: number, w: number, h: number): void;
    private _posByAnchor;
    protected _marginable(): boolean;
    protected _resetBackBounds(): boolean;
    protected _setBackgroundStyle(back: RectElement): void;
    protected _doLayout(p: IPoint$1): void;
}

/**
 * @private
 */
declare class ColorScaleView extends MapWidgetView<ColorScale> {
    static readonly SCALE_CLASS = "rm-color-scale";
    static readonly SCALE_FILL = "rm-color-scale-fill";
    private static readonly HORZ_FILL;
    private static readonly HORZ_FILL_I;
    private static readonly VERT_FILL;
    private static readonly VERT_FILL_I;
    private _scaleLayer;
    private _boxLayer;
    private _boxes;
    private _splitLayer;
    private _splits;
    private _marker;
    private _markerLabel;
    private _tickLineLayer;
    private _tickLabelLayer;
    private _nullLayer;
    private _tickLines;
    private _tickLabels;
    private _nullBar;
    private _nullLabel;
    private _vertical;
    private _reversed;
    private _inverted;
    private _fills;
    private _nullSize;
    private _markerSize;
    private _tickLen;
    private _tickLabelSize;
    private _rScale;
    private _wBar;
    private _hBar;
    private _value;
    private _stepCount;
    private _wSave;
    private _hSave;
    constructor(doc: Document);
    setValue(v: number): void;
    protected _doMeasure(doc: Document, model: ColorScale, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(): void;
    private $_getFillId;
    private $_getFillUrl;
    private $_createGradient;
    private $_setDir;
    private $_fillStops;
    private $_prepareBars;
    private $_prepareSplits;
    private $_prepareTickLines;
    private $_prepareTickLabels;
    private $_prepareMarker;
    private $_prepareNull;
    private $_layoutSplits;
    private $_layoutTickLines;
    private $_resetMarker;
    private $_layoutBar;
}

type Visitor<T extends RmElement> = (element: T, index?: number, count?: number) => void;
/** @private */
declare class ElementPool<T extends RmElement> extends RObject {
    private _reversed;
    removeDelay: number;
    private _owner;
    private _creator;
    private _pool;
    private _views;
    private _styleName;
    constructor(owner: RmElement, creator: {
        new (doc: Document, styleName?: string): T;
    }, styleName?: string, removeDelay?: number);
    protected _doDispose(): void;
    get owner(): RmElement;
    /**
     * reversed.
     */
    get reversed(): boolean;
    set reversed(value: boolean);
    get isEmpty(): boolean;
    get count(): number;
    get first(): T;
    get last(): T;
    get(index: number): T;
    getAll(): T[];
    getRange(start: number, end: number): T[];
    elementOf(dom: Element): T;
    prepare(count: number, visitor?: Visitor<T>, initor?: Visitor<T>): ElementPool<T>;
    borrow(): T;
    free(element: T, removeDelay?: number): void;
    freeAll(elements: T[], removeDelay?: number): void;
    clear(): void;
    forEach(visitor: (v: T, i?: number, count?: number) => void): void;
    visit(visitor: (v: T, i: number, count: number) => boolean): boolean;
    find(visitor: (v: T) => boolean): T;
    sort(compare: (v1: T, v2: T) => number): ElementPool<T>;
    map(callback: (v: T) => any): any[];
    setRemoveDelay(v: number): ElementPool<T>;
    removeLater(v: RmElement, duration: number): void;
    private $_create;
    _getElementId(view: T): void;
}

declare class PathBuilder {
    private _path;
    clear(): PathBuilder;
    end(close?: boolean): string;
    close(): string;
    move(x: number | IPoint$1, y?: number): PathBuilder;
    moveBy(x: number | IPoint$1, y?: number): PathBuilder;
    movep(x: number | IPoint$1, y?: number): PathBuilder;
    line(x: number | IPoint$1, y?: number): PathBuilder;
    linep(x: number | IPoint$1, y?: number): PathBuilder;
    curve(cx1: number, cy1: number, cx2: number, cy2: number, x: number, y: number): PathBuilder;
    q(x1: number, y1: number, x2: number, y2: number): PathBuilder;
    rect(x: number, y: number, width: number, height: number): PathBuilder;
    lines(...pts: (number | IPoint$1)[]): PathBuilder;
    polygon(...pts: (number | IPoint$1)[]): PathBuilder;
    circle(cx: number, cy: number, rd: number): PathBuilder;
}

interface ILine {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
}
declare class LineElement extends PathElement {
    constructor(doc: Document, styleName?: string, line?: ILine);
    setLine(x1: ILine | number, y1?: number, x2?: number, y2?: number): void;
    setVLine(x: number, y1: number, y2: number): void;
    setVLineC(x: number, y1: number, y2: number): void;
    setHLine(y: number, x1: number, x2: number): void;
    setHLineC(y: number, x1: number, x2: number): void;
}
declare class PolyLineElement extends PathElement {
    constructor(doc: Document, styleName?: string, lines?: (number | IPoint$1)[], curved?: boolean);
    setLines(pts: (number | MapCoord | IPoint$1)[], curved: boolean): void;
}

interface IPointView {
    point: DataPoint;
    tooltipColor(): string;
    tooltipPos?(): IPoint$1;
    saveStyles(): void;
    restoreStyles(): void;
}
declare class PointViewPool<T extends RmElement & IPointView> extends ElementPool<T> {
    constructor(owner: RmElement, creator: {
        new (doc: Document, group?: boolean): T;
    }, className?: string);
    _getElementId(view: T): number;
}
declare class PointLabelView extends LabelElement {
    point: DataPoint;
    constructor(doc: Document);
}
declare class PointLabelContainer extends LayerElement {
    private _labels;
    private _maps;
    constructor(doc: Document, styleName: string);
    isEmpty(): boolean;
    private $_prepareLabel;
    prepare(doc: Document, owner: SeriesView): void;
    /**
     * point에 연결된 라벨 뷰를 찾는다. 없으면 undefined를 리턴한다.
     *
     * point가 없는 경우도 "라벨 없음"으로 처리한다. 맵 시리즈에서 데이터가 연결되지 않은 area는
     * 정상 상태(null area)라서 point 없이 조회되는 일이 실제로 생긴다. 라벨을 못 찾는 것과
     * 같은 상황인데 여기서 예외를 던지면 렌더 전체가 중단된다.
     */
    get(point: DataPoint, index: number): PointLabelView;
    removePoint(p: DataPoint, delay: number): void;
}
declare class PointCalloutView extends GroupElement {
    private _line;
    private _dummy;
    private _anchor;
    point: DataPoint;
    index: number;
    constructor(doc: Document);
    render(model: DataPointCallout, point: DataPoint, coords: number[], pointColor: string): this;
    setColor(color: string): this;
}
declare class CalloutMaskView extends MaskElement {
    private _back;
    private _mask;
    constructor(doc: Document);
    setBackground(r: IRect): this;
    setCircle(cx: number, cy: number, rd: number): this;
    setRects(r1: IRect, r2?: IRect): this;
}
declare class PointCalloutContainer extends LayerElement {
    private _maskLayer;
    private _masks;
    private _callouts;
    private _map;
    constructor(doc: Document, styleName: string);
    isEmpty(): boolean;
    clear(): void;
    prepare(doc: Document, owner: SeriesView): void;
    /**
     * point에 연결된 콜아웃 뷰를 찾는다. 없으면 undefined를 리턴한다.
     *
     * point가 없는 경우도 "콜아웃 없음"으로 처리한다. 라벨 컨테이너의 get()과 같은 규칙이다.
     */
    get(point: DataPoint): PointCalloutView;
    setMask(cv: PointCalloutView, pts: number[]): CalloutMaskView;
}
declare abstract class PointElement<T extends DataPoint = DataPoint> extends PathElementEx implements IPointView {
    _static: boolean;
    point: T;
    constructor(doc: Document, group?: boolean);
    tooltipColor(): string;
    /**
     * 데이터포인트 라벨과 view 표시 동기화 #361
     * - point가 보이지 않으면 label도 숨긴다.
     */
    setVisible(value: boolean): boolean;
    protected _drawSpline(pts: {
        x: number;
        y: number;
    }[], start: number, end: number, sb: PathBuilder): void;
    protected _checkStatic(): boolean;
    protected _clearScale(view: RmElement): void;
    protected _aniScale(view: RmElement, seriesVr: number): void;
}
declare class PointContainer extends LayerElement {
}
type LabelLayoutInfo = {
    inverted: boolean;
    reversed: boolean;
    pointView: RmElement;
    x: number;
    y: number;
    hPoint: number;
    wPoint: number;
    labelView: PointLabelView;
    labelPos: PointLabelPosition;
    labelOff: number;
};
type PointPositioner = (x: number, y: number, wPoint: number, hPoint: number) => IPoint$1;
type LabelPositioner = (x: number, y: number, rLabel: IRect, wPoint: number, hPoint: number, off: number) => IPoint$1;
/**
 * @private
 *
 * View base for map chart series.
 */
declare abstract class SeriesView<T extends Series = Series> extends ChartElement<T> {
    static readonly POINT_CLASS = "rm-point";
    static readonly DATA_HOVER = "hover";
    static readonly DATA_UNHOVER = "unhover";
    static readonly LEGEND_MARKER = "rm-legend-item-marker";
    static register(...clses: [typeof Series<SeriesOptions>, typeof SeriesView<Series>][]): void;
    static seriesOf(pv: RmElement): SeriesView;
    private static _createDrawers;
    private static _drawers;
    static getDrawer(shape: string): ShapeDrawer;
    protected _pointPositioner: {
        [pos: string]: PointPositioner;
    };
    protected _labelPositioner: {
        [pos: string]: LabelPositioner;
    };
    protected _scroll: number;
    _h1: number;
    _h2: number;
    private _defs;
    _pointLayer: LayerElement;
    _pointContainer: PointContainer;
    _calloutContainer: PointCalloutContainer;
    _labelContainer: PointLabelContainer;
    protected _visPoints: DataPoint[];
    private _growRate;
    private _posRate;
    protected _prevRate: number;
    _animations: Animation[];
    _hoverPts: IPointView[];
    protected _wBody: number;
    protected _hBody: number;
    protected _transInfo: IBodyTransform;
    protected _inRegion: boolean;
    protected _dirty: boolean;
    _scale: number;
    protected _scaler: (coord: MapCoord) => MapCoord;
    _aniOpacity: number;
    constructor(doc: Document, className: string, needLabels: boolean, useDefs: boolean);
    $_setInRegion(): this;
    needClip(): boolean;
    /**
     * bounds 기반 clip을 반환한다. 기본 구현은 BodyView에서 전달된 clip(투영 클리핑)을 그대로 반환한다.
     * MapSeriesView에서 오버라이드하여 각 맵 시리즈의 bounds에 맞는 clip을 반환한다.
     */
    resolveBoundsClip(fallback: ClipElement | null, _scale: number, _tx: number, _ty: number, _prj: MapProjection): ClipElement | null;
    secondLabelContainer(): LayerElement;
    protected _setCalcedColor(model: T, dom: Element): void;
    protected _setModelColor(color: string): void;
    prepareModel(doc: Document, model: T, scroll: number): void;
    prepareLayout(doc: Document): void;
    render(wBody: number, hBody: number, transInfo: IBodyTransform): void;
    reset(): void;
    isPointLabelVisible(p: DataPoint): boolean;
    isPointCalloutVisible(p: DataPoint): boolean;
    setScaler(scaler: (coord: MapCoord) => MapCoord): void;
    getPointView(dom: Element, x: number, y: number, hitTesting: boolean): IPointView;
    pointerMoved(x: number, y: number, dom: Element): boolean;
    defaultAnimation(): string;
    setGrowRate(rate: number): void;
    setPosRate(rate: number): void;
    setPrevRate(rate: number): void;
    pointByDom(elt: Element, p: IPoint$1): IPointView;
    click(elt: Element, p: IPoint$1): void;
    protected _clusterOfDom(elt: Element): PointClusterView;
    select(elt: Element, p: IPoint$1, clear: boolean): void;
    /**
     * clear를 지정하면 이미 선택된 데이터포인트가 아닐 때 다른 선택들을 해제한다.
     */
    toggleSelect(elt: Element, p: IPoint$1, clear?: boolean): void;
    runPointAddAnimation(p: DataPoint): void;
    /**
     * 데이터포인트와 연결된 라벨 표시/숨김 처리 #361
     */
    setPointLabelVisible(point: DataPoint, visible: boolean): void;
    zoomChanged(zoom: number, oldZoom: number): void;
    protected abstract _doPrepeare(doc: Document, model: T, dataDirty: boolean): void;
    protected abstract _doRender(width: number, height: number): void;
    protected abstract _doReset(): void;
    protected get growRate(): number;
    protected _createLabelContainer(doc: Document, className: string): PointLabelContainer;
    _animating(): boolean;
    protected _addDef(elt: SVGElement, name: string): SVGElement;
    protected _getPointPositioner(pos: PointViewPosition, autoPos: string): PointPositioner;
    protected _getLabelPositioner(pos: PointLabelPosition, autoPos: string): LabelPositioner;
    protected _labelViews(): PointLabelContainer;
    protected _calloutViews(): PointCalloutContainer;
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _collectVisPoints(model: T): DataPoint[];
    protected _setPointColor(v: RmElement, color: string): void;
    protected _setPointStyle(v: RmElement, model: T, p: DataPoint): void;
    protected _doPointerMoved(x: number, y: number, dom: Element): boolean;
    protected _getGrowRate(): number;
    protected _doViewRateChanged(rate: number): void;
    protected _doPosRateChanged(rate: number): void;
    protected _doPrevRateChanged(rate: number): void;
    protected _getShowAnimation(): RmAnimation;
    protected _runShowEffect(firstTime: boolean): void;
    _animationStarted(ani: Animation): void;
    _animationFinished(ani: Animation): void;
    protected _layoutLabel(lv: PointLabelView, parent: Element): PointLabelView;
    protected _legendColorProp(): string;
    protected _doPointClicked(view: IPointView): void;
}
declare class PointClusterView extends RmElement {
    private static readonly CLASS_NAME;
    static isClusterView(dom: Element): Element;
    private _shape;
    private _label;
    _cluster: ICluster;
    constructor(doc: Document);
    setCluster(cluster: ICluster): void;
    render(rd: number, color: string): void;
}
declare abstract class MarkerSeriesPointView<T extends MarkerSeriesPoint = MarkerSeriesPoint> extends PointElement<T> implements IPointView {
    beginHover(series: SeriesView, focused: boolean): void;
    setHoverRate(series: SeriesView, focused: boolean, rate: number): void;
    endHover(series: SeriesView, focused: boolean): void;
    distance(rd: number, x: number, y: number): number;
    prepare(): void;
}
declare abstract class MarkerSeriesView<T extends MarkerSeries = MarkerSeries> extends SeriesView<T> {
    protected _markers: PointViewPool<MarkerSeriesPointView<MarkerSeriesPoint>>;
    constructor(doc: Document, styleName: string, needLabels: boolean, useDefs: boolean);
    protected abstract _createMarkers(container: RmElement): PointViewPool<MarkerSeriesPointView<MarkerSeriesPoint>>;
    getHintDistance(): number;
    protected _getPointPool(): PointViewPool<PointElement>;
}
declare abstract class SparkSeriesView<T extends SparkSeries = SparkSeries> extends SeriesView<T> {
    protected _getSeriesExt(series: T, points: SparkSeriesPoint[]): {
        min: number;
        max: number;
        minSize: number;
    };
}
declare abstract class OrthogonalSparkSeriesView<T extends OrthogonalSparkSeries = OrthogonalSparkSeries> extends SparkSeriesView<T> {
    protected _ext: {
        inverted: boolean;
        pad: number;
        width: number;
        height: number;
        minSize: number;
        min: number;
        max: number;
    };
    protected _getSeriesExt(series: T, points: SparkSeriesPoint[]): {
        min: number;
        max: number;
        minSize: number;
    };
    protected _doPrepeare(doc: Document, model: T, dataDirty: boolean): void;
}
declare abstract class GaugePointView<T extends GaugePoint = GaugePoint> extends PointElement<T> implements IPointView {
    constructor(doc: Document);
    beginHover(series: SeriesView, focused: boolean): void;
    setHoverRate(series: SeriesView, focused: boolean, rate: number): void;
    endHover(series: SeriesView, focused: boolean): void;
    distance(rd: number, x: number, y: number): number;
}
declare abstract class GaugeView<T extends Gauge = Gauge> extends SeriesView<T> {
    protected _gauges: PointViewPool<GaugePointView>;
    constructor(doc: Document, styleName: string, needLabels: boolean, useDefs: boolean);
    protected abstract _createGauges(container: RmElement): PointViewPool<GaugePointView>;
    protected _getPointPool(): PointViewPool<PointElement>;
}

declare class AreaView extends PointElement<MapSeriesPoint> {
    static idClass(area: MapArea): string;
    static getId(dom: Element): string;
    constructor(doc: Document);
    model: MapArea;
    strokeView: AreaStrokeView;
    setModel(model: MapArea): void;
    render(nullStyle: SVGStyleOrClass, dummyStyle: SVGStyleOrClass, selectStyle: SVGStyleOrClass, pointContainer: PointContainer, dirty: boolean, isHovering: boolean): void;
    reset(): void;
}
declare class AreaStrokeView extends PathElement {
    private _owner;
    private _area;
    constructor(doc: Document, owner: PointContainer);
    render(targetArea: AreaView, style: SVGStyleOrClass): void;
    refresh(): void;
    attachToOwner(): void;
    detachFromOwner(): void;
    protected _doInitStyles(): void;
    private copyPath;
}
/**
 * View for map series.
 */
declare class MapSeriesView extends SeriesView<MapSeries> {
    private static readonly DefaultHoverFilter;
    private static readonly DefaultHoverStrokeWidth;
    private _hoverArea;
    private _boundsClip;
    private _internalContainer;
    private _externalContainer;
    private _borderContainer;
    private _insetLabelContainer;
    private _areaPool;
    private _areas;
    private _internalPool;
    private _externalPool;
    private _borderPool;
    private _insetPool;
    private _insets;
    private _hoverStrokeView;
    constructor(doc: Document);
    get hoverArea(): AreaView;
    set hoverArea(value: AreaView);
    get insets(): MapInset[];
    areaOfDom(dom: Element): AreaView;
    getIntersectedAreas(rect: SVGGeometryElement): AreaView[];
    needClip(): boolean;
    /**
     * 이 시리즈의 맵에 bounds가 설정된 경우, 해당 bounds 기준의 SVG clip-path를 생성해 반환한다.
     * bounds가 없거나 세계 전체 범위인 경우 BodyView에서 전달된 투영 clip(fallback)을 그대로 반환한다.
     */
    resolveBoundsClip(fallback: ClipElement | null, scale: number, tx: number, ty: number, prj: MapProjection): ClipElement | null;
    secondLabelContainer(): LayerElement;
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _setModelColor(color: string): void;
    protected _setPointColor(v: RmElement, color: string): void;
    prepareModel(doc: Document, model: MapSeries, scroll: number): void;
    protected _doPrepeare(doc: Document, model: MapSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _doPointerMoved(x: number, y: number, dom: Element): boolean;
    protected _doPointClicked(view: IPointView): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    onScrollStart(): void;
    onScrollEnd(): void;
    onRotationStart(): void;
    onRotationEnd(): void;
    private $_layoutAreas;
    private getPointLabel;
    private setHoverStyle;
}

interface IBodyViewOwner {
    tx: number;
    ty: number;
    showTooltip(series: Series, pv: IPointView, map: RmElement, p: IPoint$1): void;
    hideTooltip(): void;
    tooltipVisible(): boolean;
    getScaleView(scale: ColorScale): ColorScaleView;
}
/**
 * @private
 */
declare class BodyView extends ChartElement<Body> implements IAnnotationAnchorOwner {
    private _owner;
    private _back;
    private _mapBack;
    private _contentLayer;
    private _axisGuideContainer;
    private _seriesContainer;
    private _annotationContainer;
    private _frontAnnotationContainer;
    _annotationViews: AnnotationView<Annotation>[];
    private _annotationMap;
    private _annotations;
    private _frontAxisGuideContainer;
    private _feedbackContainer;
    private _crosshairView;
    private _clip;
    private _clipMap;
    private _requestShow;
    private _transformInfo;
    private _mousePos;
    private _prevPrj;
    private _zoom;
    constructor(doc: Document, owner: IBodyViewOwner);
    getAnnotationAnchor(model: any): RmElement;
    get firstMap(): MapSeriesView;
    get transformInfo(): IBodyTransform;
    get isProjectionChanged(): boolean;
    getSeries(series: Series): SeriesView<Series<SeriesOptions>>;
    prepare(doc: Document, model: Body): void;
    afterRender(): void;
    clean(): void;
    reset(): void;
    getTooltipPos(): IPoint$1;
    pointerMoved(x: number, y: number, target: EventTarget): boolean;
    seriesByDom(dom: Element): SeriesView;
    showSeries(series: Series): void;
    hideSeries(series: Series): void;
    getBackBounds(): DOMRect;
    addFeedback(view: RmElement): void;
    zoomChanged(zoom: number, oldZoom: number): void;
    onScrollStart(): void;
    onScrollEnd(): void;
    onRotationStart(): void;
    onRotationEnd(): void;
    protected _doMeasure(doc: Document, model: Body, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(param: any): void;
    /**
     * 클릭된 픽셀 좌표(x, y)를 경위도 좌표로 변환한다.<br/>
     * 픽셀 좌표는 BodyView의 Dom 노드의 오프셋 좌표여야 한다.
     *
     * ```ts
     * // example
     * // 객체 e는 bodyView.dom의 클릭 이벤트일 때,
     * const coord = this.pointToMap({
     *     x: e.offsetX,
     *     y: e.offsetY,
     * });
     * ```
     *
     * @param point 픽셀 좌표
     * @returns 경위도 좌표
     */
    mouseToMap(point: IPoint$1, ignoreScroll?: boolean, ignorePadding?: boolean): MapCoord;
    boundsToMap(r: IRect, ignoreScroll?: boolean, ignorePadding?: boolean): {
        from: MapCoord;
        to: MapCoord;
    };
    pointToMap(x: number, y: number, ignoreScroll: boolean): MapCoord;
    mapToPoint(coord: MapCoord): IPoint$1;
    boundsByCoord(coordFrom: MapCoord, coordTo: MapCoord): {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    private $_prepareSeries;
    private $_prepareLayoutSeries;
    private $_prepareAnnotations;
    private $_layoutAnnotations;
    private $_layoutAxisGuides;
    /**
     * @private
     *
     * 스크롤 상황인 경우에 한해 클리핑 적용.
     *
     * 단, 프로젝션에서 클리핑을 지원해야 적용할 수 있다.
     * prj.isClipping() 반환값이 true여야 하며, prj.getClipBounds()는 클리핑 영역을 반환해야 한다.
     *
     * 프로젝션이 변경된 경우, 클리핑 영역을 갱신한다.
     */
    private $_layoutClip;
}

declare class TitleView extends BoundableElement<Title> {
    isSub: boolean;
    static readonly TITLE_CLASS = "rm-title";
    static readonly SUBTITLE_CLASS = "rm-subtitle";
    private _textView;
    private _richText;
    constructor(doc: Document, isSub: boolean);
    protected _marginable(): boolean;
    protected _setBackgroundStyle(back: RectElement): void;
    protected _doMeasure(doc: Document, model: Title, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(): void;
}

declare class ButtonElement extends RmElement {
    static readonly STYLE = "rm-button";
    static readonly BACK_STYLE = "rm-button-background";
    static readonly HIT_STYLE = "rm-button-hit";
    /**
     * 손가락 기준 목표 히트 크기. 제한이 없을 때 여기까지 넓힌다.
     * setHitLimit()으로 한계를 받으면 그보다 작아질 수 있어서 최소 보장값은 아니다.
     */
    static readonly HIT_SIZE = 44;
    private _hit;
    private _hitLimitW;
    private _hitLimitH;
    private _back;
    private _textView;
    constructor(doc: Document, text: string, style?: string);
    get text(): string;
    setText(text: string): void;
    /**
     * 히트 영역을 이 크기까지 넓힌다(px). HIT_SIZE를 넘지는 않는다.
     * 0이면 넓히지 않고 보이는 배경 크기를 그대로 쓴다.
     *
     * [주의] 기본이 '넓히지 않음'이어야 한다. 넓힌 히트 사각형은 getBBox()에 포함되므로,
     * 버튼의 bbox로 크기를 재는 패널(DrilldownPanelView)이 실제보다 큰 값을 얻어
     * 정렬 기준이 오른쪽·가운데일 때 패널이 밀린다. 넓히려는 쪽이 직접 요청하고,
     * 그때 자기 배치를 넘지 않는 한계까지만 준다. #585
     */
    setHitLimit(width: number, height: number): void;
    layout(sz?: ISize, style?: SVGStyleOrClass): void;
    click(): boolean;
    /**
     * 보이는 배경을 감싸는 투명 사각형을 배치한다. 배경보다 크면 중앙을 맞춰 넘치게 둔다.
     * setHitLimit()으로 한계를 받았으면 그 이상 넓히지 않는다.
     */
    private $_layoutHit;
    /** 보이는 크기보다는 작지 않으면서, 요청한 한계와 HIT_SIZE는 넘지 않는 크기. */
    private $_hitSize;
    setVisible(value: boolean): boolean;
}

declare class PanelButtonView extends ButtonElement {
    callback: () => void;
    constructor(doc: Document, text: string, callback: () => void);
    click(): boolean;
}
declare abstract class BodyPanelView<T extends BodyPanel = BodyPanel> extends ChartElement<T> {
}

declare class DrilldownPanelView extends BodyPanelView<DrilldownPanel> {
    private _btnBack;
    private _textViews;
    private _seperators;
    private _history;
    constructor(doc: Document);
    getButton(dom: Element): PanelButtonView;
    click(dom: Element): boolean;
    protected _doMeasure(doc: Document, model: DrilldownPanel, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(param: any): void;
}

/**
 * @private
 */
declare class CreditsView extends ChartElement<Credits> {
    private _textView;
    constructor(doc: Document);
    click(dom: Element): void;
    locateInner(credit: Credits, rBody: Rectangle): {
        x: number;
        y: number;
    };
    locateOuter(credit: Credits, width: number, height: number): {
        x: number;
        y: number;
    };
    protected _doMeasure(doc: Document, model: Credits, intWidth: number, hintHeight: number): ISize;
}
/**
 * @private
 */
declare class ChartView extends LayerElement implements IAnnotationAnchorOwner {
    private _model;
    private _annotationContainer;
    private _bodyView;
    private _titleSectionView;
    private _widgetLayer;
    private _widgetMap;
    private _frontAnnotationContainer;
    private _mapRegionContainer;
    private _annotationViews;
    private _annotationMap;
    private _annotations;
    private _mapRegionViews;
    private _mapRegionMap;
    private _mapRegions;
    private _zoomPanelView;
    private _drilldownPanelView;
    private _mapScaleView;
    private _creditView;
    private _tooltipView;
    constructor(doc: Document);
    getAnnotationAnchor(model: any): RmElement;
    titleView(): TitleView;
    subtitleView(): TitleView;
    bodyView(): BodyView;
    drilldownPanelView(): DrilldownPanelView;
    getWidgetViews(loc: ChartItemLocation, widgets: MapWidget[]): MapWidgetView<MapWidget<MapWidgetOptions>>[];
    measure(doc: Document, m: ChartObject, hintWidth: number, hintHeight: number): void;
    layout(): void;
    showTooltip(series: Series, pv: IPointView, map: BodyView, p: IPoint$1): void;
    tooltipVisible(): boolean;
    hideTooltip(): void;
    clean(): void;
    reset(): void;
    legendByDom(dom: Element): LegendItem;
    seriesByDom(dom: Element): SeriesView;
    creditByDom(dom: Element): CreditsView;
    getWidgetView(widget: MapWidget): MapWidgetView<MapWidget<MapWidgetOptions>>;
    getScaleView(scale: ColorScale): ColorScaleView;
    pointerMoved(x: number, y: number, target: EventTarget): void;
    click(ev: PointerEvent, elt: Element, sv: SeriesView): void;
    getButton(dom: Element): ButtonElement;
    buttonClicked(button: ButtonElement): void;
    updateAnnotation(anno: Annotation): void;
    zoomChanged(zoom: number, oldZoom: number): void;
    isAnimating(): void;
    onScrollStart(): void;
    onRotationStart(): void;
    private $_prepareAnnotations;
    private $_layoutAnnotations;
    private $_prepareMapRegions;
    private $_layoutMapRegions;
    private $_layoutPanel;
}

/**
 * @private
 */
declare class ChartControl extends RmControl implements IMapChartEvents {
    private static $_conf;
    private _chart;
    private _chartView;
    private _isLoading;
    private _errorView;
    constructor(doc: Document, container: string | HTMLDivElement);
    protected _createChartView(doc: Document): ChartView;
    protected _doPointerDown(event: PointerEvent): boolean;
    onModelChanged(chart: ChartObject, item: ChartItem<ChartItemOptions>, tag: any): void;
    onDataChanged(chart: ChartObject, series: Series): void;
    onProjectionChanged(chart: ChartObject, projection: MapProjection): void;
    onMapChanged(chart: ChartObject, map: MapModel): void;
    onZoomChanged(chart: ChartObject, zoom: number, oldZoom: number): void;
    onPointAdded(chart: ChartObject, series: Series, p: DataPoint, animate: boolean): void;
    onRequestRender(chart: ChartObject, now: boolean): void;
    onRequestShowSeries(chart: ChartObject, series: Series, visible: boolean): void;
    onExportRequest(chart: ChartObject, options: ExportOptions): void;
    onPointToMap(chart: ChartObject, x: number, y: number): MapCoord;
    /**
     * chart model.
     */
    get chart(): MapChart;
    set chart(value: MapChart);
    get model(): ChartObject;
    changeModel(model: ChartObject, oldModel: ChartObject): void;
    chartView(): ChartView;
    refresh(): void;
    use(_module: any): void;
    setLoading(loading: boolean): void;
    showErrorView(message?: string): void;
    hideErrorView(): void;
    protected _creatDefaultTool(): MapTool;
    protected _doBeforeRender(root: RmElement): void;
    protected _doRender(bounds: IRect): void;
    protected _doAfterRender(): void;
    /**
     * 지도가 실제로 소비하는 축만 브라우저에서 빼앗는다. #585
     *
     * 지도가 다 가져가면 브라우저가 스크롤을 시작하지 않으므로 android에서 드래그 도중
     * pointercancel이 뜨지 않고, 소비하지 않는 축은 열어두므로 임베드된 지도 위에서
     * 스와이프해도 페이지가 정상적으로 스크롤된다.
     */
    protected _updateTouchAction(): void;
    isLoading(): boolean;
    protected _doWheel(ev: WheelEvent): boolean;
    /**
     * 지도가 드래그로 소비하는 축을 touch-action 값으로 바꾼다.
     * 축 판정은 MapTool._getDragTracker와 같아야 하므로 ChartObject.dragAxes()에 모아뒀다.
     */
    private $_calcTouchAction;
    private $_loadModules;
    private $_export;
}

declare class ExternalModuleManager {
    private static instance;
    static ModuleNames: {
        realchart: string;
    };
    private _moduleMap;
    private constructor();
    static getInstance(): ExternalModuleManager;
    registerModule(id: keyof typeof ExternalModuleManager.ModuleNames, externalModule: any): void;
    findModule(id: keyof typeof ExternalModuleManager.ModuleNames): any | null;
}

declare class BarSeriesPoint extends OrthogonalSparkSeriesPoint {
    labelCount(): number;
}
/**
 * Bar 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/bar bar}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/BarSeriesOptions BarSeriesOptions}이다.
 */
declare class BarSeries extends OrthogonalSparkSeries<BarSeriesOptions> {
    private static readonly LABEL_OFFSET_CENTER;
    private static readonly LABEL_OFFSET_AUTO;
    static type: string;
    static defaults: BarSeriesOptions;
    private _subLabel;
    private _fieldColors;
    protected _doInit(op: BarSeriesOptions): void;
    get subLabel(): DataPointLabel<DataPointLabelOptions>;
    get reversed(): boolean;
    getFieldColors(): string[];
    getSubLabelOff(): number;
    pointLabelCount(): number;
    getPointLabels(): DataPointLabel<DataPointLabelOptions>[];
    protected _createPoint(source: any): BarSeriesPoint;
    protected _defLabelOff(): number;
    protected _createLegendMarker(doc: Document, size: number): RmElement;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    private $_isLabelCenter;
}

declare class BubbleSeriesPoint extends MarkerSeriesPoint {
    position: PointViewPosition;
    labelCount(): number;
    protected _readObject(series: ISeries<BubbleSeriesPoint>, v: any): void;
}
/**
 * Bubble 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/bubble bubble}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/BubbleSeriesOptions BubbleSeriesOptions}이다.
 */
declare class BubbleSeries extends MarkerSeries<BubbleSeriesOptions> {
    static type: string;
    static defaults: BubbleSeriesOptions;
    private _subLabel;
    private _minSizeDim;
    private _maxSizeDim;
    _extMin: number;
    _extMax: number;
    _vMin: number;
    _vMax: number;
    _noSize: boolean;
    private _alignToSurface;
    private _colorMin;
    private _colorMax;
    private _colorObj;
    private _colorRanger;
    protected _doInit(op: BubbleSeriesOptions): void;
    get subLabel(): DataPointLabel<DataPointLabelOptions>;
    get color(): Color;
    get alignToSurface(): boolean;
    set alignToSurface(value: boolean);
    getShape(): Shape;
    getPixelMinMax(len: number): {
        min: number;
        max: number;
    };
    getRadius(value: number, pxMin: number, pxMax: number): number;
    getSubLabelOff(): number;
    protected _doApply(options: BubbleSeriesOptions): void;
    pointLabelCount(): number;
    getPointLabels(): DataPointLabel<DataPointLabelOptions>[];
    protected _createPoint(source: any): BubbleSeriesPoint;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    getColorScale(): string | number;
    getValueRange(): {
        min: number;
        max: number;
    };
    getRangedColor(p: BubbleSeriesPoint): string;
    protected _doPrepareRender(chart: IChart, op: BubbleSeriesOptions): void;
}

declare class CircleGaugeItem<OP extends ChartItemOptions> extends ChartItem<OP> {
    gauge: CircleGauge;
    constructor(gauge: CircleGauge);
}
/**
 * 원형게이지 내부 원 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/CircleGaugeFaceptions CircleGaugeFaceptions}이다.
 */
declare class CircleGaugeFace extends CircleGaugeItem<CircleGaugeFaceOptions> {
    static defaults: CircleGaugeFaceOptions;
}
/**
 * 원형게이지 테두리(rim) 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/CircleGaugeRimOptions CircleGaugeRimOptions}이다.
 */
declare class CircleGaugeRim extends CircleGaugeItem<CircleGaugeRimOptions> {
    static defaults: CircleGaugeRimOptions;
    private _thicknessDim;
    protected _doApply(options: CircleGaugeValueRimOptions): void;
}
/**
 * 값을 표시하는 테두리(rim) 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/CircleGaugeValueRimOptions CircleGaugeValueRimOptions}이다.
 */
declare class CircleGaugeValueRim extends CircleGaugeItem<CircleGaugeValueRimOptions> {
    static defaults: CircleGaugeValueRimOptions;
    private _thicknessDim;
    getThickness(domain: number): number;
    protected _doApply(options: CircleGaugeValueRimOptions): void;
}
/**
 * 원형게이지 침(hand) 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/CircleGaugeHandOptions CircleGaugeHandOptions}이다.
 */
declare class CircleGaugeHand extends CircleGaugeItem<CircleGaugeHandOptions> {
    static defaults: CircleGaugeHandOptions;
    private _radiusDim;
    private _lengthDim;
    private _offsetDim;
    getExtents(domain: number): {
        radius: number;
        length: number;
        offset: number;
    };
    protected _doApply(options: CircleGaugeHandOptions): void;
}
/**
 * 원형게이지 핀 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/CircleGaugePinOptions CircleGaugePinOptions}이다.
 */
declare class CircleGaugePin extends CircleGaugeItem<CircleGaugePinOptions> {
    static defaults: CircleGaugePinOptions;
    private _radiusDim;
    getRadius(domain: number): number;
    protected _doApply(options: CircleGaugePinOptions): void;
}
declare class CircleGaugeLabel extends ChartText<CircleGaugeLabelOptions> {
    static defaults: CircleGaugeLabelOptions;
    private _offsetXDim;
    private _offsetYDim;
    _domain: IRichTextDomain;
    getOffset(width: number, height: number): IPoint$1;
    protected _doApply(options: CircleGaugeLabelOptions): void;
}
interface ICircleGaugeExtents {
    radius: number;
    radiusThick: number;
    inner: number;
    value: number;
}
declare class CircularProps {
    private _centerX;
    private _centerY;
    private _radius;
    private _innerRadius;
    private _valueRadius;
    private _centerXDim;
    private _centerYDim;
    private _radiusDim;
    private _innerDim;
    private _valueDim;
    _startRad: number;
    _handRad: number;
    _sweepRad: number;
    constructor();
    centerX(): PercentSize;
    setCenterX(value: PercentSize): void;
    centerY(): PercentSize;
    setCenterY(value: PercentSize): void;
    radius(): PercentSize;
    setRadius(value: PercentSize): void;
    innerRadius(): PercentSize;
    setInnerRadius(value: PercentSize): void;
    valueRadius(): PercentSize;
    setValueRadius(value: PercentSize): void;
    getCenter(gaugeWidth: number, gaugeHeight: number): {
        x: number;
        y: number;
    };
    getExtents(gaugeSize: number): ICircleGaugeExtents;
    prepareAngles(startAngle: number, sweepAngle: number): void;
}
/**
 * { name: '', coords: [lon, lat] },
 * [name, lon, lat], [lon, lat]
 */
declare class CircleGaugePoint extends GaugePoint {
    protected _readObject(series: ISeries<CircleGaugePoint>, v: any): void;
}
/**
 * Circle 게이지 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/gauge gauge}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/CircleGaugeOptions CircleGaugeOptions}이다.
 */
declare class CircleGauge extends ValueGauge<CircleGaugeOptions> {
    static readonly DEF_CENTER = "50%";
    static readonly DEF_RADIUS = "50%";
    static readonly DEF_INNER = "80%";
    static type: string;
    static defaults: CircleGaugeOptions;
    private _face;
    private _rim;
    private _valueRim;
    private _hand;
    private _pin;
    private _gaugeLabel;
    _props: CircularProps;
    protected _doInit(op: CircleGaugeOptions): void;
    get face(): CircleGaugeFace;
    get rim(): CircleGaugeRim;
    get valueRim(): CircleGaugeValueRim;
    get hand(): CircleGaugeHand;
    get pin(): CircleGaugePin;
    get gaugeLabel(): CircleGaugeLabel;
    protected _createPoint(source: any): CircleGaugePoint;
    protected _doApply(options: CircleGaugeOptions): void;
    protected _doPrepareRender(chart: IChart): void;
}

declare class ClockGaugeItem<OP extends ChartItemOptions> extends ChartItem<OP> {
    gauge: ClockGauge;
    constructor(gauge: ClockGauge);
}
/**
 * Clock 게이지 테두리(rim) 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeRimOptions ClockGaugeRimOptions}이다.
 */
declare class ClockGaugeRim extends ClockGaugeItem<ClockGaugeRimOptions> {
    static defaults: ClockGaugeRimOptions;
    private _thicknessDim;
    getThickness(domain: number): number;
    protected _doApply(options: ClockGaugeRimOptions): void;
}
/**
 * Clock 게이지 시/분침(hand) 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeHandOptions ClockGaugeHandOptions}이다.
 */
declare class ClockGaugeHand<OP extends ClockGaugeHandOptions = ClockGaugeHandOptions> extends ClockGaugeItem<OP> {
    static defaults: ClockGaugeHandOptions;
    private _lengthDim;
    getLength(domain: number): number;
    protected _doApply(op: OP): void;
}
/**
 * Clock 게이지 분침 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeHandOptions ClockGaugeHandOptions}이다.
 */
declare class ClockGaugeMinuteHand extends ClockGaugeHand<ClockGaugeHandOptions> {
    static defaults: ClockGaugeHandOptions;
}
/**
 * Clock 게이지 초침(hand) 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeSecondHandOptions ClockGaugeSecondHandOptions}이다.
 */
declare class ClockGaugeSecondHand extends ClockGaugeHand<ClockGaugeSecondHandOptions> {
    static defaults: ClockGaugeSecondHandOptions;
}
/**
 * Clock 게이지 tick 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeTickOptions ClockGaugeTickOptions}이다.
 */
declare class ClockGaugeTick extends ClockGaugeItem<ClockGaugeTickOptions> {
    static defaults: ClockGaugeTickOptions;
}
/**
 * Clock 게이지 tick 라벨 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeTickLabelOptions ClockGaugeTickLabelOptions}이다.
 */
declare class ClockGaugeTickLabel extends ClockGaugeItem<ClockGaugeTickLabelOptions> {
    static defaults: ClockGaugeTickLabelOptions;
}
/**
 * Clock 게이지 중심 pin 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugePinOptions ClockGaugePinOptions}이다.
 */
declare class ClockGaugePin extends ClockGaugeItem<ClockGaugePinOptions> {
    static defaults: ClockGaugePinOptions;
}
/**
 * Clock 게이지 내부에 표시되는 라벨 설정 모델.<br/>
 * {@link options} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeLabelOptions ClockGaugeLabelOptions}이다.
 */
declare class ClockGaugeLabel extends ChartText<ClockGaugeLabelOptions> {
    static defaults: ClockGaugeLabelOptions;
}
/**
 * { name: '', coords: [lon, lat] },
 * [name, lon, lat], [lon, lat]
 */
declare class ClockGaugePoint extends GaugePoint {
    timezone: number;
    time: number | Date;
    getTime(): Date;
    protected _readObject(series: ISeries<ClockGaugePoint>, v: any): void;
}
/**
 * Clock 게이지 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/clock clock}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/ClockGaugeOptions ClockGaugeOptions}이다.
 */
declare class ClockGauge extends Gauge<ClockGaugeOptions> {
    static readonly DEF_CENTER = "50%";
    static readonly DEF_RADIUS = "50%";
    static type: string;
    static defaults: ClockGaugeOptions;
    private _face;
    private _rim;
    private _hourHand;
    private _minuteHand;
    private _secondHand;
    private _tick;
    private _tickLabel;
    private _pin;
    private _gaugeLabel;
    private _centerX;
    private _centerY;
    private _radius;
    private _centerXDim;
    private _centerYDim;
    private _radiusDim;
    protected _doInit(op: ClockGaugeOptions): void;
    get face(): ChartItem<ChartItemOptions>;
    get rim(): ClockGaugeRim;
    get hourHand(): ClockGaugeHand<ClockGaugeHandOptions>;
    get minuteHand(): ClockGaugeMinuteHand;
    get secondHand(): ClockGaugeSecondHand;
    get tick(): ClockGaugeTick;
    get tickLabel(): ClockGaugeTickLabel;
    get pin(): ClockGaugePin;
    get gaugeLabel(): ClockGaugeLabel;
    getExtents(gaugeWidth: number, gaugeHeight: number, rate: number): {
        cx: number;
        cy: number;
        rd: number;
    };
    protected _createPoint(source: any): ClockGaugePoint;
    protected _doApply(options: ClockGaugeOptions): void;
}

/**
 * { name: '', coords: [lon, lat] },
 * [name, lon, lat], [lon, lat]
 */
declare class FigureSeriesPoint extends MarkerSeriesPoint {
    /**
     * 시리즈에 등록된 figure id를 지정한다.<br/>
     */
    figure: string;
    position: PointViewPosition;
    protected _readObject(series: ISeries<FigureSeriesPoint>, v: any): void;
}
declare class FigureSeriesImage extends ChartItem<FigureSeriesImageOptions> {
    static defaults: FigureSeriesImageOptions;
    getSize(): ISize;
}
/**
 * Figure 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/figure figure}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/FigureSeriesOptions FigureSeriesOptions}이다.
 */
declare class FigureSeries extends CoordBaseSeries<FigureSeriesOptions> {
    static type: string;
    static defaults: FigureSeriesOptions;
    private _innerLabel;
    private _innerImage;
    private _figureBox;
    private _minValue;
    private _maxValue;
    protected _doInit(op: FigureSeriesOptions): void;
    get innerLabel(): DataPointLabel<DataPointLabelOptions>;
    get innerImage(): FigureSeriesImage;
    get path(): string | (string | FigureObject)[];
    get figureBox(): [number, number];
    getFigureSize(): ISize;
    getImageSize(): ISize;
    protected _doApply(options: FigureSeriesOptions): void;
    protected _createPoint(source: any): FigureSeriesPoint;
    protected _defLabelOff(): number;
    getValueRange(): {
        min: number;
        max: number;
    };
    protected _doPrepareRender(chart: IChart, op: FigureSeriesOptions): void;
    private $_calcBox;
}

/**
 * { name: '', coords: [lon, lat], imageUrl: '' },
 */
declare class ImageSeriesPoint extends DataPoint {
    imageUrl: string;
    position: PointViewPosition;
    protected _readObject(series: ImageSeries, v: any): void;
}
/**
 * Image 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/image image}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/ImageSeriesOptions ImageSeriesOptions}이다.<br/>
 *
 * 데이터포인트에 imageUrl 속성이 지정되면 그 값을,
 * 아니면 {@link imageField}에 지정한 속성의 값을 {@link rootUrl}에 더해 이미지 경로를 만든다.
 */
declare class ImageSeries extends Series<ImageSeriesOptions> {
    static type: string;
    static defaults: ImageSeriesOptions;
    _imageFielder: (src: any) => string;
    private _root;
    getUrl(p: ImageSeriesPoint): string;
    protected _createLabel(chart: IChart): DataPointLabel;
    protected _createPoint(source: any): ImageSeriesPoint;
    protected _createFielders(op: ImageSeriesOptions): void;
    protected _defLabelOff(): number;
    protected _doApply(options: ImageSeriesOptions): void;
}

declare class LineSeriesPoint extends OrthogonalSparkSeriesPoint {
}
declare class LineSeriesArea extends ChartItem<LineSeriesAreaOptions> {
    static defaults: LineSeriesOptions;
}
/**
 * Line 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/line line}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/LineSeriesOptions LineSeriesOptions}이다.
 */
declare class LineSeries extends OrthogonalSparkSeries<LineSeriesOptions> {
    static type: string;
    static defaults: LineSeriesOptions;
    private _area;
    protected _doInit(op: LineSeriesOptions): void;
    get area(): LineSeriesArea;
    protected _createPoint(source: any): LineSeriesPoint;
    protected _defLabelOff(): number;
    protected _createLegendMarker(doc: Document, size: number): RmElement;
}

/**
 * { name: '', coords: [lon, lat] },
 * [name, lon, lat], [lon, lat]
 */
declare class PanelSeriesPoint extends ValuePoint {
    position: PointViewPosition;
}
declare abstract class PanelSeriesSection<OP extends PanelSeriesSectionOptions = PanelSeriesSectionOptions> extends ChartItem<OP> {
    series: PanelSeries;
    static defaults: PanelSeriesHeaderOptions;
    protected _richTextImpl: SvgRichText;
    private _point;
    _domain: IRichTextDomain;
    constructor(series: PanelSeries);
    getTextDomain(p: PanelSeriesPoint): IRichTextDomain;
    prepareRich(text: string): void;
    buildSvg(view: TextElement, maxWidth: number, maxHeight: number, domain: IRichTextDomain): void;
}
declare class PanelSeriesHeader extends PanelSeriesSection<PanelSeriesHeaderOptions> {
    static defaults: PanelSeriesHeaderOptions;
    private _minSizeDim;
    getMinSize(domain: number): number;
    protected _doApply(options: ChartTextOptions): void;
}
declare class PanelSeriesBody extends PanelSeriesSection<PanelSeriesBodyOptions> {
    static defaults: PanelSeriesBodyOptions;
}
/**
 * Panel 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/point panel}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/PanelSeriesOptions PanelSeriesOptions}이다.
 */
declare class PanelSeries extends CoordBaseSeries<PanelSeriesOptions> {
    static readonly DEF_MIN_WIDTH = 80;
    static readonly DEF_MIN_HEIGHT = 50;
    static type: string;
    static defaults: PanelSeriesOptions;
    private _header;
    private _divider;
    private _body;
    _vertical: boolean;
    _width: number;
    _height: number;
    _minWidth: number;
    _minHeight: number;
    _maxWidth: number;
    _maxHeight: number;
    protected _doInit(op: PanelSeriesOptions): void;
    get header(): PanelSeriesHeader;
    get divider(): ChartItem<ChartItemOptions>;
    get body(): PanelSeriesBody;
    getExtents(calcedWidth: number, calcedHeight: number): ISize;
    protected _createLabel(chart: IChart): DataPointLabel;
    protected _createPoint(source: any): PanelSeriesPoint;
    pointLabelCount(): number;
    legendMarker(doc: Document, size: number): RmElement;
    protected _doApply(options: PanelSeriesOptions): void;
}

declare class PieSeriesPoint extends SparkSeriesPoint {
}
declare class PieSeriesThresholdImpl implements PieSeriesThreshold {
    value: number;
    radius: number;
    style: SVGStyleOrClass;
    constructor(value: number, radius: number, style: SVGStyleOrClass);
}
/**
 * Pie 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/pie pie}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/PieSeriesOptions PieSeriesOptions}이다.
 */
declare class PieSeries extends SparkSeries<PieSeriesOptions> {
    static type: string;
    static defaults: PieSeriesOptions;
    _startRad: number;
    _totalRad: number;
    private _radiusDim;
    private _thresholds;
    private _fieldColors;
    getRadius(domain: number): number;
    hasThreshold(): PieSeriesThresholdImpl[];
    getThreshold(value: number): PieSeriesThresholdImpl;
    getFieldColors(): string[];
    protected _createPoint(source: any): PieSeriesPoint;
    protected _defLabelOff(): number;
    protected _doApply(options: PieSeriesOptions): void;
    protected _doPrepareRender(chart: IChart, op: PieSeriesOptions): void;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    private $_parseThresholds;
}

/**
 * { name: '', coords: [lon, lat] },
 * [name, lon, lat], [lon, lat]
 */
declare class PinSeriesPoint extends MarkerSeriesPoint {
    radius: number;
    position: PointViewPosition;
    protected _readObject(series: ISeries<PinSeriesPoint>, v: any): void;
}
/**
 * Point 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/point point}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/PinSeriesOptions PinSeriesOptions}이다.
 */
declare class PinSeries extends MarkerSeries<PinSeriesOptions> {
    private static readonly DEF_RADIUS;
    static type: string;
    static defaults: PinSeriesOptions;
    private _rd;
    private _innerRd;
    private _minValue;
    private _maxValue;
    private _colorObj;
    private _colorRanger;
    getExt(p: PinSeriesPoint, rate: number): {
        cx: number;
        cy: number;
        rd: number;
        innerRd: number;
    };
    get color(): Color;
    protected _doApply(options: PinSeriesOptions): void;
    protected _createPoint(source: any): PinSeriesPoint;
    protected _defLabelOff(): number;
    protected _createLegendMarker(doc: Document, size: number): RmElement;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    getColorScale(): string | number;
    getValueRange(): {
        min: number;
        max: number;
    };
    getRangedColor(p: PinSeriesPoint): string;
    protected _doPrepareRender(chart: IChart, op: PinSeriesOptions): void;
}

/**
 * { name: '', coords: [lon, lat] },
 * [name, lon, lat], [lon, lat]
 */
declare class PointSeriesPoint extends MarkerSeriesPoint {
    position: PointViewPosition;
    x: number;
    y: number;
    protected _readObject(series: ISeries<PointSeriesPoint>, v: any): void;
}
/**
 * Point 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/point point}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/PointSeriesOptions PointSeriesOptions}이다.
 */
declare class PointSeries extends MarkerSeries<PointSeriesOptions> {
    static type: string;
    static defaults: PointSeriesOptions;
    private _cluster;
    private _shape;
    private _stroke;
    private _strokeWidth;
    constructor(chart: IChart);
    protected _doInit(op: PointSeriesOptions): void;
    getShape(): Shape;
    getRadius(): number;
    setLegendMarkerStyle(marker: RmElement): void;
    get cluster(): PointCluster;
    protected _createPoint(source: any): PointSeriesPoint;
    protected _defLabelOff(): number;
    setCalcedColor(cs: CSSStyleDeclaration, prop: string): void;
    protected _createLegendMarker(doc: Document, size: number): RmElement;
    legendMarker(doc: Document, size: number): RmElement;
}

declare class RouteSeriesPoint extends DataPoint {
    coords: [MapCoord, MapCoord];
    path: any[];
    imageUrl: string;
    get lon1(): number;
    get lat1(): number;
    get lon2(): number;
    get lat2(): number;
    protected _assignTo(proxy: any): any;
    protected _readObject(series: RouteSeries, v: any): void;
}
/**
 * Route 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/route route}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/RouteSeriesOptions RouteSeriesOptions}이다.
 */
declare class RouteSeries extends Series<RouteSeriesOptions> {
    static type: string;
    static defaults: RouteSeriesOptions;
    private _imageFielder;
    private _root;
    private _imageUrl;
    get imageFielder(): (src: any) => string;
    getImageUrl(p: RouteSeriesPoint, useRoot?: boolean): string;
    getRouteMode(): RouteMode;
    /**
     * 선의 두께를 반환한다.<br/>
     */
    getLineWidth(): number;
    /**
     * 곡선의 제어점 좌표를 반환한다.
     */
    getCurvePoint(dataPoint: RouteSeriesPoint, p1: MapCoord, p2: MapCoord): [MapCoord, MapCoord];
    needMapScale(): boolean;
    protected _createPoint(source: any): RouteSeriesPoint;
    protected _positionsByCoord(): boolean;
    pointLabelCount(): number;
    protected _defLabelOff(): number;
    protected _doLoadPoints(src: any): void;
    protected _createLegendMarker(doc: Document, size: number): RmElement;
    protected _createFielders(op: RouteSeriesOptions): void;
    protected _doApply(op: RouteSeriesOptions): void;
    /**
     * curveFactor값으로 베지어 곡선의 제어점을 계산한다.
     *
     * p1 -> p2로 향하는 선이라고 할 때,
     * 중점(MID-A)를 구하고, 그 점에서 수직으로 curveFactor만큼 이동한 점(MID-B)을 구한다.
     * MID-B에서 P1방향으로 선분의 1/8 길이만큼 이동한 점을 제어점 C1로,
     * MID-B에서 P2방향으로 선분의 1/8 길이만큼 이동한 점을 제어점 C2로 한다.
     * 이렇게 해서 3차 베지어 곡선의 제어점 C1, C2를 반환한다.
     *
     * @param p1 Route 시작 좌표
     * @param p2 Route 끝 좌표
     * @param curveFactor options.curveFactor 값
     * @returns
     */
    private $_getCurvePointBycurveFactor;
}

type WaffleGrid = any[][];
declare class WaffleSeriesPoint extends SparkSeriesPoint {
}
/**
 * Waffle 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/Waffle waffle}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/WaffleSeriesOptions WaffleSeriesOptions}이다.
 */
declare class WaffleSeries extends SparkSeries<WaffleSeriesOptions> {
    static readonly ROW_COUNT = 10;
    static readonly COL_COUNT = 10;
    static readonly THRESHOLD = 1;
    static readonly CELL_SIZE = 5;
    static readonly GAP = 2;
    static type: string;
    static defaults: WaffleSeriesOptions;
    private _colCount;
    private _rowCount;
    private _threshold;
    private _rounder;
    private _cellSize;
    private _gap;
    private _runGrid;
    getPointGrid(point: WaffleSeriesPoint, ext: {
        min: number;
        max: number;
    }, rate: number): {
        grid: WaffleGrid;
        count: number;
        rows: number;
        cols: number;
    };
    protected _createPoint(source: any): WaffleSeriesPoint;
    protected _defLabelOff(): number;
    protected _doApply(op: WaffleSeriesOptions): void;
    getWaffleInfo(): {
        rowCount: number;
        colCount: number;
        wCell: number;
        hCell: number;
        gap: number;
    };
    protected _doPrepareRender(chart: IChart, op: WaffleSeriesOptions): void;
    private $_caculate;
    private $_rows;
    private $_cols;
    private $_fillRowFirst;
    private $_fillColFirst;
}

/**
 */
declare class HtmlSeriesPoint extends ValuePoint {
    protected _readObject(series: HtmlSeries, v: any): void;
}
/**
 * Html 시리즈 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/SeriesOptions#type type}은 {@link https://realmap.co.kr/config/config/series/html html}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/HtmlSeriesOptions HtmlSeriesOptions}이다.<br/>
 *
 * 데이터포인트에 html 속성이 지정되면 그 값을,
 * 아니면 {@link htmlField}에 지정한 속성의 값을
 */
declare class HtmlSeries extends ValueSeries<HtmlSeriesOptions> {
    static readonly DEF_SIZE = 100;
    static type: string;
    static defaults: HtmlSeriesOptions;
    _htmlFielder: (src: any) => string;
    private _paramRegx;
    private _params;
    private _paramCallback;
    private _userParams;
    getSize(): {
        width: number;
        height: number;
    };
    setParams(params: object): void;
    applyParams(p: HtmlSeriesPoint, target: string): string;
    protected _createLabel(chart: IChart): DataPointLabel;
    protected _createPoint(source: any): HtmlSeriesPoint;
    protected _createFielders(op: HtmlSeriesOptions): void;
    protected _defLabelOff(): number;
    protected _doApply(options: HtmlSeriesOptions): void;
    protected _doPrepareRender(chart: IChart, op: HtmlSeriesOptions): void;
    /**
     * ${param;default;format;type} 형식으로 지정한다.
     * 첫번째 param만 필수값이다.
     * type이 지정되지 않으면 먼저 숫자로 변경되는 지 판단해서 format에 지정된 숫자 형식으로 변환한다.
     */
    private $_apply;
}

/**
 * Text Annotation 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 {@link https://realmap.co.kr/config/config/annotation/image shape}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/ShapeAnnotationOptions ShapeAnnotationOptions}이다.
 */
declare class TextAnnotation extends Annotation<TextAnnotationOptions> {
    static readonly type = "text";
    static defaults: TextAnnotationOptions;
    private _numberFormat;
    private _timeFormat;
    _domain: IRichTextDomain;
    protected _isVisible(): boolean;
    protected _doSetSimple(op: TextAnnotationOptions, src: any): boolean;
    protected _doApply(options: TextAnnotationOptions): void;
}

/**
 * 이미지 Annotation 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 {@link https://realmap.co.kr/config/config/annotation/image image}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/ImageAnnotationOptions ImageAnnotationOptions}이다.
 */
declare class ImageAnnotation extends Annotation<ImageAnnotationOptions> {
    static type: string;
    static defaults: ImageAnnotationOptions;
    protected _isVisible(): boolean;
    protected _doSetSimple(op: ImageAnnotationOptions, src: any): boolean;
}

/**
 * Shape Annotation 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 {@link https://realmap.co.kr/config/config/annotation/image shape}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/ShapeAnnotationOptions ShapeAnnotationOptions}이다.
 */
declare class ShapeAnnotation extends Annotation<ShapeAnnotationOptions> {
    static type: string;
    static defaults: ShapeAnnotationOptions;
    private _xRange;
    private _yRange;
    getSeries(): {
        series: ISeries;
        xRange: number[];
        yRange: number[];
    };
    getShape(): Shape;
    protected _doSetSimple(op: ShapeAnnotationOptions, src: any): boolean;
}

/**
 * Text Annotation 모델.<br/>
 * {@link https://realmap.co.kr/docs/api/options/AnnotationOptions#type type}은 {@link https://realmap.co.kr/config/config/annotation/image shape}이고,
 * {@link options 설정} 모델은 {@link https://realmap.co.kr/docs/api/options/ShapeAnnotationOptions ShapeAnnotationOptions}이다.
 */
declare class HtmlAnnotation extends Annotation<HtmlAnnotationOptions> {
    static readonly type = "html";
    static defaults: HtmlAnnotationOptions;
    private _paramRegx;
    private _params;
    private _paramCallback;
    private _userParams;
    setParams(params: object): void;
    applyParams(target: string): string;
    /**
     * ${param;default;format;type} 형식으로 지정한다.
     * 첫번째 param만 필수값이다.
     * type이 지정되지 않으면 먼저 숫자로 변경되는 지 판단해서 format에 지정된 숫자 형식으로 변환한다.
     */
    private $_apply;
    protected _isVisible(): boolean;
    protected _doSetSimple(op: HtmlAnnotationOptions, src: any): boolean;
    protected _doPrepareRender(chart: IChart, op: HtmlAnnotationOptions): void;
}

declare abstract class SeriesAnimation {
    static reveal(series: SeriesView<Series>, options?: IRevealAnimation): void;
    static grow(series: SeriesView<Series>, endHandler?: RmAnimationEndHandler): void;
    static spread(series: SeriesView<Series>, endHandler?: RmAnimationEndHandler): void;
    static fadeIn(series: SeriesView<Series>): void;
    constructor(sv: SeriesView<Series>, options?: any);
    protected abstract _createAnimation(series: SeriesView<Series>, options?: any): Animation | RmAnimation;
}
interface IRevealAnimation {
    from: 'left' | 'right' | 'top' | 'bottom';
}

interface ISectorShape {
    cx: number;
    cy: number;
    rx: number;
    ry: number;
    innerRadius?: number;
    start: number;
    angle: number;
    borderRadius?: number;
    clockwise?: boolean;
}
declare class SectorElement extends PathElement {
    static create(doc: Document, styleName: string, x: number, y: number, rx: number, ry: number, start: number, angle: number, clockwise?: boolean): SectorElement;
    static createInner(doc: Document, styleName: string, x: number, y: number, rx: number, ry: number, innerRadius: number, start: number, angle: number, clockwise?: boolean): SectorElement;
    constructor(doc: Document, styleName?: string, shape?: ISectorShape);
    /**
     * 중심 x.
     */
    cx: number;
    /**
     * 중심 y.
     */
    cy: number;
    /**
     * 수평 반지름.
     */
    rx: number;
    /**
     * 수직 반지름.
     */
    ry: number;
    /**
     * 내부 반지름.
     * 수평/수직 반지름에 대한 비율. 0 ~ 1 사이 값으로 설정.
     */
    innerRadius: number;
    /**
     * 시작 각도.
     * 0 이상 2pi 미만.
     */
    start: number;
    /**
     * 각도.
     * 0 이상 2pi 미만.
     */
    angle: number;
    /**
     * 회전 방향.
     * true면 반시계 방향.
     */
    clockwise: boolean;
    /**
     * 반지름의 원래 크기에 대한 표시 비율.
     */
    rate: number;
    equals(shape: ISectorShape): boolean;
    setSector(shape: ISectorShape): void;
    setSectorEx(shape: ISectorShape, stroked: boolean): void;
    protected _getShape(): ISectorShape;
    protected _assignShape(shape: ISectorShape, stroked: boolean): void;
    private $_renderSector;
    private $_renderArc;
}

declare class CircleElement extends RmElement {
    constructor(doc: Document, styleName?: string, cx?: number, cy?: number, radius?: number);
    setCircle(cx: number, cy: number, radius: number): void;
}

declare const SVGNS = "http://www.w3.org/2000/svg";

declare class HtmlAnnotationView extends AnnotationView<HtmlAnnotation> {
    static readonly CLASS_NAME: string;
    static readonly HTML_VIEW_CLASS: string;
    private _foreignObj;
    private _htmlView;
    private _templateDom;
    private _observer;
    constructor(doc: Document);
    protected _doMeasure(doc: Document, model: HtmlAnnotation, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(p: IPoint$1): void;
    protected _doDispose(): void;
    private $_refresh;
}

declare class ImageAnnotationView extends AnnotationView<ImageAnnotation> {
    static readonly CLASS_NAME: string;
    private _imageView;
    constructor(doc: Document);
    protected _doMeasure(doc: Document, model: ImageAnnotation, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(p: IPoint$1): void;
}

declare class ShapeAnnotationView extends AnnotationView<ShapeAnnotation> {
    static readonly CLASS_NAME: string;
    private _shapeView;
    constructor(doc: Document);
    protected _doMeasure(doc: Document, model: ShapeAnnotation, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(p: IPoint$1): void;
}

declare class TextAnnotationView extends AnnotationView<TextAnnotation> {
    static readonly CLASS_NAME: string;
    private _textView;
    private _richText;
    constructor(doc: Document);
    protected _doMeasure(doc: Document, model: TextAnnotation, hintWidth: number, hintHeight: number): ISize;
    protected _doLayout(p: IPoint$1): void;
}

/**
 * View for Bar series.
 */
declare class BarSeriesView extends OrthogonalSparkSeriesView<BarSeries> {
    private _bars;
    protected _labelInfo: LabelLayoutInfo;
    private _hoverBar;
    constructor(doc: Document);
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: BarSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _doPointerMoved(x: number, y: number, dom: Element): boolean;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareBars;
    private $_layoutBars;
    private $_resolveLabelPosition;
}

declare class BubbleSeriesPointView extends MarkerSeriesPointView<BubbleSeriesPoint> {
    _radius: number;
    tooltipColor(): string;
}
/**
 * View for Bubble series.
 */
declare class BubbleSeriesView extends MarkerSeriesView<BubbleSeries> {
    constructor(doc: Document);
    protected _createMarkers(container: RmElement): PointViewPool<BubbleSeriesPointView>;
    protected _doPrepeare(doc: Document, model: BubbleSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareMarkers;
    private $_layoutMarkers;
}

declare class CircleGaugePointView extends GaugePointView<CircleGaugePoint> {
    private _faceView;
    private _rimView;
    private _valueView;
    private _handContainer;
    private _handView;
    private _pinView;
    private _textView;
    _size: number;
    constructor(doc: Document);
    prepare(doc: Document, gauge: CircleGauge): void;
    render(gauge: CircleGauge, width: number, height: number, vr: number): void;
    private $_renderBackground;
    private $_renderValue;
}
/**
 * View for Circle gauge.
 */
declare class CircleGaugeView extends GaugeView<CircleGauge> {
    constructor(doc: Document);
    protected _createGauges(container: RmElement): PointViewPool<CircleGaugePointView>;
    protected _doPrepeare(doc: Document, model: CircleGauge, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareGauges;
    private $_layoutGauges;
}

declare class ClockGaugePointView extends GaugePointView<ClockGaugePoint> {
    private _faceView;
    private _rimView;
    private _tickContainer;
    private _tickViews;
    private _tickLabelContainer;
    private _tickLabelViews;
    private _labelView;
    private _hourView;
    private _minuteView;
    private _secondView;
    private _pinView;
    private _runner;
    _exts: {
        cx: number;
        cy: number;
        rd: number;
    };
    private _rimThick;
    private _prevSec;
    private _aniSec;
    _secRate: number;
    private _zoneCallback?;
    _size: number;
    constructor(doc: Document);
    prepare(doc: Document, gauge: ClockGauge): void;
    render(gauge: ClockGauge, width: number, height: number): void;
    private $_renderFace;
    private $_getNow;
    $_renderHands(gauge: ClockGauge, exts: {
        cx: number;
        cy: number;
        rd: number;
    }): void;
    private $_moveSecond;
}
/**
 * View for Clock gauge.
 */
declare class ClockGaugeView extends GaugeView<ClockGauge> {
    constructor(doc: Document);
    protected _createGauges(container: RmElement): PointViewPool<ClockGaugePointView>;
    protected _doPrepeare(doc: Document, model: ClockGauge, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    private $_prepareGauges;
    private $_layoutGauges;
}

/**
 * @private
 *
 * View for Point series.
 */
declare class FigureSeriesView extends SeriesView<FigureSeries> {
    private _figure;
    private _image;
    private _figures;
    constructor(doc: Document);
    private $_createFigure;
    private $_createImage;
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: FigureSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareFigures;
    private $_layoutFigures;
}

/**
 * View for Html series.
 */
declare class HtmlSeriesView extends SeriesView<HtmlSeries> {
    private _templateDom;
    private _observer;
    private _htmlViews;
    constructor(doc: Document);
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: HtmlSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareHtmls;
    private _layoutPoints;
}

/**
 * View for Image series.
 */
declare class ImageSeriesView extends SeriesView<ImageSeries> {
    private _images;
    constructor(doc: Document);
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: ImageSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareImages;
    private _layoutPoints;
}

/**
 * View for line series.
 */
declare class LineSeriesView extends OrthogonalSparkSeriesView<LineSeries> {
    private _lines;
    constructor(doc: Document);
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: LineSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _legendColorProp(): string;
    protected _runShowEffect(firstTime: boolean): void;
    private $_prepareLines;
    private $_layoutLines;
}

/**
 * View for Panel series.
 */
declare class PanelSeriesView extends SeriesView<PanelSeries> {
    private _panels;
    constructor(doc: Document);
    protected _doPrepeare(doc: Document, model: PanelSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _setModelColor(color: string): void;
    protected _setPointColor(v: RmElement, color: string): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    protected _getPointPool(): PointViewPool<PointElement>;
    private $_preparePanels;
    private $_layoutPanels;
}

/**
 * View for pie series.
 */
declare class PieSeriesView extends SparkSeriesView<PieSeries> {
    private _pies;
    constructor(doc: Document);
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: PieSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_preparePies;
    private $_layoutPies;
}

declare class PinView extends MarkerSeriesPointView<PinSeriesPoint> {
    private _pin;
    private _circle;
    constructor(doc: Document);
    render(ext: {
        cx: number;
        cy: number;
        rd: number;
        innerRd: number;
    }): void;
    tooltipColor(): string;
}
/**
 * View for Point series.
 */
declare class PinSeriesView extends MarkerSeriesView<PinSeries> {
    constructor(doc: Document);
    protected _createMarkers(container: RmElement): PointViewPool<PinView>;
    protected _doPrepeare(doc: Document, model: PinSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    private $_preparePins;
    private $_layoutPins;
}

declare class PointSeriesPointView extends MarkerSeriesPointView<PointSeriesPoint> {
    _radius: number;
}
/**
 * View for Point series.
 */
declare class PointSeriesView extends MarkerSeriesView<PointSeries> {
    private _clusterContainer;
    private _clusterPool;
    constructor(doc: Document);
    protected _createMarkers(container: RmElement): PointViewPool<PointSeriesPointView>;
    protected _doPrepeare(doc: Document, model: PointSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    zoomChanged(zoom: number, oldZoom: number): void;
    protected _runClustering(m: PointSeries): boolean;
    protected _clusterOfDom(elt: Element): PointClusterView;
    private $_prepareMarkers;
    private $_layoutMarkers;
    private $_prepareClusters;
    private $_layoutClusters;
}

declare class LineView extends PointElement<RouteSeriesPoint> {
    private _line;
    private _arrow;
    private _secondArrow;
    private _image;
    private _secondImage;
    private _arrowClipPath;
    constructor(doc: Document);
    get line(): PathElement;
    get arrow(): PathElement;
    get secondArrow(): PathElement;
    get image(): ImageElement;
    get secondImage(): ImageElement;
    prepare(series: RouteSeries): void;
    isEmpty(pts: MapCoord[], topPts: MapCoord[], bottomPts: MapCoord[]): boolean;
    clear(): void;
    /**
     * T, B 경로를 그리고 fill로 채운 닫힌 도형을 렌더링합니다.
     *
     * @param series RouteSeries 객체
     * @param unit 스케일 단위
     * @param pts 중심 경로 좌표 배열
     * @param topPts T 경로 좌표 배열
     * @param bottomPts B 경로 좌표 배열
     * @param breakIndex 경로가 끊기는 지점의 인덱스 (-1이면 끊김 없음)
     * @param arrow 화살표 표시 여부
     */
    render(series: RouteSeries, unit: number, pts: MapCoord[], topPts: MapCoord[], bottomPts: MapCoord[], breakIndex: number, arrow: boolean): void;
    setPath(path: Path): PathElementEx;
    /**
     * 클리핑할 때 사용되는 내부 사각형 경로를 생성한다.
     * evenodd 룰을 사용하여, 이 내부 사각형 안의 영역만 가려지도록 한다.
     * 이를 통해 화살표 영역을 침범한 라인을 가릴 수 있다.
     */
    private $_createInnerRect;
    private $_drawArrow;
    private $_drawImage;
    private $_createClipBoundary;
    /**
     * 화살표 영역에 대한 클리핑을 적용
     * evenodd 규칙을 사용하여 화살표 영역 내의 라인을 가린다
     *
     * - innerRect 안의 영역만 가려진다.(even-odd 룰 사용)
     * - evenodd: 특정 점에서 무한대 방향으로 선을 그었을 때, 경로와의 교차회수가 홀수인지 짝수인지 여부로 내/외부를 판단
     * - innerRect 안에서 선을 긋는 경우, 교차회수가 짝수이므로 외부로 판단되어 가려진다.
     * - largeRect 안이고 innerRect 밖에서 선을 긋는 경우, 교차회수가 홀수이므로 내부로 판단되어 보인다.
     */
    private $_applyArrowClipping;
    /**
     * T, B 경로를 결합하여 경로 폴리곤 SVG path를 생성한다
     * breakIndex가 있으면 경로 폴리곤을 하나 더 그린다(scroll second)
     */
    private $_buildLinePath;
    private $_createImage;
}
/**
 * View for Point series.
 */
declare class RouteSeriesView extends SeriesView<RouteSeries> {
    private static readonly INTERPOLATION;
    private _lines;
    constructor(doc: Document);
    needClip(): boolean;
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _setPointColor(v: LineView, color: string): void;
    protected _doPrepeare(doc: Document, model: RouteSeries, dirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    runPointAddAnimation(p: DataPoint): void;
    protected _legendColorProp(): string;
    private $_prepareLines;
    private $_layoutLines;
    private $_layoutLine;
    /**
     * 단일 경로를 렌더링합니다.
     */
    private $_renderSinglePath;
    /**
     * 지도 경계를 넘는 경우, 원본 경로와 세컨드 경로를 모두 그린다.
     * 세컨드 경로는 경도를 360도 이동시켜서 생성한다.(경위도 좌표상 제자리이지만 투영했을 때 픽셀좌표는 다르다)
     */
    private $_renderDuplicatedPaths;
    /**
     * 경로가 지도 경계를 넘어가는지 확인
     */
    private $_checkBoundaryCrossing;
    /**
     * 원본 경로와 스크롤 처리를 위해 복제한 경로에 대한 오프셋 경로를 생성
     *
     * 자세한 내용은 _generateOffsetPaths 참조
     */
    private $_genSplitedOffsetPath;
    /**
     * 대권항로에 해당하는 경로를 생성
     *
     * - 두 지점 p1, p2 사이의 대권항로를 따라 일정한 간격으로 점을 생성
     * - 경계를 넘는 경로 처리를 위해 경도를 정규화하지 않고 원본 좌표를 유지
     *
     * @param p1 시작점
     * @param p2 끝점
     * @param count 중간점 개수(interpolate count)
     * @returns 대권항로의 좌표 배열
     */
    private $_genGcnPath;
    /**
     * 3차 베지어 곡선경로를 생성한다.
     *
     * - 두 지점 p1, p2 사이의 곡선 경로를 따라 일정한 간격으로 점을 생성하여 경로를 만든다.
     * - 3차 베지어 곡선을 사용하며, 제어점으로 option.curvePoint를 사용한다.
     *
     * @param p1 시작점
     * @param p2 끝점
     * @param count 중간점 개수(interpolate count)
     * @returns 곡선경로의 좌표 배열
     */
    private $_genCubicBezierPath;
    /**
     * A1 -> A2로 가는 3차 베지어 곡선 상의 t 위치 좌표를 계산한다.
     *
     * C1, C2는 A1, A2에 대한 제어점이다.
     *
     * @param p0 시작점
     * @param p1 제어점1
     * @param p2 제어점2
     * @param p3 끝점
     * @param t 경로비율
     * @returns 베지어 곡선에서 경로비율 t일 때의 좌표
     */
    private $_cubicBezier;
    /**
     * 구면 선형 보간법(SLERP)을 사용하여 두 지점 사이의 중간 지점을 계산한다.
     *
     * - t는 경로비율로, 0에서 1 사이의 값을 가진다. 해당 비율에 맞는 지점의 좌표를 반환한다.
     * - prevLon을 전달하면 경도의 연속성을 유지한다 (180도 경계에서 지도 반대편에 그려지지 않도록 보정함)
     */
    private interpolate;
    /**
     * 경로 상의 특정 점에서 법선 벡터를 계산한다.
     *
     * - 투영 좌표계에서 진행 방향에 수직인 단위 벡터를 반환한다.
     *
     * @param path 경로 좌표 배열 (투영 좌표계)
     * @param index 법선 벡터를 계산할 점의 인덱스
     * @returns 법선 단위 벡터 [x, y]
     */
    private $_getNormalVector;
    /**
     * 중심 경로(path)로부터 양옆 오프셋 경로를 생성.
     *
     * 여기서 말하는 오프셋 경로란, 중심 경로에서 일정 거리만큼 떨어진 T(Top), B(Bottom) 경로를 의미
     * T, B 경로는 점진적으로 넓어지는 경로를 만들기 위한 좌표 배열이다.
     * 랜더링할 때 해당 좌표를 통해 경로 폴리곤을 랜더링한다.
     *
     * @param path 중심 경로 좌표 배열 (투영 좌표계)
     * @param startWidth 시작점에서의 폭 (보통 0)
     * @param endWidth 끝점에서의 폭 (lineWidth/2)
     * @returns { topPath, bottomPath } 상단/하단 오프셋 경로
     */
    private $_generateOffsetPaths;
}

/**
 * View for Waffle series.
 */
declare class WaffleSeriesView extends SparkSeriesView<WaffleSeries> {
    private _waffles;
    constructor(doc: Document);
    protected _getPointPool(): PointViewPool<PointElement>;
    protected _doPrepeare(doc: Document, model: WaffleSeries, dataDirty: boolean): void;
    protected _doRender(width: number, height: number): void;
    protected _doReset(): void;
    protected _runShowEffect(firstTime: boolean): void;
    protected _doViewRateChanged(rate: number): void;
    private $_prepareWaffles;
    private $_layoutWaffles;
}

declare const getVersion: typeof Globals.getVersion;
declare const setDebugging: typeof Globals.setDebugging;
declare const setLogging: typeof Globals.setLogging;
declare const setGlobals: typeof Globals.setGlobals;
declare const getDistance: typeof Globals.getDistance;
declare const createChart: typeof Globals.createChart;
declare const createChartAsync: typeof Globals.createChartAsync;
declare const preset: typeof Globals.preset;
declare const setLicenseKey: typeof Globals.setLicenseKey;

export { Annotation, AnnotationAnimationOptions, AnnotationOptions, AnnotationOptionsType, AnnotationView, AssetItemOptions, AssetOptionsType, BackgroundImageOptions, BandSeriesOptions, BandSeriesType, BarSeries, BarSeriesOptions, BarSeriesView, Body, BodyOptions, BodyPanelOptions, BodyView, BubbleSeries, BubbleSeriesOptions, BubbleSeriesView, ChartAnnotationOptions, ChartAnnotationType, ChartConfiguration, ChartControl, ChartElement, ChartItem, ChartItemOptions, ChartObject, ChartGlobalOptions as ChartOptionsOptions, ChartTextOptions, ChartView, CircleElement, CircleGauge, CircleGaugeView, ClockGauge, ClockGaugeView, ColorListOptions, ColorRanger, CommonCallbackArgs, CoordBaseSeries, Credits, CreditsOptions, DataPoint, DataPointArgs, DataPointLabel, DataPointLabelOptions, DragTracker, DrilldownPanelOptions, DrilldownPanelType, ElementPool, ExportOptions, ExportType, Exporter, ExporterOptions, ExternalModuleManager, FeatureSeriesLabelOptions, FeatureSeriesOptions, FeatureSeriesType, FeatureType, FigureObject, FigureSeries, FigureSeriesView, GLPointSeriesOptions, GLPointSeriesType, GLSeriesOptions, GradientOptions, HeatmapCellAggregation, HeatmapGridModeOptions, HeatmapMode, HeatmapPointModeOptions, HeatmapSeriesOptions, HeatmapSeriesType, HtmlAnnotation, HtmlAnnotationOptions, HtmlAnnotationView, HtmlSeries, HtmlSeriesView, IChart, IColorRanger, ILegendSource, IPointView, ISeries, IconedTextOptions, ImageAnnotation, ImageAnnotationOptions, ImageAnnotationView, ImageElement, ImageListOptions, ImageSeries, ImageSeriesView, LayerElement, Legend, LegendOptions, LineElement, LineSeries, LineSeriesOptions, LineSeriesView, LinearGradientOptions, LoadCallbackArgs, MapArea, MapAxis, MapAxisBandGuide, MapAxisGuide, MapAxisLineGuide, MapAxisRangeGuide, MapBackgroundOptions, MapChart, MapCoord, MapCrosshair, MapInset, MapInsetDisplay, MapProjection, MapSeries, MapSeriesLabelOptions, MapSeriesOptions, MapSeriesType, MapSeriesView, MapTool, MapUnion, MarkerSeries, MarkerSeriesOptions, MarkerSeriesPoint, MarkerSeriesPointView, MarkerSeriesView, OrthogonalSparkSeries, PanelSeries, PanelSeriesView, PathElement, PatternOptions, PieSeries, PieSeriesOptions, PieSeriesView, PinSeries, PinSeriesView, PointElement, PointLabelView, PointSeries, PointSeriesView, PointViewPool, PointViewPosition, PolyLineElement, ProjectionType, RadialGradientOptions, RectElement, RegionSeriesOptions, RegionSeriesType, RmElement, RouteSeries, RouteSeriesOptions, RouteSeriesType, RouteSeriesView, SVGNS, SVGStyleOrClass, SVGStyles, SankeySeriesOptions, SankeySeriesType, SectionView, SectorElement, Series, SeriesAnimation, SeriesOptions, SeriesOptionsType, SeriesView, Shape, ShapeAnnotation, ShapeAnnotationOptions, ShapeAnnotationView, ShapeDrawer, SparkSeries, Subtitle, SubtitleOptions, TableSeriesOptions, TableSeriesType, TextAnchor, TextAnnotation, TextAnnotationOptions, TextAnnotationView, TextElement, TextLayout, TileWebProvider, TiledWebSeriesOptions, TiledWebSeriesType, Title, TitleOptions, TooltipOptions, TrackSeriesOptions, TrackSeriesOutlineOptions, TrackSeriesType, ValuePoint, ValueSeries, VectorSeriesOptions, VectorSeriesType, WaffleSeries, WaffleSeriesView, ZoomButton, ZoomPanelOptions, createChart, createChartAsync, extend, fixnum, getDistance, getVersion, parseCoord, preset, setDebugging, setGlobals, setLicenseKey, setLogging };