import * as react from 'react';
import react__default, { ReactNode } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';

type NaverMapsSubmodule = "traffic" | "transit" | "drawing" | "event" | "heatmap" | "marker";

declare const EVENT_TO_PROP$7: {
    readonly init: "onInit";
    readonly bounds_changed: "onBoundsChanged";
    readonly dragstart: "onDragStart";
    readonly dragend: "onDragEnd";
    readonly idle: "onIdle";
    readonly resize: "onResize";
    readonly scroll: "onScroll";
    readonly addLayer: "onAddLayer";
    readonly center_changed: "onCenterChanged";
    readonly centerPoint_changed: "onCenterPointChanged";
    readonly click: "onClick";
    readonly dbclick: "onDbclick";
    readonly doubletap: "onDoubletap";
    readonly mapType_changed: "onMapTypeChanged";
    readonly mapTypeId_changed: "onMapTypeIdChanged";
    readonly mousedown: "onMousedown";
    readonly mousemove: "onMousemove";
    readonly mouseout: "onMouseout";
    readonly mouseover: "onMouseover";
    readonly mouseup: "onMouseup";
    readonly panning: "onPanning";
    readonly pinch: "onPinch";
    readonly pinch_start: "onPinchStart";
    readonly projection_changed: "onProjectionChanged";
    readonly removeLayer: "onRemoveLayer";
    readonly size_changed: "onSizeChanged";
    readonly tap: "onTap";
    readonly tilesloaded: "onTilesLoaded";
    readonly touchend: "onTouchEnd";
    readonly touchstart: "onTouchStart";
    readonly touchmove: "onTouchMove";
    readonly twofintertap: "onTwoFingerTap";
    readonly zoom_changed: "onZoomChanged";
    readonly zoomend: "onZoomEnd";
    readonly zoomstart: "onZoomStart";
};
type EventKey$7 = keyof typeof EVENT_TO_PROP$7;
type PropKey$7 = (typeof EVENT_TO_PROP$7)[EventKey$7];
interface MapCallbacks {
    addLayer?: (layer: naver.maps.Layer) => void;
    center_changed?: (center: naver.maps.Coord) => void;
    centerPoint_changed?: (centerPoint: naver.maps.LatLng) => void;
    click?: (event: naver.maps.PointerEvent) => void;
    dbclick?: (event: naver.maps.PointerEvent) => void;
    doubletap?: (event: naver.maps.PointerEvent) => void;
    bounds_changed?: (bounds: naver.maps.Bounds) => void;
    drag?: (event: naver.maps.PointerEvent) => void;
    dragstart?: (event: naver.maps.PointerEvent) => void;
    dragend?: (event: naver.maps.PointerEvent) => void;
    idle?: () => void;
    init?: () => void;
    scroll?: () => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    keydown?: (event: naver.maps.DOMEvent) => void;
    keyup?: (event: naver.maps.DOMEvent) => void;
    longtap?: (event: naver.maps.PointerEvent) => void;
    mapType_changed?: (mapType: naver.maps.MapType) => void;
    mapTypeId_changed?: (mapTypeId: naver.maps.MapTypeId) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mousemove?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    panning?: () => void;
    pinch?: (event: naver.maps.PointerEvent) => void;
    pinch_start?: (event: naver.maps.PointerEvent) => void;
    projection_changed?: (projection: naver.maps.Projection) => void;
    removeLayer?: (layerName: naver.maps.Layer["name"]) => void;
    resize?: () => void;
    size_changed?: (size: naver.maps.Size) => void;
    tap?: (event: naver.maps.PointerEvent) => void;
    tilesloaded?: () => void;
    touchend?: () => void;
    touchmove?: (event: naver.maps.PointerEvent) => void;
    touchstart?: (event: naver.maps.PointerEvent) => void;
    twofintertap?: (event: naver.maps.PointerEvent) => void;
    zoom_changed?: (zoom: number) => void;
    zoomstart?: () => void;
    zoomend?: () => void;
}
type HandlerOfProp$7<P extends PropKey$7> = MapCallbacks[{
    [E in EventKey$7]: (typeof EVENT_TO_PROP$7)[E] extends P ? E : never;
}[EventKey$7]];
type MapEventProps = {
    [P in PropKey$7]?: HandlerOfProp$7<P>;
};
interface MapProps extends MapEventProps {
    ncpKeyId: string;
    id?: string;
    mapTypeId?: naver.maps.MapTypeId;
    initialOptions?: Omit<naver.maps.MapOptions, "gl">;
    children?: ReactNode;
    submodules?: NaverMapsSubmodule[];
    style?: React.CSSProperties;
    disableGL?: boolean;
    reuseMap?: boolean;
    center?: naver.maps.MapOptions["center"];
    zoom?: naver.maps.MapOptions["zoom"];
}
declare const Map: react.ForwardRefExoticComponent<MapProps & react.RefAttributes<naver.maps.Map>>;

