@macrostrat/column-components/dist/esm/index.d.ts

React rendering primitives for stratigraphic columns

import { ScaleContinuousNumeric, ScaleLinear, ScaleOrdinal } from "d3-scale";
import React, { Component, ReactNode, Context, ProviderProps, FunctionComponentElement, ReactSVGElement, JSXElementConstructor, ReactElement, JSX, ElementType, SVGAttributes, RefObject, RefAttributes, ForwardRefExoticComponent, ComponentElement, ComponentType, MutableRefObject, PropsWithChildren, DOMElement, DOMAttributes, MouseEvent, InputHTMLAttributes, DetailedReactHTMLElement } from "react";
import { Spec } from "immutability-helper";
import { BoxProps } from "ui-box";
import { EditableText, EditableTextProps, Slider, SliderProps, Popover, DefaultPopoverTargetHTMLProps, PopoverProps } from "@blueprintjs/core";
import { ColumnLayoutProviderProps as _ColumnLayoutProviderProps1 } from "column-components/src";
type HeightRange = [number, number];
type ColumnScale = ScaleContinuousNumeric<HeightRange, number> | any;
type ColumnScaleClamped = ScaleLinear<number, number>;
export interface ColumnDivision {
    section_id: string;
    id: number;
    surface: number;
    bottom: number;
    top: number;
    flooding_surface_order?: number;
    grainsize?: string;
    covered?: boolean;
    definite_boundary?: boolean;
    facies?: string;
}
export enum ColumnAxisType {
    AGE = "age",
    HEIGHT = "height",
    DEPTH = "depth",
    ORDINAL = "ordinal"
}
export interface ColumnCtx<T extends ColumnDivision> {
    divisions: T[];
    scaleClamped: ColumnScaleClamped;
    pixelsPerMeter: number;
    scale: ColumnScale;
    axisType?: ColumnAxisType;
    pixelHeight?: number;
    zoom: number;
}
export const ColumnContext: React.Context<ColumnCtx<ColumnDivision>>;
export interface ColumnProviderProps<T extends ColumnDivision> {
    pixelsPerMeter?: number;
    divisions: T[];
    range?: HeightRange | any;
    height?: number;
    zoom?: number;
    width?: number;
    axisType?: ColumnAxisType;
    children?: any;
}
export function ColumnProvider<T extends ColumnDivision>(props: ColumnProviderProps<T>): React.FunctionComponentElement<React.ProviderProps<ColumnCtx<ColumnDivision>>>;
export const useColumn: () => ColumnCtx<ColumnDivision>;
export const useColumnDivisions: () => ColumnDivision[];
export interface ColumnLayoutCtx<T extends ColumnDivision> extends ColumnCtx<T> {
    width: number;
    grainSizes?: string[];
    grainsizeScale?: (d: string) => number;
    xScale: any;
    widthForDivision: (d: ColumnDivision) => number;
}
export const ColumnLayoutContext: Context<ColumnLayoutCtx<ColumnDivision>>;
export interface ColumnLayoutProviderProps<T extends ColumnDivision> extends Partial<ColumnCtx<T>> {
    grainSizes?: string[];
    grainsizeScale?: (d: string) => number;
    width: number;
    xScale?: any;
    children?: ReactNode;
}
export function ColumnLayoutProvider<T extends ColumnDivision>({ children, width, grainSizes, grainsizeScale, xScale, }: ColumnLayoutProviderProps<T>): FunctionComponentElement<ProviderProps<ColumnLayoutCtx<ColumnDivision>>>;
export interface CrossAxisLayoutProviderProps {
    width: number;
    domain: number[];
    range?: number[];
    children?: ReactNode;
}
export class CrossAxisLayoutProvider extends Component<CrossAxisLayoutProviderProps> {
    static contextType: Context<ColumnCtx<ColumnDivision>>;
    context: ColumnCtx<ColumnDivision>;
    render(): FunctionComponentElement<ColumnLayoutProviderProps<ColumnDivision>>;
}
export type GrainsizeLayoutProps = {
    grainSizes: string[];
    children?: React.ReactNode;
    width?: number;
    grainsizeScaleStart?: number;
    grainsizeScaleRange?: [number, number];
    tickPositions?: number[];
};
export function GrainsizeLayoutProvider({ width, grainSizes, grainsizeScaleStart, grainsizeScaleRange, tickPositions, children, }: GrainsizeLayoutProps): FunctionComponentElement<ColumnLayoutProviderProps<ColumnDivision>>;
export function useColumnLayout(): ColumnLayoutCtx<ColumnDivision>;
declare class StatefulComponent<Props, State> extends Component<Props, State> {
    constructor(props: Props);
    updateState(spec: Spec<State>): void;
}
interface StrictPadding {
    paddingLeft: number;
    paddingRight: number;
    paddingTop: number;
    paddingBottom: number;
}
interface Padding extends Partial<StrictPadding> {
    paddingV?: number;
    paddingH?: number;
    padding?: number;
}
interface StrictMargin {
    marginLeft: number;
    marginRight: number;
    marginTop: number;
    marginBottom: number;
}
interface Margin extends Partial<StrictMargin> {
    marginV?: number;
    marginH?: number;
    margin?: number;
}
declare namespace InfiniteScrollView {
    var defaultProps: {
        hasMore(res: any): boolean;
        getItems(d: any): any;
        getCount(d: any): any;
        getNextParams(response: any, params: any): any;
        placeholder: (p: APIPlaceholderProps) => React.FunctionComponentElement<$$parcel$import$208<HTMLElement>>;
    };
}
type ErrorBoundaryProps = {
    description?: string;
    title?: string;
    fallback?: ReactNode;
    override?: boolean;
    onCatch?(error: Error, info: any): void;
};
type ErrorBoundaryState = {
    error: Error | null;
};
declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
    constructor(props: any);
    static getDerivedStateFromError(error: any): {
        error: any;
    };
    componentDidCatch(error: any, info: any): void;
    render(): any;
}
declare namespace ThreeColumnLayout {
    var Panels: typeof SidePanel;
}
export const FaciesContext: Context<any>;
export class FaciesProvider extends StatefulComponent<any, any> {
    constructor(props: any);
    getFaciesColor(id: any): any;
    setFaciesColor(id: any, color: any): void;
    render(): FunctionComponentElement<ProviderProps<any>>;
}
export const SettingsProvider: any, useSettings: any;
export const updateSettings: (func: any) => () => any;
export const LithologyContext: Context<{
    lithologies: any[];
}>;
export function LithologyProvider(props: any): FunctionComponentElement<ProviderProps<{
    lithologies: any[];
}>>;
export interface AssetPathCtx {
    resolveSymbol: (symbol: string) => string | null;
}
export const AssetPathContext: Context<AssetPathCtx>;
interface AssetPathProviderProps extends AssetPathCtx {
    children: React.ReactNode;
}
export function AssetPathProvider(props: AssetPathProviderProps): FunctionComponentElement<ProviderProps<AssetPathCtx>>;
export const ModelEditorContext: Context<any>;
interface ModelEditorProviderProps {
    model: any;
    onConfirmChanges: (model: any) => void;
    onDelete: (model: any) => void;
    logUpdates?: boolean;
    alwaysConfirm?: boolean;
    children: ReactNode;
}
export function ModelEditorProvider(props: ModelEditorProviderProps): FunctionComponentElement<ProviderProps<any>>;
export const useModelEditor: () => any;
declare class UUIDComponent<T> extends Component<T> {
    UUID: string;
    constructor(props: T);
}
export const useUUID: () => string;
interface FrameProps {
    id: string;
    className?: string;
}
export function SimpleFrame(props: FrameProps): ReactSVGElement;
interface GrainsizeFrameProps {
    id: string;
}
export function GrainsizeFrame(props: GrainsizeFrameProps): ReactElement<{
    id: string;
    key: string;
    d: any;
}, string | JSXElementConstructor<any>>;
interface ClipToFrameProps {
    left: number;
    shiftY: number;
    onClick?: () => void;
    frame?: any;
    width?: number;
    className?: string;
    children?: ReactNode;
    clip?: boolean;
}
export class LocalStorage {
    name: string;
    constructor(name: any);
    get(): object;
    set(obj: object): void;
}
export function ColumnBox(props: any): FunctionComponentElement<BoxProps<ElementType<any, keyof JSX.IntrinsicElements>>>;
interface ColumnScrollerProps {
    scrollToHeight: number;
    alignment: "center" | "top" | "bottom";
    animated: boolean;
    onScrolled: (height: number) => void;
    paddingTop: number;
    scrollContainer: () => HTMLElement;
}
interface ScrollToOpts {
    animated?: boolean;
    alignment?: "center" | "top" | "bottom";
}
export class ColumnScroller extends Component<ColumnScrollerProps> {
    constructor(props: any);
    static contextType: Context<ColumnCtx<ColumnDivision>>;
    context: ColumnCtx<ColumnDivision>;
    render(): FunctionComponentElement<BoxProps<ElementType<any, keyof JSX.IntrinsicElements>>>;
    scrollTo(height: any, opts?: ScrollToOpts): any;
    componentDidMount(): void;
    componentDidUpdate(prevProps: any): void;
}
export const SVGNamespaces: {
    xmlns: string;
    xmlnsXlink: string;
};
interface SVGProps extends SVGAttributes<any>, Padding, Margin {
    innerHeight?: number;
    innerWidth?: number;
    innerRef?: RefObject<SVGElement>;
}
interface SVGPropsWithNumericSize extends Omit<SVGProps, "width" | "height"> {
    width?: number;
    height?: number;
}
export const SVG: ForwardRefExoticComponent<SVGPropsWithNumericSize & RefAttributes<SVGElement>>;
export const ForeignObject: (props: any) => ReactSVGElement;
export const ColumnSVG: (props: SVGPropsWithNumericSize) => FunctionComponentElement<SVGPropsWithNumericSize & RefAttributes<SVGElement>>;
interface ColumnImageProps {
    src: string;
    insets?: {
        top?: number;
        right?: number;
        bottom?: number;
        left?: number;
    };
    clip?: boolean;
}
export function ColumnImage(props: ColumnImageProps): ReactElement<{
    style: {
        overflow: string;
    };
}, string | JSXElementConstructor<any>>;
declare const Renderer: any;
interface NoteLayoutProviderProps {
    notes: any[];
    width: number;
    paddingLeft: number;
    noteComponent: any;
    forceOptions: object;
    children?: ReactNode;
}
interface NoteLayoutState {
    notes?: any[];
    elementHeights?: object;
    columnIndex?: object;
    nodes?: object;
    updateHeight?: Function;
    generatePath: Function;
    createNodeForNote?: Function;
    noteComponent?: any;
    renderer?: typeof Renderer;
}
declare class NoteLayoutProvider extends StatefulComponent<NoteLayoutProviderProps, NoteLayoutState> {
    static contextType: Context<ColumnCtx<ColumnDivision>>;
    static defaultProps: {
        paddingLeft: number;
        estimatedTextHeight(note: any, width: any): number;
    };
    context: ColumnCtx<ColumnDivision>;
    _previousContext: ColumnCtx<ColumnDivision>;
    _rendererIndex: object;
    constructor(props: any);
    render(): FunctionComponentElement<ProviderProps<any>>;
    computeContextValue(): void;
    savedRendererForWidth(width: any): any;
    generatePath(node: any, pixelOffset: any): any;
    createNodeForNote(note: any): any;
    computeForceLayout(prevProps: any, prevState: any): void;
    updateHeight(id: any, height: any): void;
    updateNotes(): void;
    componentDidMount(): void;
    componentDidUpdate(prevProps: any, prevState: any): ColumnCtx<ColumnDivision>;
}
export interface NoteData {
    height: number;
    note: string;
    top_height?: number;
    symbol?: string;
    id?: string | number;
}
interface NodeConnectorOptions {
    deltaConnectorAttachment?: number;
}
export const NoteEditorContext: Context<{
    inEditMode: boolean;
}>;
interface NoteEditorProps {
    note: NoteData;
}
export const NoteTextEditor: (props: NoteEditorProps) => ComponentElement<EditableTextProps, EditableText>;
export const NoteEditor: (props: any) => ComponentElement<any, ErrorBoundary>;
interface NoteComponentProps {
    visibility: string;
    note: NoteData;
    onClick: Function;
}
export function NoteComponent(props: NoteComponentProps): ReactElement<{
    style: {
        visibility: string;
    };
    onClick: Function;
}, string | JSXElementConstructor<any>>;
interface NotesColumnBaseProps extends NodeConnectorOptions {
    width?: number;
    paddingLeft?: number;
    transform?: string;
    notes?: NoteData[];
    noteComponent?: ComponentType<any>;
    onClickNote?: (note: NoteData) => void;
    children?: ReactNode;
}
export function StaticNotesColumn(props: NotesColumnBaseProps): ComponentElement<any, NoteLayoutProvider>;
export function NotesColumn(props: any): FunctionComponentElement<{}>;
export interface NotesColumnProps {
    editable?: boolean;
}
export const PhotoLibraryContext: Context<PhotoLibraryProviderProps>;
interface PhotoData {
    id: number;
    src: string;
    caption?: string;
}
interface PhotoLibraryProviderProps {
    photos: PhotoData[] | null;
    computePhotoPath: (src: string) => string;
}
export class PhotoLibraryProvider extends Component<PhotoLibraryProviderProps & {
    children: ReactNode;
}> {
    static defaultProps: {
        computePhotoPath: (src: any) => any;
    };
    render(): FunctionComponentElement<ProviderProps<PhotoLibraryProviderProps>>;
}
export function PhotoOverlay(props: any): FunctionComponentElement<any>;
interface ColumnAxisProps {
    ticks?: number;
    tickArguments?: any;
    tickValues?: any;
    tickFormat?: any;
    tickSize?: any;
    tickSizeInner?: any;
    tickSizeOuter?: any;
    tickPadding?: any;
    tickSpacing?: number;
    showLabel?: (d: any) => boolean;
    showDomain?: boolean;
    className?: string;
}
interface AgeAxisProps extends ColumnAxisProps {
    scale?: ScaleLinear<number, number>;
}
export function ColumnAxis(props: ColumnAxisProps): FunctionComponentElement<AgeAxisProps>;
export function AgeAxis(props: AgeAxisProps): ReactElement<{
    className: string;
    ref: MutableRefObject<any>;
}, string | JSXElementConstructor<any>>;
interface IGeologicPatternBase {
    prefix: string;
    color?: string;
    id: string;
    width: number;
    height: number;
    backgroundColor?: string;
    name?: string;
}
interface IGeologicPatternProvider {
    resolvePattern(string: any): string;
    children?: ReactNode;
}
export const GeologicPatternContext: Context<any>;
export const GeologicPatternProvider: (props: IGeologicPatternProvider) => FunctionComponentElement<ProviderProps<any>>;
export enum PatternType {
    Vector = "vector",
    Raster = "raster"
}
interface IGeologicPattern extends IGeologicPatternBase {
    type?: PatternType;
    invert?: boolean;
}
export const GeologicPattern: (props: IGeologicPattern) => FunctionComponentElement<IGeologicPatternBase>;
type LithologySymbolCtx = any;
type LithProviderProps = PropsWithChildren<LithologySymbolCtx>;
export function PatternDefsProvider(props: LithProviderProps): FunctionComponentElement<{
    children: any;
}>;
export function useGeologicPattern(patternID: string, fallback?: string): string;
export const symbolIndex: {
    "dolomite-limestone": number;
    lime_mudstone: number;
    sandstone: number;
    siltstone: number;
    "dolomitic siltstone": number;
    shale: number;
    limestone: number;
    dolomite: number;
    conglomerate: number;
    "dolomite-mudstone": number;
    mudstone: number;
    "sandy-dolomite": number;
    quartzite: number;
};
export const defaultResolveID: (d: any) => string;
interface ColumnRectProps {
    division: any;
    padWidth?: boolean;
    key?: string;
    width: number;
    className?: string;
    fill?: string;
}
export function ColumnRect(props: ColumnRectProps): React.ReactElement<{
    className?: string;
    fill?: string;
    x: number;
    y: any;
    width: number;
    height: number;
    key: string;
}, string | React.JSXElementConstructor<any>>;
export const expandDivisionsByKey: (divisions: ColumnDivision[], key: any) => ColumnDivision[] | null;
interface ParameterIntervalsProps {
    padWidth: boolean;
    parameter: string;
    fillForInterval(param: any, division: ColumnDivision): any;
}
export function ParameterIntervals(props: ParameterIntervalsProps): React.ReactSVGElement;
export const FaciesIntervals: (props: any) => React.FunctionComponentElement<ParameterIntervalsProps>;
export const FaciesColumnInner: (props: any) => React.FunctionComponentElement<ParameterIntervalsProps>;
export class CoveredOverlay extends UUIDComponent<{}> {
    static contextType: React.Context<ColumnLayoutCtx<ColumnDivision>>;
    context: ColumnLayoutCtx<ColumnDivision>;
    render(): React.DOMElement<{}, Element>;
}
export const LithologySymbolDefs: (props: any) => React.DOMElement<any, Element>;
export class LithologyBoxes extends UUIDComponent<any> {
    static contextType: React.Context<ColumnLayoutCtx<ColumnDivision>>;
    static defaultProps: {
        resolveID: (d: any) => string;
        minimumHeight: number;
    };
    context: ColumnLayoutCtx<ColumnDivision>;
    constructor(props: any);
    constructLithologyDivisions(): any[];
    renderEach(d: any): React.FunctionComponentElement<ColumnRectProps>;
    render(): React.DOMElement<React.DOMAttributes<Element>, Element>;
}
export const LithologyColumnInner: typeof LithologyBoxes;
export interface LithologyColumnProps {
    width: number;
    left?: number;
    children?: React.ReactNode;
    clipToFrame?: boolean;
    shiftY?: number;
}
export function LithologyColumn(props: LithologyColumnProps): React.FunctionComponentElement<_ColumnLayoutProviderProps1<ColumnDivision>>;
export const SimplifiedLithologyColumn: (props: any) => React.ComponentElement<any, LithologyBoxes>;
export const GeneralizedSectionColumn: (props: any) => React.FunctionComponentElement<ClipToFrameProps>;
export const CarbonateDivisions: (props: any) => React.ComponentElement<any, LithologyBoxes>;
export function FloodingSurface(props: any): DOMElement<null, Element>;
interface TriangleBarsProps {
    offsetLeft: number;
    lineWidth: number;
    order: number;
    orders: number[];
    minOrder: number;
    maxOrder: number;
}
export class TriangleBars extends UUIDComponent<TriangleBarsProps> {
    constructor(props: TriangleBarsProps);
    static contextType: Context<ColumnCtx<ColumnDivision>>;
    static defaultProps: {
        offsetLeft: number;
        lineWidth: number;
        order: number;
    };
    context: ColumnCtx<ColumnDivision>;
    render(): DOMElement<{}, Element>;
    renderSurfaces(order: any, index: any): ReactElement<{
        clipPath: string;
        transform: string;
        key: string;
    }, string | JSXElementConstructor<any>>;
}
interface SymbolColumnProps {
    width: number;
    left: number;
    symbols: any[];
}
export class SymbolColumn extends UUIDComponent<SymbolColumnProps> {
    constructor(props: any);
    static contextType: Context<ColumnCtx<ColumnDivision>>;
    context: ColumnCtx<ColumnDivision>;
    static defaultProps: {
        width: number;
        left: number;
    };
    render(): ReactElement<{
        transform: any;
    }, string | JSXElementConstructor<any>>;
    renderSymbol(d: any): ReactSVGElement;
}
export class SymbolLegend extends Component {
    static contextType: Context<AssetPathCtx>;
    context: AssetPathCtx;
    render(): DOMElement<DOMAttributes<Element>, Element>;
}
type color = string;
interface OverlayBoxProps {
    division: ColumnDivision;
    background: color;
    className: string;
    children?: ReactNode;
    onClick?: (evt: MouseEvent) => void;
}
interface DivisionEditOverlayProps {
    left: number;
    top: number;
    showInfoBox: boolean;
    onClick(ctx: {
        event?: MouseEvent;
        height: number;
        division?: ColumnDivision;
    }): void;
    allowEditing: boolean;
    renderEditorPopup(d: ColumnDivision): ReactNode;
    scaleToGrainsize: boolean;
    editingInterval: ColumnDivision;
    color: color;
    width: number;
    popoverWidth: number;
    selectedHeight: number;
}
interface DivisionEditOverlayState {
    height: number | null;
    hoveredDivision: ColumnDivision | null;
    popoverIsOpen: boolean;
}
export class DivisionEditOverlay extends Component<DivisionEditOverlayProps, DivisionEditOverlayState> {
    static contextType: Context<ColumnLayoutCtx<ColumnDivision>>;
    static defaultProps: {
        onHoverInterval(): void;
        onClick(): void;
        left: number;
        top: number;
        showInfoBox: boolean;
        allowEditing: boolean;
        renderEditorPopup(): any;
        color: string;
        popoverWidth: number;
    };
    timeout: any;
    context: ColumnLayoutCtx<ColumnDivision>;
    constructor(props: DivisionEditOverlayProps);
    onHoverInterval(event: any): any;
    removeHoverBox(): any;
    heightForEvent(event: any): any;
    onEditInterval(event: any): void;
    onClick(event: any): void;
    renderCursorLine(): ReactElement<{
        style: {
            top: number;
            height: number;
            border: string;
            width: number;
            position: string;
            pointerEvents: string;
        };
    }, string | JSXElementConstructor<any>>;
    renderHoveredBox(): FunctionComponentElement<OverlayBoxProps>;
    closePopover(): void;
    render(): FunctionComponentElement<BoxProps<ElementType<any, keyof JSX.IntrinsicElements>>>;
}
interface PickerControlProps {
    states: {
        label: string;
        value: string;
    }[];
    activeState: string;
    vertical: boolean;
    isNullable: boolean;
    onUpdate: (value: string) => void;
}
export class PickerControl extends Component<PickerControlProps> {
    constructor(props: any);
    static defaultProps: {
        states: {
            label: string;
            value: string;
        }[];
        vertical: boolean;
        isNullable: boolean;
    };
    render(): DOMElement<DOMAttributes<Element>, Element>;
    onUpdate(value: any): () => void;
}
export function SurfaceOrderSlider(props: any): ComponentElement<SliderProps, Slider>;
export function HorizontalPicker(props: any): ComponentElement<any, PickerControl>;
interface BoundaryStyleProps {
    interval: ColumnDivision;
    onUpdate: (d: any) => void;
}
export class BoundaryStyleControl extends Component<BoundaryStyleProps> {
    render(): FunctionComponentElement<any>;
}
export const LabeledControl: (props: any) => DOMElement<DOMAttributes<Element>, Element>;
export const RaisedSelect: (props: any) => DetailedReactHTMLElement<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
interface IntervalEditorTitleProps {
    showID: boolean;
    title: string;
    interval: ColumnDivision;
    heightFormat: string;
}
export const IntervalEditorTitle: (props: IntervalEditorTitleProps) => DOMElement<DOMAttributes<Element>, Element>;
export const BasicFaciesSwatch: ({ facies: d, ...rest }: {
    [x: string]: any;
    facies: any;
}) => ReactElement<{
    style: {
        backgroundColor: any;
        width: string;
        height: string;
    };
}, string | JSXElementConstructor<any>>;
interface FaciesSwatchProps {
    isEditable: boolean;
    facies: {
        id: number;
        color: string;
    } | null;
}
export class FaciesSwatch extends Component<FaciesSwatchProps> {
    static defaultProps: {
        isEditable: boolean;
        facies: any;
    };
    constructor(props: any);
    render(): ComponentElement<PopoverProps<DefaultPopoverTargetHTMLProps>, Popover<DefaultPopoverTargetHTMLProps>> | FunctionComponentElement<{
        [x: string]: any;
        facies: any;
    }>;
}
interface FaciesPickerProps {
    interval: ColumnDivision;
    onChange: (f: number) => void;
}
export class FaciesPicker extends Component<FaciesPickerProps> {
    static contextType: Context<any>;
    context: any;
    render(): FunctionComponentElement<any>;
}
type FaciesData = any;
export const FaciesCard: ({ facies }: {
    facies: any;
}) => DOMElement<DOMAttributes<Element>, Element>;
interface FaciesDescriptionSmallProps {
    selected: string;
    onClick: (d: any) => void;
    isEditable: boolean;
}
export class FaciesDescriptionSmall extends Component<FaciesDescriptionSmallProps> {
    constructor(props: FaciesDescriptionSmallProps);
    static contextType: Context<any>;
    static defaultProps: {
        selected: any;
        isEditable: boolean;
    };
    context: any;
    renderEach(d: FaciesData): DOMElement<{
        key: any;
        onClick: any;
        style: any;
        className: string;
    }, Element>;
    render(): DOMElement<DOMAttributes<Element>, Element>;
}
export const LithologyPicker: (props: any) => FunctionComponentElement<any>;
export const LithologySymbolPicker: (props: any) => ReactElement<{
    className: string;
}, string | JSXElementConstructor<any>>;
export const grainSizes: string[];
export const createGrainsizeScale: (range: any) => ScaleOrdinal<string, unknown, never>;
export function GrainsizeAxis({ height }: {
    height?: number;
}): ReactElement<{
    className: string;
}, string | JSXElementConstructor<any>>;

//# sourceMappingURL=index.d.ts.map