import { Filter, FilterBase, PolygonFilter, Datasets, FieldDomain, TimeRangeFieldDomain, HistogramBin, Feature, FeatureValue, VisState, LineChart, TimeRangeFilter, RangeFieldDomain } from '../reducers/vis-state-updaters';
import KeplerTable, { Field, FilterRecord, FilterDatasetOpt } from './table-utils/kepler-table';
import { Layer } from 'layers';
import { ParsedFilter } from 'schemas';
import { DataContainerInterface } from './table-utils/data-container-interface';
import { Millisecond } from 'cloud-providers';
export type FilterResult = {
    filteredIndexForDomain?: number[];
    filteredIndex?: number[];
};
export type FilterChanged = {
    [key in keyof FilterRecord]: {
        [key: string]: 'added' | 'deleted' | 'name_changed' | 'value_changed' | 'dataId_changed';
    } | null;
};
export type dataValueAccessor = (data: {
    index: number;
}) => number | null;
export declare const TimestampStepMap: {
    max: number;
    step: number;
}[];
export declare const histogramBins = 30;
export declare const enlargedHistogramBins = 100;
export declare const PLOT_TYPES: {
    histogram: "histogram";
    lineChart: "lineChart";
};
export declare const FILTER_UPDATER_PROPS: {
    dataId: "dataId";
    name: "name";
    layerId: "layerId";
};
export declare const LIMITED_FILTER_EFFECT_PROPS: {
    name: "name";
};
export declare const FILTER_COMPONENTS: {
    select: string;
    multiSelect: string;
    timeRange: string;
    range: string;
    polygon: string;
};
export declare const DEFAULT_FILTER_STRUCTURE: {
    dataId: any[];
    freeze: boolean;
    id: any;
    fixedDomain: boolean;
    enlarged: boolean;
    isAnimating: boolean;
    animationWindow: "free";
    speed: number;
    name: any[];
    type: any;
    fieldIdx: any[];
    domain: any;
    value: any;
    plotType: "histogram";
    yAxis: any;
    interval: any;
    gpu: boolean;
};
export declare const FILTER_ID_LENGTH = 4;
export declare const LAYER_FILTERS: "polygon"[];
/**
 * Generates a filter with a dataset id as dataId
 */
export declare function getDefaultFilter(dataId: string | null | string[]): FilterBase;
/**
 * Check if a filter is valid based on the given dataId
 * @param  filter to validate
 * @param  datasetId id to validate filter against
 * @return true if a filter is valid, false otherwise
 */
export declare function shouldApplyFilter(filter: Filter, datasetId: string): boolean;
/**
 * Validates and modifies polygon filter structure
 * @param dataset
 * @param filter
 * @param layers
 * @return - {filter, dataset}
 */
export declare function validatePolygonFilter(dataset: KeplerTable, filter: PolygonFilter, layers: Layer[]): {
    filter: PolygonFilter | null;
    dataset: KeplerTable;
};
/**
 * Default validate filter function
 * @param dataset
 * @param filter
 * @return - {filter, dataset}
 */
export declare function validateFilter(dataset: KeplerTable, filter: ParsedFilter): {
    filter: Filter | null;
    dataset: KeplerTable;
};
/**
 * Validate saved filter config with new data,
 * calculate domain and fieldIdx based new fields and data
 *
 * @param dataset
 * @param filter - filter to be validate
 * @param layers - layers
 * @return validated filter
 */
export declare function validateFilterWithData(dataset: KeplerTable, filter: ParsedFilter, layers: Layer[]): {
    filter: Filter;
    dataset: KeplerTable;
};
/**
 * Get default filter prop based on field type
 *
 * @param field
 * @param fieldDomain
 * @returns default filter
 */
export declare function getFilterProps(field: Field, fieldDomain: FieldDomain): Partial<Filter> & {
    fieldType: string;
};
export declare const getPolygonFilterFunctor: (layer: any, filter: any, dataContainer: any) => (data: any) => boolean;
/**
 * @param param An object that represents a row record.
 * @param param.index Index of the row in data container.
 * @returns Returns true to keep the element, or false otherwise.
 */
type filterFunction = (data: {
    index: number;
}) => boolean;
/**
 * @param field dataset Field
 * @param dataId Dataset id
 * @param filter Filter object
 * @param layers list of layers to filter upon
 * @param dataContainer Data container
 * @return filterFunction
 */
export declare function getFilterFunction(field: Field | null, dataId: string, filter: Filter, layers: Layer[], dataContainer: DataContainerInterface): filterFunction;
export declare function updateFilterDataId(dataId: string): FilterBase;
export declare function filterDataByFilterTypes({ dynamicDomainFilters, cpuFilters, filterFuncs }: {
    dynamicDomainFilters: Filter[] | null;
    cpuFilters: Filter[] | null;
    filterFuncs: {
        [key: string]: filterFunction;
    };
}, dataContainer: DataContainerInterface): FilterResult;
/**
 * Get a record of filters based on domain type and gpu / cpu
 */
