@macrostrat/column-views 1.0.3 → 2.0.1

package/dist/esm/index.d.ts

@@ -1,14 +1,16 @@
 import { ScaleContinuousNumeric, ScaleLinear } from "d3-scale";
-import { Component, ReactNode, Context, FunctionComponentElement, Dispatch, SetStateAction, ProviderProps, PropsWithChildren, JSXElementConstructor, ReactElement, DOMAttributes, DOMElement, ComponentElement, MutableRefObject, RefObject } from "react";
-import { BaseUnit, UnitLong } from "@macrostrat/api-types";
-import { LithologyColumnProps, CrossAxisLayoutProviderProps as _CrossAxisLayoutProviderProps1, ColumnDivision as _ColumnDivision1, ColumnProviderProps } from "@macrostrat/column-components";
-import { AxisProps } from "@visx/axis/lib/axis/Axis";
+import { Component, ReactNode, Context, FunctionComponentElement, RefObject, ProviderProps, DOMAttributes, DOMElement, JSXElementConstructor, ReactElement, ComponentElement, CSSProperties, MutableRefObject, InputHTMLAttributes, DetailedReactHTMLElement, FunctionComponent, HTMLAttributes, AriaRole, ClipboardEventHandler, CompositionEventHandler, FocusEventHandler, FormEventHandler, ReactEventHandler, KeyboardEventHandler, MouseEventHandler, DragEventHandler, TouchEventHandler, PointerEventHandler, UIEventHandler, WheelEventHandler, AnimationEventHandler, TransitionEventHandler } from "react";
+import { UnitLong, BaseUnit, ColumnGeoJSONRecord, MacrostratRef, ColumnGeoJSONRecordWithID, Environment } from "@macrostrat/api-types";
+import { StoreApi } from "zustand";
 import { APIConfig, APIConfigOptions } from "@macrostrat/ui-components";
 import { AxiosRequestConfig, AxiosInstance } from "axios";
+import { ColumnDivision as _ColumnDivision1, ColumnProviderProps, LithologyColumnProps, CrossAxisLayoutProviderProps as _CrossAxisLayoutProviderProps1 } from "@macrostrat/column-components";
+import { AxisProps } from "@visx/axis/lib/axis/Axis";
+import mapboxgl from "mapbox-gl";
+import { Geometry, FeatureCollection, Polygon, LineString, Point } from "geojson";
 import { ExtendedFeature } from "d3-geo";
-import { Polygon } from "geojson";
 import { IFeature } from "@macrostrat/svg-map-components";
-import { UnitSelectionProps as _UnitSelectionProps1 } from "column-views/src";
+import { MacrostratDataProviderProps as _MacrostratDataProviderProps1, MacrostratColumnDataContext as _MacrostratColumnDataContext1, ColumnContainerProps as _ColumnContainerProps1 } from "column-views/src";
 type HeightRange = [number, number];
 type ColumnScale = ScaleContinuousNumeric<HeightRange, number> | any;
 type ColumnScaleClamped = ScaleLinear<number, number>;
