import * as react_jsx_runtime from 'react/jsx-runtime';
import ndarray, { TypedArray, NdArray } from 'ndarray';
import { PickD3Scale, PickScaleConfigWithoutType } from '@visx/scale';
import * as react from 'react';
import { HTMLAttributes, PropsWithChildren, ReactElement, ReactNode, ComponentType, AnchorHTMLAttributes, SVGAttributes, CSSProperties, SVGProps, ModifierKey as ModifierKey$1 } from 'react';
import { interpolateTurbo, interpolateViridis, interpolateInferno, interpolateMagma, interpolatePlasma, interpolateCividis, interpolateWarm, interpolateCool, interpolateCubehelixDefault, interpolateBuGn, interpolateBuPu, interpolateGnBu, interpolateOrRd, interpolatePuBuGn, interpolatePuBu, interpolatePuRd, interpolateRdPu, interpolateYlGnBu, interpolateYlGn, interpolateYlOrBr, interpolateYlOrRd, interpolateRainbow, interpolateSinebow, interpolateBrBG, interpolatePRGn, interpolatePiYG, interpolatePuOr, interpolateRdBu, interpolateRdGy, interpolateRdYlBu, interpolateRdYlGn, interpolateSpectral } from 'd3-scale-chromatic';
import { ScalePower, ScaleThreshold } from 'd3-scale';
import { Vector3, MagnificationTextureFilter, MinificationTextureFilter, Box3, Camera, BufferAttribute, BufferGeometry, Vector2 } from 'three';
import { ThreeEvent, Object3DNode, PointsProps, MeshProps, Camera as Camera$1 } from '@react-three/fiber';
import { LineMaterialParameters, LineMaterial } from 'three/addons/lines/LineMaterial.js';
import { Line2 } from 'three/addons/lines/Line2.js';
import { RGBColor } from 'd3-color';
import { LineGeometry as LineGeometry$1 } from 'three/addons/lines/LineGeometry.js';

type H5WebComplex = [real: number, imag: number];

interface NoProps {
}
type NumArray = TypedArray | number[];
type AnyNumArray = NdArray<NumArray> | NumArray;
type TypedArrayConstructor = Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
type Domain = [min: number, max: number];
type Axis = 'x' | 'y';
type DimensionMapping = (number | Axis | null)[];
interface VisibleDomains {
    xVisibleDomain: Domain;
    yVisibleDomain: Domain;
}
declare enum ScaleType {
    Linear = "linear",
    Log = "log",
    SymLog = "symlog",
    Sqrt = "sqrt",
    Gamma = "gamma"
}
type ColorScaleType = Exclude<ScaleType, 'gamma'>;
type AxisScaleType = Exclude<ScaleType, 'sqrt' | 'gamma'>;
declare enum ComplexVisType {
    Amplitude = "amplitude",
    Phase = "phase",
    PhaseUnwrapped = "phase-unwrapped",
    PhaseAmplitude = "phase-amplitude"
}
interface Bounds {
    min: number;
    max: number;
    positiveMin: number;
    strictPositiveMin: number;
}
type IgnoreValue = (val: number) => boolean;
interface ExportEntry {
    format: string;
    url: ExportURL;
}
type ExportFormat = 'json' | 'csv' | 'npy' | 'tiff';
type ExportURL = URL | (() => Promise<URL | Blob>);
type BuiltInExporter = () => string;
type MappedTuple<T extends unknown[], U = T[number]> = {
    [index in keyof T]: U;
};

declare function interpolateHsl(t: number): string;
declare const INTERPOLATORS: {
    Blues: (t: number) => string;
    Greens: (t: number) => string;
    Greys: (t: number) => string;
    Oranges: (t: number) => string;
    Purples: (t: number) => string;
    Reds: (t: number) => string;
    Turbo: typeof interpolateTurbo;
    Viridis: typeof interpolateViridis;
    Inferno: typeof interpolateInferno;
    Magma: typeof interpolateMagma;
    Plasma: typeof interpolatePlasma;
    Cividis: typeof interpolateCividis;
    Warm: typeof interpolateWarm;
    Cool: typeof interpolateCool;
    Cubehelix: typeof interpolateCubehelixDefault;
    BuGn: typeof interpolateBuGn;
    BuPu: typeof interpolateBuPu;
    GnBu: typeof interpolateGnBu;
    OrRd: typeof interpolateOrRd;
    PuBuGn: typeof interpolatePuBuGn;
    PuBu: typeof interpolatePuBu;
    PuRd: typeof interpolatePuRd;
    RdPu: typeof interpolateRdPu;
    YlGnBu: typeof interpolateYlGnBu;
    YlGn: typeof interpolateYlGn;
    YlOrBr: typeof interpolateYlOrBr;
    YlOrRd: typeof interpolateYlOrRd;
    Rainbow: typeof interpolateRainbow;
    Sinebow: typeof interpolateSinebow;
    HSL: typeof interpolateHsl;
    BrBG: typeof interpolateBrBG;
    PRGn: typeof interpolatePRGn;
    PiYG: typeof interpolatePiYG;
    PuOr: typeof interpolatePuOr;
    RdBu: typeof interpolateRdBu;
    RdGy: typeof interpolateRdGy;
    RdYlBu: typeof interpolateRdYlBu;
    RdYlGn: typeof interpolateRdYlGn;
    Spectral: typeof interpolateSpectral;
};

type D3Interpolator = (t: number) => string;
type ColorMap = keyof typeof INTERPOLATORS;
interface TooltipData$1 {
    abscissa: number;
    ordinate: number;
    xi: number;
    yi: number;
    x: number;
    y: number;
}
type TextureSafeTypedArray = Float32Array | Uint8Array | Uint8ClampedArray;

type Range = number;
type Output = Range;
type ScaleGamma = ScalePower<Range, Output>;
declare function scaleGamma(config?: ScaleGammaConfig): ScaleGamma;