interface MapProviderProps {
    children: react__default.ReactNode;
}
declare const MapProvider: ({ children }: MapProviderProps) => react_jsx_runtime.JSX.Element;
type MapCollection = {
    [id: string]: naver.maps.Map | undefined;
    current?: naver.maps.Map;
};
declare const useMap: () => MapCollection;

declare const EVENT_TO_PROP$6: {
    readonly click: "onClick";
    readonly position_changed: "onPositionChanged";
    readonly rightclick: "onRightclick";
    readonly title_changed: "onTitleChanged";
    readonly touchend: "onTouchEnd";
    readonly touchstart: "onTouchStart";
    readonly visible_changed: "onVisibleChanged";
    readonly zindex_changed: "onZIndexChanged";
    readonly clickable_changed: "onClickableChanged";
    readonly dblclick: "onDblclick";
    readonly draggable_changed: "onDraggableChanged";
    readonly icon_changed: "onIconChanged";
    readonly icon_loaded: "onIconLoaded";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
};
type EventKey$6 = keyof typeof EVENT_TO_PROP$6;
type PropKey$6 = (typeof EVENT_TO_PROP$6)[EventKey$6];
interface MarkerCallbacks {
    click?: (event: naver.maps.PointerEvent) => void;
    clickable_changed?: (clickable: boolean) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    draggable_changed?: (draggable: boolean) => void;
    icon_changed?: (icon: string | naver.maps.ImageIcon | naver.maps.SymbolIcon | naver.maps.HtmlIcon) => void;
    icon_loaded?: (marker: naver.maps.Marker) => void;
    position_changed?: (position: naver.maps.Coord) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    title_changed?: (title: string) => void;
    touchend?: (event: naver.maps.PointerEvent) => void;
    touchstart?: (event: naver.maps.PointerEvent) => void;
    visible_changed?: (visible: boolean) => void;
    zindex_changed?: (zIndex: number) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp$6<P extends PropKey$6> = MarkerCallbacks[{
    [E in EventKey$6]: (typeof EVENT_TO_PROP$6)[E] extends P ? E : never;
}[EventKey$6]];
type MarkerEventProps = {
    [P in PropKey$6]?: HandlerOfProp$6<P>;
};
type BaseMarkerProps = Omit<naver.maps.MarkerOptions, "map">;
interface MarkerProps extends BaseMarkerProps, MarkerEventProps {
}
declare const Marker: react.ForwardRefExoticComponent<MarkerProps & react.RefAttributes<naver.maps.Marker>>;

type OverlayAnchorType = "top-left" | "top-center" | "top-right" | "center-left" | "center-center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";

interface Props {
    children: ReactNode;
    position: naver.maps.Coord | naver.maps.CoordLiteral;
    zIndex?: number;
    anchor?: OverlayAnchorType;
    style?: Partial<CSSStyleDeclaration>;
}
declare const Overlay: react.ForwardRefExoticComponent<Props & react.RefAttributes<HTMLDivElement>>;

declare const EVENT_TO_PROP$5: {
    readonly click: "onClick";
    readonly dblclick: "onDblclick";
    readonly rightclick: "onRightclick";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
    readonly mouseenter: "onMouseEnter";
    readonly mouseleave: "onMouseLeave";
};
type EventKey$5 = keyof typeof EVENT_TO_PROP$5;
type PropKey$5 = (typeof EVENT_TO_PROP$5)[EventKey$5];
interface PolygonCallbacks {
    click?: (event: naver.maps.PointerEvent) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mouseenter?: (event: naver.maps.PointerEvent) => void;
    mouseleave?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp$5<P extends PropKey$5> = PolygonCallbacks[{
    [E in EventKey$5]: (typeof EVENT_TO_PROP$5)[E] extends P ? E : never;
}[EventKey$5]];
type PolygonEventProps = {
    [P in PropKey$5]?: HandlerOfProp$5<P>;
};
type BasePolygonProps = Omit<naver.maps.PolygonOptions, "map">;
interface PolygonProps extends BasePolygonProps, PolygonEventProps {
}
declare const Polygon: react.ForwardRefExoticComponent<PolygonProps & react.RefAttributes<naver.maps.Polygon>>;

declare const EVENT_TO_PROP$4: {
    readonly click: "onClick";
    readonly dblclick: "onDblclick";
    readonly rightclick: "onRightclick";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
    readonly mouseenter: "onMouseEnter";
    readonly mouseleave: "onMouseLeave";
};
type EventKey$4 = keyof typeof EVENT_TO_PROP$4;
type PropKey$4 = (typeof EVENT_TO_PROP$4)[EventKey$4];
interface PolylineCallbacks {
    click?: (event: naver.maps.PointerEvent) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mouseenter?: (event: naver.maps.PointerEvent) => void;
    mouseleave?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp$4<P extends PropKey$4> = PolylineCallbacks[{
    [E in EventKey$4]: (typeof EVENT_TO_PROP$4)[E] extends P ? E : never;
}[EventKey$4]];
type PolylineEventProps = {
    [P in PropKey$4]?: HandlerOfProp$4<P>;
};
type BasePolylineProps = Omit<naver.maps.PolylineOptions, "map">;
interface PolylineProps extends BasePolylineProps, PolylineEventProps {
}
declare const Polyline: react.ForwardRefExoticComponent<PolylineProps & react.RefAttributes<naver.maps.Polyline>>;

declare const EVENT_TO_PROP$3: {
    readonly click: "onClick";
    readonly dblclick: "onDblclick";
    readonly rightclick: "onRightclick";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
    readonly mouseenter: "onMouseEnter";
    readonly mouseleave: "onMouseLeave";
};
type EventKey$3 = keyof typeof EVENT_TO_PROP$3;
type PropKey$3 = (typeof EVENT_TO_PROP$3)[EventKey$3];
interface RectangleCallbacks {
    click?: (event: naver.maps.PointerEvent) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mouseenter?: (event: naver.maps.PointerEvent) => void;
    mouseleave?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp$3<P extends PropKey$3> = RectangleCallbacks[{
    [E in EventKey$3]: (typeof EVENT_TO_PROP$3)[E] extends P ? E : never;
}[EventKey$3]];
type RectangleEventProps = {
    [P in PropKey$3]?: HandlerOfProp$3<P>;
};
type BaseRectangleProps = Omit<naver.maps.RectangleOptions, "map">;
interface RectangleProps extends BaseRectangleProps, RectangleEventProps {
}
declare const Rectangle: react.ForwardRefExoticComponent<RectangleProps & react.RefAttributes<naver.maps.Rectangle>>;

declare const EVENT_TO_PROP$2: {
    readonly click: "onClick";
    readonly dblclick: "onDblclick";
    readonly rightclick: "onRightclick";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
    readonly mouseenter: "onMouseEnter";
    readonly mouseleave: "onMouseLeave";
};
type EventKey$2 = keyof typeof EVENT_TO_PROP$2;
type PropKey$2 = (typeof EVENT_TO_PROP$2)[EventKey$2];
interface CircleCallbacks {
    click?: (event: naver.maps.PointerEvent) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mouseenter?: (event: naver.maps.PointerEvent) => void;
    mouseleave?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp$2<P extends PropKey$2> = CircleCallbacks[{
    [E in EventKey$2]: (typeof EVENT_TO_PROP$2)[E] extends P ? E : never;
}[EventKey$2]];
type CircleEventProps = {
    [P in PropKey$2]?: HandlerOfProp$2<P>;
};
type BaseCircleProps = Omit<naver.maps.CircleOptions, "map">;
interface CircleProps extends BaseCircleProps, CircleEventProps {
}
declare const Circle: react.ForwardRefExoticComponent<CircleProps & react.RefAttributes<naver.maps.Circle>>;

declare const EVENT_TO_PROP$1: {
    readonly click: "onClick";
    readonly dblclick: "onDblclick";
    readonly rightclick: "onRightclick";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
    readonly mouseenter: "onMouseEnter";
    readonly mouseleave: "onMouseLeave";
};
type EventKey$1 = keyof typeof EVENT_TO_PROP$1;
type PropKey$1 = (typeof EVENT_TO_PROP$1)[EventKey$1];
interface EllipseCallbacks {
    click?: (event: naver.maps.PointerEvent) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mouseenter?: (event: naver.maps.PointerEvent) => void;
    mouseleave?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp$1<P extends PropKey$1> = EllipseCallbacks[{
    [E in EventKey$1]: (typeof EVENT_TO_PROP$1)[E] extends P ? E : never;
}[EventKey$1]];
type EllipseEventProps = {
    [P in PropKey$1]?: HandlerOfProp$1<P>;
};
type BaseEllipseProps = Omit<naver.maps.EllipseOptions, "map">;
interface EllipseProps extends BaseEllipseProps, EllipseEventProps {
}
declare const Ellipse: react.ForwardRefExoticComponent<EllipseProps & react.RefAttributes<naver.maps.Ellipse>>;

declare const EVENT_TO_PROP: {
    readonly addfeature: "onAddFeature";
    readonly removefeature: "onRemoveFeature";
    readonly setfeature: "onSetFeature";
    readonly setgeometry: "onSetGeometry";
    readonly setproperty: "onSetProperty";
    readonly removeproperty: "onRemoveProperty";
    readonly click: "onClick";
    readonly dblclick: "onDblclick";
    readonly rightclick: "onRightclick";
    readonly mousedown: "onMouseDown";
    readonly mouseup: "onMouseUp";
    readonly mouseover: "onMouseOver";
    readonly mouseout: "onMouseOut";
    readonly mousemove: "onMouseMove";
};
type EventKey = keyof typeof EVENT_TO_PROP;
type PropKey = (typeof EVENT_TO_PROP)[EventKey];
interface DataLayerCallbacks {
    addfeature?: (event: naver.maps.FeatureEvent) => void;
    removefeature?: (event: naver.maps.FeatureEvent) => void;
    setfeature?: (event: naver.maps.FeatureEvent) => void;
    setgeometry?: (event: naver.maps.FeatureEvent) => void;
    setproperty?: (event: naver.maps.PropertyEvent) => void;
    removeproperty?: (event: naver.maps.PropertyEvent) => void;
    click?: (event: naver.maps.PointerEvent) => void;
    dblclick?: (event: naver.maps.PointerEvent) => void;
    rightclick?: (event: naver.maps.PointerEvent) => void;
    mousedown?: (event: naver.maps.PointerEvent) => void;
    mouseup?: (event: naver.maps.PointerEvent) => void;
    mouseover?: (event: naver.maps.PointerEvent) => void;
    mouseout?: (event: naver.maps.PointerEvent) => void;
    mousemove?: (event: naver.maps.PointerEvent) => void;
}
type HandlerOfProp<P extends PropKey> = DataLayerCallbacks[{
    [E in EventKey]: (typeof EVENT_TO_PROP)[E] extends P ? E : never;
}[EventKey]];
type DataLayerEventProps = {
    [P in PropKey]?: HandlerOfProp<P>;
};
type DataLayerType = "gpx" | "kml" | "geojson";
interface DataLayerProps extends DataLayerEventProps {
    type: DataLayerType;
    data: string | naver.maps.GeoJSON | naver.maps.GPX | naver.maps.KML;
    autoStyle?: boolean;
    style?: naver.maps.StyleOptions | naver.maps.StylingFunction;
    onLoad?: (layer: naver.maps.Data) => void;
    onError?: (error: Error) => void;
}
declare const DataLayer: ({ type, data, autoStyle, style, onLoad, onError, ...eventProps }: DataLayerProps) => null;

export { Circle, DataLayer, Ellipse, Map, MapProvider, Marker, Overlay, Polygon, Polyline, Rectangle, useMap };
export type { CircleProps, DataLayerProps, EllipseProps, MapProps, MarkerProps, PolylineProps, RectangleProps };