import { CharacterArg, TextType } from '..';
import { AnyExpression, Expression } from '../../expressions';
import { ConstraintConfig } from '../../functions';
import { Type } from '../index';
import { IntervalArg, IntervalType } from './interval';
export declare const TIMESTAMP: (precission?: number | undefined) => TimestampType<true>;
export declare type TimestampTypeArg = TimestampType['argument'];
export interface TimestampType<R extends boolean = any> extends Type<'TIMESTAMP', R> {
    expression: TimestampExpression<TimestampType<R>>;
    argument: Expression<TimestampType> | this['input'];
    required(conf?: ConstraintConfig): TimestampType<false>;
}
export declare const TIMESTAMPTZ: (precission?: number | undefined) => TimestamptzType<true>;
export declare type TimestamptzTypeLiteral = TimestamptzType['input'];
export declare type TimestamptzTypeArg = TimestamptzType['argument'];
export interface TimestamptzType<R extends boolean = any> extends Type<'TIMESTAMPTZ', R> {
    expression: TimestampExpression<TimestamptzType<R>>;
    argument: Expression<TimestamptzType> | this['input'];
    required(conf?: ConstraintConfig): TimestamptzType<false>;
}
export declare type TimestampTypes = TimestampType | TimestamptzType;
export declare type TimestampArg = TimestampTypes['argument'];
export interface TimestampExpression<T extends Type = TimestampTypes> extends AnyExpression<T> {
    concat(arg: CharacterArg): Expression<TextType<T['nullable']>>;
    add(arg: IntervalArg): TimestampExpression<T>;
    sub(arg: IntervalArg): TimestampExpression<T>;
    sub(arg: T['argument']): Expression<IntervalType<T['nullable']>>;
    tz(arg: CharacterArg): TimestampExpression<T extends TimestampType ? TimestamptzType : TimestampType>;
}