import { BooleanType } from '..';
import { AnyExpression, Expression } from '../../expressions';
import { ConstraintConfig } from '../../functions';
import { Type } from '../index';
import { TSQueryType } from '../search/tsquery';
export declare const CHAR: (n?: number | undefined) => CharType<true>;
export declare type CharArg = CharType['argument'];
export interface CharType<R extends boolean = any> extends Type<'CHAR', R> {
    expression: StringExpression<CharType<R>>;
    argument: Expression<CharType> | this['input'] | Expression<VarcharType> | Expression<TextType>;
    required(conf?: ConstraintConfig): CharType<false>;
}
export declare const VARCHAR: (n?: number | undefined) => VarcharType<true>;
export declare type VarcharArg = VarcharType['argument'];
export interface VarcharType<R extends boolean = any> extends Type<'VARCHAR', R> {
    expression: StringExpression<VarcharType<R>>;
    argument: Expression<VarcharType> | this['input'] | Expression<CharType> | Expression<TextType>;
    required(conf?: ConstraintConfig): VarcharType<false>;
}
export declare const TEXT: () => TextType<true>;
export declare type TextArg = TextType['argument'];
export interface TextType<R extends boolean = any> extends Type<'TEXT', R> {
    expression: StringExpression<TextType<R>>;
    argument: Expression<TextType> | this['input'] | Expression<CharType> | Expression<VarcharType>;
    required(conf?: ConstraintConfig): TextType<false>;
}
export declare type CharacterTypes = CharType<any> | VarcharType<any> | TextType<any>;
export declare type CharacterArg = CharacterTypes['argument'];
export interface StringExpression<T extends CharacterTypes = CharacterTypes> extends AnyExpression<T> {
    concat(arg: CharacterArg): Expression<TextType<T['nullable']>>;
    match(arg: Expression<TSQueryType>): Expression<BooleanType<T['nullable']>>;
    similarTo(pattern: CharacterArg, escape?: CharacterArg): Expression<BooleanType<T['nullable']>>;
    notSimilarTo(pattern: CharacterArg, escape?: CharacterArg): Expression<BooleanType<T['nullable']>>;
    matchRegex(pattern: CharacterArg, caseSensitively?: boolean): Expression<BooleanType<T['nullable']>>;
    notMatchRegex(pattern: CharacterArg, caseSensitively?: boolean): Expression<BooleanType<T['nullable']>>;
    isNormalized(form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD'): Expression<BooleanType<T['nullable']>>;
    isNotNormalized(form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD'): Expression<BooleanType<T['nullable']>>;
    like(pattern: CharacterArg, escape?: CharacterArg): Expression<BooleanType<T['nullable']>>;
    notLike(pattern: CharacterArg, escape?: CharacterArg): Expression<BooleanType<T['nullable']>>;
}