import { Constructor, Expression } from '.';
import { BooleanType, CharacterArg } from '../types';
import { AnyExpression } from './any';
export declare function StringOps<T extends Constructor>(Base: T): {
    new (...args: any[]): {
        /**
         * @description Checks whether the string is in the specified Unicode normalization form.
         * The optional form key word specifies the form: NFC (the default), NFD, NFKC, or NFKD.
         * This expression can only be used when the server encoding is UTF8.
         * Note that checking for normalization using this expression is often faster than
         * normalizing possibly already normalized strings.
         */
        isNormalized(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | undefined): Expression<BooleanType>;
        /**
         * @description Checks whether the string is in the specified Unicode normalization form.
         * The optional form key word specifies the form: NFC (the default), NFD, NFKC, or NFKD.
         * This expression can only be used when the server encoding is UTF8.
         * Note that checking for normalization using this expression is often faster than
         * normalizing possibly already normalized strings.
         */
        isNotNormalized(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | undefined): Expression<BooleanType>;
        /**
         * BooleanExpr: LIKE '%some%'
         * @param {string} operand
         */
        like(pattern: CharacterArg, escape?: string | import("../types").StringExpression<import("../types").CharType<any>> | import("../types").StringExpression<import("../types").VarcharType<any>> | import("../types").StringExpression<import("../types").TextType<any>> | undefined): Expression<BooleanType>;
        /**
         * BooleanExpr: NOT LIKE '%some%'
         * @param {string} operand
         */
        notLike(pattern: CharacterArg, escape?: string | import("../types").StringExpression<import("../types").CharType<any>> | import("../types").StringExpression<import("../types").VarcharType<any>> | import("../types").StringExpression<import("../types").TextType<any>> | undefined): Expression<BooleanType>;
        /**
         * BooleanExpr: SIMILAR TO '%some%'
         * @param {string} operand
         */
        similarTo(pattern: CharacterArg, escape?: string | import("../types").StringExpression<import("../types").CharType<any>> | import("../types").StringExpression<import("../types").VarcharType<any>> | import("../types").StringExpression<import("../types").TextType<any>> | undefined): Expression<BooleanType>;
        /**
         * BooleanExpr: NOT SIMILAR TO '%some%'
         * @param {string} operand
         */
        notSimilarTo(pattern: CharacterArg, escape?: string | import("../types").StringExpression<import("../types").CharType<any>> | import("../types").StringExpression<import("../types").VarcharType<any>> | import("../types").StringExpression<import("../types").TextType<any>> | undefined): Expression<BooleanType>;
        /**
         * @description String matches regular expression
         * Case sensitively operator: ~
         * Case insensitively operator: ~*
         */
        matchRegex(pattern: CharacterArg, caseSensitively?: boolean): Expression<BooleanType>;
        /**
         * @description String does not matches regular expression
         * Case sensitively operator: !~
         * Case insensitively operator: !~*
         */
        notMatchRegex(pattern: CharacterArg, caseSensitively?: boolean): Expression<BooleanType>;
        type: import("../types").Type<keyof import("../types").DefaultOutputMapping<any>, boolean, any>;
        alias?: string | undefined;
        columns?: string[] | undefined;
        as(alias: string, columns?: string[] | undefined): any;
        toQuery(start?: number): [string, any[]];
        toSource(): import("../template").Template;
        cast<NT extends import("../types").Type<keyof import("../types").DefaultOutputMapping<any>, boolean, any>>(type: NT): Expression<NT>;
        concat(operand: any): AnyExpression<import("../types").Type<keyof import("../types").DefaultOutputMapping<any>, boolean, any>>;
        eq(operand: any): import("../types").BooleanExpression<boolean>;
        ne(operand: any): import("../types").BooleanExpression<boolean>;
        is(operand: boolean | "UNKNOWN" | null): import("../types").BooleanExpression<boolean>;
        isNot(operand: boolean | "UNKNOWN" | null): import("../types").BooleanExpression<boolean>;
        isDistinctFrom(operand: any): import("../types").BooleanExpression<boolean>;
        isNotDistinctFrom(operand: any): import("../types").BooleanExpression<boolean>;
        gt(operand: any): import("../types").BooleanExpression<boolean>;
        lt(operand: any): import("../types").BooleanExpression<boolean>;
        gte(operand: any): import("../types").BooleanExpression<boolean>;
        lte(operand: any): import("../types").BooleanExpression<boolean>;
        gl(operand: any): import("../types").BooleanExpression<boolean>;
        between(from: any, to: any): import("../types").BooleanExpression<boolean>;
        notBetween(from: any, to: any): import("../types").BooleanExpression<boolean>;
        betweenSymetric(from: any, to: any): import("../types").BooleanExpression<boolean>;
        notBetweenSymetric(from: any, to: any): import("../types").BooleanExpression<boolean>;
        in(subquery: any): import("../types").BooleanExpression<boolean>;
        in(...operands: any[]): import("../types").BooleanExpression<boolean>;
        notIn(subquery: any): import("../types").BooleanExpression<boolean>;
        notIn(...operands: any[]): import("../types").BooleanExpression<boolean>;
        contain(arg: any): import("../types").BooleanExpression<boolean>;
        contained(arg: any): import("../types").BooleanExpression<boolean>;
        strings: string[];
        literals: any[];
        readonly text: string;
        readonly values: any[];
    };
} & T;