import { Bin, TimeBins, Millisecond, TimeRangeFilter, RangeFilter, PlotType, PlotGroupBy, Filter, LineChart, Field, ValueOf, ColorRange } from '@kepler.gl/types';
import { AggregationTypes } from '@kepler.gl/constants';
import { DataContainerInterface } from '.';
import { KeplerTableModel } from './types';
type Datasets = any;
/**
 * Merge per-layer polygon-filtered indices into a dataset-level index.
 * When any layers are polygon-filtered, take the union of their indices (a row is kept if it
 * is visible on at least one targeted layer), then intersect with the base index.
 * Used for filtered export and filter plots/histograms.
 */
export declare function mergePolygonLayerIndexes(baseIndex: number[], filteredIndexByLayer?: Record<string, number[]>): number[];
/**
 *
 * @param thresholds
 * @param values
 * @param indexes
 */
export declare function histogramFromThreshold(thresholds: number[], values: number[], valueAccessor?: (d: unknown) => number, filterEmptyBins?: boolean): Bin[];
/**
 *
 * @param values
 * @param numBins
 * @param valueAccessor
 */
export declare function histogramFromValues(values: (Millisecond | null | number)[], numBins: number, valueAccessor?: (d: number) => number): Bin[];
export declare function histogramFromOrdinal(domain: [string], values: (Millisecond | null | number)[], valueAccessor?: (d: unknown) => string): Bin[];
/**
 * Bin rows by time interval overlap: a feature [start, end] is counted in every
 * bin whose range intersects that span. Null/undefined end is treated as still
 * active through the last threshold (open-ended).
 */
export declare function histogramFromTimeIntervals(thresholds: number[], indexes: number[], startAccessor: (idx: number) => number | null | undefined, endAccessor: (idx: number) => number | null | undefined): Bin[];
/**
 * @param domain
 * @param values
 * @param numBins
 * @param valueAccessor
 */
export declare function histogramFromDomain(domain: [number, number], values: (Millisecond | null | number)[], numBins: number, valueAccessor?: (d: unknown) => number): Bin[];
/**
 * @param filter
 * @param datasets
 * @param interval
 */
export declare function getTimeBins(filter: TimeRangeFilter, datasets: Datasets, interval: PlotType['interval'], plotBaseIndexByDataId?: Record<string, number[]>): TimeBins;
export declare function binByTime(indexes: any, dataset: any, interval: any, filter: any): Bin[] | null;
export declare function getBinThresholds(interval: string, domain: number[]): number[];
/**
 * Build histogram thresholds in the numeric field's own units.
 * Unlike time intervals, numeric intervals are anchored to the filter domain
 * and never pass through calendar conversion.
 */
export declare function getNumericBinThresholds(domain: number[], interval?: number, numBins?: number): number[];
/** Return the next representable IEEE-754 number above value. */
export declare function nextUp(value: number): number;
/** Return the next representable IEEE-754 number below value. */
export declare function nextDown(value: number): number;
/**
 * Smallest useful range width across a numeric domain. It is large enough to
 * move either endpoint by one representable value and never exceeds the span.
 */
export declare function getNumericRangeMinimum(domain: number[]): number;
/** Infer the regular numeric bin width, ignoring tiny padded edge bins. */
export declare function getNumericPlotInterval(filter: RangeFilter): number;
/** Return the plotted bin boundaries for either a time or numeric range filter. */
export declare function getFilterBinThresholds(filter: TimeRangeFilter | RangeFilter): number[];
/**
 * Run GPU filter on current filter result to generate indexes for ploting chart
 * Skip ruuning for the same field
 * @param dataset
 * @param filter Histogram filter whose dataId-paired column should be skipped
 * @param skipFieldNames Extra GPU field names to skip (charts cross-filter). Histogram callers omit this.
 * @param baseIndex CPU base that excludes the plotted filter and already includes polygon filters.
 */
export declare function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(dataset: K, filter?: Filter, skipFieldNames?: string[], baseIndex?: number[]): number[];
export declare function getFilterDataFunc(filterRange: any, getFilterValue: any, dataContainer: DataContainerInterface, skips: any): (index: any) => any;
export declare function validBin(b: any): boolean;
/**
 * Turn a histogram brush or slider position into one bin.
 * Interval playback steps by bin, and the filter comparison is inclusive.
 * Time bins preserve their millisecond offset. Numeric bins use the immediate
 * representable predecessor of the next mark so their membership matches D3's
 * half-open bins; only the final numeric bin includes its upper boundary.
 */
