import { DataType } from '../DataPrimitive';
import { DataPoint } from '../DataPoint';
/**
 * returns true if this dataPoint is a finite number
 * @param dataPoint
 * @returns {*}
 */
export declare function isNumber(dataPoint: any): boolean;
export declare function isGeoJsonObject(dataPoint: any): boolean;
/**
 *returns OK if data is time
 * @param dataPoint
 * @returns {boolean}
 */
export declare function isTime(dataPoint: any): boolean;
/**
 * returns OK if data is string
 * @param dataPoint
 * @returns {boolean}
 */
export declare function isString(dataPoint: any): boolean;
/**
 * getDataTypeForPoint
 * naive implementation of checking for the data type of a single data point
 * number > time > string > unknown
 * starting with number because a Date.parse(number) is a valid date
 *
 * @param {any} dataPoint
 * @param {object} metaData meta data about the data field
 * @return {string} type
 */
export declare const getDataTypeForPoint: <T>(dataPoint?: T, metaData?: MetaData) => DataType;
export interface MetaData {
    name?: string;
    type?: string;
}
/**
 * canInferTypeFromMeta
 * verifies whether a data type can be inferred from meta data
 * @param {object} metaData
 * @return {boolean} whether the data type can be inferred from meta
 */
export declare const canInferTypeFromMeta: (metaData?: MetaData) => boolean;
/**
 * getDataTypeForMeta
 * returns a data type based on meta data
 * @param {object} metaData
 * @return {string} type
 */
export declare const getDataTypeForMeta: (metaData?: MetaData) => DataType;
/**
 * inferDataTypeFromDataPoints
 * based on the input data points this function determines a hashmap of type and its count
 * and returns type based on a type prioritization logic
 *
 * @param {Array} dataPoints an array of arbitrary size containing data points of any data type
 * @return {string} type, the most applicable type for the datapoints
 */
export declare const inferDataTypeFromDataPoints: (dataPoints: DataPoint<DataType>[]) => DataType;
export declare const dataPointValues: <T>(data: T[]) => DataPoint<DataType>[];
/**
 * inferDataTypeFromData
 * @param {*} data
 * @return {string} type of a data set
 */
export declare const inferDataTypeFromData: <T>(data: T[]) => DataType;
