/// <reference types="node" />
import { Condition, Expression, Table } from '..';
import { AnyExpression } from '../expressions/any';
import { ConstraintConfig, IndexParametersConfig, ReferenceConfig } from '../functions';
import { Template } from '../template';
import { PostgresInterval } from './datetime/interval';
export * from './other/boolean';
export * from './other/string';
export * from './other/binary';
export * from './other/bytea';
export * from './other/unknown';
export * from './other/uuid';
export * from './search/tsquery';
export * from './search/tsvector';
export * from './complex/array';
export * from './complex/json';
export * from './complex/jsonb';
export * from './datetime/date';
export * from './datetime/interval';
export * from './datetime/time';
export * from './datetime/timestamp';
export * from './math';
export declare const type: (strings: TemplateStringsArray, ...literals: any[]) => Type<keyof DefaultOutputMapping<any>, boolean, any>;
export interface DefaultOutputMapping<T = any> {
    UNKNOWN: Exclude<T, null | undefined> extends never ? null : string;
    INTERVAL: PostgresInterval;
    ARRAY: Array<T>;
    TSVECTOR: string;
    TSQUERY: string;
    UUID: string;
    JSON: T;
    JSONB: T;
    CHAR: string;
    VARCHAR: string;
    TEXT: string;
    BYTEA: Buffer;
    BOOLEAN: boolean;
    BIT: string;
    VARBIT: string;
    SMALLINT: number;
    INTEGER: number;
    BIGINT: bigint;
    NUMERIC: number;
    REAL: number;
    DOUBLE: number;
    TIMESTAMP: Date;
    TIMESTAMPTZ: Date;
    TIME: string;
    TIMETZ: string;
    DATE: Date;
    NULL: null;
}
export interface DefaultInputMapping<T = any> {
    UNKNOWN: any;
    INTERVAL: string;
    ARRAY: Array<T> | string;
    TSVECTOR: string;
    TSQUERY: string;
    UUID: string;
    JSON: T | string;
    JSONB: T | string;
    CHAR: string;
    VARCHAR: string;
    TEXT: string;
    BYTEA: Buffer | string;
    BOOLEAN: boolean;
    BIT: string;
    VARBIT: string;
    SMALLINT: number | string | bigint;
    INTEGER: number | string | bigint;
    BIGINT: number | string | bigint;
    NUMERIC: number | string | bigint;
    REAL: number | string | bigint;
    DOUBLE: number | string | bigint;
    TIMESTAMP: Date | string;
    TIMESTAMPTZ: Date | string;
    TIME: string;
    TIMETZ: string;
    DATE: Date | string;
    NULL: null;
}
export interface OverrideOutputMapping<T = any> {
    [key: string]: unknown;
}
export interface OverrideInputMapping<T = any> {
    [key: string]: unknown;
}
export declare type OutputMapping<T = any> = {
    [K in keyof DefaultOutputMapping<T>]: unknown extends OverrideOutputMapping<T>[K] ? DefaultOutputMapping<T>[K] : OverrideOutputMapping<T>[K];
};
export declare type InputMapping<T = any> = {
    [K in keyof DefaultInputMapping<T>]: unknown extends OverrideInputMapping<T>[K] ? DefaultInputMapping<T>[K] : OverrideInputMapping<T>[K];
};
export declare class Type<N extends keyof DefaultOutputMapping = keyof DefaultOutputMapping, R extends boolean = boolean, T = any> extends Template {
    primitive: this['nullable'] extends false ? this['output'] : this['output'] | null;
    constraints: Template[];
    output: OutputMapping<T>[N];
    expression: AnyExpression;
    nullable: R;
    input: InputMapping<T>[N];
    argument: any;
    type: T;
    required(conf?: ConstraintConfig): Type<N, false, T>;
    default(value: any, conf?: ConstraintConfig): this;
    check(expression: Condition, conf?: ConstraintConfig & {
        noInherit?: boolean;
    }): this;
    generated(type: 'ALWAYS' | 'BY DEFAULT', conf?: ConstraintConfig & {
        expression?: Expression;
        identity?: any;
    }): this;
    unique(params?: IndexParametersConfig & ConstraintConfig): this;
    primary(params?: IndexParametersConfig & ConstraintConfig): this;
    references(table: string | Table, conf?: ReferenceConfig<string | Expression> & ConstraintConfig): this;
}