import { BaseLiteralType } from '../base/literal.js';
import { IS_OF_TYPE, SUBTYPE, UNIQUE_NAME } from '../../symbols.js';
import type { Validation, AlphaOptions, FieldContext, FieldOptions, AlphaNumericOptions, NormalizeEmailOptions } from '../../types.js';
import { urlRule, uuidRule, emailRule, mobileRule, passportRule, creditCardRule, postalCodeRule, normalizeUrlRule, vatRule } from './rules.js';
/**
 * VineString represents a string value in the validation schema.
 * It provides comprehensive string validation with built-in rules
 * for common patterns like email, URL, UUID, and more.
 *
 * @example
 * const schema = vine.string()
 *   .email()
 *   .minLength(5)
 *   .maxLength(100)
 *
 * const result = await vine.validate({
 *   schema,
 *   data: 'user@example.com'
 * })
 */
export declare class VineString extends BaseLiteralType<string, string, string> {
    /**
     * Static collection of all available validation rules for strings
     */
    static rules: {
        in: (options: {
            choices: string[] | ((field: FieldContext) => string[]);
        }) => Validation<{
            choices: string[] | ((field: FieldContext) => string[]);
        }>;
        jwt: (options?: undefined) => Validation<undefined>;
        url: (options?: import("validator/lib/isURL.js").IsURLOptions | undefined) => Validation<import("validator/lib/isURL.js").IsURLOptions | undefined>;
        iban: (options?: undefined) => Validation<undefined>;
        uuid: (options?: {
            version?: (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8)[];
        } | undefined) => Validation<{
            version?: (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8)[];
        } | undefined>;
        ulid: (options?: undefined) => Validation<undefined>;
        trim: (options?: undefined) => Validation<undefined>;
        email: (options?: import("validator/lib/isEmail.js").IsEmailOptions | undefined) => Validation<import("validator/lib/isEmail.js").IsEmailOptions | undefined>;
        alpha: (options?: AlphaOptions | undefined) => Validation<AlphaOptions | undefined>;
        ascii: (options?: undefined) => Validation<undefined>;
        notIn: (options: {
            list: string[] | ((field: FieldContext) => string[]);
        }) => Validation<{
            list: string[] | ((field: FieldContext) => string[]);
        }>;
        regex: (options: RegExp) => Validation<RegExp>;
        escape: (options?: undefined) => Validation<undefined>;
        sameAs: (options: {
            otherField: string;
        }) => Validation<{
            otherField: string;
        }>;
        mobile: (options?: import("../../types.js").MobileOptions | ((field: FieldContext) => import("../../types.js").MobileOptions | undefined) | undefined) => Validation<import("../../types.js").MobileOptions | ((field: FieldContext) => import("../../types.js").MobileOptions | undefined) | undefined>;
        string: (options?: undefined) => Validation<undefined>;
        hexCode: (options?: undefined) => Validation<undefined>;
        passport: (options: import("../../types.js").PassportOptions | ((field: FieldContext) => import("../../types.js").PassportOptions)) => Validation<import("../../types.js").PassportOptions | ((field: FieldContext) => import("../../types.js").PassportOptions)>;
        endsWith: (options: {
            substring: string;
        }) => Validation<{
            substring: string;
        }>;
        confirmed: (options?: {
            confirmationField?: string;
        } | {
            as?: string;
        } | undefined) => Validation<{
            confirmationField?: string;
        } | {
            as?: string;
        } | undefined>;
        activeUrl: (options?: undefined) => Validation<undefined>;
        minLength: (options: {
            min: number;
        }) => Validation<{
            min: number;
        }>;
        notSameAs: (options: {
            otherField: string;
        }) => Validation<{
            otherField: string;
        }>;
        maxLength: (options: {
            max: number;
        }) => Validation<{
            max: number;
        }>;
        vat: (options: import("../../types.js").VATOptions | ((field: FieldContext) => import("../../types.js").VATOptions)) => Validation<import("../../types.js").VATOptions | ((field: FieldContext) => import("../../types.js").VATOptions)>;
        ipAddress: (options?: {
            version: 4 | 6;
        } | undefined) => Validation<{
            version: 4 | 6;
        } | undefined>;
        creditCard: (options?: import("../../types.js").CreditCardOptions | ((field: FieldContext) => import("../../types.js").CreditCardOptions | void | undefined) | undefined) => Validation<import("../../types.js").CreditCardOptions | ((field: FieldContext) => import("../../types.js").CreditCardOptions | void | undefined) | undefined>;
        postalCode: (options?: import("../../types.js").PostalCodeOptions | ((field: FieldContext) => import("../../types.js").PostalCodeOptions | void | undefined) | undefined) => Validation<import("../../types.js").PostalCodeOptions | ((field: FieldContext) => import("../../types.js").PostalCodeOptions | void | undefined) | undefined>;
        startsWith: (options: {
            substring: string;
        }) => Validation<{
            substring: string;
        }>;
        toUpperCase: (options?: string | string[] | undefined) => Validation<string | string[] | undefined>;
        toLowerCase: (options?: string | string[] | undefined) => Validation<string | string[] | undefined>;
        toCamelCase: (options?: undefined) => Validation<undefined>;
        fixedLength: (options: {
            size: number;
        }) => Validation<{
            size: number;
        }>;
        coordinates: (options?: undefined) => Validation<undefined>;
        normalizeUrl: (options?: import("normalize-url").Options | undefined) => Validation<import("normalize-url").Options | undefined>;
        alphaNumeric: (options?: AlphaOptions | undefined) => Validation<AlphaOptions | undefined>;
        normalizeEmail: (options?: import("validator").NormalizeEmailOptions | undefined) => Validation<import("validator").NormalizeEmailOptions | undefined>;
    };
    /**
     * The subtype identifier for the literal schema field
     */
    [SUBTYPE]: string;
    /**
     * Unique name identifier for union type resolution
     */
    [UNIQUE_NAME]: string;
    /**
     * Type checker function to determine if a value is a string.
     * Required for "unionOfTypes" functionality.
     *
     * @param value - The value to check
     * @returns True if the value is a string
     */
    [IS_OF_TYPE]: (value: unknown) => value is string;
    /**
     * Creates a new VineString instance with optional configuration.
     *
     * @param options - Field options like bail mode and nullability
     * @param validations - Initial set of validations to apply
     */
    constructor(options?: FieldOptions, validations?: Validation<any>[]);
    /**
     * Validates the value to be a valid URL.
     *
     * @param args - Optional URL validation options
     * @returns This string schema instance for method chaining
     */
    url(...args: Parameters<typeof urlRule>): this;
    /**
     * Validates the value to be an active URL by making an HTTP request.
     *
     * @returns This string schema instance for method chaining
     */
    activeUrl(): this;
    /**
     * Validates the value to be a valid email address.
     *
     * @param args - Optional email validation options
     * @returns This string schema instance for method chaining
     */
    email(...args: Parameters<typeof emailRule>): this;
    /**
     * Validates the value to be a valid mobile phone number for specified locales.
     *
     * @param options - Optional mobile validation options including locale and strictMode
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().mobile({ locale: ['en-US', 'en-GB'] })
     */
    mobile(...args: Parameters<typeof mobileRule>): this;
    /**
     * Validates the value to be a valid VAT (Value Added Tax) number for specified countries.
     *
     * @param options - VAT validation options including country codes
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().vat({ countryCode: ['FR', 'CH', 'VE'] })
     */
    vat(...args: Parameters<typeof vatRule>): this;
    /**
     * Validates the value to be a valid IP address (IPv4 or IPv6).
     *
     * @param version - Optional IP version (4 for IPv4, 6 for IPv6). Omit to allow both.
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().ipAddress()     // Allows IPv4 and IPv6
     * vine.string().ipAddress(4)    // Only IPv4
     * vine.string().ipAddress(6)    // Only IPv6
     */
    ipAddress(version?: 4 | 6): this;
    /**
     * Validates the value to be a valid hexadecimal color code.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().hexCode()  // Accepts #FFF, #FFFFFF, etc.
     */
    hexCode(): this;
    /**
     * Validates the value against a custom regular expression pattern.
     *
     * @param expression - The regular expression to match against
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().regex(/^[A-Z]{3}\d{3}$/)  // Matches ABC123 pattern
     */
    regex(expression: RegExp): this;
    /**
     * Validates the value to contain only alphabetic characters.
     *
     * @param options - Options to allow spaces, underscores, or dashes
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().alpha()
     * vine.string().alpha({ allowSpaces: true })
     * vine.string().alpha({ allowSpaces: true, allowDashes: true })
     */
    alpha(options?: AlphaOptions): this;
    /**
     * Validates the value to contain only alphanumeric characters (letters and numbers).
     *
     * @param options - Options to allow spaces, underscores, or dashes
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().alphaNumeric()
     * vine.string().alphaNumeric({ allowSpaces: true, allowUnderscores: true })
     */
    alphaNumeric(options?: AlphaNumericOptions): this;
    /**
     * Enforce a minimum length on a string field.
     *
     * @param expectedLength - The minimum required length
     * @returns This string schema instance for method chaining
     */
    minLength(expectedLength: number): this;
    /**
     * Enforce a maximum length on a string field.
     *
     * @param expectedLength - The maximum allowed length
     * @returns This string schema instance for method chaining
     */
    maxLength(expectedLength: number): this;
    /**
     * Enforce a fixed length on a string field.
     *
     * @param expectedLength - The exact required length
     * @returns This string schema instance for method chaining
     */
    fixedLength(expectedLength: number): this;
    /**
     * Ensures the field is confirmed by having another field with "_confirmation" suffix
     * (or a custom suffix). Useful for password confirmation fields.
     *
     * @param options - Optional configuration for the confirmation field name
     * @returns This string schema instance for method chaining
     *
     * @example
     * // Validates that "password_confirmation" field matches "password"
     * vine.string().confirmed()
     *
     * @example
     * // Custom confirmation field name
     * vine.string().confirmed({ as: 'passwordConfirm' })
     */
    confirmed(options?: {
        /**
         * @deprecated
         * Use "as" field instead
         */
        confirmationField?: string;
    } | {
        as?: string;
    }): this;
    /**
     * Trims leading and trailing whitespace from the string value.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().trim()  // "  hello  " becomes "hello"
     */
    trim(): this;
    /**
     * Normalizes the email address by applying transformations like
     * lowercasing and removing dots from Gmail addresses.
     *
     * @param options - Email normalization options
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().email().normalizeEmail({ gmail_remove_dots: true })
     */
    normalizeEmail(options?: NormalizeEmailOptions): this;
    /**
     * Converts the field value to UPPERCASE.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().toUpperCase()  // "hello" becomes "HELLO"
     */
    toUpperCase(): this;
    /**
     * Converts the field value to lowercase.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().toLowerCase()  // "HELLO" becomes "hello"
     */
    toLowerCase(): this;
    /**
     * Converts the field value to camelCase.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().toCamelCase()  // "hello_world" becomes "helloWorld"
     */
    toCamelCase(): this;
    /**
     * Escapes HTML entities in the string to prevent XSS attacks.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().escape()  // "<script>" becomes "&lt;script&gt;"
     */
    escape(): this;
    /**
     * Normalizes a URL by applying standardization rules like removing trailing slashes,
     * sorting query parameters, and stripping default ports.
     *
     * @param options - URL normalization options
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().url().normalizeUrl({ stripWWW: true })
     */
    normalizeUrl(...args: Parameters<typeof normalizeUrlRule>): this;
    /**
     * Ensures the value starts with a specified substring.
     *
     * @param substring - The required starting substring
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().startsWith('https://')
     */
    startsWith(substring: string): this;
    /**
     * Ensures the value ends with a specified substring.
     *
     * @param substring - The required ending substring
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().endsWith('.com')
     */
    endsWith(substring: string): this;
    /**
     * Ensures the value matches the value of another field in the data.
     *
     * @param otherField - The name of the field to compare with
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().sameAs('password')
     */
    sameAs(otherField: string): this;
    /**
     * Ensures the value does not match the value of another field in the data.
     *
     * @param otherField - The name of the field to compare with
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().notSameAs('oldPassword')
     */
    notSameAs(otherField: string): this;
    /**
     * Ensures the field's value is one of the predefined choices.
     *
     * @param choices - Array of allowed values or function returning allowed values
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().in(['red', 'green', 'blue'])
     *
     * @example
     * // Dynamic choices based on metadata
     * vine.string().in((field) => getUserRoles(field.meta.userId))
     */
    in(choices: string[] | ((field: FieldContext) => string[])): this;
    /**
     * Ensures the field's value is not in the predefined list.
     *
     * @param list - Array of disallowed values or function returning disallowed values
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().notIn(['admin', 'root', 'system'])
     */
    notIn(list: string[] | ((field: FieldContext) => string[])): this;
    /**
     * Validates the value to be a valid credit card number for specified providers.
     *
     * @param options - Credit card validation options including accepted providers
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().creditCard({ provider: ['visa', 'mastercard'] })
     */
    creditCard(...args: Parameters<typeof creditCardRule>): this;
    /**
     * Validates the value to be a valid passport number for specified countries.
     *
     * @param options - Passport validation options including country codes
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().passport({ countryCode: ['US', 'GB', 'CA'] })
     */
    passport(...args: Parameters<typeof passportRule>): this;
    /**
     * Validates the value to be a valid postal code for specified countries.
     *
     * @param options - Postal code validation options including country codes
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().postalCode({ countryCode: ['US', 'GB', 'CA'] })
     */
    postalCode(...args: Parameters<typeof postalCodeRule>): this;
    /**
     * Validates the value to be a valid UUID (Universally Unique Identifier).
     *
     * @param options - Optional UUID validation options including version
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().uuid()
     * vine.string().uuid({ version: 4 })
     */
    uuid(...args: Parameters<typeof uuidRule>): this;
    /**
     * Validates the value to be a valid ULID (Universally Unique Lexicographically Sortable Identifier).
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().ulid()
     */
    ulid(): this;
    /**
     * Validates the value contains only ASCII characters.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().ascii()
     */
    ascii(): this;
    /**
     * Validates the value to be a valid IBAN (International Bank Account Number).
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().iban()
     */
    iban(): this;
    /**
     * Validates the value to be a valid JWT (JSON Web Token).
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().jwt()
     */
    jwt(): this;
    /**
     * Validates the value to be a string containing latitude and longitude coordinates.
     *
     * @returns This string schema instance for method chaining
     *
     * @example
     * vine.string().coordinates()  // Accepts "40.7128,-74.0060"
     */
    coordinates(): this;
    /**
     * Clones the VineString schema type. The applied options
     * and validations are copied to the new instance.
     *
     * @returns A cloned instance of this VineString schema
     */
    clone(): this;
}