export declare function intervalBinFromMarks(marks: number[], value: number, endOffset?: number): [number, number];
export declare function snapToMarks(value: number, marks: number[]): number;
export declare function normalizeValue(val: any, minValue: any, step: any, marks: any): number;
export declare function isPercentField(field: any): any;
export declare function updateAggregationByField(field: Field, aggregation: ValueOf<AggregationTypes>): ValueOf<"count" | "average" | "maximum" | "minimum" | "median" | "stdev" | "sum" | "variance" | "mode" | "countUnique">;
export declare const getValueAggrFunc: (field: Field | string | null, aggregation: string, dataset: KeplerTableModel<any, any>) => ((bin: Bin) => number);
export declare const getAggregationOptiosnBasedOnField: (field: any) => import("@kepler.gl/constants").TimeAggregation[];
export declare function getPctChange(y: unknown, y0: unknown): number | null;
export declare const PLOT_GROUP_OTHERS_NAME = "Others";
export declare const PLOT_NUM_GROUPS_ALL: "ALL";
export declare const DEFAULT_PLOT_NUM_GROUPS = 10;
/** Qualitative palettes stop at 20. All uses this cap instead of one series per value. */
export declare const MAX_PLOT_NUM_GROUPS = 20;
export declare const PLOT_NUM_GROUPS_OPTIONS: number[];
export declare function plotGroupColorSteps(numGroups: number | typeof PLOT_NUM_GROUPS_ALL | undefined): number;
export declare function defaultPlotGroupColorRange(numGroups?: number | typeof PLOT_NUM_GROUPS_ALL): ColorRange;
/**
 * Merge a partial timeline group-by onto the previous one.
 * `null` clears grouping. Missing fields keep the previous value, then defaults.
 */
export declare function mergePlotGroupBy(prev: PlotGroupBy | null | undefined, next: Partial<PlotGroupBy> | null | undefined): PlotGroupBy | null;
export declare function lineChartSeriesLegend(lineChart?: LineChart | null): {
    name: string;
    color: string;
}[];
/**
 *
 * @param datasets
 * @param filter
 */
