import { Type } from '../';
import { Expression } from '../../expressions';
import { ConstraintConfig } from '../../functions';
import { IntegralExpression } from './integral';
import { NumberExpression } from './number';
export * from './integral';
export * from './number';
export declare const SMALLINT: () => SmallintType<true>;
export declare const SMALLSERIAL: () => SmallintType<true>;
export declare type SmallintArg = SmallintType['argument'];
export interface SmallintType<R extends boolean = any> extends Type<'SMALLINT', R> {
    expression: IntegralExpression<SmallintType<R>>;
    argument: Expression<SmallintType> | this['input'];
    required(conf?: ConstraintConfig): SmallintType<false>;
}
export declare const INTEGER: () => IntegerType<true>;
export declare const SERIAL: () => IntegerType<true>;
export declare type IntegerArg = IntegerType['argument'];
export interface IntegerType<R extends boolean = any> extends Type<'INTEGER', R> {
    expression: IntegralExpression<IntegerType<R>>;
    argument: Expression<IntegerType> | this['input'] | Expression<SmallintType>;
    required(conf?: ConstraintConfig): IntegerType<false>;
}
export declare const BIGINT: () => BigintType<true>;
export declare const BIGSERIAL: () => BigintType<true>;
export declare type BigintArg = BigintType['argument'];
export interface BigintType<R extends boolean = any> extends Type<'BIGINT', R> {
    expression: IntegralExpression<BigintType<R>>;
    argument: Expression<BigintType> | this['input'] | Expression<SmallintType> | Expression<IntegerType>;
    required(conf?: ConstraintConfig): BigintType<false>;
}
export declare const NUMERIC: () => NumericType<true>;
export declare type NumericArg = NumericType['argument'];
export interface NumericType<R extends boolean = any> extends Type<'NUMERIC', R> {
    expression: NumberExpression<NumericType<R>>;
    argument: Expression<NumericType> | this['input'] | Expression<SmallintType> | Expression<IntegerType> | Expression<BigintType>;
    required(conf?: ConstraintConfig): NumericType<false>;
}
export declare const REAL: () => RealType<true>;
export declare type RealArg = RealType['argument'];
export interface RealType<R extends boolean = any> extends Type<'REAL', R> {
    expression: NumberExpression<RealType<R>>;
    argument: Expression<RealType> | this['input'] | Expression<SmallintType> | Expression<IntegerType> | Expression<BigintType> | Expression<NumericType>;
    required(conf?: ConstraintConfig): RealType<false>;
}
export declare const DOUBLE: () => DoubleType<true>;
export declare type DoubleArg = DoubleType['argument'];
export interface DoubleType<R extends boolean = any> extends Type<'DOUBLE', R> {
    expression: NumberExpression<DoubleType<R>>;
    argument: Expression<DoubleType> | this['input'] | Expression<SmallintType> | Expression<IntegerType> | Expression<BigintType> | Expression<NumericType> | Expression<RealType>;
    required(conf?: ConstraintConfig): DoubleType<false>;
}
export declare type MathTypesPrec<R extends boolean> = [SmallintType<R>, IntegerType<R>, BigintType<R>, NumericType<R>, RealType<R>, DoubleType<R>];
export declare type InferMathTypePrec<X, Y, V extends boolean = boolean, T extends any[] = MathTypesPrec<V>> = T extends [...infer R, infer L] ? L extends X ? X : L extends Y ? Y : InferMathTypePrec<X, Y, V, R> : never;
export declare type ToMathExpression<T extends (MathArg)> = T extends MathExpression ? T : Expression<NumericType>;
export declare type MathType = SmallintType | IntegerType | BigintType | NumericType | RealType | DoubleType;
export declare type MathExpression = MathType['expression'];
export declare type MathLiteral = MathType['input'];
export declare type MathArg = MathType['argument'];
export declare type IntegralType = SmallintType | IntegerType | BigintType;
export declare type IntegralLiteral = IntegralType['input'];
export declare type IntegralArg = IntegralType['argument'];