import { SortFourTables } from './sort_four_tables';
import { FilterFourTables } from './filter_four_tables';
import { GroupFourTables } from './group_four_tables';
import { EnforceNonEmptyRecord, ValueOrNestedValueRecord, ValueRecord } from '../../record';
import { Value } from '../../value';
import { Subtable } from '../subtable';
import { Table } from '../one/table';
import { SelectScalar } from '../selection/select_scalar';
import { SelectRows } from '../selection/select_rows';
import { SelectVector } from '../selection/select_vector';
import { AggregatableTable } from '../aggregatable_table';
import { SelectStatement } from '../../statements/select_statement';
import { JoinFifthTable } from '../five/join_fifth_table';
import { SelectGuaranteedSingleRow } from '../selection/select_guaranteed_single_row';
import { SelectSetsOfRows } from '../selection/select_sets_of_rows';
export declare class JoinFourthTable<T1, T2, T3, T4> {
    private readonly statement;
    constructor(statement: SelectStatement);
    filter(predicate: (first: T1, second: T2, third: T3, fourth: T4) => boolean): FilterFourTables<T1, T2, T3, T4>;
    filter<P extends ValueOrNestedValueRecord>(provided: P, predicate: (parameters: P, first: T1, second: T2, third: T3, fourth: T4) => boolean): FilterFourTables<T1, T2, T3, T4>;
    sortBy(sortBy: (first: T1, second: T2, third: T3, fourth: T4) => Value): SortFourTables<T1, T2, T3, T4>;
    sortDescendinglyBy(sortBy: (first: T1, second: T2, third: T3, fourth: T4) => Value): SortFourTables<T1, T2, T3, T4>;
    join<U, K extends Value>(otherTable: Table<U>, left: (firstTable: T1, secondTable: T2, thirdTable: T3, fourthTable: T4) => K, right: (thirdTable: U) => K): JoinFifthTable<T1, T2, T3, T4, U>;
    select<K extends string>(firstName: string, secondName: string, thirdName: string, fourthName: string): SelectSetsOfRows<{
        [first in K]: T1;
    } & {
        [second in K]: T2;
    } & {
        [third in K]: T3;
    } & {
        [fourth in K]: T4;
    }>;
    map<U extends ValueRecord>(f: (first: T1, second: T2, third: T3, fourth: T4) => EnforceNonEmptyRecord<U> & U): SelectRows<U>;
    map<S, U extends ValueRecord>(tableInSubquery: Table<S>, f: (s: Subtable<S>, first: T1, second: T2, third: T3, fourth: T4) => EnforceNonEmptyRecord<U> & U): SelectRows<U>;
    get<U extends Value>(f: (first: T1, second: T2, third: T3, fourth: T4) => U): SelectVector<U>;
    count(): SelectScalar<number>;
    max<V extends Value>(f: (first: T1, second: T2, third: T3, fourth: T4) => V): SelectScalar<V>;
    min<V extends Value>(f: (first: T1, second: T2, third: T3, fourth: T4) => V): SelectScalar<V>;
    sum<V extends Value>(f: (first: T1, second: T2, third: T3, fourth: T4) => V): SelectScalar<V>;
    average<V extends Value>(f: (first: T1, second: T2, third: T3, fourth: T4) => V): SelectScalar<V>;
    aggregate<A extends ValueRecord>(aggregation: (first: AggregatableTable<T1>, second: AggregatableTable<T2>, third: AggregatableTable<T3>, fourth: AggregatableTable<T4>, count: () => number) => EnforceNonEmptyRecord<A> & A): SelectGuaranteedSingleRow<A>;
    groupBy<K extends ValueRecord>(getKey: (first: T1, second: T2, third: T3, fourth: T4) => EnforceNonEmptyRecord<K> & K): GroupFourTables<T1, T2, T3, T4, K>;
}