@maroonedog/luq 0.1.0-alpha

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,119 @@
+/**
+ * @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

@@ -0,0 +1,43 @@
+/**
+ * @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

@@ -0,0 +1,47 @@
+/**
+ * @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

@@ -0,0 +1,48 @@
+/**
+ * @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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,41 @@
+/**
+ * @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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,46 @@
+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">;