import { FilterTable } from './filter_table';
import { SortTable } from './sort_table';
import { GroupTable } from './group_table';
import { JoinSecondTable } from '../two/join_second_table';
import { EnforceNonEmptyRecord, TableAggregationRecord, ValueOrNestedValueRecord, ValueRecord } from '../../record';
import { Value } from '../../value';
import { Subtable } from '../subtable';
import { SelectScalar } from '../selection/select_scalar';
import { SelectRows } from '../selection/select_rows';
import { SelectVector } from '../selection/select_vector';
import { AggregatableTable, Count } from '../aggregatable_table';
import { Constructor } from '../../statements/select_statement';
import { SelectGuaranteedSingleRow } from '../selection/select_guaranteed_single_row';
export declare type Columns<T> = {
    [P in keyof T]: 'string' | 'number' | 'boolean';
};
export declare class Table<T> {
    readonly typeConstructor: Constructor<T>;
    readonly tableName: string;
    readonly columns: Columns<T>;
    private readonly statement;
    constructor(typeConstructor: Constructor<T>, tableName: string, columns: Columns<T>);
    filter(predicate: (table: T) => boolean): FilterTable<T>;
    filter<P extends ValueOrNestedValueRecord>(provided: P, predicate: (parameters: P, table: T) => boolean): FilterTable<T>;
    sortBy(sortBy: (table: T) => Value): SortTable<T>;
    sortDescendinglyBy(sortBy: (table: T) => Value): SortTable<T>;
    join<U, K extends Value>(otherTable: Table<U>, left: (firstTable: T) => K, right: (secondTable: U) => K): JoinSecondTable<T, U>;
    map<U extends ValueRecord>(f: (table: T) => EnforceNonEmptyRecord<U> & U): SelectRows<U>;
    map<S, U extends ValueRecord>(tableInSubquery: Table<S>, f: (s: Subtable<S>, x: T) => EnforceNonEmptyRecord<U> & U): SelectRows<U>;
    get<U extends Value>(f: (table: T) => U): SelectVector<U>;
    count(): SelectScalar<number>;
    max<V extends Value>(f: (table: T) => V): SelectScalar<V>;
    min<V extends Value>(f: (table: T) => V): SelectScalar<V>;
    sum<V extends Value>(f: (table: T) => V): SelectScalar<V>;
    average<V extends Value>(f: (table: T) => V): SelectScalar<V>;
    aggregate<A extends TableAggregationRecord>(aggregation: (table: AggregatableTable<T>, count: () => Count) => EnforceNonEmptyRecord<A> & A): SelectGuaranteedSingleRow<A>;
    groupBy<K extends ValueRecord>(getKey: (table: T) => EnforceNonEmptyRecord<K> & K): GroupTable<T, K>;
}
export declare function defineTable<T>(typeConstructor: Constructor<T>, tableName: string, columns: Columns<T>): Table<T>;