import { CharacterArg, TextType } from '..';
import { AnyExpression, Expression } from '../../expressions';
import { ConstraintConfig } from '../../functions';
import { Type } from '../index';
import { DateArg } from './date';
import { IntervalArg, IntervalType } from './interval';
import { TimestampType } from './timestamp';
export declare const TIME: (precission?: number | undefined) => TimeType<true>;
export declare type TimeTypeLiteral = TimeType['input'];
export declare type TimeTypeArg = TimeType['argument'];
export interface TimeType<R extends boolean = any> extends Type<'TIME', R> {
    expression: TimeExpression<TimeType<R>>;
    argument: Expression<TimeType> | this['input'];
    required(conf?: ConstraintConfig): TimeType<false>;
}
export declare const TIMETZ: (precission?: number | undefined) => TimetzType<true>;
export declare type TimetzTypeLiteral = TimeType['input'];
export declare type TimetzTypeArg = TimeType['argument'];
export interface TimetzType<R extends boolean = any> extends Type<'TIMETZ', R> {
    expression: TimeExpression<TimetzType<R>>;
    argument: Expression<TimetzType> | this['input'];
    required(conf?: ConstraintConfig): TimetzType<false>;
}
export declare type TimeTypes = TimeType | TimetzType;
export declare type TimeLiteral = TimeTypes['input'];
export declare type TimeArg = TimeTypes['argument'];
export interface TimeExpression<T extends Type> extends AnyExpression<T> {
    concat(arg: CharacterArg): Expression<TextType<T['nullable']>>;
    add(arg: DateArg): Expression<TimestampType<T['nullable']>>;
    add(arg: IntervalArg): TimeExpression<T>;
    sub(arg: TimeArg): Expression<IntervalType<T['nullable']>>;
    sub(arg: IntervalArg): TimeExpression<T>;
    tz(arg: CharacterArg): TimeExpression<TimetzType<T['nullable']>>;
}