export declare function getLineChart(datasets: Datasets, filter: Filter): LineChart;
export declare function splitSeries(series: any): {
    lines: any[];
    markers: any;
};
type MinVisStateForAnimationWindow = {
    datasets: Datasets;
};
export declare function adjustValueToAnimationWindow<S extends MinVisStateForAnimationWindow>(state: S, filter: TimeRangeFilter | RangeFilter, plotBaseIndexByDataId?: Record<string, number[]>): {
    value: any[];
    plotType: {
        [key: string]: any;
    } & {
        [key: string]: any;
    };
    timeBins: any;
    dataId: string[];
    id: string;
    enabled: boolean;
    inverted?: boolean;
    fixedDomain: true;
    view: import("@kepler.gl/types").FilterViewType;
    isAnimating: boolean;
    animationWindow?: string;
    speed: number;
    showTimeDisplay?: boolean;
    name: string[];
    type: "range";
    fieldIdx: number[];
    domain: any[] & number[];
    mappedValue?: number[];
    yAxis: Field | null;
    lineChart?: LineChart | undefined;
    gpu: boolean;
    gpuChannel?: number[];
    gpuEndChannel?: number[];
    fieldType: "real" | "integer";
    endName?: (string | null | undefined)[];
    endFieldIdx?: (number | null | undefined)[];
    endMappedValue?: ((number | null)[] | null | undefined)[];
    layerId?: string[];
    step: number;
    bins?: import("@kepler.gl/types").Bins;
    typeOptions: ["range"];
} | {
    value: any[];
    bins: any;
    dataId: string[];
    id: string;
    enabled: boolean;
    inverted?: boolean;
    fixedDomain: true;
    view: import("@kepler.gl/types").FilterViewType;
    isAnimating: boolean;
    animationWindow?: string;
    speed: number;
    showTimeDisplay?: boolean;
    name: string[];
    type: "range";
    fieldIdx: number[];
    domain: any[] & number[];
    mappedValue?: number[];
    yAxis: Field | null;
    plotType: {
        [key: string]: any;
    } & {
        [key: string]: any;
    };
    lineChart?: LineChart | undefined;
    gpu: boolean;
    gpuChannel?: number[];
    gpuEndChannel?: number[];
    fieldType: "real" | "integer";
    endName?: (string | null | undefined)[];
    endFieldIdx?: (number | null | undefined)[];
    endMappedValue?: ((number | null)[] | null | undefined)[];
    layerId?: string[];
    step: number;
    typeOptions: ["range"];
} | {
    value: any[];
    plotType: {
        [key: string]: any;
    } & {
        [key: string]: any;
    };
    timeBins: any;
    dataId: string[];
    id: string;
    enabled: boolean;
    inverted?: boolean;
    fixedDomain: boolean;
    view: import("@kepler.gl/types").FilterViewType;
    isAnimating: boolean;
    animationWindow: string;
    speed: number;
    showTimeDisplay?: boolean;
    name: string[];
    type: "timeRange";
    fieldIdx: number[];
    domain: any[] & [number, number];
    mappedValue: number[] & (number | null)[];
    yAxis: Field | null;
    lineChart?: LineChart | undefined;
    gpu: boolean;
    gpuChannel?: number[];
    gpuEndChannel?: number[];
    fieldType: "timestamp";
    endName?: (string | null | undefined)[];
    endFieldIdx?: (number | null | undefined)[];
    endMappedValue?: ((number | null)[] | null | undefined)[];
    layerId?: string[];
    step: number;
    defaultTimeFormat?: string | null;
    timeFormat?: string | null;
    timezone?: string | null;
    syncedWithLayerTimeline: boolean;
    syncTimelineMode: import("@kepler.gl/types").SyncTimelineMode;
    invertTrendColor: boolean;
} | {
    value: any[];
    bins: any;
    dataId: string[];
    id: string;
    enabled: boolean;
    inverted?: boolean;
    fixedDomain: boolean;
    view: import("@kepler.gl/types").FilterViewType;
    isAnimating: boolean;
    animationWindow: string;
    speed: number;
    showTimeDisplay?: boolean;
    name: string[];
    type: "timeRange";
    fieldIdx: number[];
    domain: any[] & [number, number];
    mappedValue: number[] & (number | null)[];
    yAxis: Field | null;
    plotType: {
        [key: string]: any;
    } & {
        [key: string]: any;
    };
    lineChart?: LineChart | undefined;
    gpu: boolean;
    gpuChannel?: number[];
    gpuEndChannel?: number[];
    fieldType: "timestamp";
    endName?: (string | null | undefined)[];
    endFieldIdx?: (number | null | undefined)[];
    endMappedValue?: ((number | null)[] | null | undefined)[];
    layerId?: string[];
    step: number;
    timeBins?: TimeBins;
    defaultTimeFormat?: string | null;
    timeFormat?: string | null;
    timezone?: string | null;
    syncedWithLayerTimeline: boolean;
    syncTimelineMode: import("@kepler.gl/types").SyncTimelineMode;
    invertTrendColor: boolean;
};
/**
 *
 * @param filter
 * @param plotType
 * @param datasets
 * @param dataId
 */
export declare function updateTimeFilterPlotType(filter: TimeRangeFilter, plotType: TimeRangeFilter['plotType'], datasets: Datasets, _dataId?: string, plotBaseIndexByDataId?: Record<string, number[]>): TimeRangeFilter;
export declare function getRangeFilterBins(filter: any, datasets: any, numBins: any, plotBaseIndexByDataId?: Record<string, number[]>): any;
export declare function updateRangeFilterPlotType(filter: RangeFilter, plotType: RangeFilter['plotType'], datasets: Datasets, _dataId?: string, plotBaseIndexByDataId?: Record<string, number[]>): RangeFilter;
export declare function getChartTitle(yAxis: Field, plotType: PlotType): string;
export declare function getDefaultPlotType(filter: any, datasets: any): {
    interval: string;
    defaultTimeFormat: string;
    type: "histogram";
    aggregation: "average";
};
export {};