import { DataTypeFieldConfig, Maybe, SortOrder, DataTypeFields, ReadonlyDataTypeFields } from '@terascope/types';
import { SerializeOptions, Vector } from '../vector/index.js';
import { ColumnOptions } from './interfaces.js';
type NameType = (number | string | symbol);
/**
 * A single column of values with the same data type.
 *
 * Changing the values is safe as long the length doesn't change.
 * When adding or removing values it is better to create a new Column.
*/
export declare class Column<T = unknown, N extends NameType = string> {
    /**
     * Create a Column from an array of values
    */
    static fromJSON<R, F extends NameType = string>(name: F, config: Readonly<DataTypeFieldConfig>, values?: Maybe<R>[] | readonly Maybe<R>[], version?: number, childConfig?: DataTypeFields | ReadonlyDataTypeFields): Column<R, F>;
    /**
     * Create a Column from the custom serialized format
    */
    static deserialize<R, F extends NameType = string>(columnConfig: Buffer | string): Column<R, F>;
    /**
     * The field name for the column
    */
    name: N;
    /**
     * The DataType version to use for the field definition
    */
    readonly version: number;
    readonly vector: Vector<T>;
    /**
     * Get the Data Type field configuration.
    */
    readonly config: Readonly<DataTypeFieldConfig>;
    constructor(vector: Vector<T>, options: ColumnOptions<N> | Readonly<ColumnOptions<N>>);
    /**
     * Iterate over each value, this is returned in the stored value format.
     * And may not be compatible with the JSON spec.
    */
    [Symbol.iterator](): IterableIterator<Maybe<T>>;
    /**
     * Returns the size of the column
    */
    get size(): number;
    /**
     * A Unique ID for the Column.
     * The ID should only change if the data vector changes.
    */
    get id(): string;
    /**
     * Rename the column
    */
    rename<K extends NameType>(name: K): Column<T, K>;
    /**
     * Create a new Column with the same metadata but with different data
    */
    fork(vector: Vector<T>): Column<T, N>;
    /**
     * Sort the column
    */
    sort(direction?: SortOrder): Column<T, N>;
    /**
     * Get the unique values. This doesn't change the
     * the size, it just drops the duplicate values.
     * @example
     *   [null, 1, 3, 2, 2, null, 1] => [null, 1, 3, 2, null, null, null]
    */
    unique(): Column<T, N>;
    isEmpty(): boolean;
    /**
     * Average all of the values in the Column
    */
    avg(): number | bigint;
    /**
     * Sum all of the values in the Column
    */
    sum(): number | bigint;
    /**
     * Find the minimum value in the Column
    */
    min(): number | bigint;
    /**
     * Find the maximum value in the Column
    */
    max(): number | bigint;
    /**
     * Select the child fields with in a given vector.
     * This involves recreating the whole column in
     * most cases.
    */
    selectSubFields(fields: Iterable<string>): Column<T, N>;
    /**
     * Convert the Column an array of values (the output is JSON compatible)
     *
     * @note probably only useful for debugging
    */
    toJSON(options?: SerializeOptions): Maybe<T>[];
    serialize(): string;
    /**
     * return an empty column with the same size and metadata as the previous one
    */
    clearAll(): Column<T, N>;
}
export {};
//# sourceMappingURL=Column.d.ts.map