export declare function getFilterRecord(dataId: string, filters: Filter[], opt?: FilterDatasetOpt): FilterRecord;
/**
 * Compare filter records to get what has changed
 */
export declare function diffFilters(filterRecord: FilterRecord, oldFilterRecord?: FilterRecord | {}): FilterChanged;
/**
 * Call by parsing filters from URL
 * Check if value of filter within filter domain, if not adjust it to match
 * filter domain
 *
 * @returns value - adjusted value to match filter or null to remove filter
 */
export declare function adjustValueToFilterDomain(value: Filter['value'], { domain, type }: {
    domain: any;
    type: any;
}): any;
/**
 * Calculate numeric domain and suitable step
 */
export declare function getNumericFieldDomain(dataContainer: DataContainerInterface, valueAccessor: dataValueAccessor): RangeFieldDomain;
/**
 * Calculate step size for range and timerange filter
 */
export declare function getNumericStepSize(diff: number): number;
/**
 * Calculate timestamp domain and suitable step
 */
export declare function getTimestampFieldDomain(dataContainer: DataContainerInterface, valueAccessor: dataValueAccessor): TimeRangeFieldDomain;
export declare function histogramConstruct(domain: [number, number], mappedValue: (Millisecond | number)[], bins: number): HistogramBin[];
/**
 * Calculate histogram from domain and array of values
 */
export declare function getHistogram(domain: [number, number], mappedValue: (Millisecond | number)[]): {
    histogram: HistogramBin[];
    enlargedHistogram: HistogramBin[];
};
/**
 * round number based on step
 *
 * @param {Number} val
 * @param {Number} step
 * @param {string} bound
 * @returns {Number} rounded number
 */
export declare function formatNumberByStep(val: number, step: number, bound: 'floor' | 'ceil'): number;
export declare function isInRange(val: any, domain: number[]): boolean;
/**
 * Determines whether a point is within the provided polygon
 *
 * @param point as input search [lat, lng]
 * @param polygon Points must be within these (Multi)Polygon(s)
 * @return {boolean}
 */
export declare function isInPolygon(point: number[], polygon: any): boolean;
export declare function isValidTimeDomain(domain: any): boolean;
export declare function getTimeWidgetTitleFormatter(domain: [number, number]): string | null;
export declare function getTimeWidgetHintFormatter(domain: [number, number]): string | undefined;
/**
 * Sanity check on filters to prepare for save
 */
export declare function isValidFilterValue(type: string | null, value: any): boolean;
export declare function getFilterPlot(filter: Filter, dataset: KeplerTable): {
    lineChart: LineChart;
    yAxs: Field;
} | {};
export declare function getDefaultFilterPlotType(filter: Filter): string | null;
/**
 *
 * @param datasetIds list of dataset ids to be filtered
 * @param datasets all datasets
 * @param filters all filters to be applied to datasets
 * @return datasets - new updated datasets
 */
export declare function applyFiltersToDatasets(datasetIds: string[], datasets: Datasets, filters: Filter[], layers?: Layer[]): Datasets;
/**
 * Applies a new field name value to fielter and update both filter and dataset
 * @param filter - to be applied the new field name on
 * @param dataset - dataset the field belongs to
 * @param fieldName - field.name
 * @param filterDatasetIndex - field.name
 * @param option
 * @return - {filter, datasets}
 */
export declare function applyFilterFieldName(filter: Filter, dataset: KeplerTable, fieldName: string, filterDatasetIndex?: number, option?: {
    mergeDomain: boolean;
}): {
    filter: Filter | null;
    dataset: KeplerTable;
};
/**
 * Merge one filter with other filter prop domain
 */
export declare function mergeFilterDomainStep(filter: Filter, filterProps?: any): Filter | null;
/**
 * Generates polygon filter
 */
export declare const featureToFilterValue: (feature: Feature, filterId: string, properties?: {}) => FeatureValue;
export declare const getFilterIdInFeature: (f: FeatureValue) => string;
/**
 * Generates polygon filter
 */
export declare function generatePolygonFilter(layers: Layer[], feature: Feature): PolygonFilter;
/**
 * Run filter entirely on CPU
 */
export declare function filterDatasetCPU(state: VisState, dataId: string): VisState;
/**
 * Validate parsed filters with datasets and add filterProps to field
 */
export declare function validateFiltersUpdateDatasets(state: VisState, filtersToValidate?: ParsedFilter[]): {
    validated: Filter[];
    failed: Filter[];
    updatedDatasets: Datasets;
};
/**
 * Retrieve interval bins for time filter
 */
export declare function getIntervalBins(filter: TimeRangeFilter): any;
export {};