@maroonedog/luq 0.1.2-alpha → 2.0.0

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

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

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

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

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

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

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

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