@maroonedog/luq 0.1.0-alpha

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

@@ -0,0 +1,104 @@
+/**
+ * @luq-plugin
+ * @name stringHostname
+ * @category string
+ * @description Validates hostname format (RFC 1123)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc1123 - RFC 1123: Requirements for Internet Hosts - Application and Support
+ * @see https://tools.ietf.org/html/rfc952 - RFC 952: DoD Internet Host Table Specification
+ * @see https://en.wikipedia.org/wiki/Hostname - Hostname Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates hostname format (RFC 1123 compliant)
+ * const validator = Builder()
+ *   .use(stringHostnamePlugin)
+ *   .for<{ hostname: string }>()
+ *   .v("hostname", (b) => b.string.hostname())
+ *   .build();
+ *
+ * // ✅ VALID hostnames (RFC 1123)
+ * validator.parse({ hostname: "example.com" });                 // Standard domain
+ * validator.parse({ hostname: "www.example.com" });             // Subdomain
+ * validator.parse({ hostname: "mail-server.company.org" });     // With hyphens
+ * validator.parse({ hostname: "a.b.c" });                      // Short labels
+ * validator.parse({ hostname: "host123.domain.co.uk" });        // With numbers
+ * validator.parse({ hostname: "localhost" });                  // Single label
+ * validator.parse({ hostname: "api-v2.service.internal" });     // Multiple hyphens
+ * validator.parse({ hostname: "test" });                       // Single word
+ * validator.parse({ hostname: "1a.2b.3c" });                   // Starting with numbers
+ * validator.parse({ hostname: "x" });                          // Single character
+ * validator.parse({ hostname: "sub.domain.example.com" });      // Multiple levels
+ * validator.parse({ hostname: "ftp.files.company-name.org" });  // Complex structure
+ * validator.parse({ hostname: "db1.cluster.production" });      // Database naming
+ * validator.parse({ hostname: "web01.dmz.corp" });             // Network zones
+ * validator.parse({ hostname: "backup-server.it.department" }); // Organizational
+ *
+ * // Edge cases
+ * validator.parse({ hostname: "a".repeat(63) });               // Max label length (63 chars)
+ * validator.parse({ hostname: "a".repeat(63) + "." + "b".repeat(63) }); // Multiple max labels
+ * validator.parse({ hostname: "0" });                          // Single digit
+ * validator.parse({ hostname: "9a" });                         // Number followed by letter
+ *
+ * // ❌ INVALID hostnames
+ * validator.parse({ hostname: "-example.com" });               // Starting with hyphen
+ * validator.parse({ hostname: "example-.com" });               // Label ending with hyphen
+ * validator.parse({ hostname: "example.com-" });               // Hostname ending with hyphen
+ * validator.parse({ hostname: ".example.com" });               // Starting with dot
+ * validator.parse({ hostname: "example..com" });               // Double dot (empty label)
+ * validator.parse({ hostname: "example.com." });               // Trailing dot
+ * validator.parse({ hostname: "" });                          // Empty string
+ * validator.parse({ hostname: "example .com" });               // Space in hostname
+ * validator.parse({ hostname: "example_com" });                // Underscore not allowed
+ * validator.parse({ hostname: "EXAMPLE.COM" });                // All caps (valid but not recommended)
+ * validator.parse({ hostname: "example.com/path" });           // With path
+ * validator.parse({ hostname: "example.com:8080" });           // With port
+ * validator.parse({ hostname: "user@example.com" });           // With user
+ * validator.parse({ hostname: "http://example.com" });         // Full URL
+ * validator.parse({ hostname: "192.168.1.1" });               // IP address (not hostname)
+ * validator.parse({ hostname: "[::1]" });                     // IPv6 address
+ *
+ * // Label too long (> 63 characters)
+ * validator.parse({ hostname: "a".repeat(64) + ".com" });      // Single label > 63 chars
+ *
+ * // Hostname too long (> 253 characters total)
+ * const longLabel = "a".repeat(50);
+ * const longHostname = Array(10).fill(longLabel).join(".") + ".com"; // > 253 chars total
+ * validator.parse({ hostname: longHostname });
+ *
+ * // Special characters not allowed
+ * validator.parse({ hostname: "exam@ple.com" });               // @ symbol
+ * validator.parse({ hostname: "exam#ple.com" });               // # symbol
+ * validator.parse({ hostname: "exam$ple.com" });               // $ symbol
+ * validator.parse({ hostname: "exam%ple.com" });               // % symbol
+ * validator.parse({ hostname: "exam&ple.com" });               // & symbol
+ * validator.parse({ hostname: "example.com!" });               // Exclamation mark
+ * validator.parse({ hostname: "example.com?" });               // Question mark
+ *
+ * // Unicode/international domain names (IDN not supported in basic hostname)
+ * validator.parse({ hostname: "ドメイン.com" });                // Japanese characters
+ * validator.parse({ hostname: "münchen.de" });                // German umlaut
+ * validator.parse({ hostname: "café.fr" });                   // French accent
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks hostname format
+ * @customError
+ * ```typescript
+ * .hostname({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid hostname format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringHostnamePlugin: import("../..").TypedPlugin<"stringHostname", "hostname", (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/stringIpv4.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @luq-plugin
+ * @name stringIpv4
+ * @category string
+ * @description Validates IPv4 address format
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc791 - RFC 791: Internet Protocol - DARPA Internet Program Protocol Specification
+ * @see https://en.wikipedia.org/wiki/IPv4 - IPv4 Address Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates IPv4 address format (RFC 791 compliant)
+ * const validator = Builder()
+ *   .use(stringIpv4Plugin)
+ *   .for<{ ipAddress: string }>()
+ *   .v("ipAddress", (b) => b.string.ipv4())
+ *   .build();
+ *
+ * // ✅ VALID IPv4 addresses (RFC 791)
+ * validator.parse({ ipAddress: "192.168.1.1" });        // Private network (Class C)
+ * validator.parse({ ipAddress: "127.0.0.1" });          // Localhost/loopback
+ * validator.parse({ ipAddress: "8.8.8.8" });            // Google DNS
+ * validator.parse({ ipAddress: "0.0.0.0" });            // All zeros (any address)
+ * validator.parse({ ipAddress: "255.255.255.255" });    // Broadcast address
+ * validator.parse({ ipAddress: "10.0.0.1" });           // Private network (Class A)
+ * validator.parse({ ipAddress: "172.16.0.1" });         // Private network (Class B)
+ * validator.parse({ ipAddress: "203.0.113.1" });        // Documentation/test network
+ * validator.parse({ ipAddress: "1.1.1.1" });            // Cloudflare DNS
+ * validator.parse({ ipAddress: "192.0.2.146" });        // Documentation network
+ * validator.parse({ ipAddress: "198.51.100.1" });       // Documentation network
+ * validator.parse({ ipAddress: "169.254.1.1" });        // Link-local address
+ * validator.parse({ ipAddress: "224.0.0.1" });          // Multicast address
+ * validator.parse({ ipAddress: "239.255.255.255" });    // Local multicast
+ * validator.parse({ ipAddress: "1.2.3.4" });            // Simple valid address
+ * validator.parse({ ipAddress: "100.64.0.1" });         // Carrier-grade NAT
+ *
+ * // ❌ INVALID IPv4 addresses
+ * validator.parse({ ipAddress: "256.1.1.1" });          // Octet > 255
+ * validator.parse({ ipAddress: "192.168.1.256" });      // Last octet > 255
+ * validator.parse({ ipAddress: "300.300.300.300" });    // All octets > 255
+ * validator.parse({ ipAddress: "192.168.1" });          // Missing octet
+ * validator.parse({ ipAddress: "192.168" });            // Only 2 octets
+ * validator.parse({ ipAddress: "192" });                // Only 1 octet
+ * validator.parse({ ipAddress: "192.168.1.1.1" });      // Extra octet (5 octets)
+ * validator.parse({ ipAddress: "192.168.01.1" });       // Leading zeros (octal notation)
+ * validator.parse({ ipAddress: "192.168.001.1" });      // Multiple leading zeros
+ * validator.parse({ ipAddress: "192.168.-1.1" });       // Negative number
+ * validator.parse({ ipAddress: "192.168.1.-1" });       // Negative last octet
+ * validator.parse({ ipAddress: "not.an.ip.address" });  // Non-numeric text
+ * validator.parse({ ipAddress: "192.168.1.1/24" });     // CIDR notation
+ * validator.parse({ ipAddress: "192.168.1.1:8080" });   // With port number
+ * validator.parse({ ipAddress: "192.168.1." });         // Trailing dot
+ * validator.parse({ ipAddress: ".192.168.1.1" });       // Leading dot
+ * validator.parse({ ipAddress: "192..168.1.1" });       // Double dot
+ * validator.parse({ ipAddress: "192 168 1 1" });        // Spaces instead of dots
+ * validator.parse({ ipAddress: "192,168,1,1" });        // Commas instead of dots
+ * validator.parse({ ipAddress: "192-168-1-1" });        // Hyphens instead of dots
+ * validator.parse({ ipAddress: "" });                   // Empty string
+ * validator.parse({ ipAddress: "192.168.1.1 " });       // Trailing space
+ * validator.parse({ ipAddress: " 192.168.1.1" });       // Leading space
+ * validator.parse({ ipAddress: "192.168.a.1" });        // Letter in octet
+ * validator.parse({ ipAddress: "192.168.1.1." });       // Trailing dot after last octet
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IPv4 format
+ * @customError
+ * ```typescript
+ * .ipv4({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IPv4 format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringIpv4Plugin: import("../..").TypedPlugin<"stringIpv4", "ipv4", (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/stringIpv6.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @luq-plugin
+ * @name stringIpv6
+ * @category string
+ * @description Validates IPv6 address format
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc4291 - RFC 4291: IP Version 6 Addressing Architecture
+ * @see https://en.wikipedia.org/wiki/IPv6 - IPv6 Address Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates IPv6 address format (RFC 4291 compliant)
+ * const validator = Builder()
+ *   .use(stringIpv6Plugin)
+ *   .for<{ ipv6Address: string }>()
+ *   .v("ipv6Address", (b) => b.string.ipv6())
+ *   .build();
+ *
+ * // ✅ VALID IPv6 addresses (RFC 4291)
+ * // Full format (128-bit address)
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334" });
+ * validator.parse({ ipv6Address: "2001:0DB8:85A3:0000:0000:8A2E:0370:7334" }); // Case insensitive
+ *
+ * // Leading zeros omitted
+ * validator.parse({ ipv6Address: "2001:db8:85a3:0:0:8a2e:370:7334" });
+ * validator.parse({ ipv6Address: "2001:db8:85a3:1:1:8a2e:370:7334" });
+ *
+ * // Compressed format with :: (consecutive zeros)
+ * validator.parse({ ipv6Address: "2001:db8:85a3::8a2e:370:7334" });
+ * validator.parse({ ipv6Address: "2001:db8::1" });
+ * validator.parse({ ipv6Address: "2001:db8::" });
+ * validator.parse({ ipv6Address: "::2001:db8:85a3:0:0:8a2e:370:7334" });
+ * validator.parse({ ipv6Address: "2001:db8:85a3:0:0:8a2e::" });
+ *
+ * // Special addresses
+ * validator.parse({ ipv6Address: "::1" });                    // IPv6 loopback
+ * validator.parse({ ipv6Address: "::" });                     // All zeros (unspecified)
+ * validator.parse({ ipv6Address: "::ffff:0:0" });             // IPv4-mapped prefix
+ * validator.parse({ ipv6Address: "::ffff:192.0.2.1" });       // IPv4-mapped IPv6
+ * validator.parse({ ipv6Address: "::ffff:c000:0201" });       // IPv4-mapped (hex format)
+ * validator.parse({ ipv6Address: "2001:db8::192.0.2.1" });    // IPv4 suffix notation
+ *
+ * // Link-local addresses
+ * validator.parse({ ipv6Address: "fe80::1" });                // Link-local
+ * validator.parse({ ipv6Address: "fe80::1%lo0" });            // With zone identifier
+ * validator.parse({ ipv6Address: "fe80::1%eth0" });           // With interface name
+ * validator.parse({ ipv6Address: "fe80::200:f8ff:fe21:67cf%en0" }); // Full link-local with zone
+ *
+ * // Multicast addresses
+ * validator.parse({ ipv6Address: "ff02::1" });                // All nodes multicast
+ * validator.parse({ ipv6Address: "ff02::2" });                // All routers multicast
+ *
+ * // Documentation addresses
+ * validator.parse({ ipv6Address: "2001:db8::1" });            // Documentation prefix
+ * validator.parse({ ipv6Address: "2001:db8:85a3::8a2e:370:7334" }); // RFC 3849 example
+ *
+ * // Edge cases
+ * validator.parse({ ipv6Address: "1:2:3:4:5:6:7:8" });        // All single digits
+ * validator.parse({ ipv6Address: "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" }); // All ones
+ *
+ * // ❌ INVALID IPv6 addresses
+ * validator.parse({ ipv6Address: "2001:0db8:85a3::8a2e::7334" });        // Double :: (not allowed)
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334:extra" }); // Too many groups
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370" }); // Too few groups without ::
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:733g" }); // Invalid hex char (g)
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:73345" }); // Group too long (5 chars)
+ * validator.parse({ ipv6Address: "2001::db8::85a3" });                   // Multiple :: not allowed
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:" }); // Trailing colon
+ * validator.parse({ ipv6Address: ":2001:0db8:85a3:0000:0000:8a2e:0370:7334" }); // Leading colon (not ::)
+ * validator.parse({ ipv6Address: "2001-0db8-85a3-0000-0000-8a2e-0370-7334" }); // Hyphens instead of colons
+ * validator.parse({ ipv6Address: "2001.0db8.85a3.0000.0000.8a2e.0370.7334" }); // Dots instead of colons
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334/64" }); // With CIDR notation
+ * validator.parse({ ipv6Address: "gggg::1" });                           // Invalid hex chars
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:::8a2e:0370:7334" });   // Triple colon
+ * validator.parse({ ipv6Address: "" });                                  // Empty string
+ * validator.parse({ ipv6Address: "not:an:ipv6:address" });               // Non-hex text
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334 " }); // Trailing space
+ * validator.parse({ ipv6Address: " 2001:0db8:85a3:0000:0000:8a2e:0370:7334" }); // Leading space
+ * validator.parse({ ipv6Address: "::ffff:256.1.1.1" });                 // Invalid IPv4 in mapping
+ * validator.parse({ ipv6Address: "::ffff:192.168.1" });                 // Incomplete IPv4 in mapping
+ * validator.parse({ ipv6Address: "192.168.1.1" });                      // Plain IPv4 address
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IPv6 format
+ * @customError
+ * ```typescript
+ * .ipv6({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IPv6 format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringIpv6Plugin: import("../..").TypedPlugin<"stringIpv6", "ipv6", (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/stringIri.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @luq-plugin
+ * @name stringIri
+ * @category string
+ * @description Validates IRI (Internationalized Resource Identifier) format (RFC 3987)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc3987 - RFC 3987: Internationalized Resource Identifiers (IRIs)
+ * @see https://en.wikipedia.org/wiki/Internationalized_Resource_Identifier - IRI Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates IRI format (RFC 3987 compliant)
+ * const validator = Builder()
+ *   .use(stringIriPlugin)
+ *   .for<{ identifier: string }>()
+ *   .v("identifier", (b) => b.string.iri())
+ *   .build();
+ *
+ * // ✅ VALID IRI formats (RFC 3987)
+ * // Standard ASCII URIs (subset of IRI)
+ * validator.parse({ identifier: "https://www.example.com/path" });    // Regular HTTP URL
+ * validator.parse({ identifier: "http://example.org:8080/api/v1" }); // With port and path
+ * validator.parse({ identifier: "ftp://files.example.com/file.txt" }); // FTP scheme
+ * validator.parse({ identifier: "mailto:user@example.com" });         // Email scheme
+ * validator.parse({ identifier: "tel:+1-555-123-4567" });            // Telephone scheme
+ *
+ * // Internationalized domain names and paths (Unicode)
+ * validator.parse({ identifier: "https://例え.jp/パス" });              // Japanese characters
+ * validator.parse({ identifier: "http://münchen.de/straße" });       // German umlauts
+ * validator.parse({ identifier: "https://café.fr/menu" });           // French accents
+ * validator.parse({ identifier: "http://домен.рф/путь" });           // Cyrillic script
+ * validator.parse({ identifier: "https://测试.cn/路径" });             // Chinese characters
+ * validator.parse({ identifier: "http://테스트.kr/경로" });             // Korean characters
+ * validator.parse({ identifier: "https://тест.bg/път" });            // Bulgarian Cyrillic
+ * validator.parse({ identifier: "http://δοκιμή.gr/διαδρομή" });      // Greek characters
+ * validator.parse({ identifier: "https://परीक्षा.in/पथ" });           // Hindi/Devanagari
+ * validator.parse({ identifier: "http://اختبار.sa/مسار" });           // Arabic script
+ *
+ * // Internationalized email addresses
+ * validator.parse({ identifier: "mailto:ユーザー@例え.jp" });          // Japanese email
+ * validator.parse({ identifier: "mailto:utilisateur@café.fr" });     // French domain
+ * validator.parse({ identifier: "mailto:пользователь@домен.рф" });    // Cyrillic email
+ *
+ * // Mixed ASCII and Unicode
+ * validator.parse({ identifier: "https://api.例え.jp/v1/users" });    // Mixed path
+ * validator.parse({ identifier: "https://例え.example.com/path" });   // Mixed domain
+ * validator.parse({ identifier: "ftp://files.café.com/données.txt" }); // Mixed filename
+ *
+ * // Various schemes with Unicode
+ * validator.parse({ identifier: "ldap://服务器.com/cn=用户,dc=例子,dc=com" }); // LDAP with Chinese
+ * validator.parse({ identifier: "news://nieuws.nl/groep.测试" });     // News with mixed Unicode
+ * validator.parse({ identifier: "urn:isbn:978-3-86680-192-9" });     // URN (ASCII)
+ *
+ * // Edge cases
+ * validator.parse({ identifier: "custom-scheme://测试.example/路径" }); // Custom scheme with Unicode
+ * validator.parse({ identifier: "x-proprietary://例え.internal" });   // Non-standard scheme
+ * validator.parse({ identifier: "data:text/plain;charset=utf-8,你好" }); // Data URI with Unicode
+ *
+ * // ❌ INVALID IRI formats
+ * validator.parse({ identifier: "not-an-iri" });                     // No scheme separator
+ * validator.parse({ identifier: "://missing-scheme.com" });          // Missing scheme
+ * validator.parse({ identifier: "http://" });                        // Missing authority
+ * validator.parse({ identifier: "https:/" });                        // Malformed scheme separator
+ * validator.parse({ identifier: "" });                              // Empty string
+ * validator.parse({ identifier: "http://exam ple.com" });            // Space in authority
+ * validator.parse({ identifier: "https://example.com/path with spaces" }); // Spaces in path
+ * validator.parse({ identifier: "http://example.com/path\twith\ttabs" }); // Tab characters
+ * validator.parse({ identifier: "https://example.com/path\nwith\nnewlines" }); // Newline characters
+ * validator.parse({ identifier: "http://example.com/path\rwith\rcarriage" }); // Carriage returns
+ * validator.parse({ identifier: "ftp://example.com\x00null" });      // Null character (control char)
+ * validator.parse({ identifier: "https://example.com\x01control" }); // Control character
+ * validator.parse({ identifier: "http://example.com\x7Fdel" });      // DEL character
+ *
+ * // Malformed schemes
+ * validator.parse({ identifier: "123://invalid-scheme.com" });       // Scheme starting with number
+ * validator.parse({ identifier: "-http://invalid-scheme.com" });     // Scheme starting with hyphen
+ * validator.parse({ identifier: ".http://invalid-scheme.com" });     // Scheme starting with dot
+ * validator.parse({ identifier: "ht@tp://invalid-char.com" });       // Invalid char in scheme
+ * validator.parse({ identifier: "ht tp://space-in-scheme.com" });    // Space in scheme
+ *
+ * // Missing or empty components
+ * validator.parse({ identifier: "http:" });                          // Scheme only
+ * validator.parse({ identifier: ":" });                             // Just separator
+ * validator.parse({ identifier: "http://example.com:" });           // Trailing colon
+ *
+ * // Invalid Unicode sequences (rare but possible)
+ * validator.parse({ identifier: "https://example.com/\uFFFD" });     // Replacement character
+ * validator.parse({ identifier: "http://\uFEFF.example.com" });      // BOM character
+ *
+ * // Leading/trailing whitespace
+ * validator.parse({ identifier: " https://example.com" });          // Leading space
+ * validator.parse({ identifier: "https://example.com " });          // Trailing space
+ * validator.parse({ identifier: "\thttps://example.com" });         // Leading tab
+ * validator.parse({ identifier: "https://example.com\n" });         // Trailing newline
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IRI format
+ * @customError
+ * ```typescript
+ * .iri({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IRI format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringIriPlugin: import("../..").TypedPlugin<"stringIri", "iri", (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/stringIriReference.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @luq-plugin
+ * @name stringIriReference
+ * @category string
+ * @description Validates IRI-reference format (RFC 3987) - can be absolute or relative
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringIriReferencePlugin)
+ *   .for<{ ref: string }>()
+ *   .v("ref", (b) => b.string.iriReference())
+ *   .build();
+ *
+ * // Valid: https://example.com/path
+ * // Valid: /relative/path
+ * // Valid: ../parent
+ * // Valid: #fragment
+ * // Valid: ?query=param
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IRI-reference format
+ * @customError
+ * ```typescript
+ * .iriReference({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IRI-reference format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringIriReferencePlugin: import("../..").TypedPlugin<"stringIriReference", "iriReference", (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/stringJsonPointer.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @luq-plugin
+ * @name stringJsonPointer
+ * @category string
+ * @description Validates JSON Pointer format (RFC 6901)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc6901 - RFC 6901: JavaScript Object Notation (JSON) Pointer
+ * @see https://datatracker.ietf.org/doc/html/rfc6901 - JSON Pointer Specification
+ * @example
+ * ```typescript
+ * // Basic usage - validates JSON Pointer format (RFC 6901 compliant)
+ * const validator = Builder()
+ *   .use(stringJsonPointerPlugin)
+ *   .for<{ pointer: string }>()
+ *   .v("pointer", (b) => b.string.jsonPointer())
+ *   .build();
+ *
+ * // ✅ VALID JSON Pointers (RFC 6901)
+ * validator.parse({ pointer: "" });                    // Empty string (points to root document)
+ * validator.parse({ pointer: "/" });                   // Points to empty property name
+ * validator.parse({ pointer: "/foo" });                // Simple property access
+ * validator.parse({ pointer: "/foo/bar" });            // Nested property access
+ * validator.parse({ pointer: "/foo/0" });              // Array element by index
+ * validator.parse({ pointer: "/foo/0/bar" });          // Property of array element
+ * validator.parse({ pointer: "/users/123/name" });     // Deep nested access
+ * validator.parse({ pointer: "/data/items/0/id" });    // Array element property
+ *
+ * // Escaped characters (RFC 6901 escape sequences)
+ * validator.parse({ pointer: "/~0" });                 // Escaped ~ character (represents "~")
+ * validator.parse({ pointer: "/~1" });                 // Escaped / character (represents "/")
+ * validator.parse({ pointer: "/~0~1" });               // Both escapes (represents "~/")
+ * validator.parse({ pointer: "/foo~1bar" });           // Forward slash escaped in middle
+ * validator.parse({ pointer: "/~0field" });            // Tilde escaped at start of token
+ * validator.parse({ pointer: "/field~0" });            // Tilde escaped at end of token
+ * validator.parse({ pointer: "/foo~0bar~1baz" });      // Multiple escapes in one token
+ *
+ * // Real-world JSON structure examples
+ * // For JSON: { "user": { "settings": { "theme": "dark" } } }
+ * validator.parse({ pointer: "/user" });               // Access user object
+ * validator.parse({ pointer: "/user/settings" });      // Access nested settings
+ * validator.parse({ pointer: "/user/settings/theme" }); // Access theme value
+ *
+ * // For JSON: { "items": [{"name": "Item1"}, {"name": "Item2"}] }
+ * validator.parse({ pointer: "/items" });              // Access items array
+ * validator.parse({ pointer: "/items/0" });            // First item
+ * validator.parse({ pointer: "/items/1" });            // Second item
+ * validator.parse({ pointer: "/items/0/name" });       // Name of first item
+ *
+ * // For JSON with special property names
+ * // { "": "empty name", "a/b": "slash in name", "c~d": "tilde in name" }
+ * validator.parse({ pointer: "/" });                   // Empty property name
+ * validator.parse({ pointer: "/a~1b" });               // Property "a/b" (/ escaped as ~1)
+ * validator.parse({ pointer: "/c~0d" });               // Property "c~d" (~ escaped as ~0)
+ *
+ * // Edge cases
+ * validator.parse({ pointer: "/0" });                  // String "0" as property name
+ * validator.parse({ pointer: "/-1" });                 // String "-1" as property name
+ * validator.parse({ pointer: "/123" });                // Numeric string as property name
+ * validator.parse({ pointer: "/true" });               // Boolean string as property name
+ * validator.parse({ pointer: "/null" });               // Null string as property name
+ *
+ * // ❌ INVALID JSON Pointers
+ * validator.parse({ pointer: "foo" });                 // Missing initial slash
+ * validator.parse({ pointer: "foo/bar" });             // Missing initial slash
+ * validator.parse({ pointer: "/foo/" });               // Trailing slash (points to empty property)
+ * validator.parse({ pointer: "/foo//" });              // Double slash (empty token)
+ * validator.parse({ pointer: "/~" });                  // Incomplete escape sequence
+ * validator.parse({ pointer: "/~2" });                 // Invalid escape sequence (only ~0 and ~1 allowed)
+ * validator.parse({ pointer: "/~3" });                 // Invalid escape sequence
+ * validator.parse({ pointer: "/foo~" });               // Incomplete escape at end
+ * validator.parse({ pointer: "/foo~bar" });            // Tilde without proper escape
+ * validator.parse({ pointer: "/foo~/bar" });           // Incomplete escape in middle
+ * validator.parse({ pointer: "~/foo" });               // Escape at start without leading slash
+ * validator.parse({ pointer: "/foo bar" });            // Space in token (technically valid by RFC but often problematic)
+ * validator.parse({ pointer: "/foo\tbar" });           // Tab character
+ * validator.parse({ pointer: "/foo\nbar" });           // Newline character
+ * validator.parse({ pointer: "/foo\rbar" });           // Carriage return
+ * validator.parse({ pointer: "/foo\"bar" });           // Double quote (valid but can be problematic)
+ * validator.parse({ pointer: "/foo'bar" });            // Single quote (valid but can be problematic)
+ * validator.parse({ pointer: "/foo\\bar" });           // Backslash (valid but can be confusing)
+ * validator.parse({ pointer: " /foo" });               // Leading space
+ * validator.parse({ pointer: "/foo " });               // Trailing space
+ * validator.parse({ pointer: "//foo" });               // Double slash at start
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks JSON Pointer format
+ * @customError
+ * ```typescript
+ * .jsonPointer({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid JSON Pointer format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringJsonPointerPlugin: import("../..").TypedPlugin<"stringJsonPointer", "jsonPointer", (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/stringMax.d.ts

@@ -0,0 +1,43 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface StringMaxContext extends MessageContext {
+    max: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name stringMax
+ * @category standard
+ * @description Validates that a string does not exceed the specified maximum length
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * // Basic usage - set maximum string length
+ * const validator = Builder()
+ *   .use(stringMaxPlugin)
+ *   .for<UserProfile>()
+ *   .v("username", (b) => b.string.max(20))
+ *   .v("bio", (b) => b.string.max(500))
+ *   .build();
+ *
+ * // Combined with min for length range
+ * builder.v("description", b => b.string.min(10).max(200))
+ * ```
+ * @params
+ * - max: number - Maximum character count
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if string length is within the maximum
+ * @customError
+ * ```typescript
+ * .max(100, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must not exceed ${params.max} characters (current: ${value.length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringMaxPlugin: import("../..").TypedPlugin<"stringMax", "max", (maxLength: number, options?: ValidationOptions<StringMaxContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<StringMaxContext>)[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,43 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface StringMinContext extends MessageContext {
+    min: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name stringMin
+ * @category standard
+ * @description Validates that a string has at least the specified minimum length
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * // Basic usage - set minimum string length
+ * const validator = Builder()
+ *   .use(stringMinPlugin)
+ *   .for<UserProfile>()
+ *   .v("password", (b) => b.string.min(8))
+ *   .v("username", (b) => b.string.min(3))
+ *   .build();
+ *
+ * // Combined with other validators
+ * builder.v("bio", b => b.string.required().min(10).max(500))
+ * ```
+ * @params
+ * - min: number - Minimum character count
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if string length is at least the minimum
+ * @customError
+ * ```typescript
+ * .min(8, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be at least ${params.min} characters (current: ${value.length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringMinPlugin: import("../..").TypedPlugin<"stringMin", "min", (minLength: number, options?: ValidationOptions<StringMinContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => any;
+    params: (number | ValidationOptions<StringMinContext>)[];
+}, readonly ["string"], "validator", "standard">;