interface Size {
    width: number;
    height: number;
}
type Aspect = 'auto' | 'equal' | number;
type CustomDomain = [min: number | null, max: number | null];
interface GetDomainOpts {
    includeErrors?: boolean;
    scaleType?: ScaleType;
    ignoreValue?: IgnoreValue;
}
interface DomainErrors {
    minGreater?: boolean;
    minError?: DomainError.InvalidMinWithScale | DomainError.CustomMaxFallback;
    maxError?: DomainError.InvalidMaxWithScale;
}
declare enum DomainError {
    MinGreater = "min-greater",
    InvalidMinWithScale = "invalid-min-with-scale",
    InvalidMaxWithScale = "invalid-max-with-scale",
    CustomMaxFallback = "custom-max-fallback"
}
interface AxisConfig {
    isIndexAxis?: boolean;
    visDomain: Domain;
    showGrid?: boolean;
    scaleType?: AxisScaleType;
    label?: string;
    flip?: boolean;
    nice?: boolean;
    formatTick?: (val: number) => string;
}
type VisScaleType = ColorScaleType | [ScaleType.Gamma, number];
type ExtractScaleType<V extends VisScaleType> = V extends ColorScaleType ? V : ScaleType.Gamma;
interface ScaleGammaConfig {
    domain?: Domain;
    range?: Domain;
    exponent?: number;
    clamp?: boolean;
}
type ScaleConfig<S = ScaleType> = S extends ColorScaleType ? PickScaleConfigWithoutType<S, number> : ScaleGammaConfig;
type Scale<S = ScaleType> = S extends ColorScaleType ? PickD3Scale<S, number> : ScaleGamma;
type AxisScale = Scale<AxisScaleType>;
interface AxisParams {
    label?: string;
    value?: NumArray;
    scaleType?: AxisScaleType;
}
interface HistogramParams {
    values: NumArray;
    bins: NumArray;
    showLeftAxis?: boolean;
    colorMap?: ColorMap;
    invertColorMap?: boolean;
}
type ClassStyleAttrs = Pick<HTMLAttributes<HTMLElement>, 'className' | 'style'>;
interface H5WebGeometry {
    update: () => void;
}

interface Props$_ extends ClassStyleAttrs {
    dims: number[];
    cellFormatter: (row: number, col: number) => string;
    cellWidth: number;
    columnHeaders?: string[];
}
declare function MatrixVis(props: Props$_): react_jsx_runtime.JSX.Element;

type ModifierKey = 'Alt' | 'Control' | 'Shift';
declare enum MouseButton {
    'Left' = 0,
    'Middle' = 1,
    'Right' = 2
}
type Rect = [start: Vector3, end: Vector3];
interface Selection {
    html: Rect;
    world: Rect;
    data: Rect;
}
interface CanvasEvent<T extends MouseEvent> {
    htmlPt: Vector3;
    worldPt: Vector3;
    dataPt: Vector3;
    sourceEvent: T;
}
interface InteractionInfo {
    shortcut: string;
    description: string;
}
interface InteractionConfig extends CommonInteractionProps {
    button?: MouseButton | MouseButton[] | 'Wheel';
}
interface CommonInteractionProps {
    modifierKey?: ModifierKey | ModifierKey[];
    disabled?: boolean;
}
interface UseDragOpts {
    onDragEnd: (delta: Vector3) => void;
}
interface UseDragState {
    delta: Vector3;
    isDragging: boolean;
    startDrag: (evt: PointerEvent) => void;
}
type MouseEventName = {
    [Key in keyof GlobalEventHandlersEventMap]: GlobalEventHandlersEventMap[Key] extends MouseEvent ? Key : never;
}[keyof GlobalEventHandlersEventMap];

interface Props$Z extends CommonInteractionProps {
    id?: string;
    button?: MouseButton | MouseButton[];
}
declare function Pan(props: Props$Z): null;

interface Props$Y extends CommonInteractionProps {
    minZoom?: number;
}
declare function SelectToZoom(props: Props$Y): react_jsx_runtime.JSX.Element;

type Props$X = CommonInteractionProps;
declare function XAxisZoom(props: Props$X): null;

type Props$W = CommonInteractionProps;
declare function YAxisZoom(props: Props$W): null;

type Props$V = CommonInteractionProps;
declare function Zoom(props: Props$V): null;

interface Props$U extends CommonInteractionProps {
    axis: Axis;
    minZoom?: number;
}
declare function AxialSelectToZoom(props: Props$U): react_jsx_runtime.JSX.Element;

interface DefaultInteractionsConfig {
    pan?: Props$Z | false;
    zoom?: Props$V | false;
    xAxisZoom?: Props$X | false;
    yAxisZoom?: Props$W | false;
    selectToZoom?: Props$Y | false;
    xSelectToZoom?: Omit<Props$U, 'axis'> | false;
    ySelectToZoom?: Omit<Props$U, 'axis'> | false;
}
declare function DefaultInteractions(props: DefaultInteractionsConfig): react_jsx_runtime.JSX.Element;

declare enum CurveType {
    LineOnly = "OnlyLine",
    GlyphsOnly = "OnlyGlyphs",
    LineAndGlyphs = "LineAndGlyphs"
}
declare enum GlyphType {
    Circle = "Circle",
    Cross = "Cross",
    Square = "Square",
    Cap = "Cap"
}
interface TooltipData {
    abscissa: number;
    xi: number;
    x: number;
}
interface AuxiliaryParams {
    array: NdArray<NumArray>;
    label?: string;
    errors?: NdArray<NumArray>;
    visible?: boolean;
}
declare enum Interpolation {
    Linear = "Linear",
    Constant = "Constant"
}

interface Props$T extends ClassStyleAttrs {
    dataArray: NdArray<NumArray>;
    domain: Domain | undefined;
    scaleType?: AxisScaleType;
    curveType?: CurveType;
    showGrid?: boolean;
    abscissaParams?: AxisParams;
    ordinateLabel?: string;
    title?: string;
    dtype?: string;
    errorsArray?: NdArray<NumArray>;
    showErrors?: boolean;
    auxiliaries?: AuxiliaryParams[];
    renderTooltip?: (data: TooltipData) => ReactElement;
    interactions?: DefaultInteractionsConfig;
    testid?: string;
    ignoreValue?: IgnoreValue;
    interpolation?: Interpolation;
    visible?: boolean;
}
declare function LineVis(props: PropsWithChildren<Props$T>): react_jsx_runtime.JSX.Element;

