@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/core/plugin/stringAlphanumeric.d.ts

@@ -1,42 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name stringAlphanumeric
- * @category standard
- * @description Validates that a string contains only alphanumeric characters (letters and numbers)
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - only letters and numbers allowed
- * const validator = Builder()
- *   .use(stringAlphanumericPlugin)
- *   .for<UserData>()
- *   .v("username", (b) => b.string.alphanumeric())
- *   .v("userId", (b) => b.string.required().alphanumeric())
- *   .build();
- *
- * // Allow spaces in addition to alphanumeric characters
- * builder.v("displayName", b => b.string.alphanumeric(true))
- *
- * // Combined with length validation
- * builder.v("productCode", b => b.string.alphanumeric().min(3).max(20))
- * ```
- * @params
- * - allowSpaces?: boolean - Whether to allow spaces (default: false)
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string contains only allowed characters
- * @customError
- * ```typescript
- * .alphanumeric(false, {
- *   messageFactory: ({ path, value }) =>
- *     `${path} must contain only letters and numbers (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringAlphanumericPlugin: import("../..").TypedPlugin<"stringAlphanumeric", "alphanumeric", (allowSpaces?: boolean, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (boolean | ValidationOptions<{}>)[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringBase64.d.ts

@@ -1,119 +0,0 @@
-/**
- * @luq-plugin
- * @name stringBase64
- * @category string
- * @description Validates base64 encoded string
- * @allowedTypes ["string"]
- * @see https://tools.ietf.org/html/rfc4648 - RFC 4648: The Base16, Base32, and Base64 Data Encodings
- * @see https://developer.mozilla.org/en-US/docs/Glossary/Base64 - MDN Base64 Encoding Reference
- * @see https://developer.mozilla.org/en-US/docs/Web/API/btoa - MDN btoa() Function
- * @example
- * ```typescript
- * // Basic usage - validates base64 encoded string (RFC 4648 compliant)
- * const validator = Builder()
- *   .use(stringBase64Plugin)
- *   .for<{ encodedData: string }>()
- *   .v("encodedData", (b) => b.string.base64())
- *   .build();
- *
- * // URL-safe base64 validation
- * const urlSafeValidator = Builder()
- *   .use(stringBase64Plugin)
- *   .for<{ token: string }>()
- *   .v("token", (b) => b.string.base64({ urlSafe: true }))
- *   .build();
- *
- * // ✅ VALID base64 strings (RFC 4648)
- * // Standard base64 encoding
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=" });           // "Hello World"
- * validator.parse({ encodedData: "YW55IGNhcm5hbCBwbGVhc3VyZS4=" }); // "any carnal pleasure."
- * validator.parse({ encodedData: "" });                          // Empty string
- * validator.parse({ encodedData: "YQ==" });                      // Single char "a"
- * validator.parse({ encodedData: "YWI=" });                      // Two chars "ab"
- * validator.parse({ encodedData: "YWJj" });                      // Three chars "abc"
- * validator.parse({ encodedData: "YWJjZA==" });                  // Four chars "abcd"
- * validator.parse({ encodedData: "VGhpcyBpcyBhIHRlc3Q=" });       // "This is a test"
- *
- * // With numbers and special base64 characters
- * validator.parse({ encodedData: "MTIzNDU2Nzg5MA==" });          // "1234567890"
- * validator.parse({ encodedData: "QUJDREVGRw==" });              // "ABCDEFG"
- * validator.parse({ encodedData: "YWJjZGVmZ2hpams=" });           // "abcdefghijk"
- * validator.parse({ encodedData: "Pz8/Pz8/Pz8=" });              // Contains + and / chars
- * validator.parse({ encodedData: "+/+/+/+/+/+=" });              // All special chars
- *
- * // Different padding scenarios
- * validator.parse({ encodedData: "YWI=" });                      // One padding char
- * validator.parse({ encodedData: "YQ==" });                      // Two padding chars
- * validator.parse({ encodedData: "YWJj" });                      // No padding needed
- * validator.parse({ encodedData: "YWJjZA==" });                  // Two padding chars
- *
- * // URL-safe base64 (RFC 4648 Section 5)
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ" });          // URL-safe without padding
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ=" });         // URL-safe with padding
- * urlSafeValidator.parse({ token: "YW55IGNhcm5hbC1wbGVhc3VyZS4" }); // Uses - instead of /
- * urlSafeValidator.parse({ token: "YWJjZGVmZ2hpams_" });         // Uses _ instead of +
- * urlSafeValidator.parse({ token: "-_-_-_-_-_-_" });            // All URL-safe special chars
- *
- * // Real-world examples
- * validator.parse({ encodedData: "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9" }); // JWT header
- * validator.parse({ encodedData: "VG8gYmUgb3Igbm90IHRvIGJlLCB0aGF0IGlzIHRoZSBxdWVzdGlvbg==" }); // Long text
- * validator.parse({ encodedData: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==" }); // Base64 image
- *
- * // ❌ INVALID base64 strings
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ" });          // Wrong length (not multiple of 4)
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ===" });       // Too many padding chars (3)
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ====" });      // Too many padding chars (4)
- * validator.parse({ encodedData: "SGV@bG8gV29ybGQ=" });         // Invalid character (@)
- * validator.parse({ encodedData: "SGV sbG8gV29ybGQ=" });        // Space not allowed
- * validator.parse({ encodedData: "SGV\tbG8gV29ybGQ=" });        // Tab not allowed
- * validator.parse({ encodedData: "SGV\nbG8gV29ybGQ=" });        // Newline not allowed
- * validator.parse({ encodedData: "SGVsbG8\rgV29ybGQ=" });       // Carriage return not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=" });         // Non-standard characters
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ!=" });        // Exclamation mark not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ?=" });        // Question mark not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ&=" });        // Ampersand not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ*=" });        // Asterisk not allowed
- *
- * // Padding in wrong position
- * validator.parse({ encodedData: "SGVsbG=gV29ybGQ=" });         // Padding in middle
- * validator.parse({ encodedData: "=GVsbG8gV29ybGQ=" });         // Padding at start
- * validator.parse({ encodedData: "SGVsbG8=V29ybGQ=" });         // Padding before end
- *
- * // URL-safe base64 invalid examples
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ+" });        // + not allowed in URL-safe
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ/" });        // / not allowed in URL-safe
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ-" });         // - not allowed in standard
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ_" });         // _ not allowed in standard
- *
- * // Edge cases
- * validator.parse({ encodedData: " SGVsbG8gV29ybGQ=" });        // Leading space
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ= " });        // Trailing space
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=\n" });       // Trailing newline
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=\r\n" });     // CRLF at end
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string; urlSafe?: boolean } - Optional configuration
- * @returns Validation function that checks base64 encoding
- * @customError
- * ```typescript
- * .base64({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be valid base64 encoded string (received: ${value.substring(0, 20)}...)`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringBase64Plugin: import("../..").TypedPlugin<"stringBase64", "base64", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-    urlSafe?: boolean;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    messageFactory: (context: MessageContext) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-        urlSafe?: boolean;
-    }[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringContentEncoding.d.ts

@@ -1,43 +0,0 @@
-/**
- * @luq-plugin
- * @name stringContentEncoding
- * @category string
- * @description Validates string content encoding (base64, base32, binary, etc.)
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringContentEncodingPlugin)
- *   .for<{ data: string }>()
- *   .v("data", (b) => b.string.contentEncoding("base64"))
- *   .build();
- *
- * // Valid for base64: SGVsbG8gV29ybGQ=
- * // Valid for base32: JBSWY3DPEBLW64TMMQ======
- * // Valid for binary: 01001000 01100101
- * ```
- * @params
- * - encoding: "base64" | "base32" | "binary" | "7bit" | "8bit" | "quoted-printable"
- * - options?: { messageFactory?: (context: MessageContext) => string }
- * @returns Validation function that checks content encoding
- * @customError
- * ```typescript
- * .contentEncoding("base64", {
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be valid base64 encoded content (received: ${value.substring(0, 20)}...)`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringContentEncodingPlugin: import("../..").TypedPlugin<"stringContentEncoding", "contentEncoding", (encoding: "base64" | "base32" | "binary" | "7bit" | "8bit" | "quoted-printable" | string, options?: {
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    messageFactory: (context: MessageContext) => string;
-    params: (string | {
-        messageFactory?: (context: MessageContext) => string;
-    })[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringContentMediaType.d.ts

@@ -1,47 +0,0 @@
-/**
- * @luq-plugin
- * @name stringContentMediaType
- * @category string
- * @description Validates that a string's decoded content matches the specified media type
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringContentMediaTypePlugin)
- *   .for<{ data: string }>()
- *   .v("data", (b) => b.string.contentMediaType("application/json"))
- *   .build();
- *
- * // Valid: base64-encoded JSON
- * validator.validate({ data: "eyJrZXkiOiJ2YWx1ZSJ9" }); // {"key":"value"}
- *
- * // Invalid: not valid JSON when decoded
- * validator.validate({ data: "aGVsbG8gd29ybGQ=" }); // "hello world"
- * ```
- * @params
- * - mediaType: string - The expected media type
- * - options?: { encoding?: string; messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that checks content media type
- * @customError
- * ```typescript
- * .contentMediaType("application/json", {
- *   messageFactory: ({ path, value }) =>
- *     `${path} must contain valid JSON content (received: ${value.substring(0, 20)}...)`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringContentMediaTypePlugin: import("../..").TypedPlugin<"stringContentMediaType", "contentMediaType", (mediaType: string, options?: {
-    encoding?: string;
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    messageFactory: (context: MessageContext) => string;
-    params: (string | {
-        encoding?: string;
-        messageFactory?: (context: MessageContext) => string;
-    })[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringDate.d.ts

@@ -1,48 +0,0 @@
-/**
- * @luq-plugin
- * @name stringDate
- * @category string
- * @description Validates ISO 8601 date format (YYYY-MM-DD)
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringDatePlugin)
- *   .for<{ birthDate: string }>()
- *   .v("birthDate", (b) => b.string.date())
- *   .build();
- *
- * // Valid formats:
- * // 2024-01-15
- * // 2024-12-31
- * // 2000-02-29 (leap year)
- *
- * // Invalid:
- * // 2024-13-01 (invalid month)
- * // 2024-02-30 (invalid day)
- * // 2024-1-1 (must be zero-padded)
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that checks ISO 8601 date format
- * @customError
- * ```typescript
- * .date({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be a valid ISO 8601 date format (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringDatePlugin: import("../..").TypedPlugin<"stringDate", "date", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    messageFactory: (context: MessageContext) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-    }[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringDatetime.d.ts

@@ -1,108 +0,0 @@
-import type { MessageContext } from "./types";
-/**
- * @luq-plugin
- * @name stringDatetime
- * @category string
- * @description Validates ISO 8601 datetime format with optional timezone support
- * @allowedTypes ["string"]
- * @see https://tools.ietf.org/html/rfc3339 - RFC 3339: Date and Time on the Internet: Timestamps
- * @see https://en.wikipedia.org/wiki/ISO_8601 - ISO 8601 Date and Time Format
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date - MDN Date Object
- * @example
- * ```typescript
- * // Basic usage - validates ISO 8601 datetime format (RFC 3339 compliant)
- * const validator = Builder()
- *   .use(stringDatetimePlugin)
- *   .for<{ timestamp: string }>()
- *   .v("timestamp", (b) => b.string.datetime())
- *   .build();
- *
- * // Strict mode - requires timezone
- * const strictValidator = Builder()
- *   .use(stringDatetimePlugin)
- *   .for<{ timestamp: string }>()
- *   .v("timestamp", (b) => b.string.datetime({ strict: true }))
- *   .build();
- *
- * // ✅ VALID datetime formats (RFC 3339 / ISO 8601)
- * // UTC timezone
- * validator.parse({ timestamp: "2024-01-15T10:30:00Z" });           // UTC with Z
- * validator.parse({ timestamp: "2024-12-31T23:59:59Z" });           // End of year
- * validator.parse({ timestamp: "2000-01-01T00:00:00Z" });           // Y2K date
- *
- * // With timezone offsets
- * validator.parse({ timestamp: "2024-01-15T10:30:00+09:00" });      // Japan timezone
- * validator.parse({ timestamp: "2024-01-15T10:30:00-05:00" });      // EST timezone
- * validator.parse({ timestamp: "2024-01-15T10:30:00+00:00" });      // UTC with offset
- * validator.parse({ timestamp: "2024-01-15T10:30:00-12:00" });      // Far west timezone
- * validator.parse({ timestamp: "2024-01-15T10:30:00+14:00" });      // Far east timezone
- *
- * // With milliseconds
- * validator.parse({ timestamp: "2024-01-15T10:30:00.123Z" });       // 3-digit milliseconds
- * validator.parse({ timestamp: "2024-01-15T10:30:00.1Z" });         // 1-digit milliseconds
- * validator.parse({ timestamp: "2024-01-15T10:30:00.12Z" });        // 2-digit milliseconds
- * validator.parse({ timestamp: "2024-01-15T10:30:00.999+09:00" });  // Max milliseconds with offset
- *
- * // Leap year dates
- * validator.parse({ timestamp: "2024-02-29T12:00:00Z" });           // Valid leap day 2024
- * validator.parse({ timestamp: "2000-02-29T12:00:00Z" });           // Valid leap day 2000
- *
- * // Edge cases
- * validator.parse({ timestamp: "2024-01-01T00:00:00Z" });           // Start of year
- * validator.parse({ timestamp: "2024-12-31T23:59:59.999Z" });       // End of year with ms
- * validator.parse({ timestamp: "1970-01-01T00:00:00Z" });           // Unix epoch
- * validator.parse({ timestamp: "9999-12-31T23:59:59Z" });           // Far future
- *
- * // Without timezone (lenient mode only)
- * validator.parse({ timestamp: "2024-01-15T10:30:00" });            // Local time (strict: false)
- * validator.parse({ timestamp: "2024-01-15T10:30:00.123" });        // Local time with ms
- *
- * // ❌ INVALID datetime formats
- * validator.parse({ timestamp: "invalid-datetime" });               // Plain text
- * validator.parse({ timestamp: "2024-13-15T10:30:00Z" });           // Invalid month (13)
- * validator.parse({ timestamp: "2024-00-15T10:30:00Z" });           // Invalid month (0)
- * validator.parse({ timestamp: "2024-01-32T10:30:00Z" });           // Invalid day (32)
- * validator.parse({ timestamp: "2024-01-00T10:30:00Z" });           // Invalid day (0)
- * validator.parse({ timestamp: "2024-01-15T25:30:00Z" });           // Invalid hour (25)
- * validator.parse({ timestamp: "2024-01-15T10:60:00Z" });           // Invalid minute (60)
- * validator.parse({ timestamp: "2024-01-15T10:30:61Z" });           // Invalid second (61)
- * validator.parse({ timestamp: "2024-02-30T10:30:00Z" });           // Invalid day for February
- * validator.parse({ timestamp: "2023-02-29T10:30:00Z" });           // Not a leap year
- * validator.parse({ timestamp: "2024-04-31T10:30:00Z" });           // Invalid day for April
- * validator.parse({ timestamp: "2024-01-15 10:30:00Z" });           // Space instead of T
- * validator.parse({ timestamp: "2024/01/15T10:30:00Z" });           // Wrong date separator
- * validator.parse({ timestamp: "24-01-15T10:30:00Z" });             // 2-digit year
- * validator.parse({ timestamp: "2024-1-15T10:30:00Z" });            // Single-digit month
- * validator.parse({ timestamp: "2024-01-5T10:30:00Z" });            // Single-digit day
- * validator.parse({ timestamp: "2024-01-15T10:30:00" });            // Missing timezone (strict: true)
- * validator.parse({ timestamp: "2024-01-15T10:30:00+25:00" });      // Invalid timezone offset
- * validator.parse({ timestamp: "2024-01-15T10:30:00.1234Z" });      // Too many milliseconds digits
- * validator.parse({ timestamp: "" });                              // Empty string
- * validator.parse({ timestamp: "2024-01-15T10:30:00Z " });          // Trailing space
- * validator.parse({ timestamp: " 2024-01-15T10:30:00Z" });          // Leading space
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string; strict?: boolean } - Optional configuration
- * @returns Validation function that checks ISO 8601 datetime format
- * @customError
- * ```typescript
- * .datetime({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be a valid ISO 8601 datetime (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringDatetimePlugin: import("../..").TypedPlugin<"stringDatetime", "datetime", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-    strict?: boolean;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    messageFactory: (context: MessageContext) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-        strict?: boolean;
-    }[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringDuration.d.ts

@@ -1,41 +0,0 @@
-/**
- * @luq-plugin
- * @name stringDuration
- * @category string
- * @description Validates ISO 8601 duration format
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * const validator = Builder()
- *   .use(stringDurationPlugin)
- *   .for<{ duration: string }>()
- *   .v("duration", (b) => b.string.duration())
- *   .build();
- *
- * // Valid: P3Y6M4DT12H30M5S (3 years, 6 months, 4 days, 12 hours, 30 minutes, 5 seconds)
- * // Valid: PT1H30M (1 hour, 30 minutes)
- * // Valid: P7D (7 days)
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
- * @returns Validation function that checks ISO 8601 duration format
- * @customError
- * ```typescript
- * .duration({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be valid ISO 8601 duration format, received: ${value}`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "./types";
-export declare const stringDurationPlugin: import("../..").TypedPlugin<"stringDuration", "duration", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-    }[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringEmail.d.ts

@@ -1,81 +0,0 @@
-import { ValidationOptions } from "./types";
-interface EmailValidationOptions extends ValidationOptions {
-    allowedDomains?: string[];
-    customRegex?: RegExp;
-}
-/**
- * @luq-plugin
- * @name stringEmail
- * @category standard
- * @description Simple and fast email validation with domain restriction and custom regex support (RFC 5322 compliant)
- * @allowedTypes ["string"]
- * @see https://tools.ietf.org/html/rfc5322 - RFC 5322: Internet Message Format
- * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email - MDN Email Input Validation
- * @example
- * ```typescript
- * // Basic usage - validates email format (RFC 5322 compliant)
- * const validator = Builder()
- *   .use(stringEmailPlugin)
- *   .for<UserProfile>()
- *   .v("email", (b) => b.string.email())
- *   .v("contactEmail", (b) => b.string.required().email())
- *   .build();
- *
- * // Domain restriction (practical: corporate email only)
- * builder.v("workEmail", b => b.string.required().email({
- *   allowedDomains: ["company.com", "subsidiary.co.jp"]
- * }))
- *
- * // Custom regex for specific format requirements
- * builder.v("strictEmail", b => b.string.email({
- *   customRegex: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
- * }))
- *
- * // For length limits, use existing string plugins:
- * builder.v("email", b => b.string.required().max(100).email())
- *
- * // ✅ VALID email formats (RFC 5322)
- * validator.parse({ email: "user@example.com" });              // Standard format
- * validator.parse({ email: "test.email+tag@domain.co.uk" });   // With plus and dots
- * validator.parse({ email: "user123@test-server.com" });       // Numbers and hyphens
- * validator.parse({ email: "firstname.lastname@example.org" }); // Multiple dots
- * validator.parse({ email: "user+filter@gmail.com" });         // Plus addressing
- * validator.parse({ email: "a@b.co" });                        // Minimal valid
- * validator.parse({ email: "test_email@domain-name.com" });     // Underscores and hyphens
- *
- * // ❌ INVALID email formats
- * validator.parse({ email: "plainaddress" });          // No @ symbol
- * validator.parse({ email: "@missingdomain.com" });    // Missing local part
- * validator.parse({ email: "missing.domain@" });       // Missing domain
- * validator.parse({ email: "spaces @domain.com" });    // Spaces not allowed
- * validator.parse({ email: "user@.com" });             // Invalid domain start
- * validator.parse({ email: "user@domain" });           // Missing TLD
- * validator.parse({ email: "user@@domain.com" });      // Double @ symbol
- * validator.parse({ email: "user@domain..com" });      // Double dots in domain
- * validator.parse({ email: ".user@domain.com" });      // Leading dot
- * validator.parse({ email: "user.@domain.com" });      // Trailing dot
- * ```
- * @params
- * - options?: EmailValidationOptions - Simple email validation configuration
- *   - allowedDomains?: string[] - Only allow emails from these domains (practical for corporate restrictions)
- *   - customRegex?: RegExp - Custom regex to override basic validation (practical escape hatch)
- *   - messageFactory?: (context: MessageContext) => string - Custom error message factory
- * @returns Validation function optimized for performance - regex validation with optional domain filtering or custom regex
- * @customError
- * ```typescript
- * .email({
- *   allowedDomains: ["company.com"],
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be a company email address (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringEmailPlugin: import("../..").TypedPlugin<"stringEmail", "email", (options?: EmailValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: EmailValidationOptions[];
-    validationOptions: EmailValidationOptions;
-}, readonly ["string"], "validator", "standard">;
-export {};

package/dist/core/plugin/stringEndsWith.d.ts

@@ -1,42 +0,0 @@
-import { ValidationOptions } from "./types";
-/**
- * @luq-plugin
- * @name stringEndsWith
- * @category standard
- * @description Validates that a string ends with a specific suffix
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - checks if string ends with suffix
- * const validator = Builder()
- *   .use(stringEndsWithPlugin)
- *   .for<FileData>()
- *   .v("filename", (b) => b.string.endsWith(".pdf"))
- *   .v("configFile", (b) => b.string.required().endsWith(".json"))
- *   .build();
- *
- * // For file extension validation
- * builder.v("document", b => b.string.endsWith(".pdf").min(5))
- *
- * // Email domain validation
- * builder.v("email", b => b.string.email().endsWith("@company.com"))
- * ```
- * @params
- * - suffix: string - The suffix that the string must end with
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string ends with the suffix
- * @customError
- * ```typescript
- * .endsWith(".json", {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must end with '${params.suffix}' (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringEndsWithPlugin: import("../..").TypedPlugin<"stringEndsWith", "endsWith", (suffix: string, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | ValidationOptions<{}>)[];
-}, readonly ["string"], "validator", "standard">;

package/dist/core/plugin/stringExactLength.d.ts

@@ -1,46 +0,0 @@
-import { ValidationOptions, MessageContext } from "./types";
-export interface StringExactLengthContext extends MessageContext {
-    expected: number;
-    actual: number;
-}
-/**
- * @luq-plugin
- * @name stringExactLength
- * @category standard
- * @description Validates that a string has exactly the specified length
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - requires exact string length
- * const validator = Builder()
- *   .use(stringExactLengthPlugin)
- *   .for<FormData>()
- *   .v("zipCode", (b) => b.string.exactLength(5))
- *   .v("countryCode", (b) => b.string.required().exactLength(2))
- *   .build();
- *
- * // For product codes or SKUs
- * builder.v("productCode", b => b.string.exactLength(8).alphanumeric())
- *
- * // For fixed-format phone extensions
- * builder.v("extension", b => b.string.optional().exactLength(4))
- * ```
- * @params
- * - expectedLength: number - The exact length the string must have
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string has exact length
- * @customError
- * ```typescript
- * .exactLength(4, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must be exactly ${params.expected} characters (received: ${params.actual})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringExactLengthPlugin: import("../..").TypedPlugin<"stringExactLength", "exactLength", (expectedLength: number, options?: ValidationOptions<StringExactLengthContext>) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (number | ValidationOptions<StringExactLengthContext>)[];
-}, readonly ["string"], "validator", "standard">;