@validex/core 1.0.0

package/dist/index-Cid7Ygr_.d.cts

@@ -0,0 +1,950 @@
+import { ZodPipe, ZodTransform } from 'zod';
+
+/** Options for composition methods (hasUppercase, hasLowercase, hasDigits, hasSpecial). */
+interface CompositionMethodOptions {
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
+    readonly label?: string | undefined;
+    readonly namespace?: string | undefined;
+}
+/** Options for simple boolean check methods. */
+interface CheckMethodOptions {
+    readonly label?: string | undefined;
+    readonly namespace?: string | undefined;
+}
+/** Options for the maxWords chainable method. */
+interface MaxWordsOptions extends CheckMethodOptions {
+    readonly max: number;
+}
+/** Options for the minWords chainable method. */
+interface MinWordsOptions extends CheckMethodOptions {
+    readonly min: number;
+}
+/** Options for the maxConsecutive chainable method. */
+interface MaxConsecutiveOptions extends CheckMethodOptions {
+    readonly max: number;
+}
+declare module 'zod' {
+    /** Chainable validation and transform methods added by validex. */
+    interface ZodType {
+        hasUppercase: (opts?: CompositionMethodOptions) => this;
+        hasLowercase: (opts?: CompositionMethodOptions) => this;
+        hasDigits: (opts?: CompositionMethodOptions) => this;
+        hasSpecial: (opts?: CompositionMethodOptions) => this;
+        noEmails: (opts?: CheckMethodOptions) => this;
+        noUrls: (opts?: CheckMethodOptions) => this;
+        noHtml: (opts?: CheckMethodOptions) => this;
+        noPhoneNumbers: (opts?: CheckMethodOptions) => this;
+        noSpaces: (opts?: CheckMethodOptions) => this;
+        onlyAlpha: (opts?: CheckMethodOptions) => this;
+        onlyNumeric: (opts?: CheckMethodOptions) => this;
+        onlyAlphanumeric: (opts?: CheckMethodOptions) => this;
+        onlyAlphaSpaceHyphen: (opts?: CheckMethodOptions) => this;
+        onlyAlphanumericSpaceHyphen: (opts?: CheckMethodOptions) => this;
+        maxWords: (opts: MaxWordsOptions) => this;
+        minWords: (opts: MinWordsOptions) => this;
+        maxConsecutive: (opts: MaxConsecutiveOptions) => this;
+        toTitleCase: () => ZodPipe<this, ZodTransform<string, string>>;
+        toSlug: () => ZodPipe<this, ZodTransform<string, string>>;
+        stripHtml: () => ZodPipe<this, ZodTransform<string, string>>;
+        collapseWhitespace: () => ZodPipe<this, ZodTransform<string, string>>;
+        emptyToUndefined: () => ZodPipe<this, ZodTransform<string | undefined, unknown>>;
+    }
+}
+
+/**
+ * BusinessNameOptions
+ * Configuration options for the business name validation rule.
+ */
+interface BusinessNameOptions extends FormatRuleOptions {
+    /** Length constraints for the business name. */
+    readonly length?: Range | undefined;
+    /** Extra characters to allow beyond the default set. */
+    readonly extraChars?: string | undefined;
+    /** Characters to disallow from the default character class. */
+    readonly disallowChars?: string | undefined;
+    /** Boundary constraint for first/last character. */
+    readonly boundary?: Boundary | undefined;
+    /** Maximum consecutive identical characters. */
+    readonly consecutive?: Range | undefined;
+    /** Apply title-case transform to the parsed value. */
+    readonly titleCase?: boolean | undefined;
+}
+/**
+ * BusinessName
+ * Validates that a string is a plausible business or company name. Allows
+ * letters, digits, ampersands, dots, commas, hyphens, apostrophes, and parens.
+ *
+ * @param options - Optional business name validation options.
+ * @returns A Zod schema that validates business name strings.
+ */
+declare const BusinessName: RuleFactory<BusinessNameOptions>;
+
+/**
+ * ColorOptions
+ * Options for the color validation rule.
+ */
+interface ColorOptions extends BaseRuleOptions {
+    /** Color format to validate. Defaults to 'hex'. */
+    readonly format?: 'hex' | 'rgb' | 'hsl' | 'any' | undefined;
+    /** Whether to allow alpha channel values. Defaults to true. */
+    readonly alpha?: boolean | undefined;
+}
+/**
+ * Color
+ * Validates that a string is a valid CSS color in the specified format.
+ * Supports hex, rgb, hsl, or any format with optional alpha channel.
+ *
+ * @param options - Optional color validation options.
+ * @returns A Zod schema that validates color strings.
+ */
+declare const Color: RuleFactory<ColorOptions>;
+
+/**
+ * CountryOptions
+ * Configuration options for the country code validation rule.
+ */
+interface CountryOptions extends BaseRuleOptions {
+    /** Country code format: 'alpha2' (default) or 'alpha3'. */
+    readonly format?: 'alpha2' | 'alpha3' | undefined;
+    /** Restrict to only these country codes. */
+    readonly allowCountries?: readonly string[] | undefined;
+    /** Block these country codes. */
+    readonly blockCountries?: readonly string[] | undefined;
+}
+/**
+ * Country
+ * Validates that a string is a valid ISO 3166-1 country code.
+ * Supports alpha-2 and alpha-3 formats with allow/block filtering.
+ *
+ * @param options - Per-call country validation options.
+ * @returns A Zod schema that validates country code strings.
+ */
+declare const Country: RuleFactory<CountryOptions>;
+
+/** IssuerType -- supported card network identifiers. */
+type IssuerType = 'visa' | 'mastercard' | 'amex' | 'discover' | 'diners' | 'jcb' | 'unionpay';
+/**
+ * CreditCardOptions
+ * Configuration options for the credit card validation rule.
+ */
+interface CreditCardOptions extends BaseRuleOptions {
+    /** Only accept cards from these issuers. */
+    readonly allowIssuers?: readonly IssuerType[] | undefined;
+    /** Reject cards from these issuers. */
+    readonly blockIssuers?: readonly IssuerType[] | undefined;
+}
+/**
+ * Credit Card
+ * Validates that a string is a valid credit card number using the Luhn
+ * algorithm with optional issuer filtering. Strips spaces and dashes
+ * from formatted input by default.
+ *
+ * @param options - Per-call credit card validation options.
+ * @returns A Zod schema that validates credit card number strings.
+ */
+declare const CreditCard: RuleFactory<CreditCardOptions>;
+
+/**
+ * CurrencyOptions
+ * Configuration options for the currency code validation rule.
+ */
+interface CurrencyOptions extends BaseRuleOptions {
+    /** Restrict to only these currency codes. */
+    readonly allowCurrencies?: readonly string[] | undefined;
+    /** Block these currency codes. */
+    readonly blockCurrencies?: readonly string[] | undefined;
+}
+/**
+ * Currency
+ * Validates that a string is a valid ISO 4217 currency code.
+ * Supports allow/block filtering for restricting accepted currencies.
+ *
+ * @param options - Per-call currency validation options.
+ * @returns A Zod schema that validates currency code strings.
+ */
+declare const Currency: RuleFactory<CurrencyOptions>;
+
+/**
+ * DateTimeOptions
+ * Configuration options for the dateTime validation rule.
+ */
+interface DateTimeOptions extends BaseRuleOptions {
+    /** Format to validate: full ISO datetime, date-only, or time-only. */
+    readonly format?: 'iso' | 'date' | 'time' | undefined;
+    /** Earliest allowed date/time (inclusive). */
+    readonly min?: Date | string | undefined;
+    /** Latest allowed date/time (inclusive). */
+    readonly max?: Date | string | undefined;
+    /** Whether future dates are accepted. */
+    readonly allowFuture?: boolean | undefined;
+    /** Whether past dates are accepted. */
+    readonly allowPast?: boolean | undefined;
+    /** Whether UTC offset suffixes are accepted. */
+    readonly allowOffset?: boolean | undefined;
+    /** Whether local datetimes (no Z or offset) are accepted. */
+    readonly allowLocal?: boolean | undefined;
+    /** Fractional-seconds precision (0-9). */
+    readonly precision?: number | undefined;
+}
+/**
+ * DateTime
+ * Validates that a string is a valid ISO 8601 datetime, date, or time.
+ * Supports range constraints, future/past restrictions, and precision.
+ *
+ * @param options - Per-call dateTime validation options.
+ * @returns A Zod schema that validates date/time strings.
+ */
+declare const DateTime: RuleFactory<DateTimeOptions>;
+
+/**
+ * EmailOptions
+ * Configuration options for the email validation rule.
+ */
+interface EmailOptions extends BaseRuleOptions {
+    /** Length constraints for the email string. Defaults to { max: 254 }. */
+    readonly length?: Range | undefined;
+    /** Block email addresses that use plus aliases (e.g. user+tag@domain). */
+    readonly blockPlusAlias?: boolean | undefined;
+    /** List of domains to block. */
+    readonly blockDomains?: readonly string[] | undefined;
+    /** Restrict to only these domains. */
+    readonly allowDomains?: readonly string[] | undefined;
+    /** Block known disposable/temporary email domains (async). */
+    readonly blockDisposable?: boolean | undefined;
+    /** Allow subdomain email addresses. Defaults to true. */
+    readonly allowSubdomains?: boolean | undefined;
+}
+/**
+ * Email
+ * Validates that a string is a valid email address with configurable
+ * domain restrictions, plus-alias blocking, and disposable detection.
+ *
+ * @param options - Per-call email validation options.
+ * @returns A Zod schema that validates email strings.
+ */
+declare const Email: RuleFactory<EmailOptions>;
+
+/**
+ * IbanOptions
+ * Configuration options for the IBAN validation rule.
+ */
+interface IbanOptions extends BaseRuleOptions {
+    /** Only accept IBANs from these country codes. */
+    readonly allowCountries?: readonly string[] | undefined;
+    /** Reject IBANs from these country codes. */
+    readonly blockCountries?: readonly string[] | undefined;
+}
+/**
+ * IBAN
+ * Validates that a string is a valid IBAN with MOD-97 checksum verification.
+ * Supports country-specific BBAN format validation and allow/block filtering.
+ *
+ * @param options - Per-call IBAN validation options.
+ * @returns A Zod schema that validates IBAN strings.
+ */
+declare const Iban: RuleFactory<IbanOptions>;
+
+/**
+ * IpAddressOptions
+ * Configuration options for the ipAddress validation rule.
+ */
+interface IpAddressOptions extends BaseRuleOptions {
+    /** IP version to accept: v4, v6, or any. */
+    readonly version?: 'v4' | 'v6' | 'any' | undefined;
+    /** Whether CIDR notation (e.g., /24) is accepted. */
+    readonly allowCidr?: boolean | undefined;
+    /** Whether private/reserved addresses are accepted. */
+    readonly allowPrivate?: boolean | undefined;
+}
+/**
+ * IP Address
+ * Validates that a string is a valid IP address, with optional version
+ * filtering, CIDR notation support, and private range restriction.
+ *
+ * @param options - Per-call ipAddress validation options.
+ * @returns A Zod schema that validates IP address strings.
+ */
+declare const IpAddress: RuleFactory<IpAddressOptions>;
+
+/**
+ * JWTOptions
+ * Configuration options for the JWT validation rule.
+ */
+interface JWTOptions extends BaseRuleOptions {
+    /** Require the exp claim to be present. */
+    readonly requireExpiry?: boolean | undefined;
+    /** Validate that the token has not expired. */
+    readonly checkExpiry?: boolean | undefined;
+    /** Validate that the token nbf claim is satisfied. */
+    readonly checkNotBefore?: boolean | undefined;
+    /** Clock tolerance in seconds for temporal checks. */
+    readonly clockTolerance?: number | undefined;
+    /** Require specific claims to be present in the payload. */
+    readonly requireClaims?: readonly string[] | undefined;
+    /** Restrict allowed signing algorithms. */
+    readonly allowAlgorithms?: readonly string[] | undefined;
+}
+/**
+ * JWT
+ * Validates that a string is a structurally valid JWT and optionally
+ * checks expiry, not-before, required claims, and allowed algorithms.
+ *
+ * @param options - Per-call JWT validation options.
+ * @returns A Zod schema that validates JWT strings.
+ */
+declare const Jwt: RuleFactory<JWTOptions>;
+
+/**
+ * LicenseKeyOptions
+ * Configuration options for the license key validation rule.
+ */
+interface LicenseKeyOptions extends FormatRuleOptions {
+    /** License key format type. Defaults to 'custom'. */
+    readonly type?: 'windows' | 'uuid' | 'custom' | undefined;
+    /** Number of segments in the key. Defaults to 5. */
+    readonly segments?: number | undefined;
+    /** Length of each segment. Defaults to 5. */
+    readonly segmentLength?: number | undefined;
+    /** Separator between segments. Defaults to '-'. */
+    readonly separator?: string | undefined;
+    /** Character set for each segment. Defaults to 'alphanumeric'. */
+    readonly charset?: 'alphanumeric' | 'alpha' | 'numeric' | 'hex' | undefined;
+}
+/**
+ * LicenseKey
+ * Validates that a string is a valid license key. Supports UUID format,
+ * Windows-style keys, and fully customizable segment patterns.
+ *
+ * @param options - Optional license key validation options.
+ * @returns A Zod schema that validates license key strings.
+ */
+declare const LicenseKey: RuleFactory<LicenseKeyOptions>;
+
+/**
+ * MacAddressOptions
+ * Configuration options for the MAC address validation rule.
+ */
+interface MacAddressOptions extends BaseRuleOptions {
+    /** Delimiter between octets. Defaults to ':'. */
+    readonly delimiter?: ':' | '-' | 'none' | undefined;
+}
+/**
+ * Mac Address
+ * Validates that a string is a valid MAC address in the specified
+ * delimiter format. Trims whitespace by default.
+ *
+ * @param options - Per-call MAC address validation options.
+ * @returns A Zod schema that validates MAC address strings.
+ */
+declare const MacAddress: RuleFactory<MacAddressOptions>;
+
+/**
+ * PasswordOptions
+ * Configuration options for the password validation rule.
+ */
+interface PasswordOptions extends BaseRuleOptions {
+    /** Length constraint for the password string. */
+    readonly length?: Range | undefined;
+    /** Required uppercase letter count. */
+    readonly uppercase?: Range | undefined;
+    /** Required lowercase letter count. */
+    readonly lowercase?: Range | undefined;
+    /** Required digit count. */
+    readonly digits?: Range | undefined;
+    /** Required special character count. */
+    readonly special?: Range | undefined;
+    /** Maximum consecutive identical characters. */
+    readonly consecutive?: Range | undefined;
+    /** Block common passwords. */
+    readonly blockCommon?: boolean | 'basic' | 'moderate' | 'strict' | undefined;
+}
+/**
+ * Password
+ * Validates that a string meets password strength requirements including
+ * length, character composition, and consecutive character limits.
+ *
+ * @param options - Per-call password validation options.
+ * @returns A Zod schema that validates password strings.
+ */
+declare const Password: RuleFactory<PasswordOptions>;
+
+/**
+ * PasswordConfirmationOptions
+ * Configuration for the password confirmation validation rule.
+ */
+interface PasswordConfirmationOptions extends BaseRuleOptions {
+    /** Name of the password field to match against (used by sameAs). */
+    readonly passwordField?: string | undefined;
+}
+/**
+ * Password Confirmation
+ * Returns a schema that validates the confirmation string using the same
+ * base password rule. Cross-field matching (sameAs) is resolved by
+ * validate() using the registered metadata.
+ *
+ * @param options - Per-call options (passwordField controls sameAs target).
+ * @returns A Zod schema that validates the confirmation string.
+ */
+declare const PasswordConfirmation: (options?: Partial<PasswordConfirmationOptions>) => unknown;
+
+/**
+ * PersonNameOptions
+ * Configuration options for the person name validation rule.
+ */
+interface PersonNameOptions extends FormatRuleOptions {
+    /** Length constraints for the full name string. */
+    readonly length?: Range | undefined;
+    /** Word count constraints. */
+    readonly words?: Range | undefined;
+    /** Allow unicode letters (\p{L}) vs ASCII-only. Defaults to true. */
+    readonly allowUnicode?: boolean | undefined;
+    /** Extra characters to allow in the character class. */
+    readonly extraChars?: string | undefined;
+    /** Characters to disallow from the default character class. */
+    readonly disallowChars?: string | undefined;
+    /** Boundary constraint for first/last character. */
+    readonly boundary?: Boundary | undefined;
+    /** Maximum consecutive identical characters. */
+    readonly consecutive?: Range | undefined;
+    /** Apply title-case transform to the parsed value. */
+    readonly titleCase?: boolean | undefined;
+}
+/**
+ * PersonName
+ * Validates that a string is a plausible human name. Supports unicode,
+ * hyphens, apostrophes, boundary constraints, and word limits.
+ *
+ * @param options - Optional person name validation options.
+ * @returns A Zod schema that validates person name strings.
+ */
+declare const PersonName: RuleFactory<PersonNameOptions>;
+
+/**
+ * PhoneOptions
+ * Configuration options for the phone number validation rule.
+ */
+interface PhoneOptions extends BaseRuleOptions {
+    /** Default country code for parsing (ISO 3166-1 alpha-2). */
+    readonly country?: string | undefined;
+    /** Restrict to only these country codes. */
+    readonly allowCountries?: readonly string[] | undefined;
+    /** Block these country codes. */
+    readonly blockCountries?: readonly string[] | undefined;
+    /** Require a mobile phone number. */
+    readonly requireMobile?: boolean | undefined;
+    /** Require the input to start with '+' (country code prefix). */
+    readonly requireCountryCode?: boolean | undefined;
+    /** Output format for the normalized phone number. */
+    readonly format?: 'e164' | 'international' | 'national' | undefined;
+    /** Which metadata bundle libphonenumber-js should use. */
+    readonly metadata?: 'min' | 'mobile' | 'max' | 'custom' | undefined;
+    /** Path to a custom metadata JSON file (used when metadata is 'custom'). */
+    readonly customMetadataPath?: string | undefined;
+}
+/**
+ * Phone
+ * Validates that a string is a valid phone number. Supports country
+ * filtering, mobile requirement, and output format normalization.
+ *
+ * @param options - Per-call phone validation options.
+ * @returns A Zod schema that validates phone number strings.
+ */
+declare const Phone: RuleFactory<PhoneOptions>;
+
+/**
+ * PostalCodeOptions
+ * Configuration options for the postal code validation rule.
+ */
+interface PostalCodeOptions extends FormatRuleOptions {
+    /** ISO 3166-1 alpha-2 country code (required). */
+    readonly country: string;
+}
+/**
+ * Postal Code
+ * Validates that a string is a valid postal code for the specified country.
+ * Uses postcode-validator for validation, or a custom regex/customFn override.
+ * Throws at creation time if the module is preloaded and the country is
+ * unsupported. Otherwise defers validation to parse time.
+ *
+ * @param options - Per-call postal code validation options.
+ * @returns A Zod schema that validates postal code strings.
+ */
+declare const PostalCode: RuleFactory<PostalCodeOptions>;
+
+/**
+ * SlugOptions
+ * Options for the slug validation rule.
+ */
+interface SlugOptions extends FormatRuleOptions {
+    /** Length constraints for the slug. Defaults to { min: 3, max: 100 }. */
+    readonly length?: Range | undefined;
+    /** Additional characters to allow in the slug character class. */
+    readonly extraChars?: string | undefined;
+}
+/**
+ * Slug
+ * Validates that a string is a URL-friendly slug. Supports custom length
+ * constraints, extra allowed characters, and regex override.
+ *
+ * @param options - Optional slug validation options.
+ * @returns A Zod schema that validates slug strings.
+ */
+declare const Slug: RuleFactory<SlugOptions>;
+
+/**
+ * TextOptions
+ * Configuration options for the text validation rule.
+ */
+interface TextOptions extends FormatRuleOptions {
+    /** Length constraints for the text string. */
+    readonly length?: Range | undefined;
+    /** Word count constraints. */
+    readonly words?: Range | undefined;
+    /** Consecutive character repetition constraints. */
+    readonly consecutive?: Range | undefined;
+    /** Reject text that contains email addresses. */
+    readonly noEmails?: boolean | undefined;
+    /** Reject text that contains URLs. */
+    readonly noUrls?: boolean | undefined;
+    /** Reject text that contains phone numbers. */
+    readonly noPhoneNumbers?: boolean | undefined;
+    /** Reject text that contains HTML tags. */
+    readonly noHtml?: boolean | undefined;
+}
+/**
+ * Text
+ * Validates free-form text with optional content detection,
+ * word limits, and consecutive character restrictions.
+ *
+ * @param options - Per-call text validation options.
+ * @returns A Zod schema that validates text strings.
+ */
+declare const Text: RuleFactory<TextOptions>;
+
+/**
+ * TokenType
+ * Supported token format types.
+ */
+type TokenType = 'nanoid' | 'hex' | 'base64' | 'cuid' | 'cuid2' | 'ulid';
+/**
+ * TokenOptions
+ * Configuration options for the token validation rule.
+ */
+interface TokenOptions extends FormatRuleOptions {
+    /** Token format type. Required, no default. */
+    readonly type: TokenType;
+    /** Length constraints for the token. Defaults vary by type. */
+    readonly length?: Range | undefined;
+}
+/**
+ * Token
+ * Validates that a string is a valid token of the specified type.
+ * Supports nanoid, hex, base64, cuid, cuid2, and ulid formats.
+ *
+ * @param options - Token validation options (type is required).
+ * @returns A Zod schema that validates token strings.
+ */
+declare const Token: RuleFactory<TokenOptions>;
+
+/**
+ * URLOptions
+ * Configuration options for the URL validation rule.
+ */
+interface URLOptions extends BaseRuleOptions {
+    /** Allowed protocols (without trailing colon). Defaults to ['http', 'https']. */
+    readonly protocols?: readonly string[] | undefined;
+    /** Require a TLD (at least one dot in hostname). Defaults to true. */
+    readonly requireTLD?: boolean | undefined;
+    /** Length constraints for the full URL. Defaults to { max: 2048 }. */
+    readonly length?: Range | undefined;
+    /** Whitelist of allowed domains. Empty means allow all. */
+    readonly allowDomains?: readonly string[] | undefined;
+    /** Blacklist of blocked domains. */
+    readonly blockDomains?: readonly string[] | undefined;
+    /** Allow query strings. Defaults to true. */
+    readonly allowQuery?: boolean | undefined;
+    /** Allow userinfo (user:pass@). Defaults to false. */
+    readonly allowAuth?: boolean | undefined;
+}
+/**
+ * Url
+ * Validates that a string is a valid URL with configurable protocol,
+ * TLD, domain, query, and auth constraints.
+ *
+ * @param options - Optional URL validation options.
+ * @returns A Zod schema that validates URL strings.
+ */
+declare const Url: RuleFactory<URLOptions>;
+
+/**
+ * UsernameOptions
+ * Configuration options for the username validation rule.
+ */
+interface UsernameOptions extends FormatRuleOptions {
+    /** Length constraints for the username. Defaults to { min: 3, max: 20 }. */
+    readonly length?: Range | undefined;
+    /** Character pattern preset. Defaults to 'alphanumeric-underscore'. */
+    readonly pattern?: 'alphanumeric' | 'alphanumeric-dash' | 'alphanumeric-underscore' | undefined;
+    /** Additional characters to allow in the character class. */
+    readonly extraChars?: string | undefined;
+    /** Characters to disallow from the pattern character class. */
+    readonly disallowChars?: string | undefined;
+    /** Boundary constraint for first/last character. Defaults to 'alphanumeric'. */
+    readonly boundary?: Boundary | undefined;
+    /** Maximum consecutive identical characters. */
+    readonly consecutive?: Range | undefined;
+    /** Reserved words that cannot be used as usernames. */
+    readonly reservedWords?: readonly string[] | undefined;
+    /** Block reserved words. Defaults to false. */
+    readonly blockReserved?: boolean | undefined;
+    /** Ignore case when checking patterns and reserved words. Defaults to true. */
+    readonly ignoreCase?: boolean | undefined;
+}
+/**
+ * Username
+ * Validates that a string is a valid username with configurable pattern,
+ * boundary constraints, and consecutive character limits.
+ *
+ * @param options - Optional username validation options.
+ * @returns A Zod schema that validates username strings.
+ */
+declare const Username: RuleFactory<UsernameOptions>;
+
+/**
+ * UUIDOptions
+ * Configuration options for the UUID validation rule.
+ */
+interface UUIDOptions extends BaseRuleOptions {
+    /** UUID version to accept (1-8 or 'any'). Defaults to 'any'. */
+    readonly version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 'any' | undefined;
+}
+/**
+ * UUID
+ * Validates that a string is a valid UUID, optionally restricted to a
+ * specific version. Normalizes to lowercase + trimmed by default.
+ *
+ * @param options - Per-call UUID validation options.
+ * @returns A Zod schema that validates UUID strings.
+ */
+declare const Uuid: RuleFactory<UUIDOptions>;
+
+/**
+ * VatNumberOptions
+ * Configuration options for the VAT number validation rule.
+ */
+interface VatNumberOptions extends BaseRuleOptions {
+    /** ISO country code to validate against (e.g. 'DE', 'FR'). */
+    readonly country?: string | undefined;
+    /** Require the country prefix at the start of the value. */
+    readonly requirePrefix?: boolean | undefined;
+}
+/**
+ * VAT Number
+ * Validates that a string is a valid VAT identification number.
+ * Auto-detects country from prefix or validates against a specified code.
+ *
+ * @param options - Per-call VAT number validation options.
+ * @returns A Zod schema that validates VAT number strings.
+ */
+declare const VatNumber: RuleFactory<VatNumberOptions>;
+
+/**
+ * WebsiteOptions
+ * Configuration options for the website validation rule.
+ */
+interface WebsiteOptions extends BaseRuleOptions {
+    /** Length constraints for the full URL. Defaults to { max: 255 }. */
+    readonly length?: Range | undefined;
+    /** Require the hostname to start with 'www.'. */
+    readonly requireWww?: boolean | undefined;
+    /** Require https protocol (reject http). */
+    readonly requireHttps?: boolean | undefined;
+    /** Whitelist of allowed domains. Empty means allow all. */
+    readonly allowDomains?: readonly string[] | undefined;
+    /** Blacklist of blocked domains. */
+    readonly blockDomains?: readonly string[] | undefined;
+    /** Allow subdomain URLs. Defaults to true. */
+    readonly allowSubdomains?: boolean | undefined;
+    /** Allow URL paths beyond '/'. Defaults to true. */
+    readonly allowPath?: boolean | undefined;
+    /** Allow query strings. Defaults to false. */
+    readonly allowQuery?: boolean | undefined;
+}
+/**
+ * Website
+ * Validates that a string is a valid website URL. Auto-prepends https://
+ * to bare domains, enforces protocol/domain/path constraints.
+ *
+ * @param options - Optional website validation options.
+ * @returns A Zod schema that validates website URLs.
+ */
+declare const Website: RuleFactory<WebsiteOptions>;
+
+/**
+ * Range
+ * Defines a numeric range constraint. A number means exact value.
+ *
+ * @returns number | object with min/max
+ */
+type Range = number | {
+    readonly min?: number;
+    readonly max?: number;
+};
+/**
+ * Boundary
+ * Controls character restrictions at string start/end.
+ * A string shorthand applies to both start and end.
+ *
+ * @returns string | object with start/end
+ */
+type Boundary = 'alpha' | 'alphanumeric' | 'any' | {
+    readonly start?: 'alpha' | 'alphanumeric' | 'any';
+    readonly end?: 'alpha' | 'alphanumeric' | 'any';
+};
+/**
+ * BaseRuleOptions
+ * Base options available on every validation rule.
+ */
+interface BaseRuleOptions {
+    /** Explicit label for error messages. */
+    readonly label?: string;
+    /** Convert empty strings to undefined before validation. */
+    readonly emptyToUndefined?: boolean;
+    /** Apply rule-specific normalization (trim, lowercase, etc.). */
+    readonly normalize?: boolean;
+    /** Custom validation function that runs after all built-in checks. */
+    readonly customFn?: (value: string) => true | string | Promise<true | string>;
+    /** Cross-field equality check. Field name that this field must match. */
+    readonly sameAs?: string;
+    /** Conditional requirement. Field name — when that field has a value, this field becomes required. */
+    readonly requiredWhen?: string;
+}
+/**
+ * FormatRuleOptions
+ * Extended options for rules that support regex override.
+ */
+interface FormatRuleOptions extends BaseRuleOptions {
+    /** Override the built-in format pattern with a custom regex. */
+    readonly regex?: RegExp;
+}
+/**
+ * TranslationFunction
+ * A function that translates i18n keys to localized strings.
+ *
+ * @param key   - The i18n key to translate.
+ * @param params - Interpolation parameters.
+ * @returns The translated string.
+ */
+type TranslationFunction = (key: string, params?: Record<string, unknown>) => string;
+/**
+ * PathTransform
+ * Transforms a field path array into a custom string format.
+ *
+ * @param path - The field path segments.
+ * @returns The transformed path string.
+ */
+type PathTransform = (path: ReadonlyArray<string | number>) => string;
+/**
+ * LabelTransform
+ * Transforms field labels for error messages.
+ *
+ * @param ctx - Context with path, fieldName, defaultLabel, and optional explicitLabel.
+ * @returns The transformed label string.
+ */
+type LabelTransform = (ctx: {
+    readonly path: ReadonlyArray<string | number>;
+    readonly fieldName: string;
+    readonly defaultLabel: string;
+    readonly explicitLabel?: string;
+}) => string;
+/**
+ * MessageTransform
+ * Transforms error messages for custom formatting.
+ *
+ * @param ctx - Context with key, code, namespace, path, label, message, and params.
+ * @returns The transformed message string.
+ */
+type MessageTransform = (ctx: {
+    readonly key: string;
+    readonly code: string;
+    readonly namespace: string;
+    readonly path: ReadonlyArray<string | number>;
+    readonly label: string;
+    readonly message: string;
+    readonly params: Record<string, unknown>;
+}) => string;
+/**
+ * I18nConfig
+ * Internationalization configuration.
+ */
+interface I18nConfig {
+    /** Enable i18n mode. When true, messages become i18n keys. */
+    readonly enabled: boolean;
+    /** Key prefix for all i18n keys. */
+    readonly prefix?: string;
+    /** Separator between key segments. */
+    readonly separator?: string;
+    /** How field paths are encoded into message keys. */
+    readonly pathMode?: 'semantic' | 'key' | 'full' | PathTransform;
+    /** Translation function for automatic message translation. */
+    readonly t?: TranslationFunction;
+}
+/**
+ * LabelConfig
+ * Label derivation configuration.
+ */
+interface LabelConfig {
+    /** How labels are derived when not explicitly provided. */
+    readonly fallback?: 'derived' | 'generic' | 'none';
+    /** Custom label transform function. */
+    readonly transform?: LabelTransform;
+}
+/**
+ * MessageConfig
+ * Message formatting configuration.
+ */
+interface MessageConfig {
+    /** Custom message transform function. */
+    readonly transform?: MessageTransform;
+}
+/**
+ * RuleDefaults
+ * Typed per-rule defaults for all 25 built-in rules. Keys are namespace
+ * names (camelCase) matching each rule's `name` in createRule.
+ */
+interface RuleDefaults {
+    readonly email?: Partial<EmailOptions>;
+    readonly personName?: Partial<PersonNameOptions>;
+    readonly businessName?: Partial<BusinessNameOptions>;
+    readonly password?: Partial<PasswordOptions>;
+    readonly passwordConfirmation?: Partial<PasswordConfirmationOptions>;
+    readonly phone?: Partial<PhoneOptions>;
+    readonly website?: Partial<WebsiteOptions>;
+    readonly url?: Partial<URLOptions>;
+    readonly username?: Partial<UsernameOptions>;
+    readonly slug?: Partial<SlugOptions>;
+    readonly postalCode?: Partial<PostalCodeOptions>;
+    readonly licenseKey?: Partial<LicenseKeyOptions>;
+    readonly uuid?: Partial<UUIDOptions>;
+    readonly jwt?: Partial<JWTOptions>;
+    readonly dateTime?: Partial<DateTimeOptions>;
+    readonly token?: Partial<TokenOptions>;
+    readonly text?: Partial<TextOptions>;
+    readonly country?: Partial<CountryOptions>;
+    readonly currency?: Partial<CurrencyOptions>;
+    readonly color?: Partial<ColorOptions>;
+    readonly creditCard?: Partial<CreditCardOptions>;
+    readonly iban?: Partial<IbanOptions>;
+    readonly vatNumber?: Partial<VatNumberOptions>;
+    readonly macAddress?: Partial<MacAddressOptions>;
+    readonly ipAddress?: Partial<IpAddressOptions>;
+    /** Index signature for custom rules created with createRule. */
+    readonly [key: string]: Partial<Record<string, unknown>> | undefined;
+}
+/**
+ * GlobalConfig
+ * Top-level configuration for the validex library.
+ */
+interface GlobalConfig {
+    /** Internationalization settings. */
+    readonly i18n: I18nConfig;
+    /** Label derivation settings. */
+    readonly label?: LabelConfig;
+    /** Message formatting settings. */
+    readonly message?: MessageConfig;
+    /** Global rule defaults (overrides built-in defaults). */
+    readonly rules?: Partial<RuleDefaults>;
+}
+/**
+ * PreloadOptions
+ * Options for preloading async data at startup.
+ */
+interface PreloadOptions {
+    /** Preload disposable email domain list. */
+    readonly disposable?: boolean;
+    /** Preload common password lists. */
+    readonly passwords?: boolean | 'basic' | 'moderate' | 'strict';
+    /** Preload reserved username list. */
+    readonly reserved?: boolean;
+    /** Preload phone number metadata variant. */
+    readonly phone?: 'min' | 'mobile' | 'max';
+    /** Preload country codes. */
+    readonly countryCodes?: boolean;
+    /** Preload currency codes. */
+    readonly currencyCodes?: boolean;
+    /** Preload IBAN patterns. */
+    readonly ibanPatterns?: boolean;
+    /** Preload VAT patterns. */
+    readonly vatPatterns?: boolean;
+    /** Preload credit card prefixes. */
+    readonly creditCardPrefixes?: boolean;
+    /** Preload postal code validation module. */
+    readonly postalCodes?: boolean;
+}
+/**
+ * NestedErrors
+ * Recursive type for nested error objects matching schema shape.
+ */
+interface NestedErrors {
+    readonly [field: string]: readonly string[] | NestedErrors;
+}
+/**
+ * ValidationResult
+ * Result of running validate() on a schema and data.
+ */
+interface ValidationResult<T> {
+    /** Whether validation passed. */
+    readonly success: boolean;
+    /** Typed parsed data, only populated when success is true. */
+    readonly data?: T;
+    /** Flat dot-path to all error messages per field. */
+    readonly errors: Record<string, readonly string[]>;
+    /** Flat dot-path to first error message per field. */
+    readonly firstErrors: Record<string, string>;
+    /** Nested error object matching schema shape. */
+    readonly nestedErrors: NestedErrors;
+    /** Raw Zod issues (escape hatch). */
+    readonly issues: ReadonlyArray<unknown>;
+}
+/**
+ * CreateRuleOptions
+ * Configuration object passed to the createRule factory.
+ */
+interface CreateRuleOptions<T extends BaseRuleOptions> {
+    /** Namespace for error codes (e.g., 'email', 'password'). */
+    readonly name: string;
+    /** Tier 1 defaults for this rule. */
+    readonly defaults: Partial<T>;
+    /** Builder function that constructs the Zod schema from resolved options. */
+    readonly build: (opts: T) => unknown;
+    /** English message templates keyed by error code. */
+    readonly messages: Readonly<Record<string, string>>;
+}
+/**
+ * RuleFactory
+ * The function returned by createRule. Accepts per-call options and returns a Zod schema.
+ */
+type RuleFactory<T extends BaseRuleOptions> = (options?: Partial<T>) => unknown;
+/**
+ * ErrorParams
+ * Normalized error parameters extracted from a Zod issue by getParams().
+ */
+interface ErrorParams {
+    /** The validex error code. */
+    readonly code: string;
+    /** The error namespace. */
+    readonly namespace: string;
+    /** The resolved field label. */
+    readonly label: string;
+    /** i18n key for the label (only in i18n mode). */
+    readonly labelKey?: string;
+    /** Full i18n key for the message. */
+    readonly key: string;
+    /** Field path as array. */
+    readonly path: ReadonlyArray<string | number>;
+    /** Additional interpolation parameters. */
+    readonly [param: string]: unknown;
+}
+
+export { type PhoneOptions as $, type MaxConsecutiveOptions as A, type BaseRuleOptions as B, type CreateRuleOptions as C, DateTime as D, type ErrorParams as E, type FormatRuleOptions as F, type GlobalConfig as G, type MaxWordsOptions as H, type I18nConfig as I, type JWTOptions as J, type MessageConfig as K, type LabelConfig as L, MacAddress as M, type MessageTransform as N, type MinWordsOptions as O, type PreloadOptions as P, type NestedErrors as Q, type RuleFactory as R, Password as S, PasswordConfirmation as T, type PasswordConfirmationOptions as U, type ValidationResult as V, type PasswordOptions as W, type PathTransform as X, PersonName as Y, type PersonNameOptions as Z, Phone as _, type Boundary as a, PostalCode as a0, type PostalCodeOptions as a1, type Range as a2, type RuleDefaults as a3, Slug as a4, type SlugOptions as a5, Text as a6, type TextOptions as a7, Token as a8, type TokenOptions as a9, type TokenType as aa, type TranslationFunction as ab, type URLOptions as ac, type UUIDOptions as ad, Url as ae, Username as af, type UsernameOptions as ag, Uuid as ah, VatNumber as ai, type VatNumberOptions as aj, Website as ak, type WebsiteOptions as al, BusinessName as b, type BusinessNameOptions as c, type CheckMethodOptions as d, Color as e, type ColorOptions as f, type CompositionMethodOptions as g, Country as h, type CountryOptions as i, CreditCard as j, type CreditCardOptions as k, Currency as l, type CurrencyOptions as m, type DateTimeOptions as n, Email as o, type EmailOptions as p, Iban as q, type IbanOptions as r, IpAddress as s, type IpAddressOptions as t, type IssuerType as u, Jwt as v, type LabelTransform as w, LicenseKey as x, type LicenseKeyOptions as y, type MacAddressOptions as z };