import type { Datum } from "../shared/datumTypes";
import * as React from "react";
import type { StreamGeoFrameProps, ProjectionProp } from "../../stream/geoTypes";
import type { BaseChartProps, ChartAccessor } from "../shared/types";
import { type TooltipProp } from "../../Tooltip/Tooltip";
import type { LegendInteractionMode } from "../shared/hooks";
import { type AreasProp } from "../../geo/useReferenceAreas";
/**
 * ChoroplethMap component props
 */
export interface ChoroplethMapProps<TDatum extends Datum = Datum> extends BaseChartProps {
    /**
     * Either a `GeoJSON.Feature[]` array (one feature per region) or a
     * reference string the library resolves into bundled topology:
     * `"world-110m"`, `"world-50m"`, `"land-110m"`, `"land-50m"`. To pass a
     * custom geography stored as a `FeatureCollection`, hand its `.features`
     * array in. Each feature's `properties` should carry the value
     * `valueAccessor` reads.
     * @example
     * ```ts
     * areas="world-110m"                  // bundled world borders
     * areas={features}                     // GeoJSON.Feature[]
     * areas={featureCollection.features}   // FeatureCollection → unwrap to .features
     * areas={mergeData(world, rows, { featureKey: "iso", dataKey: "iso" })}
     * ```
     */
    areas: AreasProp;
    /**
     * Field name or function returning the numeric value for each feature.
     * Read from `feature.properties` after merging or directly off the
     * feature when values are baked in.
     */
    valueAccessor: ChartAccessor<TDatum, number>;
    /** Sequential color scheme @default "blues" */
    colorScheme?: string;
    /** Geographic projection @default "equalEarth" */
    projection?: ProjectionProp;
    /** Show graticule grid lines */
    graticule?: boolean | import("../../stream/geoTypes").GraticuleConfig;
    /** Tooltip config */
    tooltip?: TooltipProp;
    /** Show legend @default true */
    showLegend?: boolean;
    /** Legend interaction mode */
    legendInteraction?: LegendInteractionMode;
    /** Padding fraction for auto-fit projection. 0.1 = 10% inset from edges. @default 0 */
    fitPadding?: number;
    /** Enable zoom/pan. Defaults to true when tileURL is set, false otherwise. */
    zoomable?: boolean;
    /** [minZoom, maxZoom] @default [1, 8] */
    zoomExtent?: [number, number];
    /** Zoom change callback */
    onZoom?: StreamGeoFrameProps["onZoom"];
    /**
     * When true, drag gestures rotate the projection (globe spinning)
     * instead of panning. Defaults to true for orthographic projection.
     */
    dragRotate?: boolean;
    /** Raster tile URL template or function. Enables tile basemap (Mercator only). */
    tileURL?: string | ((z: number, x: number, y: number, dpr: number) => string);
    /** Attribution text for tile provider */
    tileAttribution?: string;
    /** Max cached tiles @default 256 */
    tileCacheSize?: number;
    /** Fill opacity for area polygons. Useful for layering over tile basemaps. @default 1 */
    areaOpacity?: number;
    /** Annotations */
    annotations?: Datum[];
    /** Passthrough to StreamGeoFrame */
    frameProps?: Partial<Omit<StreamGeoFrameProps, "areas" | "projection">>;
}
/**
 * ChoroplethMap - Encode a numeric value per region with a sequential color scale.
 *
 * Each feature in `areas` is filled with a color derived from its
 * `valueAccessor` value, scaled across the data extent. For point-based
 * geographic data use {@link ProportionalSymbolMap}; for flow data use
 * {@link FlowMap}.
 *
 * @example
 * ```tsx
 * // World choropleth from a bundled topology, values merged in.
 * // `resolveReferenceGeography` is async, so resolve it in an effect
 * // before merging — or pass the reference string directly to `areas`
 * // if your topology already carries the values you need.
 * import * as React from "react"
 * import { ChoroplethMap, mergeData, resolveReferenceGeography } from "semiotic/geo"
 *
 * function WorldGDPMap({ gdpRows }) {
 *   const [areas, setAreas] = React.useState([])
 *   React.useEffect(() => {
 *     let cancelled = false
 *     resolveReferenceGeography("world-110m").then(world => {
 *       if (cancelled) return
 *       setAreas(mergeData(world, gdpRows, { featureKey: "iso_a3", dataKey: "iso" }))
 *     })
 *     return () => { cancelled = true }
 *   }, [gdpRows])
 *
 *   return (
 *     <ChoroplethMap
 *       areas={areas}
 *       valueAccessor={(f) => f.properties.gdp}
 *       colorScheme="viridis"
 *       projection="equalEarth"
 *     />
 *   )
 * }
 * ```
 *
 * @example
 * ```tsx
 * // Custom GeoJSON + graticule + zoom/pan
 * <ChoroplethMap
 *   areas={statesGeoJson}
 *   valueAccessor="population_density"
 *   colorScheme="oranges"
 *   projection="albersUsa"
 *   graticule
 *   zoomable
 * />
 * ```
 *
 * @example
 * ```tsx
 * // Tile basemap underlay (Mercator only) with semi-transparent areas
 * <ChoroplethMap
 *   areas={countiesGeoJson}
 *   valueAccessor="rate"
 *   projection="mercator"
 *   tileURL="https://tile.openstreetmap.org/{z}/{x}/{y}.png"
 *   tileAttribution="© OpenStreetMap contributors"
 *   areaOpacity={0.7}
 * />
 * ```
 *
 * @remarks
 * The legend defaults to a sequential gradient legend matching the chosen
 * `colorScheme`. For diverging data (positive/negative around zero), use
 * a diverging scheme name and pass `frameProps={{ colorDomain: [-max, max] }}`.
 */
export declare function ChoroplethMap<TDatum extends Datum = Datum>(props: ChoroplethMapProps<TDatum>): React.JSX.Element;
export declare namespace ChoroplethMap {
    var displayName: string;
}