@@ -27,7 +29,8 @@ interface ColumnDivision {
 enum ColumnAxisType {
     AGE = "age",
     HEIGHT = "height",
-    DEPTH = "depth"
+    DEPTH = "depth",
+    ORDINAL = "ordinal"
 }
 interface ColumnCtx<T extends ColumnDivision> {
     divisions: T[];
@@ -65,7 +68,7 @@ declare namespace InfiniteScrollView {
         getItems(d: any): any;
         getCount(d: any): any;
         getNextParams(response: any, params: any): any;
-        placeholder: (p: APIPlaceholderProps) => React.ComponentElement<$$parcel$import$208<HTMLElement>, Spinner>;
+        placeholder: (p: APIPlaceholderProps) => React.FunctionComponentElement<$$parcel$import$208<HTMLElement>>;
     };
 }
 declare namespace ThreeColumnLayout {
@@ -79,24 +82,209 @@ export interface IUnit {
     b_age: number;
     [x: string]: any;
 }
-export enum MacrostratAxisKey {
-    AGE = "age",
-    POS = "pos"
+export interface RectBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
 }
-export function transformAxisType(t: ColumnAxisType): MacrostratAxisKey;
+interface StratigraphicPackage {
+    /** A collection of stratigraphic information organized in time, corresponding
+     * to single or multiple columns. */
+    t_age: number;
+    b_age: number;
+}
+interface SectionInfo<T extends UnitLong = ExtUnit> extends StratigraphicPackage {
+    /** A time-bounded part of a single stratigraphic column. */
+    section_id: number | number[];
+    units: T[];
+}
+interface ExtUnit extends UnitLong {
+    bottomOverlap: boolean;
+    overlappingUnits: number[];
+    column?: number;
+    t_clip_pos?: number;
+    b_clip_pos?: number;
+}
+export function preprocessUnits<T extends UnitLong = UnitLong>(section: SectionInfo<T>, axisType?: ColumnAxisType): ExtUnit[];
+export function groupUnitsIntoSections<T extends UnitLong>(units: T[], axisType?: ColumnAxisType): SectionInfo<T>[];
+interface UnitsOverlap {
+    (a: StratigraphicPackage, b: StratigraphicPackage, axisType?: ColumnAxisType.AGE, tolerance?: number): boolean;
+    (a: BaseUnit, b: BaseUnit, axisType: ColumnAxisType, tolerance?: number): boolean;
+}
+export const unitsOverlap: UnitsOverlap;
+/** A more permissive overlap function in the age space */
+export function agesOverlap(a: StratigraphicPackage, b: StratigraphicPackage, tolerance?: number): boolean;
+interface PossiblyClippedUnit extends BaseUnit {
+    t_clip_pos?: number;
+    b_clip_pos?: number;
+}
+export function getUnitHeightRange(unit: PossiblyClippedUnit, axisType: ColumnAxisType): [number, number];
+export const createUnitSorter: (axisType: ColumnAxisType) => (a: BaseUnit, b: BaseUnit) => number;
+export function ensureArray<T>(x: T | T[]): T[];
+export function ensureRealFloat(x: number | string | null): number | null;
 type UnitSelectDispatch = (unit: BaseUnit | null, target: HTMLElement | null, event: Event | null) => void;
 export function useUnitSelectionDispatch(): UnitSelectDispatch;
+export function useUnitSelectionStore<T>(selector: (state: UnitSelectionStore) => T): T;
 export function useSelectedUnit(): BaseUnit;
-export interface UnitSelectionProps<T extends BaseUnit> {
+interface UnitSelectionStore {
+    selectedUnit: number | null;
+    selectedUnitData: BaseUnit | null;
+    overlayPosition: RectBounds | null;
+    onUnitSelected: UnitSelectDispatch;
+    setSelectedUnit: (unit: number | null) => void;
+}
+export function UnitSelectionProvider<T extends BaseUnit>(props: {
+    children: ReactNode;
+    columnRef?: RefObject<HTMLElement>;
+    units: T[];
+    selectedUnit: number | null;
+    onUnitSelected?: (unitID: number | null, unit: T | null) => void;
+}): FunctionComponentElement<ProviderProps<StoreApi<UnitSelectionStore>>>;
+export function useUnitSelectionTarget(unit: IUnit): [React.RefObject<HTMLElement>, boolean, (evt: Event) => void];
+export function UnitKeyboardNavigation<T extends BaseUnit>({ units, }: {
+    units: T[];
+}): any;
+declare function defaultFetch(url: string, options?: RequestInit | undefined): Promise<Response>;
+export interface ColumnFetchOptions {
+    apiBaseURL?: string;
+    projectID?: number;
+    statusCode?: "in process";
+    format?: "geojson" | "topojson" | "geojson_bare";
+    fetch?: any;
+}
+export function fetchAllColumns(options?: ColumnFetchOptions): Promise<ColumnGeoJSONRecord[]>;
+export function useColumnFeatures({ apiRoute, status_code, project_id, format, }: {
+    apiRoute?: string;
+    status_code: any;
+    project_id: any;
+    format?: string;
+}): unknown;
+export function fetchLithologies(fetch?: typeof defaultFetch): Promise<any>;
+export function fetchIntervals(timescaleID: number | null, fetch?: typeof defaultFetch): Promise<any>;
+export function fetchEnvironments(fetch?: typeof defaultFetch): Promise<any>;
+export function fetchRefs(refs: number[], fetch?: typeof defaultFetch): Promise<MacrostratRef[]>;
+export type ColumnData = {
+    units: UnitLong[];
+    columnID: number;
+};
+export function fetchUnits(columns: number[], fetch?: typeof defaultFetch): Promise<ColumnData[]>;
+export function fetchColumnUnits(col_id: number, fetch?: typeof defaultFetch): Promise<ColumnData>;
+interface ColumnHeightScaleOptions {
+    /** A fixed pixel scale to use for the section (pixels per Myr) */
+    pixelScale?: number;
+    /** The target height of a constituent unit in pixels, for dynamic
+     * scale generation */
+    targetUnitHeight?: number;
+    /** Min height of a section in pixels. Will override minPixelScale in some cases. */
+    minSectionHeight?: number;
+    /** The minimum pixel scale to use for the section (pixels per Myr). This is mostly
+     * needed because small sections (<1-2 units) don't necessarily have space to comfortably
+     * render two axis labels */
+    minPixelScale?: number;
+    axisType?: ColumnAxisType;
+    unconformityHeight?: number;
+    collapseSmallUnconformities?: boolean | number;
+}
+interface LinearScaleDef {
+    domain: [number, number];
+    pixelScale: number;
+}
+/** Output of a section scale. For now, this assumes that the
+ * mapping is linear, but it could be extended to support arbitrary
+ * scale functions.
+ */
+interface PackageScaleInfo extends LinearScaleDef {
+    pixelHeight: number;
+    scale: ScaleLinear<number, number>;
+}
+type PackageScaleLayoutData = PackageScaleInfo & {
+    key: string;
+    offset: number;
+    paddingTop: number;
+};
+type PackageLayoutData<T extends UnitLong = ExtUnit> = SectionInfo<T> & {
+    scaleInfo: PackageScaleLayoutData;
+    key: string;
+};
+interface CompositeScaleData {
+    totalHeight: number;
+    sections: PackageScaleLayoutData[];
+}
+interface ColumnScaleOptions extends ColumnHeightScaleOptions {
+    axisType: ColumnAxisType;
+    unconformityHeight: number;
+}
+interface CompositeColumnData<T extends UnitLong = ExtUnit> extends Omit<CompositeScaleData, "sections"> {
+    sections: PackageLayoutData<T>[];
+}
+export interface MacrostratColumnDataContext {
+    units: ExtUnit[];
+    sections: PackageLayoutData[];
+    totalHeight?: number;
+    axisType?: ColumnAxisType;
+}
+export function MacrostratColumnDataProvider({ children, units, sections, totalHeight, axisType, }: MacrostratColumnDataContext & {
+    children: ReactNode;
+}): FunctionComponentElement<ProviderProps<MacrostratColumnDataContext>>;
+export function useMacrostratColumnData(): MacrostratColumnDataContext;
+export function useMacrostratUnits(): ExtUnit[];
+export function useCompositeScale(): (age: number) => number | null;
+export interface MacrostratDataProviderProps {
+    baseURL: string;
     children: React.ReactNode;
-    unit: T | null;
-    setUnit: Dispatch<SetStateAction<T>>;
-    onUnitSelected?: (unit: T, target: HTMLElement, event: Event) => void;
 }
-export function UnitSelectionProvider<T extends BaseUnit>(props: Partial<UnitSelectionProps<T>>): FunctionComponentElement<UnitSelectionProps<BaseUnit>> | FunctionComponentElement<{
+interface ColumnFootprintsStorage {
+    project_id: number;
+    inProcess: boolean;
+    columns: ColumnGeoJSONRecordWithID[];
+}
+interface RefsSlice {
+    refs: Map<number, MacrostratRef>;
+    inFlightRequests: Set<string>;
+    getRefs(ids: number[]): Promise<MacrostratRef[]>;
+}
+interface MacrostratStore extends RefsSlice {
+    baseURL: string;
+    fetch: any;
+    lithologies: Map<number, any> | null;
+    getLithologies(ids: number[] | null): Promise<any>;
+    intervals: Map<number, any> | null;
+    getIntervals(ids: number[] | null, timescaleID: number | null): Promise<any>;
+    environments: Map<number, Environment> | null;
+    getEnvironments(ids: number[] | null): Promise<Environment[]>;
+    columnFootprints: Map<number, ColumnFootprintsStorage>;
+    getColumns(projectID: number | null, inProcess: boolean): Promise<ColumnGeoJSONRecord[]>;
+}
+type MacrostratSelector = (store: MacrostratStore) => any;
+export function useMacrostratStore(selector: MacrostratSelector | "api"): any;
+export function useMacrostratDefs(dataType: string): Map<number, any> | null;
+export function useMacrostratColumns(projectID: number | null, inProcess: boolean): any;
+export function useMacrostratData(dataType: string, ...args: any[]): any;
+export function MacrostratDataProvider(props: MacrostratDataProviderProps): FunctionComponentElement<APIProviderProps>;
+/** Legacy API provider so useAPIResult can work */
+type APIProviderProps = {
     children: ReactNode;
-    onUnitSelected?: (unit: BaseUnit, target: HTMLElement, event: Event) => void;
+    useDev?: boolean;
+    baseURL?: string;
+};
+export function MacrostratAPIProvider({ children, useDev, baseURL, }: APIProviderProps): FunctionComponentElement<Partial<APIConfig> & AxiosRequestConfig<any> & Partial<AxiosRequestConfig<any>> & {
+    config?: Partial<APIConfigOptions>;
+} & {
+    context?: Context<{
+        baseURL: string;
+        axiosInstance: AxiosInstance;
+    } & {
+        config: APIConfig;
+    }>;
+    children?: React.ReactChild;
 }>;
+export function MacrostratColumnProvider(props: any): FunctionComponentElement<ColumnProviderProps<_ColumnDivision1>>;
+/** This is now a legacy provider */
+export function LithologiesProvider({ children }: {
+    children: any;
+}): any;
+export function useLithologies(): any;
 export interface ColumnArgs {
     col_id?: number;
     unit_id?: number;
@@ -109,31 +297,27 @@ export function ColumnNavProvider({ children, ...defaultArgs }: {
     [x: string]: any;
     children: any;
 }): FunctionComponentElement<ProviderProps<ColumnManagerData>>;
-export function UnitKeyboardNavigation<T extends BaseUnit>({ units, }: {
-    units: T[];
-}): any;
-interface RectBounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
+export function getMixedUnitColor(unit: UnitLong, lithMap: any, inDarkMode?: boolean, asBackground?: boolean): string | null;
 interface UnitRectOptions {
     widthFraction?: number;
     axisType?: ColumnAxisType;
+    padding?: number;
 }
 interface LabeledUnitProps extends UnitRectOptions, Clickable, Partial<RectBounds> {
     division: IUnit;
     label: string;
     onLabelUpdated?(label: string, shown: boolean): any;
     halfWidth?: boolean;
+    showLabel?: boolean;
+    backgroundColor?: string;
 }
-export function TrackedLabeledUnit({ division, nameForDivision, axisType, ...rest }: {
+export function LabelTrackerProvider(props: any): FunctionComponentElement<ProviderProps<any>>;
+export function TrackedLabeledUnit({ division, nameForDivision, ...rest }: {
     [x: string]: any;
     division: any;
     nameForDivision?: (div: any) => any;
-    axisType: any;
 }): FunctionComponentElement<LabeledUnitProps>;
+export const CompositeUnitComponent: typeof TrackedLabeledUnit;
 type BaseUnitProps = {
     width: number;
     showLabels?: boolean;
@@ -151,25 +335,32 @@ export type ICompositeUnitProps = BaseUnitProps & {
     noteMode?: "labeled" | "unlabeled";
     showLabelColumn?: boolean;
     noteComponent?: React.FC<any>;
-    shouldRenderNote?: (d: BaseUnit) => boolean;
-};
-type AnnotatedUnitProps = ICompositeUnitProps & {
-    minimumLabelHeight?: number;
-    axisType: ColumnAxisType;
+    shouldRenderNote?: (d: any) => boolean;
 };
-export function AnnotatedUnitsColumn(props: AnnotatedUnitProps): FunctionComponentElement<PropsWithChildren<{
-    width: number;
-    unitComponent?: React.FC<any>;
+interface CompositeUnitProps {
+    unitComponent: React.FC<any>;
     unitComponentProps?: any;
-    clipToFrame?: boolean;
-}>>;
-export function CompositeUnitsColumn(props: ICompositeUnitProps): FunctionComponentElement<PropsWithChildren<{
     width: number;
-    unitComponent?: React.FC<any>;
-    unitComponentProps?: any;
+    showLabels?: boolean;
     clipToFrame?: boolean;
-}>>;
-export function CompositeUnitComponent({ division, nColumns, ...rest }: {
+}
+export function CompositeUnitsColumn(props: CompositeUnitProps): FunctionComponentElement<LithologyColumnProps>;
+export function AnnotatedUnitsColumn(props: ICompositeUnitProps): any;
+export function SectionLabelsColumn(props: ICompositeUnitProps): DOMElement<DOMAttributes<Element>, Element>;
+type CompositeScaleOpts = {
+    clamped?: boolean;
+};
+export interface CompositeColumnScale {
+    (val: number): number;
+    copy(): CompositeColumnScale;
+    domain(): number[];
+}
+export function compositeScale(sections: any, opts?: CompositeScaleOpts): CompositeColumnScale;
+export function UnitsColumn({ width }: {
+    width?: number;
+}): FunctionComponentElement<LithologyColumnProps>;
+export function SimpleUnitsColumn(props: ICompositeUnitProps): ReactElement<any, string | JSXElementConstructor<any>>;
+export function UnitComponent({ division, nColumns, ...rest }: {
     [x: string]: any;
     division: any;
     nColumns?: number;
@@ -177,13 +368,42 @@ export function CompositeUnitComponent({ division, nColumns, ...rest }: {
     [x: string]: any;
     division: any;
     nameForDivision?: (div: any) => any;
-    axisType: any;
 }>;
-export const UnitsColumn: ({ width }: {
-    width?: number;
-}) => FunctionComponentElement<LithologyColumnProps>;
-export const SimpleUnitsColumn: (props: ICompositeUnitProps) => ReactElement<any, string | JSXElementConstructor<any>>;
-export function AgeAxis(props: any): DOMElement<DOMAttributes<Element>, Element>;
+export function ColoredUnitComponent(props: any): FunctionComponentElement<{
+    [x: string]: any;
+    division: any;
+    nColumns?: number;
+}>;
+enum LithologyTagFeature {
+    Proportion = "proportion",
+    Attributes = "attributes"
+}
+type LatLng = {
+    lng: number;
+    lat: number;
+};
+type TargetPosition = LatLng & {
+    zoom: number;
+};
+type CameraPosition = LatLng & {
+    bearing?: number;
+    pitch?: number;
+    altitude: number;
+};
+type MapPosition = {
+    camera: CameraPosition;
+    target?: TargetPosition;
+};
+export function VerticalAxisLabel(props: any): ReactElement<{
+    className: any;
+}, string | JSXElementConstructor<any>>;
+export function CompositeAgeAxis(): FunctionComponentElement<CompositeStratigraphicScaleInfo>;
+export interface CompositeStratigraphicScaleInfo {
+    axisType: ColumnAxisType;
+    totalHeight: number;
+    packages: PackageScaleLayoutData[];
+}
+export function CompositeAgeAxisCore(props: CompositeStratigraphicScaleInfo): ReactElement<any, string | JSXElementConstructor<any>>;
 export const MeasurementDataContext: Context<any>;
 export function MeasurementDataProvider(props: any): FunctionComponentElement<ProviderProps<any>>;
 export const useMeasurementData: () => any;
@@ -211,23 +431,126 @@ export function IsotopesDataset(props: any): FunctionComponentElement<DataAreaPr
 export function IsotopesColumn(props: IsotopeColumnProps & {
     children?: React.ReactNode;
 } & AxisProps<any>): ComponentElement<_CrossAxisLayoutProviderProps1, CrossAxisLayoutProvider>;
-export function MacrostratColumnProvider(props: any): FunctionComponentElement<ColumnProviderProps<_ColumnDivision1>>;
-type APIProviderProps = {
-    children: ReactNode;
-    useDev?: boolean;
-    baseURL?: string;
+type MapboxCoreOptions = Omit<mapboxgl.MapboxOptions, "container">;
+interface MapViewProps extends MapboxCoreOptions {
+    showLineSymbols?: boolean;
+    children?: React.ReactNode;
+    mapboxToken?: string;
+    accessToken?: string;
+    terrainSourceID?: string;
+    enableTerrain?: boolean;
+    infoMarkerPosition?: mapboxgl.LngLatLike;
+    mapPosition?: MapPosition;
+    initializeMap?: (container: HTMLElement, args: MapboxOptionsExt) => mapboxgl.Map;
+    onMapLoaded?: (map: mapboxgl.Map) => void;
+    onStyleLoaded?: (map: mapboxgl.Map) => void;
+    onMapMoved?: (mapPosition: MapPosition, map: mapboxgl.Map) => void;
+    /** This map sets its own viewport, rather than being positioned by a parent.
+     * This is a hack to ensure that the map can overflow its "safe area" when false */
+    standalone?: boolean;
+    /** Overlay styles to apply to the map: a list of mapbox style objects or fragments to
+     * overlay on top of the main map style at runtime */
+    overlayStyles?: Partial<mapboxgl.Style>[];
+    /** A function to transform the map style before it is loaded */
+    transformStyle?: (style: mapboxgl.Style) => mapboxgl.Style;
+}
+interface MapboxOptionsExt extends MapboxCoreOptions {
+    mapPosition?: MapPosition;
+}
+export interface InsetMapProps extends Omit<MapViewProps, "style"> {
+    controls?: ReactNode;
+    className?: string;
+    children?: ReactNode;
+    style?: CSSProperties;
+    mapStyle?: mapboxgl.Style | string;
+    showLabels?: boolean;
+    showAdmin?: boolean;
+    showRoads?: boolean;
+}
+export function InsetMap({ controls, className, children, style, mapStyle, accessToken, showLabels, showAdmin, showRoads, ...rest }: InsetMapProps): ReactElement<{
+    className: string;
+    style: CSSProperties;
+}, string | JSXElementConstructor<any>>;
+export function buildColumnsStyle(color: string): {
+    sources: {
+        columns: {
+            type: string;
+            data: FeatureCollection<Geometry, {
+                [name: string]: any;
+            }>;
+        };
+    };
+    layers: ({
+        id: string;
+        type: string;
+        source: string;
+        paint: {
+            "fill-color": string;
+            "fill-opacity": (string | number | (string | boolean | string[])[])[];
+            "line-color"?: undefined;
+            "line-width"?: undefined;
+            "line-opacity"?: undefined;
+            "circle-radius"?: undefined;
+            "circle-color"?: undefined;
+            "circle-opacity"?: undefined;
+        };
+        filter?: undefined;
+    } | {
+        id: string;
+        type: string;
+        source: string;
+        paint: {
+            "line-color": string;
+            "line-width": number;
+            "line-opacity": number;
+            "fill-color"?: undefined;
+            "fill-opacity"?: undefined;
+            "circle-radius"?: undefined;
+            "circle-color"?: undefined;
+            "circle-opacity"?: undefined;
+        };
+        filter?: undefined;
+    } | {
+        id: string;
+        type: string;
+        source: string;
+        paint: {
+            "circle-radius": number;
+            "circle-color": string;
+            "circle-opacity": (string | number | (string | boolean | string[])[])[];
+            "fill-color"?: undefined;
+            "fill-opacity"?: undefined;
+            "line-color"?: undefined;
+            "line-width"?: undefined;
+            "line-opacity"?: undefined;
+        };
+        filter: string[];
+    })[];
 };
-export function MacrostratAPIProvider({ children, useDev, baseURL, }: APIProviderProps): FunctionComponentElement<Partial<APIConfig> & AxiosRequestConfig<any> & Partial<AxiosRequestConfig<any>> & {
-    config?: Partial<APIConfigOptions>;
-} & {
-    context?: Context<{
-        baseURL: string;
-        axiosInstance: AxiosInstance;
-    } & {
-        config: APIConfig;
-    }>;
-    children?: React.ReactChild;
-}>;
+interface NavigationProviderProps {
+    projectID?: number;
+    inProcess?: boolean;
+    selectedColumn?: number | null;
+    hoveredColumn?: number | null;
+    columns?: ColumnGeoJSONRecordWithID[] | null;
+    children: ReactNode;
+    onSelectColumn?: (col_id: number | null, column: any) => void;
+    onHoverColumn?: (col_id: number | null, column: any) => void;
+}
+export interface ColumnNavigationMapProps extends InsetMapProps {
+    padding?: number;
+    children?: ReactNode;
+    accessToken?: string;
+    selectedColumn?: number;
+    hoveredColumn?: number;
+    onSelectColumn?: (colID: number | null) => void;
+    onHoverColumn?: (colID: number | null) => void;
+    showTriangulation?: boolean;
+    columnColor?: string;
+    triangulationColor?: string;
+    keyboardNavigation?: boolean;
+}
+export function ColumnNavigationMap(props: ColumnNavigationMapProps & NavigationProviderProps): FunctionComponentElement<NavigationProviderProps>;
 export function MeasurementsLayer(props: any): FunctionComponentElement<{
     [k: string]: any;
     geometry?: object;
@@ -240,7 +563,6 @@ type _ColumnProps1 = {
     col_id: number;
 };
 type ColumnFeature = ExtendedFeature<Polygon, _ColumnProps1>;
-export function processTopoJSON(res: any): any;
 export function ColumnFeatures(props: any): FunctionComponentElement<{
     [k: string]: any;
     geometry?: object;
@@ -263,12 +585,6 @@ interface KeyboardNavProps extends ColumnNavProps {
     showLayers: boolean;
 }
 export function ColumnKeyboardNavigation(props: KeyboardNavProps): ReactElement<any, string | JSXElementConstructor<any>>;
-export function useColumnData({ apiRoute, status_code, project_id, format, }: {
-    apiRoute?: string;
-    status_code: any;
-    project_id: any;
-    format?: string;
-}): unknown;
 interface ColumnExtraInfo {
     apiRoute?: string;
     color?: string;
@@ -291,83 +607,434 @@ export function ResizableMapFrame(props: any): ReactElement<{
     style: any;
     className: any;
 }, string | JSXElementConstructor<any>>;
-export const ColumnNavigatorMap: (props: any) => FunctionComponentElement<any>;
-export function CarbonIsotopesColumn(columnArgs: any): FunctionComponentElement<{
-    children: ReactNode;
-    useDev?: boolean;
-    baseURL?: string;
-}>;
-export function CarbonIsotopesApp(): FunctionComponentElement<{
+export type ColumnNavigationSVGMapProps = any;
+export function ColumnNavigationSVGMap(props: any): FunctionComponentElement<any>;
+export interface CorrelationMapInput {
+    columns: ColumnGeoJSONRecord[];
+    focusedLine: LineString | null;
+}
+export interface CorrelationMapStore extends CorrelationMapInput {
+    onClickMap: (event: mapboxgl.MapMouseEvent, point: Point) => void;
+}
+export interface CorrelationProviderProps extends CorrelationMapInput {
+    projectID?: number;
+    inProcess?: boolean;
+    columns: ColumnGeoJSONRecord[] | null;
     children: ReactNode;
-    useDev?: boolean;
-    baseURL?: string;
+    onSelectColumns?: (columns: FocusedColumnGeoJSONRecord[], line: LineString | null) => void;
+}
+type ComputedStore = {
+    focusedColumns: FocusedColumnGeoJSONRecord[];
+};
+export function ColumnCorrelationProvider({ children, columns, projectID, inProcess, focusedLine, onSelectColumns, }: CorrelationProviderProps): FunctionComponentElement<ProviderProps<StoreApi<CorrelationMapStore>>>;
+export function useCorrelationMapStore(selector: (state: CorrelationMapStore & ComputedStore) => any): any;
+interface FocusedColumnGeoJSONRecord extends ColumnGeoJSONRecord {
+    properties: {
+        centroid: Point;
+        nearestPointOnLine: Point;
+        distanceAlongLine: number;
+    } & ColumnGeoJSONRecord["properties"];
+}
+export interface CorrelationMapProps extends InsetMapProps {
+    padding?: number;
+    children?: ReactNode;
+    accessToken?: string;
+    columnColor?: string;
+}
+export function ColumnCorrelationMap(props: CorrelationMapProps): DetailedReactHTMLElement<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+export function CarbonIsotopesColumn(columnArgs: any): FunctionComponentElement<_MacrostratDataProviderProps1>;
+export function CarbonIsotopesApp(): FunctionComponentElement<_MacrostratDataProviderProps1>;
+export interface PrepareColumnOptions extends ColumnScaleOptions {
+    axisType: ColumnAxisType;
+    t_age?: number;
+    b_age?: number;
+    mergeSections?: MergeSectionsMode;
+    collapseSmallUnconformities?: boolean | number;
+}
+export enum MergeSectionsMode {
+    ALL = "all",
+    OVERLAPPING = "overlapping"
+}
+export interface PreparedColumnData extends CompositeColumnData {
+    sections: PackageLayoutData[];
+    units: ExtUnit[];
+}
+export function usePreparedColumnUnits(data: UnitLong[], options: PrepareColumnOptions): PreparedColumnData;
+export function prepareColumnUnits(units: UnitLong[], options: PrepareColumnOptions): PreparedColumnData;
+export function UnitDetailsPanel({ unit, onClose, className, features, lithologyFeatures, actions, selectUnit, columnUnits, }: {
+    unit: any;
+    onClose?: any;
+    showLithologyProportions?: boolean;
+    className?: string;
+    actions?: ReactNode;
+    features?: Set<UnitDetailsFeature>;
+    lithologyFeatures?: Set<LithologyTagFeature>;
+    columnUnits?: UnitLong[];
+    selectUnit?: (unitID: number) => void;
+}): ReactElement<{
+    className: string;
+}, string | JSXElementConstructor<any>>;
+export function LegendPanelHeader({ title, id, onClose, actions, hiddenActions, }: {
+    title?: string | null;
+    id?: number | null;
+    onClose?: () => void;
+    actions?: ReactNode | null;
+    hiddenActions?: ReactNode | null;
+}): DOMElement<DOMAttributes<Element>, Element>;
+export enum UnitDetailsFeature {
+    AdjacentUnits = "adjacent-units",
+    Color = "color",
+    OutcropType = "outcrop-type",
+    JSONToggle = "json-toggle",
+    DepthRange = "depth-range"
+}
+export function Duration({ value, maximumFractionDigits, minimumFractionDigits, }: {
+    value: any;
+    maximumFractionDigits?: number;
+    minimumFractionDigits?: number;
+}): FunctionComponentElement<{
+    value?: any;
+    unit?: string;
+    children?: any;
 }>;
+export function UnitDetailsPopover({ style, children, viewportPadding, }: {
+    style: object;
+    viewportPadding?: number;
+    children: React.ReactNode;
+}): ReactElement<{
+    style: object;
+}, string | JSXElementConstructor<any>>;
+export function UnitSelectionPopover(): DOMElement<DOMAttributes<Element>, Element>;
 declare namespace AgeAxis {
     var defaultProps: {
         width: number;
         margin: number;
     };
 }
-interface SectionInfo {
-    section_id: number | number[];
-    t_age: number;
-    b_age: number;
-    units: IUnit[];
-}
-interface IColumnProps {
-    data: IUnit[];
-    pixelScale?: number;
-    range?: [number, number];
-    unitComponent?: React.FunctionComponent<any>;
+interface SectionSharedProps {
+    unitComponent?: FunctionComponent<any>;
     unitComponentProps?: any;
     showLabels?: boolean;
     width?: number;
     columnWidth?: number;
-    targetUnitHeight?: number;
     children?: ReactNode;
     showLabelColumn?: boolean;
-}
-interface ExtUnit extends UnitLong {
-    bottomOverlap: boolean;
-    overlappingUnits: number[];
-    column?: number;
-}
-export function extendDivision(unit: UnitLong, i: number, divisions: UnitLong[]): ExtUnit;
-export function preprocessUnits(units: UnitLong[]): ExtUnit[];
-export function groupUnitsIntoSections(units: IUnit[]): SectionInfo[];
-export function _mergeOverlappingSections(sections: SectionInfo[]): SectionInfo[];
-export function ensureArray<T>(x: T | T[]): T[];
-export function UnitDetailsPanel({ unit, onClose, }: {
-    unit: any;
-    onClose?: any;
-}): DOMElement<DOMAttributes<Element>, Element>;
-export function LegendPanelHeader({ title, id, onClose, actions }: {
-    title: any;
-    id: any;
-    onClose: any;
-    actions?: any;
-}): DOMElement<DOMAttributes<Element>, Element>;
-export function UnitComponent({ division, nColumns, ...rest }: {
-    [x: string]: any;
-    division: any;
-    nColumns?: number;
-}): FunctionComponentElement<{
-    [x: string]: any;
-    division: any;
-    nameForDivision?: (div: any) => any;
-    axisType: any;
-}>;
-export interface ColumnProps extends IColumnProps {
+    axisType?: ColumnAxisType;
+    className?: string;
+    clipUnits?: boolean;
+    maxInternalColumns?: number;
+    verticalSpacing?: number;
     unconformityLabels?: boolean;
+}
+interface BaseColumnProps extends SectionSharedProps {
     className?: string;
-    mergeOverlappingSections?: boolean;
     showLabelColumn?: boolean;
-    columnRef?: RefObject<HTMLElement>;
     keyboardNavigation?: boolean;
-    showUnitPopover?: boolean;
+    showLabels?: boolean;
+    maxInternalColumns?: number;
+    showTimescale?: boolean;
+    timescaleLevels?: number | [number, number];
+}
+export interface ColumnProps extends BaseColumnProps, ColumnHeightScaleOptions {
+    units: UnitLong[];
     t_age?: number;
     b_age?: number;
+    mergeSections?: MergeSectionsMode;
+    showUnitPopover?: boolean;
+    selectedUnit?: number | null;
+    onUnitSelected?: (unitID: number | null, unit: any) => void;
+    unconformityHeight?: number;
+}
+export function Column(props: ColumnProps): DOMElement<DOMAttributes<Element>, Element> | FunctionComponentElement<_MacrostratColumnDataContext1 & {
+    children: ReactNode;
+}>;
+export interface ColumnContainerProps extends HTMLAttributes<HTMLDivElement> {
+    className?: string;
+}
+export function ColumnContainer(props: ColumnContainerProps): DOMElement<{
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+    autoFocus?: boolean | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+    hidden?: boolean | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    nonce?: string | undefined;
+    slot?: string | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    style?: CSSProperties | undefined;
+    tabIndex?: number | undefined;
+    title?: string | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    role?: AriaRole | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    color?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+    is?: string | undefined;
+    "aria-activedescendant"?: string | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+    "aria-braillelabel"?: string | undefined;
+    "aria-brailleroledescription"?: string | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-colcount"?: number | undefined;
+    "aria-colindex"?: number | undefined;
+    "aria-colindextext"?: string | undefined;
+    "aria-colspan"?: number | undefined;
+    "aria-controls"?: string | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+    "aria-describedby"?: string | undefined;
+    "aria-description"?: string | undefined;
+    "aria-details"?: string | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+    "aria-errormessage"?: string | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    "aria-keyshortcuts"?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-labelledby"?: string | undefined;
+    "aria-level"?: number | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    "aria-owns"?: string | undefined;
+    "aria-placeholder"?: string | undefined;
+    "aria-posinset"?: number | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined;
+    "aria-rowcount"?: number | undefined;
+    "aria-rowindex"?: number | undefined;
+    "aria-rowindextext"?: string | undefined;
+    "aria-rowspan"?: number | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    "aria-valuemax"?: number | undefined;
+    "aria-valuemin"?: number | undefined;
+    "aria-valuenow"?: number | undefined;
+    "aria-valuetext"?: string | undefined;
+    children?: ReactNode | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: ClipboardEventHandler<HTMLDivElement>;
+    onCopyCapture?: ClipboardEventHandler<HTMLDivElement>;
+    onCut?: ClipboardEventHandler<HTMLDivElement>;
+    onCutCapture?: ClipboardEventHandler<HTMLDivElement>;
+    onPaste?: ClipboardEventHandler<HTMLDivElement>;
+    onPasteCapture?: ClipboardEventHandler<HTMLDivElement>;
+    onCompositionEnd?: CompositionEventHandler<HTMLDivElement>;
+    onCompositionEndCapture?: CompositionEventHandler<HTMLDivElement>;
+    onCompositionStart?: CompositionEventHandler<HTMLDivElement>;
+    onCompositionStartCapture?: CompositionEventHandler<HTMLDivElement>;
+    onCompositionUpdate?: CompositionEventHandler<HTMLDivElement>;
+    onCompositionUpdateCapture?: CompositionEventHandler<HTMLDivElement>;
+    onFocus?: FocusEventHandler<HTMLDivElement>;
+    onFocusCapture?: FocusEventHandler<HTMLDivElement>;
+    onBlur?: FocusEventHandler<HTMLDivElement>;
+    onBlurCapture?: FocusEventHandler<HTMLDivElement>;
+    onChange?: FormEventHandler<HTMLDivElement>;
+    onChangeCapture?: FormEventHandler<HTMLDivElement>;
+    onBeforeInput?: FormEventHandler<HTMLDivElement>;
+    onBeforeInputCapture?: FormEventHandler<HTMLDivElement>;
+    onInput?: FormEventHandler<HTMLDivElement>;
+    onInputCapture?: FormEventHandler<HTMLDivElement>;
+    onReset?: FormEventHandler<HTMLDivElement>;
+    onResetCapture?: FormEventHandler<HTMLDivElement>;
+    onSubmit?: FormEventHandler<HTMLDivElement>;
+    onSubmitCapture?: FormEventHandler<HTMLDivElement>;
+    onInvalid?: FormEventHandler<HTMLDivElement>;
+    onInvalidCapture?: FormEventHandler<HTMLDivElement>;
+    onLoad?: ReactEventHandler<HTMLDivElement>;
+    onLoadCapture?: ReactEventHandler<HTMLDivElement>;
+    onError?: ReactEventHandler<HTMLDivElement>;
+    onErrorCapture?: ReactEventHandler<HTMLDivElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLDivElement>;
+    onKeyDownCapture?: KeyboardEventHandler<HTMLDivElement>;
+    onKeyPress?: KeyboardEventHandler<HTMLDivElement>;
+    onKeyPressCapture?: KeyboardEventHandler<HTMLDivElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLDivElement>;
+    onKeyUpCapture?: KeyboardEventHandler<HTMLDivElement>;
+    onAbort?: ReactEventHandler<HTMLDivElement>;
+    onAbortCapture?: ReactEventHandler<HTMLDivElement>;
+    onCanPlay?: ReactEventHandler<HTMLDivElement>;
+    onCanPlayCapture?: ReactEventHandler<HTMLDivElement>;
+    onCanPlayThrough?: ReactEventHandler<HTMLDivElement>;
+    onCanPlayThroughCapture?: ReactEventHandler<HTMLDivElement>;
+    onDurationChange?: ReactEventHandler<HTMLDivElement>;
+    onDurationChangeCapture?: ReactEventHandler<HTMLDivElement>;
+    onEmptied?: ReactEventHandler<HTMLDivElement>;
+    onEmptiedCapture?: ReactEventHandler<HTMLDivElement>;
+    onEncrypted?: ReactEventHandler<HTMLDivElement>;
+    onEncryptedCapture?: ReactEventHandler<HTMLDivElement>;
+    onEnded?: ReactEventHandler<HTMLDivElement>;
+    onEndedCapture?: ReactEventHandler<HTMLDivElement>;
+    onLoadedData?: ReactEventHandler<HTMLDivElement>;
+    onLoadedDataCapture?: ReactEventHandler<HTMLDivElement>;
+    onLoadedMetadata?: ReactEventHandler<HTMLDivElement>;
+    onLoadedMetadataCapture?: ReactEventHandler<HTMLDivElement>;
+    onLoadStart?: ReactEventHandler<HTMLDivElement>;
+    onLoadStartCapture?: ReactEventHandler<HTMLDivElement>;
+    onPause?: ReactEventHandler<HTMLDivElement>;
+    onPauseCapture?: ReactEventHandler<HTMLDivElement>;
+    onPlay?: ReactEventHandler<HTMLDivElement>;
+    onPlayCapture?: ReactEventHandler<HTMLDivElement>;
+    onPlaying?: ReactEventHandler<HTMLDivElement>;
+    onPlayingCapture?: ReactEventHandler<HTMLDivElement>;
+    onProgress?: ReactEventHandler<HTMLDivElement>;
+    onProgressCapture?: ReactEventHandler<HTMLDivElement>;
+    onRateChange?: ReactEventHandler<HTMLDivElement>;
+    onRateChangeCapture?: ReactEventHandler<HTMLDivElement>;
+    onResize?: ReactEventHandler<HTMLDivElement>;
+    onResizeCapture?: ReactEventHandler<HTMLDivElement>;
+    onSeeked?: ReactEventHandler<HTMLDivElement>;
+    onSeekedCapture?: ReactEventHandler<HTMLDivElement>;
+    onSeeking?: ReactEventHandler<HTMLDivElement>;
+    onSeekingCapture?: ReactEventHandler<HTMLDivElement>;
+    onStalled?: ReactEventHandler<HTMLDivElement>;
+    onStalledCapture?: ReactEventHandler<HTMLDivElement>;
+    onSuspend?: ReactEventHandler<HTMLDivElement>;
+    onSuspendCapture?: ReactEventHandler<HTMLDivElement>;
+    onTimeUpdate?: ReactEventHandler<HTMLDivElement>;
+    onTimeUpdateCapture?: ReactEventHandler<HTMLDivElement>;
+    onVolumeChange?: ReactEventHandler<HTMLDivElement>;
+    onVolumeChangeCapture?: ReactEventHandler<HTMLDivElement>;
+    onWaiting?: ReactEventHandler<HTMLDivElement>;
+    onWaitingCapture?: ReactEventHandler<HTMLDivElement>;
+    onAuxClick?: MouseEventHandler<HTMLDivElement>;
+    onAuxClickCapture?: MouseEventHandler<HTMLDivElement>;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    onClickCapture?: MouseEventHandler<HTMLDivElement>;
+    onContextMenu?: MouseEventHandler<HTMLDivElement>;
+    onContextMenuCapture?: MouseEventHandler<HTMLDivElement>;
+    onDoubleClick?: MouseEventHandler<HTMLDivElement>;
+    onDoubleClickCapture?: MouseEventHandler<HTMLDivElement>;
+    onDrag?: DragEventHandler<HTMLDivElement>;
+    onDragCapture?: DragEventHandler<HTMLDivElement>;
+    onDragEnd?: DragEventHandler<HTMLDivElement>;
+    onDragEndCapture?: DragEventHandler<HTMLDivElement>;
+    onDragEnter?: DragEventHandler<HTMLDivElement>;
+    onDragEnterCapture?: DragEventHandler<HTMLDivElement>;
+    onDragExit?: DragEventHandler<HTMLDivElement>;
+    onDragExitCapture?: DragEventHandler<HTMLDivElement>;
+    onDragLeave?: DragEventHandler<HTMLDivElement>;
+    onDragLeaveCapture?: DragEventHandler<HTMLDivElement>;
+    onDragOver?: DragEventHandler<HTMLDivElement>;
+    onDragOverCapture?: DragEventHandler<HTMLDivElement>;
+    onDragStart?: DragEventHandler<HTMLDivElement>;
+    onDragStartCapture?: DragEventHandler<HTMLDivElement>;
+    onDrop?: DragEventHandler<HTMLDivElement>;
+    onDropCapture?: DragEventHandler<HTMLDivElement>;
+    onMouseDown?: MouseEventHandler<HTMLDivElement>;
+    onMouseDownCapture?: MouseEventHandler<HTMLDivElement>;
+    onMouseEnter?: MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: MouseEventHandler<HTMLDivElement>;
+    onMouseMove?: MouseEventHandler<HTMLDivElement>;
+    onMouseMoveCapture?: MouseEventHandler<HTMLDivElement>;
+    onMouseOut?: MouseEventHandler<HTMLDivElement>;
+    onMouseOutCapture?: MouseEventHandler<HTMLDivElement>;
+    onMouseOver?: MouseEventHandler<HTMLDivElement>;
+    onMouseOverCapture?: MouseEventHandler<HTMLDivElement>;
+    onMouseUp?: MouseEventHandler<HTMLDivElement>;
+    onMouseUpCapture?: MouseEventHandler<HTMLDivElement>;
+    onSelect?: ReactEventHandler<HTMLDivElement>;
+    onSelectCapture?: ReactEventHandler<HTMLDivElement>;
+    onTouchCancel?: TouchEventHandler<HTMLDivElement>;
+    onTouchCancelCapture?: TouchEventHandler<HTMLDivElement>;
+    onTouchEnd?: TouchEventHandler<HTMLDivElement>;
+    onTouchEndCapture?: TouchEventHandler<HTMLDivElement>;
+    onTouchMove?: TouchEventHandler<HTMLDivElement>;
+    onTouchMoveCapture?: TouchEventHandler<HTMLDivElement>;
+    onTouchStart?: TouchEventHandler<HTMLDivElement>;
+    onTouchStartCapture?: TouchEventHandler<HTMLDivElement>;
+    onPointerDown?: PointerEventHandler<HTMLDivElement>;
+    onPointerDownCapture?: PointerEventHandler<HTMLDivElement>;
+    onPointerMove?: PointerEventHandler<HTMLDivElement>;
+    onPointerMoveCapture?: PointerEventHandler<HTMLDivElement>;
+    onPointerUp?: PointerEventHandler<HTMLDivElement>;
+    onPointerUpCapture?: PointerEventHandler<HTMLDivElement>;
+    onPointerCancel?: PointerEventHandler<HTMLDivElement>;
+    onPointerCancelCapture?: PointerEventHandler<HTMLDivElement>;
+    onPointerEnter?: PointerEventHandler<HTMLDivElement>;
+    onPointerLeave?: PointerEventHandler<HTMLDivElement>;
+    onPointerOver?: PointerEventHandler<HTMLDivElement>;
+    onPointerOverCapture?: PointerEventHandler<HTMLDivElement>;
+    onPointerOut?: PointerEventHandler<HTMLDivElement>;
+    onPointerOutCapture?: PointerEventHandler<HTMLDivElement>;
+    onGotPointerCapture?: PointerEventHandler<HTMLDivElement>;
+    onGotPointerCaptureCapture?: PointerEventHandler<HTMLDivElement>;
+    onLostPointerCapture?: PointerEventHandler<HTMLDivElement>;
+    onLostPointerCaptureCapture?: PointerEventHandler<HTMLDivElement>;
+    onScroll?: UIEventHandler<HTMLDivElement>;
+    onScrollCapture?: UIEventHandler<HTMLDivElement>;
+    onWheel?: WheelEventHandler<HTMLDivElement>;
+    onWheelCapture?: WheelEventHandler<HTMLDivElement>;
+    onAnimationStart?: AnimationEventHandler<HTMLDivElement>;
+    onAnimationStartCapture?: AnimationEventHandler<HTMLDivElement>;
+    onAnimationEnd?: AnimationEventHandler<HTMLDivElement>;
+    onAnimationEndCapture?: AnimationEventHandler<HTMLDivElement>;
+    onAnimationIteration?: AnimationEventHandler<HTMLDivElement>;
+    onAnimationIterationCapture?: AnimationEventHandler<HTMLDivElement>;
+    onTransitionEnd?: TransitionEventHandler<HTMLDivElement>;
+    onTransitionEndCapture?: TransitionEventHandler<HTMLDivElement>;
+    className: string;
+}, Element>;
+export function BoundaryAgeModelOverlay(): DOMElement<any, Element>;
+interface CorrelationChartSettings extends Omit<PrepareColumnOptions, "axisType"> {
+    targetUnitHeight?: number;
+}
+export interface CorrelationChartProps extends CorrelationChartSettings {
+    data: ColumnData[];
+    columnWidth?: number;
+    columnSpacing?: number;
+    targetUnitHeight?: number;
+    unconformityLabels?: boolean;
+    selectedUnit?: number | null;
+    showUnitPopover?: boolean;
+    onUnitSelected?: (unitID: number | null, unit: BaseUnit | null) => void;
 }
-export function Column(props: ColumnProps): FunctionComponentElement<Omit<ColumnProps, "showUnitPopover">> | FunctionComponentElement<Partial<_UnitSelectionProps1<BaseUnit>>>;
+export function CorrelationChart({ data, columnSpacing, columnWidth, unconformityLabels, showUnitPopover, selectedUnit, onUnitSelected, ...scaleProps }: CorrelationChartProps): FunctionComponentElement<_ColumnContainerProps1>;
+export function parseLineFromString(section: string): LineString | null;
+export function stringifyLine(line: LineString | null): string | null;
 
 //# sourceMappingURL=index.d.ts.map