interface Props$S extends ClassStyleAttrs {
    dataArray: NdArray<NumArray>;
    domain: Domain | undefined;
    colorMap?: ColorMap;
    scaleType?: VisScaleType;
    aspect?: Aspect;
    showGrid?: boolean;
    title?: string;
    dtype?: string;
    invertColorMap?: boolean;
    abscissaParams?: AxisParams;
    ordinateParams?: AxisParams;
    alpha?: {
        array: NdArray<NumArray>;
        domain: Domain;
    };
    magFilter?: MagnificationTextureFilter;
    minFilter?: MinificationTextureFilter;
    flipXAxis?: boolean;
    flipYAxis?: boolean;
    renderTooltip?: (data: TooltipData$1) => ReactElement;
    interactions?: DefaultInteractionsConfig;
    ignoreValue?: IgnoreValue;
}
declare function HeatmapVis(props: PropsWithChildren<Props$S>): react_jsx_runtime.JSX.Element;

interface ScatterAxisParams {
    label?: string;
    value: NumArray;
    scaleType?: AxisScaleType;
}

interface Props$R extends ClassStyleAttrs {
    abscissaParams: ScatterAxisParams;
    ordinateParams: ScatterAxisParams;
    dataArray: NdArray<NumArray>;
    domain: Domain;
    colorMap?: ColorMap;
    invertColorMap?: boolean;
    scaleType?: ColorScaleType;
    showGrid?: boolean;
    title?: string;
    size?: number;
    interactions?: DefaultInteractionsConfig;
    onPointClick?: (index: number, evt: ThreeEvent<MouseEvent>) => void;
}
declare function ScatterVis(props: PropsWithChildren<Props$R>): react_jsx_runtime.JSX.Element;

interface Props$Q {
    interactions?: InteractionInfo[];
    overflowChildren?: ReactNode;
}
declare function Toolbar(props: PropsWithChildren<Props$Q>): react_jsx_runtime.JSX.Element;

declare function Separator(props: HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;

interface Props$P extends HTMLAttributes<HTMLButtonElement> {
    label: string;
    Icon?: ComponentType<{
        className: string;
    }>;
    iconOnly?: boolean;
    small?: boolean;
    raised?: boolean;
    withArrow?: boolean;
    disabled?: boolean;
}
declare const Btn: react.ForwardRefExoticComponent<Props$P & react.RefAttributes<HTMLButtonElement>>;

interface Props$O extends AnchorHTMLAttributes<HTMLAnchorElement> {
    label: string;
    icon?: ComponentType<SVGAttributes<SVGElement>>;
    iconOnly?: boolean;
    small?: boolean;
    raised?: boolean;
}
declare function LinkBtn(props: Props$O): react_jsx_runtime.JSX.Element;

interface Props$N extends Omit<Props$P, 'onClick'> {
    value: boolean;
    onToggle: () => void;
}
declare function ToggleBtn(props: Props$N): react_jsx_runtime.JSX.Element;

interface ToggleGroupContextValue {
    role: 'tablist' | 'radiogroup';
    value: string;
    disabled?: boolean;
    onChange: (val: string) => void;
}

interface Props$M {
    label: string;
    value: string;
    icon?: ComponentType<SVGAttributes<SVGElement>>;
    iconOnly?: boolean;
    hint?: string;
    disabled?: boolean;
}
declare function ToggleGroupBtn(props: Props$M): react_jsx_runtime.JSX.Element;

interface Props$L extends ToggleGroupContextValue {
    ariaLabel?: string;
    children: ReactElement<Props$M>[];
    id?: string;
}
declare function ToggleGroup(props: Props$L): react_jsx_runtime.JSX.Element;
declare namespace ToggleGroup {
    var Btn: typeof ToggleGroupBtn;
}

interface Props$K<T extends string> {
    name: string;
    label?: string;
    options: T[];
    optionsLabels?: Record<T, string>;
    disabled?: boolean;
    value: T;
    onChange: (value: T) => void;
}
declare function RadioGroup<T extends string>(props: Props$K<T>): react_jsx_runtime.JSX.Element;

interface Props$J extends ClassStyleAttrs {
    label: string;
    disabled?: boolean;
    checked: boolean;
    indeterminate?: boolean;
    onChange?: (checked: boolean) => void;
}
declare function Checkbox(props: Props$J): react_jsx_runtime.JSX.Element;

interface Props$I {
    label: string;
    Icon?: ComponentType<{
        className: string;
    }>;
}
declare function Menu(props: PropsWithChildren<Props$I>): react_jsx_runtime.JSX.Element;

declare function MenuSeparator(props: HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;

interface Props$H {
    dataDomain: Domain;
    customDomain: CustomDomain;
    scaleType: ColorScaleType;
    histogram?: HistogramParams;
    disabled?: boolean;
    onCustomDomainChange: (domain: CustomDomain) => void;
}
declare function DomainWidget(props: Props$H): react_jsx_runtime.JSX.Element;

interface Props$G {
    value: Domain;
    dataDomain: Domain;
    safeVisDomain: Domain;
    scaleType: ColorScaleType;
    errors: DomainErrors;
    isAutoMin: boolean;
    isAutoMax: boolean;
    disabled?: boolean;
    onChange: (newValue: Domain) => void;
    onAfterChange: (hasMinChanged: boolean, hasMaxChanged: boolean) => void;
}
declare function DomainSlider(props: Props$G): react_jsx_runtime.JSX.Element;

interface Props$F {
    sliderDomain: Domain;
    dataDomain: Domain;
    errors: DomainErrors;
    isAutoMin: boolean;
    isAutoMax: boolean;
    onAutoMinToggle: () => void;
    onAutoMaxToggle: () => void;
    isEditingMin: boolean;
    isEditingMax: boolean;
    onEditMin: (force: boolean) => void;
    onEditMax: (force: boolean) => void;
    onChangeMin: (val: number) => void;
    onChangeMax: (val: number) => void;
    onSwap: () => void;
}
interface Handle {
    cancelEditing: () => void;
}
declare const DomainControls: react.ForwardRefExoticComponent<Props$F & react.RefAttributes<Handle>>;

interface Props$E {
    colorMap: ColorMap;
}
declare function ColorMapGradient(props: Props$E): react_jsx_runtime.JSX.Element;

interface Props$D {
    value: ColorMap;
    onValueChange: (colorMap: ColorMap) => void;
    invert: boolean;
    onInversionChange: () => void;
}
declare function ColorMapSelector(props: Props$D): react_jsx_runtime.JSX.Element;

interface Props$C<T extends ScaleType> {
    label?: string;
    value: T;
    onScaleChange: (scale: T) => void;
    options: T[];
}
declare function ScaleSelector<T extends ScaleType>(props: Props$C<T>): react_jsx_runtime.JSX.Element;

interface Props$B<T extends ComplexVisType> {
    label?: string;
    value: T;
    onChange: (scale: T) => void;
    options: T[];
}
declare function ComplexVisTypeSelector<T extends ComplexVisType>(props: Props$B<T>): react_jsx_runtime.JSX.Element;

interface Props$A<T> {
    label?: string;
    options: Record<string, T[]> | T[];
    disabled?: boolean;
    value: T;
    onChange: (value: T) => void;
    renderOption: (option: T) => ReactNode;
    renderSelection?: (option: T) => ReactNode;
}
declare function Selector<T extends string>(props: Props$A<T>): react_jsx_runtime.JSX.Element;

interface Props$z {
    interactions: InteractionInfo[];
}
declare function InteractionHelp(props: Props$z): react_jsx_runtime.JSX.Element;

declare enum Notation {
    Auto = "Auto",
    Scientific = "Scientific",
    Exact = "Exact"
}

interface Props$y {
    value: Notation;
    onChange: (val: Notation) => void;
}
declare function NotationToggleGroup(props: Props$y): react_jsx_runtime.JSX.Element;

interface Props$x extends HistogramParams {
    scaleType: ColorScaleType;
    dataDomain: Domain;
    value: Domain;
    onChangeMin?: (val: number) => void;
    onChangeMax?: (val: number) => void;
}
declare function Histogram(props: Props$x): react_jsx_runtime.JSX.Element;

declare function FloatingControl(props: PropsWithChildren<NoProps>): react_jsx_runtime.JSX.Element | null;

declare function ResetZoomButton(): react_jsx_runtime.JSX.Element;

interface Props$w extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
    dims: number[];
    dimHints?: (string | undefined)[];
    dimMapping: DimensionMapping;
    canSliceFast?: (nextMapping: DimensionMapping) => boolean;
    onChange: (d: DimensionMapping) => void;
}
declare function DimensionMapper(props: Props$w): react_jsx_runtime.JSX.Element | null;

interface Props$v {
    title?: string;
    aspect?: Aspect;
    abscissaConfig: AxisConfig;
    ordinateConfig: AxisConfig;
    raycasterThreshold?: number;
    showAxes?: boolean;
}
declare function VisCanvas(props: PropsWithChildren<Props$v>): react_jsx_runtime.JSX.Element;

interface Props$u {
    size?: Size;
    guides?: 'horizontal' | 'vertical' | 'both';
    renderTooltip: (x: number, y: number) => ReactNode;
}
declare function TooltipMesh(props: Props$u): react_jsx_runtime.JSX.Element;

interface Props$t {
    overflowCanvas?: boolean;
}
declare function Html(props: PropsWithChildren<Props$t>): null;

interface Props$s {
    className?: string;
    style?: CSSProperties;
}
declare function Overlay(props: PropsWithChildren<Props$s>): react_jsx_runtime.JSX.Element;

interface Props$r extends HTMLAttributes<HTMLDivElement> {
    x: number;
    y: number;
    overflowCanvas?: boolean;
    scaleOnZoom?: boolean;
    center?: boolean;
}
declare function Annotation(props: Props$r): react_jsx_runtime.JSX.Element;

interface Props$q<T extends Vector3[]> {
    points: T;
    children: (...points: MappedTuple<T>) => ReactNode;
}
declare function DataToHtml<T extends Vector3[]>(props: Props$q<T>): ReactNode;

interface Props$p extends ClassStyleAttrs {
    show?: boolean;
    left: number | undefined;
    top: number | undefined;
}
declare function Tooltip(props: PropsWithChildren<Props$p>): react_jsx_runtime.JSX.Element;

interface Props$o extends SVGAttributes<SVGSVGElement> {
    show?: boolean;
    top?: number | false;
    left?: number | false;
}
declare function Guides(props: Props$o): react_jsx_runtime.JSX.Element;

interface Props$n {
    abscissas: NumArray;
    ordinates: NumArray;
    errors?: NumArray;
    showErrors?: boolean;
    color: string;
    curveType?: CurveType;
    width?: number;
    interpolation?: Interpolation;
    glyphType?: GlyphType;
    glyphSize?: number;
    materialProps?: LineMaterialParameters;
    visible?: boolean;
    onLineClick?: (index: number, event: ThreeEvent<MouseEvent>) => void;
    onLineEnter?: (index: number, event: ThreeEvent<PointerEvent>) => void;
    onLineLeave?: (index: number, event: ThreeEvent<PointerEvent>) => void;
    onDataPointClick?: (index: number, evt: ThreeEvent<MouseEvent>) => void;
    onDataPointEnter?: (index: number, evt: ThreeEvent<PointerEvent>) => void;
    onDataPointLeave?: (index: number, evt: ThreeEvent<PointerEvent>) => void;
    ignoreValue?: IgnoreValue;
}
declare function DataCurve(props: Props$n): react_jsx_runtime.JSX.Element;

declare module '@react-three/fiber' {
    interface ThreeElements {
        line2: Object3DNode<Line2, typeof Line2>;
        lineMaterial: Object3DNode<LineMaterial, typeof LineMaterial>;
    }
}
interface Props$m extends Object3DNode<Line2, typeof Line2> {
    abscissas: NumArray;
    ordinates: NumArray;
    color: string;
    width?: number;
    interpolation?: Interpolation;
    materialProps?: LineMaterialParameters;
    visible?: boolean;
    ignoreValue?: IgnoreValue;
}
declare function Line(props: Props$m): react_jsx_runtime.JSX.Element;

interface Props$l extends PointsProps {
    abscissas: NumArray;
    ordinates: NumArray;
    glyphType?: GlyphType;
    color: string;
    size?: number;
    visible?: boolean;
    ignoreValue?: IgnoreValue;
}
declare function Glyphs(props: Props$l): react_jsx_runtime.JSX.Element;

interface Props$k {
    abscissas: NumArray;
    ordinates: NumArray;
    errors: NumArray;
    color: string;
    visible?: boolean;
    ignoreValue?: IgnoreValue;
}
declare function ErrorBars(props: Props$k): react_jsx_runtime.JSX.Element;

interface Props$j {
    domain: Domain;
    scaleType: VisScaleType;
    colorMap: ColorMap;
    horizontal?: boolean;
    withBounds?: boolean;
    invertColorMap: boolean;
}
declare function ColorBar(props: Props$j): react_jsx_runtime.JSX.Element;

interface Props$i extends MeshProps {
    size?: Size;
}
declare function VisMesh(props: Props$i): react_jsx_runtime.JSX.Element;

interface Props$h extends Props$i {
    values: NdArray<TextureSafeTypedArray | Uint16Array>;
    domain: Domain;
    scaleType: VisScaleType;
    colorMap: ColorMap;
    invertColorMap?: boolean;
    alphaValues?: NdArray<TextureSafeTypedArray | Uint16Array>;
    alphaDomain?: Domain;
    badColor?: RGBColor | string;
    magFilter?: MagnificationTextureFilter;
    minFilter?: MinificationTextureFilter;
    mask?: NdArray<Uint8Array>;
}
declare function HeatmapMesh(props: Props$h): react_jsx_runtime.JSX.Element;

declare class Box extends Box3 {
    get size(): Size;
    get center(): Vector3;
    static empty(center?: Vector3): Box;
    static fromPoints(...points: Vector3[]): Box;
    static fromSize({ width, height }: Size): Box;
    clampPoint(pt: Vector3): Vector3;
    expandBySize(width: number, height: number): this;
    expandToRatio(ratio: number | undefined): this;
    hasMinSize(minWidth: number, minHeight?: number): boolean;
    keepWithin(area: Box): this;
    toRect(): Rect;
}

interface VisCanvasContextValue {
    canvasSize: Size;
    canvasRatio: number;
    canvasBox: Box;
    visRatio: number | undefined;
    visSize: Size;
    abscissaConfig: AxisConfig;
    ordinateConfig: AxisConfig;
    abscissaScale: AxisScale;
    ordinateScale: AxisScale;
    dataToWorld: (dataPt: Vector3) => Vector3;
    dataToHtml: (camera: Camera, dataPt: Vector3) => Vector3;
    worldToHtml: (camera: Camera, worldPt: Vector3) => Vector3;
    worldToData: (worldPt: Vector3) => Vector3;
    htmlToWorld: (camera: Camera, htmlPt: Vector3) => Vector3;
    htmlToData: (camera: Camera, htmlPt: Vector3) => Vector3;
    getFovBox: (camera: Camera, center?: Vector3) => Box;
    getVisibleDomains: (camera: Camera) => VisibleDomains;
    visCanvas: HTMLElement;
    canvasArea: HTMLElement;
    r3fRoot: HTMLElement;
    svgOverlay: SVGSVGElement | null;
    floatingToolbar: HTMLDivElement | null;
}
declare function useVisCanvasContext(): VisCanvasContextValue;

interface Props$g extends CommonInteractionProps {
    id?: string;
    transform?: (rawSelection: Selection, camera: Camera, context: VisCanvasContextValue) => Selection;
    validate?: (selection: Selection) => boolean;
    onSelectionStart?: () => void;
    onSelectionChange?: (selection: Selection | undefined, rawSelection: Selection, isValid: boolean) => void;
    onSelectionEnd?: (selection: Selection | undefined, isValid: boolean) => void;
    onValidSelection?: (selection: Selection) => void;
    children: (selection: Selection, rawSelection: Selection, isValid: boolean) => ReactNode;
}
declare function SelectionTool(props: Props$g): ReactNode;

interface Props$f extends Omit<Props$g, 'transform'> {
    axis: Axis;
}
declare function AxialSelectionTool(props: Props$f): react_jsx_runtime.JSX.Element;

interface Props$e {
    when?: 'as-needed' | 'always' | 'never';
}
declare function PreventDefaultContextMenu(props: Props$e): null;

interface Props$d {
    visKey: string;
    xOnly?: boolean;
}
declare function KeepZoom(props: Props$d): null;

declare function KeepZoomProvider(props: PropsWithChildren<NoProps>): react_jsx_runtime.JSX.Element;

declare function SvgElement(props: PropsWithChildren<NoProps>): react_jsx_runtime.JSX.Element | null;

interface Props$c extends SVGProps<SVGLineElement> {
    coords: Rect;
}
declare function SvgLine(props: Props$c): react_jsx_runtime.JSX.Element;

interface Props$b extends SVGProps<SVGPathElement> {
    coords: Rect;
    strokePosition?: 'inside' | 'outside';
    strokeWidth?: number;
}
declare function SvgRect(props: Props$b): react_jsx_runtime.JSX.Element;

interface Props$a extends SVGProps<SVGCircleElement> {
    coords: Rect;
}
declare function SvgCircle(props: Props$a): react_jsx_runtime.JSX.Element;

declare class Interaction {
    readonly id: string;
    readonly buttons: MouseButton[];
    readonly modifierKeys: ModifierKey$1[];
    readonly isWheel: boolean;
    readonly isEnabled: boolean;
    constructor(id: string, config: InteractionConfig);
    matches(event: MouseEvent): boolean;
}

interface InteractionsContextValue {
    registerInteraction: (id: string, config: InteractionConfig) => void;
    unregisterInteraction: (id: string) => void;
    getInteractions: (button?: InteractionConfig['button'], modifierKey?: InteractionConfig['modifierKey']) => Interaction[];
    shouldInteract: (id: string, event: MouseEvent) => boolean;
}
declare function useInteractionsContext(): InteractionsContextValue;

declare const AXIS_SCALE_TYPES: AxisScaleType[];
declare const COLOR_SCALE_TYPES: ColorScaleType[];
declare function toTypedNdArray<T extends TypedArrayConstructor>(arr: NdArray<NumArray>, Constructor: T): NdArray<InstanceType<T>>;
declare function getBounds(valuesArray: AnyNumArray, ignoreValue?: IgnoreValue): Bounds | undefined;
declare function getBoundsWithErrors(valuesArray: AnyNumArray, errorsArray: AnyNumArray | undefined, ignoreValue?: IgnoreValue): [
    boundsWithErrors: Bounds | undefined,
    boundsWithoutErrors: Bounds | undefined
];
declare function getValidDomainForScale(bounds: Bounds | undefined, scaleType: ScaleType): Domain | undefined;

declare const Z_MIN: number;
declare const Z_MAX: number;
declare function getDomain(values: AnyNumArray, opts?: GetDomainOpts & {
    errors?: AnyNumArray;
}): Domain | undefined;
declare function getDomains(valuesArrays: AnyNumArray[], opts?: GetDomainOpts & {
    errorsArrays?: (AnyNumArray | undefined)[];
}): (Domain | undefined)[];
declare function extendDomain(domain: Domain, extendFactor: number, scaleType?: ColorScaleType): Domain;
declare function getValueToIndexScale(values: NumArray, switchAtMidpoints?: boolean): ScaleThreshold<number, number>;
declare function getCombinedDomain(domains: [Domain, ...Domain[]]): Domain;
declare function getCombinedDomain(domains: (Domain | undefined)[]): Domain | undefined;
declare function getAxisDomain(axisValues: NumArray, opts?: {
    scaleType?: AxisScaleType;
    extensionFactor?: number;
    forceAscending?: boolean;
}): Domain | undefined;
declare function createBufferAttr(dataLength: number, itemSize?: number, TypedArrayCtor?: TypedArrayConstructor): BufferAttribute;
declare function createIndex(length: number, maxValue: number): BufferAttribute;

declare const useBounds: typeof getBounds;
declare const useBoundsWithErrors: typeof getBoundsWithErrors;
declare const useValidDomainForScale: typeof getValidDomainForScale;
declare const useCombinedDomain: typeof getCombinedDomain;
declare const useValueToIndexScale: typeof getValueToIndexScale;
declare const useAxisDomain: typeof getAxisDomain;
declare function useDomain(values: AnyNumArray, opts?: GetDomainOpts & {
    errors?: AnyNumArray;
}): Domain | undefined;
declare function useDomains(valuesArrays: AnyNumArray[], opts?: GetDomainOpts & {
    errorsArrays?: (AnyNumArray | undefined)[];
}): (Domain | undefined)[];
declare function useCameraState<T>(factory: (camera: Camera$1) => T, deps: unknown[], equalityFn?: (prev: T, next: T) => boolean): T;
declare function useUpdateGeometry(geometry: H5WebGeometry & BufferGeometry, config?: {
    skipUpdates?: boolean;
    isInteractive?: boolean;
}): void;

declare function getAxisValues(rawValues: NumArray | undefined, axisLength: number): NumArray;

declare const useAxisValues: typeof getAxisValues;

declare function getVisDomain(customDomain: CustomDomain, dataDomain: Domain): Domain;
declare function getSafeDomain(domain: Domain, fallbackDomain: Domain, scaleType: ScaleType): [Domain, DomainErrors];
declare function getLinearGradient(interpolator: D3Interpolator, direction: 'top' | 'bottom' | 'right' | 'left', minMaxOnly?: boolean): string;

declare const useVisDomain: typeof getVisDomain;
declare const useSafeDomain: typeof getSafeDomain;

declare function useCanvasEvent<T extends MouseEventName, U extends GlobalEventHandlersEventMap[T]>(mouseEventName: T, listener: (evt: CanvasEvent<U>) => void, options?: AddEventListenerOptions): void;
declare function useInteraction(id: string, config: InteractionConfig): (event: MouseEvent) => boolean;
declare function useModifierKeyPressed(modifierKey?: ModifierKey | ModifierKey[]): boolean;
declare function useDrag(opts: UseDragOpts): UseDragState;

declare function initDimMapping(dims: number[], axesCount: number, lockedDimsCount?: number): DimensionMapping;
declare function getSliceSelection(dimMapping?: DimensionMapping): string | undefined;
declare function getSlicedDimsAndMapping(dims: number[], dimMapping: DimensionMapping): [number[], DimensionMapping];

declare const useSlicedDimsAndMapping: typeof getSlicedDimsAndMapping;

interface Params$4 {
    abscissas: NumArray;
    ordinates: NumArray;
    abscissaScale: AxisScale;
    ordinateScale: AxisScale;
    ignoreValue?: IgnoreValue;
}
declare class LineGeometry extends LineGeometry$1 implements H5WebGeometry {
    private readonly params;
    private readonly length;
    private readonly positions;
    constructor(params: Params$4);
    update(): void;
    private setInvalidSegment;
}

declare class GlyphsGeometry extends BufferGeometry<Record<'position', BufferAttribute>> implements H5WebGeometry {
    private readonly params;
    constructor(params: Params$4);
    update(): void;
}

interface Params$3 extends Params$4 {
    errors: NumArray;
}
declare class ErrorBarsGeometry extends BufferGeometry<Record<'position', BufferAttribute>> implements H5WebGeometry {
    private readonly params;
    constructor(params: Params$3);
    update(): void;
}

interface Params$2 extends Params$4 {
    errors: NumArray;
}
declare class ErrorCapsGeometry extends BufferGeometry<Record<'position', BufferAttribute>> implements H5WebGeometry {
    private readonly params;
    constructor(params: Params$2);
    update(): void;
}

declare enum ImageType {
    RGB = "RGB",
    BGR = "BGR"
}

declare const mockValues: {
    oneD: () => ndarray.NdArray<number[]>;
    oneD_linear: () => ndarray.NdArray<number[]>;
    oneD_bigint: () => ndarray.NdArray<bigint[]>;
    oneD_complex: () => ndarray.NdArray<H5WebComplex[]>;
    oneD_compound: () => ndarray.NdArray<[string, number, number, boolean, H5WebComplex][]>;
    oneD_boolean: () => ndarray.NdArray<boolean[]>;
    oneD_enum: () => ndarray.NdArray<number[]>;
    oneD_errors: () => ndarray.NdArray<number[]>;
    oneD_str: () => ndarray.NdArray<string[]>;
    twoD: () => ndarray.NdArray<number[]>;
    twoD_asym: () => ndarray.NdArray<number[]>;
    twoD_bigint: () => ndarray.NdArray<bigint[]>;
    twoD_complex: () => ndarray.NdArray<H5WebComplex[]>;
    twoD_compound: () => ndarray.NdArray<[string, number, number, boolean, H5WebComplex][]>;
    twoD_boolean: () => ndarray.NdArray<boolean[]>;
    twoD_enum: () => ndarray.NdArray<number[]>;
    twoD_errors: () => ndarray.NdArray<number[]>;
    twoD_negative: () => ndarray.NdArray<number[]>;
    twoD_opaque: () => ndarray.NdArray<Uint8Array<ArrayBuffer>[]>;
    threeD: () => ndarray.NdArray<number[]>;
    threeD_complex: () => ndarray.NdArray<H5WebComplex[]>;
    threeD_boolean: () => ndarray.NdArray<boolean[]>;
    threeD_rgb: () => ndarray.NdArray<number[]>;
    threeD_rgba: () => ndarray.NdArray<number[]>;
    fourD: () => ndarray.NdArray<number[]>;
    fourD_rgb: () => ndarray.NdArray<number[]>;
    uint8: () => ndarray.NdArray<Uint8Array<ArrayBuffer>>;
    int16: () => ndarray.NdArray<Int16Array<ArrayBuffer>>;
    int64: () => ndarray.NdArray<BigInt64Array<ArrayBuffer>>;
    float32: () => ndarray.NdArray<Float32Array<ArrayBuffer>>;
    float64: () => ndarray.NdArray<Float64Array<ArrayBuffer>>;
    int8_rgb: () => ndarray.NdArray<Int8Array<ArrayBuffer>>;
    uint8_rgb: () => ndarray.NdArray<Uint8Array<ArrayBuffer>>;
    int32_rgb: () => ndarray.NdArray<Uint32Array<ArrayBuffer>>;
    float32_rgb: () => ndarray.NdArray<Float32Array<ArrayBuffer>>;
    X: () => ndarray.NdArray<number[]>;
    X_desc: () => ndarray.NdArray<number[]>;
    X_log: () => ndarray.NdArray<number[]>;
    X_rgb: () => ndarray.NdArray<number[]>;
    X_bigint: () => ndarray.NdArray<bigint[]>;
    Y: () => ndarray.NdArray<number[]>;
    Y_desc: () => ndarray.NdArray<number[]>;
    Y_rgb: () => ndarray.NdArray<number[]>;
    secondary: () => ndarray.NdArray<number[]>;
    secondary_cplx: () => ndarray.NdArray<H5WebComplex[]>;
    secondary_bigint: () => ndarray.NdArray<bigint[]>;
    secondary_boolean: () => ndarray.NdArray<boolean[]>;
    secondary_enum: () => ndarray.NdArray<number[]>;
    tertiary: () => ndarray.NdArray<number[]>;
    tertiary_cplx: () => ndarray.NdArray<H5WebComplex[]>;
    tertiary_float: () => ndarray.NdArray<number[]>;
    position: () => ndarray.NdArray<number[]>;
    scatter_data: () => ndarray.NdArray<number[]>;
    Y_scatter: () => ndarray.NdArray<number[]>;
};

declare function SnapshotBtn(): react_jsx_runtime.JSX.Element;

interface Props$9 {
    entries: ExportEntry[];
    isSlice?: boolean;
}
declare function ExportMenu(props: Props$9): react_jsx_runtime.JSX.Element;

interface Props$8 {
    value: number | undefined;
    defaultValue: number;
    onChange: (val: number | undefined) => void;
}
declare function CellWidthInput(props: Props$8): react_jsx_runtime.JSX.Element;

interface Props$7 extends ClassStyleAttrs {
    value: string;
}
declare function ScalarVis(props: Props$7): react_jsx_runtime.JSX.Element;

interface Props$6 extends ClassStyleAttrs {
    value: Uint8Array;
    title?: string;
    fit?: boolean;
}
declare function BinaryImageVis(props: Props$6): react_jsx_runtime.JSX.Element;

interface Props$5 extends ClassStyleAttrs {
    dataArray: NdArray<NumArray>;
    aspect?: Aspect;
    showGrid?: boolean;
    title?: string;
    imageType?: ImageType;
    abscissaParams?: AxisParams;
    ordinateParams?: AxisParams;
    flipXAxis?: boolean;
    flipYAxis?: boolean;
    interactions?: DefaultInteractionsConfig;
}
declare function RgbVis(props: PropsWithChildren<Props$5>): react_jsx_runtime.JSX.Element;

interface Props$4 {
    abscissas: NumArray;
    ordinates: NumArray;
    data: NumArray;
    domain: Domain;
    scaleType: ColorScaleType;
    colorMap: ColorMap;
    invertColorMap: boolean;
    size: number;
    onClick?: (index: number, evt: ThreeEvent<MouseEvent>) => void;
    onPointerEnter?: (index: number, evt: ThreeEvent<PointerEvent>) => void;
    onPointerOut?: (index: number, evt: ThreeEvent<PointerEvent>) => void;
}
declare function ScatterPoints(props: Props$4): react_jsx_runtime.JSX.Element;

interface Params$1 {
    abscissas: NumArray;
    ordinates: NumArray;
    data: NumArray;
    abscissaScale: AxisScale;
    ordinateScale: AxisScale;
    colorScale: Scale<ColorScaleType>;
    interpolator: D3Interpolator;
}
declare class ScatterPointsGeometry extends BufferGeometry<Record<'position' | 'color', BufferAttribute>> implements H5WebGeometry {
    private readonly params;
    constructor(params: Params$1);
    update(): void;
}

interface ColorMapProps {
    domain: Domain;
    scaleType: VisScaleType;
    colorMap: ColorMap;
    invertColorMap?: boolean;
}
type TileArray = NdArray<TextureSafeTypedArray | Uint16Array>;

declare function getLayerSizes(baseLayerSize: Size, tileSize: Size, roundToEven?: boolean): Size[];
declare abstract class TilesApi {
    readonly tileSize: Size;
    readonly layerSizes: Size[];
    constructor(tileSize: Size, layerSizes: Size[]);
    get baseLayerSize(): Size;
    get baseLayerIndex(): number;
    get numLayers(): number;
    abstract get(layer: number, offset: Vector2): TileArray;
}

interface Props$3 extends ColorMapProps {
    api: TilesApi;
    displayLowerResolutions?: boolean;
    qualityFactor?: number;
    size?: Size;
}
declare function TiledHeatmapMesh(props: Props$3): react_jsx_runtime.JSX.Element;

interface Props$2 {
    size?: Size;
    renderTooltip: (x: number, y: number, v: number) => ReactElement | undefined;
}
declare function TiledTooltipMesh(props: Props$2): react_jsx_runtime.JSX.Element;

declare function assertDefined<T>(val: T, message?: string): asserts val is T extends undefined ? never : T;
declare function assertNonNull<T>(val: T, message?: string): asserts val is T extends null ? never : T;
declare function assertLength(arr: AnyNumArray | undefined, dataLength: number, arrName: string): void;

interface Props$1 extends ClassStyleAttrs {
    dataArray: NdArray<NumArray>;
    domain: Domain;
    scaleType?: ColorScaleType;
    colorMap?: ColorMap;
    invertColorMap?: boolean;
    showPoints?: boolean;
}
declare function SurfaceVis(props: PropsWithChildren<Props$1>): react_jsx_runtime.JSX.Element;

interface Params {
    dataArray: NdArray<NumArray>;
    rows: number;
    cols: number;
}
declare class SurfaceMeshGeometry extends BufferGeometry<Record<'position' | 'uv', BufferAttribute>> implements H5WebGeometry {
    private readonly params;
    private skipCount;
    constructor(params: Params);
    update(): void;
}

interface Props {
    className?: string;
    orthographic?: boolean;
}
declare function R3FCanvas(props: PropsWithChildren<Props>): react_jsx_runtime.JSX.Element;

export { AXIS_SCALE_TYPES, Annotation, AxialSelectToZoom, AxialSelectionTool, BinaryImageVis, Box, Btn, COLOR_SCALE_TYPES, CellWidthInput, Checkbox, ColorBar, ColorMapGradient, ColorMapSelector, ComplexVisType, ComplexVisTypeSelector, CurveType, DataCurve, DataToHtml, DefaultInteractions, DimensionMapper, DomainControls, DomainSlider, DomainWidget, ErrorBars, ErrorBarsGeometry, ErrorCapsGeometry, ExportMenu, FloatingControl, GlyphType, Glyphs, GlyphsGeometry, Guides, HeatmapMesh, HeatmapVis, Histogram, Html, INTERPOLATORS, ImageType, InteractionHelp, Interpolation, KeepZoom, KeepZoomProvider, Line, LineGeometry, LineVis, LinkBtn, MatrixVis, Menu, MenuSeparator, MouseButton, Notation, NotationToggleGroup, Overlay, Pan, PreventDefaultContextMenu, R3FCanvas, RadioGroup, ResetZoomButton, RgbVis, ScalarVis, ScaleSelector, ScaleType, ScatterPoints, ScatterPointsGeometry, ScatterVis, SelectToZoom, SelectionTool, Selector, Separator, SnapshotBtn, SurfaceMeshGeometry, SurfaceVis, SvgCircle, SvgElement, SvgLine, SvgRect, TiledHeatmapMesh, TiledTooltipMesh, TilesApi, ToggleBtn, ToggleGroup, Toolbar, Tooltip, TooltipMesh, VisCanvas, VisMesh, XAxisZoom, YAxisZoom, Z_MAX, Z_MIN, Zoom, assertDefined, assertLength, assertNonNull, createBufferAttr, createIndex, extendDomain, getAxisDomain, getAxisValues, getBounds, getBoundsWithErrors, getCombinedDomain, getDomain, getDomains, getLayerSizes, getLinearGradient, getSafeDomain, getSliceSelection, getSlicedDimsAndMapping, getValidDomainForScale, getValueToIndexScale, getVisDomain, initDimMapping, mockValues, scaleGamma, toTypedNdArray, useAxisDomain, useAxisValues, useBounds, useBoundsWithErrors, useCameraState, useCanvasEvent, useCombinedDomain, useDomain, useDomains, useDrag, useInteraction, useInteractionsContext, useModifierKeyPressed, useSafeDomain, useSlicedDimsAndMapping, useUpdateGeometry, useValidDomainForScale, useValueToIndexScale, useVisCanvasContext, useVisDomain };
export type { Aspect, AuxiliaryParams, Props$U as AxialSelectToZoomProps, Props$f as AxialSelectionToolProps, Axis, AxisConfig, AxisParams, AxisScale, AxisScaleType, BuiltInExporter, CanvasEvent, Props$j as ColorBarProps, ColorMap, ColorScaleType, CommonInteractionProps, CustomDomain, D3Interpolator, Props$n as DataCurveProps, Props$q as DataToHtmlProps, DefaultInteractionsConfig, DimensionMapping, Domain, Handle as DomainControlsHandle, Props$F as DomainControlsProps, DomainErrors, Props$G as DomainSliderProps, Props$H as DomainWidgetProps, Props$k as ErrorBarsProps, ExportEntry, ExportFormat, ExportURL, ExtractScaleType, Props$l as GlyphsProps, Props$o as GuidesProps, H5WebGeometry, Props$h as HeatmapMeshProps, Props$S as HeatmapVisProps, HistogramParams, Props$x as HistogramProps, IgnoreValue, InteractionConfig, InteractionInfo, InteractionsContextValue, Props$m as LineProps, Props$T as LineVisProps, Props$_ as MatrixVisProps, ModifierKey, Props$Z as PanProps, Props$e as PreventDefaultContextMenuProps, Rect, Scale, ScaleConfig, ScaleGammaConfig, ScatterAxisParams, Props$R as ScatterVisProps, Props$Y as SelectToZoomProps, Selection, Props$g as SelectionToolProps, Size, Props$1 as SurfaceVisProps, Props$a as SvgCircleProps, Props$c as SvgLineProps, Props$b as SvgRectProps, Props$3 as TiledHeatmapMeshProps, Props$Q as ToolbarProps, Props$u as TooltipMeshProps, Props$p as TooltipProps, VisCanvasContextValue, Props$v as VisCanvasProps, VisScaleType, VisibleDomains, Props$X as XAxisZoomProps, Props$W as YAxisZoomProps, Props$V as ZoomProps };