@maroonedog/luq 0.1.0-alpha

package/dist/plugins/objectMinProperties.mjs

@@ -0,0 +1 @@
+var p=(a,o,s,i)=>{let t=(n=>(...r)=>{let m=n(...r);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:i}:m})(s);switch(a){case"conditional":return(n,...r)=>t(n,...r);case"fieldReference":return(n,...r)=>t(n,...r);case"multiFieldReference":return t;case"transform":return n=>t(n);case"arrayElement":return(n,...r)=>t(n,...r);case"context":return n=>t(n);default:return t}};function l(a){let{name:o,methodName:s,allowedTypes:i,category:e,impl:t}=a;return{name:o,methodName:s,allowedTypes:i,category:e,create:()=>p(e,s,t,o)}}var T="objectMinProperties",u=["object"],y=l({name:"objectMinProperties",methodName:"minProperties",allowedTypes:u,category:"standard",impl:(a,o)=>{let s=o?.code||T,i=o?.messageFactory||(e=>`Must have at least ${e.min} properties, but has ${e.actual}`);if(typeof a!="number"||isNaN(a)||a<0)throw new Error(`Invalid minValue: ${a}. Must be a non-negative number.`);return{check:e=>typeof e!="object"||e===null?!0:Object.keys(e).length>=a,code:s,getErrorMessage:(e,t)=>{let n=typeof e=="object"&&e!==null?Object.keys(e).length:0;return i({path:t,value:e,code:s,min:a,actual:n})},params:[a,o]}}});export{y as objectMinPropertiesPlugin};

package/dist/plugins/objectPatternProperties.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @luq-plugin
+ * @name objectPatternProperties
+ * @category object
+ * @description Validates object properties that match specific patterns with corresponding schemas
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Pattern-based property validation
+ * const validator = Builder()
+ *   .use(objectPatternPropertiesPlugin)
+ *   .for<{ [key: string]: any }>()
+ *   .v("config", (b) => b.object.patternProperties({
+ *     "^str_": (value) => typeof value === "string",
+ *     "^num_": (value) => typeof value === "number"
+ *   }))
+ *   .build();
+ *
+ * // With custom validators and messages
+ * builder.v("data", b => b.object.patternProperties({
+ *   "^email_": {
+ *     validator: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+ *     message: "Email properties must be valid email addresses"
+ *   },
+ *   "^id_": {
+ *     validator: (value) => typeof value === "string" && value.length > 0,
+ *     message: "ID properties must be non-empty strings"
+ *   }
+ * }))
+ * ```
+ * @params
+ * - patterns: Record<string, (value: any) => boolean | PatternValidator> - Pattern to validator mapping
+ * @returns Validation function that checks properties matching patterns
+ * @since 0.1.0-alpha
+ */
+export interface PatternValidator {
+    validator: (value: any) => boolean;
+    message?: string;
+}
+export type PatternPropertiesSchema = Record<string, ((value: any) => boolean) | PatternValidator>;
+export declare const objectPatternPropertiesPlugin: import("../index").TypedPlugin<"objectPatternProperties", "patternProperties", (patterns: PatternPropertiesSchema) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: PatternPropertiesSchema[];
+}, readonly ["object"], "validator", "standard">;

package/dist/plugins/objectPatternProperties.js

@@ -0,0 +1 @@
+"use strict";var u=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var f=(r,e)=>{for(var o in e)u(r,o,{get:e[o],enumerable:!0})},N=(r,e,o,l)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of y(e))!c.call(r,i)&&i!==o&&u(r,i,{get:()=>e[i],enumerable:!(l=g(e,i))||l.enumerable});return r};var P=r=>N(u({},"__esModule",{value:!0}),r);var I={};f(I,{objectPatternPropertiesPlugin:()=>x});module.exports=P(I);var h=(r,e,o,l)=>{let n=(t=>(...a)=>{let m=t(...a);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:l}:m})(o);switch(r){case"conditional":return(t,...a)=>n(t,...a);case"fieldReference":return(t,...a)=>n(t,...a);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...a)=>n(t,...a);case"context":return t=>n(t);default:return n}};function d(r){let{name:e,methodName:o,allowedTypes:l,category:i,impl:n}=r;return{name:e,methodName:o,allowedTypes:l,category:i,create:()=>h(i,o,n,e)}}var x=d({name:"objectPatternProperties",methodName:"patternProperties",allowedTypes:["object"],category:"standard",impl:r=>({check:e=>{if(!e||typeof e!="object"||Array.isArray(e))return!1;let o=Object.keys(e),l=Object.entries(r);for(let i of o){let n=e[i];for(let[t,a]of l)if(new RegExp(t).test(i)){let s=!1;if(typeof a=="function"?s=a(n):typeof a=="object"&&a!==null&&"validator"in a&&(s=a.validator(n)),!s)return!1;break}}return!0},code:"PATTERN_PROPERTIES",getErrorMessage:(e,o)=>{let l=Object.keys(e||{}),i=Object.entries(r),n=[];for(let t of l){let a=e[t];for(let[m,s]of i)if(new RegExp(m).test(t)){let p=!1,T;typeof s=="function"?p=s(a):typeof s=="object"&&s!==null&&"validator"in s&&(p=s.validator(a),T=s.message),p||(T?n.push(`${t}: ${T}`):n.push(`${t} (matching pattern ${m}) has invalid value`));break}}return n.length>0?`${o} has pattern property violations: ${n.join(", ")}`:`${o} has invalid pattern properties`},params:[r]})});0&&(module.exports={objectPatternPropertiesPlugin});

package/dist/plugins/objectPatternProperties.mjs

@@ -0,0 +1 @@
+var d=(l,a,o,m)=>{let t=(e=>(...n)=>{let i=e(...n);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:m}:i})(o);switch(l){case"conditional":return(e,...n)=>t(e,...n);case"fieldReference":return(e,...n)=>t(e,...n);case"multiFieldReference":return t;case"transform":return e=>t(e);case"arrayElement":return(e,...n)=>t(e,...n);case"context":return e=>t(e);default:return t}};function u(l){let{name:a,methodName:o,allowedTypes:m,category:s,impl:t}=l;return{name:a,methodName:o,allowedTypes:m,category:s,create:()=>d(s,o,t,a)}}var f=u({name:"objectPatternProperties",methodName:"patternProperties",allowedTypes:["object"],category:"standard",impl:l=>({check:a=>{if(!a||typeof a!="object"||Array.isArray(a))return!1;let o=Object.keys(a),m=Object.entries(l);for(let s of o){let t=a[s];for(let[e,n]of m)if(new RegExp(e).test(s)){let r=!1;if(typeof n=="function"?r=n(t):typeof n=="object"&&n!==null&&"validator"in n&&(r=n.validator(t)),!r)return!1;break}}return!0},code:"PATTERN_PROPERTIES",getErrorMessage:(a,o)=>{let m=Object.keys(a||{}),s=Object.entries(l),t=[];for(let e of m){let n=a[e];for(let[i,r]of s)if(new RegExp(i).test(e)){let p=!1,T;typeof r=="function"?p=r(n):typeof r=="object"&&r!==null&&"validator"in r&&(p=r.validator(n),T=r.message),p||(T?t.push(`${e}: ${T}`):t.push(`${e} (matching pattern ${i}) has invalid value`));break}}return t.length>0?`${o} has pattern property violations: ${t.join(", ")}`:`${o} has invalid pattern properties`},params:[l]})});export{f as objectPatternPropertiesPlugin};

package/dist/plugins/objectPropertyNames.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @luq-plugin
+ * @name objectPropertyNames
+ * @category object
+ * @description Validates that all property names in an object match a specified pattern or schema
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Property names must match pattern
+ * const validator = Builder()
+ *   .use(objectPropertyNamesPlugin)
+ *   .for<{ [key: string]: any }>()
+ *   .v("config", (b) => b.object.propertyNames(/^[a-zA-Z_][a-zA-Z0-9_]*$/))
+ *   .build();
+ *
+ * // Property names with custom validator
+ * builder.v("data", b => b.object.propertyNames({
+ *   validator: (name) => name.length >= 3 && !name.startsWith('_'),
+ *   message: "Property names must be at least 3 characters and not start with underscore"
+ * }))
+ * ```
+ * @params
+ * - schema: RegExp | string | { validator: (name: string) => boolean, message?: string } - Pattern or validation schema for property names
+ * @returns Validation function that checks all property names
+ * @since 0.1.0-alpha
+ */
+export interface PropertyNamesSchema {
+    validator: (name: string) => boolean;
+    message?: string;
+}
+export declare const objectPropertyNamesPlugin: import("../index").TypedPlugin<"objectPropertyNames", "propertyNames", (schema: RegExp | string | PropertyNamesSchema) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | RegExp | PropertyNamesSchema)[];
+}, readonly ["object"], "validator", "standard">;

package/dist/plugins/objectPropertyNames.js

@@ -0,0 +1 @@
+"use strict";var p=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(e,n)=>{for(var t in n)p(e,t,{get:n[t],enumerable:!0})},y=(e,n,t,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of T(n))!g.call(e,o)&&o!==t&&p(e,o,{get:()=>n[o],enumerable:!(a=u(n,o))||a.enumerable});return e};var f=e=>y(p({},"__esModule",{value:!0}),e);var x={};d(x,{objectPropertyNamesPlugin:()=>c});module.exports=f(x);var N=(e,n,t,a)=>{let r=(i=>(...s)=>{let l=i(...s);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(t);switch(e){case"conditional":return(i,...s)=>r(i,...s);case"fieldReference":return(i,...s)=>r(i,...s);case"multiFieldReference":return r;case"transform":return i=>r(i);case"arrayElement":return(i,...s)=>r(i,...s);case"context":return i=>r(i);default:return r}};function m(e){let{name:n,methodName:t,allowedTypes:a,category:o,impl:r}=e;return{name:n,methodName:t,allowedTypes:a,category:o,create:()=>N(o,t,r,n)}}var c=m({name:"objectPropertyNames",methodName:"propertyNames",allowedTypes:["object"],category:"standard",impl:e=>({check:n=>{if(!n||typeof n!="object"||Array.isArray(n))return!1;let t=Object.keys(n);for(let a of t)if(e instanceof RegExp){if(!e.test(a))return!1}else if(typeof e=="string"){if(!new RegExp(e).test(a))return!1}else if(typeof e=="object"&&e!==null&&"validator"in e){if(!e.validator(a))return!1}else return!1;return!0},code:"PROPERTY_NAMES",getErrorMessage:(n,t)=>{let a=Object.keys(n||{}).filter(r=>e instanceof RegExp?!e.test(r):typeof e=="string"?!new RegExp(e).test(r):typeof e=="object"&&e!==null&&"validator"in e?!e.validator(r):!0);if(typeof e=="object"&&e!==null&&"message"in e&&e.message)return e.message;let o=e instanceof RegExp?e.toString():typeof e=="string"?`/${e}/`:"the specified pattern";return`${t} has invalid property names: ${a.join(", ")}. Property names must match ${o}`},params:[e]})});0&&(module.exports={objectPropertyNamesPlugin});

package/dist/plugins/objectPropertyNames.mjs

@@ -0,0 +1 @@
+var m=(e,r,o,a)=>{let n=(t=>(...i)=>{let l=t(...i);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(o);switch(e){case"conditional":return(t,...i)=>n(t,...i);case"fieldReference":return(t,...i)=>n(t,...i);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...i)=>n(t,...i);case"context":return t=>n(t);default:return n}};function p(e){let{name:r,methodName:o,allowedTypes:a,category:s,impl:n}=e;return{name:r,methodName:o,allowedTypes:a,category:s,create:()=>m(s,o,n,r)}}var g=p({name:"objectPropertyNames",methodName:"propertyNames",allowedTypes:["object"],category:"standard",impl:e=>({check:r=>{if(!r||typeof r!="object"||Array.isArray(r))return!1;let o=Object.keys(r);for(let a of o)if(e instanceof RegExp){if(!e.test(a))return!1}else if(typeof e=="string"){if(!new RegExp(e).test(a))return!1}else if(typeof e=="object"&&e!==null&&"validator"in e){if(!e.validator(a))return!1}else return!1;return!0},code:"PROPERTY_NAMES",getErrorMessage:(r,o)=>{let a=Object.keys(r||{}).filter(n=>e instanceof RegExp?!e.test(n):typeof e=="string"?!new RegExp(e).test(n):typeof e=="object"&&e!==null&&"validator"in e?!e.validator(n):!0);if(typeof e=="object"&&e!==null&&"message"in e&&e.message)return e.message;let s=e instanceof RegExp?e.toString():typeof e=="string"?`/${e}/`:"the specified pattern";return`${o} has invalid property names: ${a.join(", ")}. Property names must match ${s}`},params:[e]})});export{g as objectPropertyNamesPlugin};

package/dist/plugins/oneOf.d.ts

@@ -0,0 +1,44 @@
+import { ValidationOptions } from "../core/plugin/types";
+/**
+ * @luq-plugin
+ * @name oneOf
+ * @category standard
+ * @description Validates that a value is one of the specified allowed values (enum-like validation)
+ * @allowedTypes ["string", "number", "boolean"]
+ * @example
+ * ```typescript
+ * // String enum validation
+ * const validator = Builder()
+ *   .use(oneOfPlugin)
+ *   .for<FormData>()
+ *   .v("status", (b) => b.string.oneOf(["active", "inactive", "pending"]))
+ *   .v("role", (b) => b.string.oneOf(["admin", "user", "guest"]))
+ *   .build();
+ *
+ * // Number enum validation
+ * builder.v("priority", b => b.number.oneOf([0, 1, 2, 3]))
+ *
+ * // With TypeScript const for type safety
+ * const ROLES = ["admin", "user", "guest"] as const;
+ * builder.v("userRole", b => b.string.oneOf(ROLES))
+ * ```
+ * @params
+ * - allowed: Array<string | number | boolean> - Array of allowed values
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if value is in the allowed list
+ * @customError
+ * ```typescript
+ * .oneOf(["A", "B", "C"], {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be one of: ${params.allowed.join(", ")} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const oneOfPlugin: import("../index").TypedPlugin<"oneOf", "oneOf", (allowedValues: readonly any[], options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (any[] | ValidationOptions<{}>)[];
+    allowedValues: readonly any[];
+}, readonly ["string", "number", "boolean"], "validator", "standard">;

package/dist/plugins/oneOf.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var y=(e,n)=>{for(var a in n)l(e,a,{get:n[a],enumerable:!0})},c=(e,n,a,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of d(n))!g.call(e,o)&&o!==a&&l(e,o,{get:()=>n[o],enumerable:!(i=u(n,o))||i.enumerable});return e};var f=e=>c(l({},"__esModule",{value:!0}),e);var w={};y(w,{oneOfPlugin:()=>P});module.exports=f(w);var N=(e,n,a,i)=>{let s=(r=>(...t)=>{let m=r(...t);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:i}:m})(a);switch(e){case"conditional":return(r,...t)=>s(r,...t);case"fieldReference":return(r,...t)=>s(r,...t);case"multiFieldReference":return s;case"transform":return r=>s(r);case"arrayElement":return(r,...t)=>s(r,...t);case"context":return r=>s(r);default:return s}};function p(e){let{name:n,methodName:a,allowedTypes:i,category:o,impl:s}=e;return{name:n,methodName:a,allowedTypes:i,category:o,create:()=>N(o,a,s,n)}}var h="oneOf",x=e=>Array.isArray(e)?`Value must be one of: ${e.map(a=>JSON.stringify(a)).join(", ")}`:"Value must be one of the allowed values",I=["string","number","boolean"],P=p({name:"oneOf",methodName:"oneOf",allowedTypes:I,category:"standard",impl:(e,n)=>{if(!Array.isArray(e)||e.length===0)throw new Error("oneOf requires a non-empty array of allowed values");let a=n?.code||h,i=n?.messageFactory||(t=>x(t.options)),o=Object.freeze([...e]),s=e.length>7,r=s?new Set(e):null;return{check:t=>t==null?!0:s?r.has(t):e.includes(t),code:a,getErrorMessage:(t,m)=>{let T={path:m,value:t,code:a,options:[...o]};return i(T)},params:[e,n],allowedValues:o}}});0&&(module.exports={oneOfPlugin});

package/dist/plugins/oneOf.mjs

@@ -0,0 +1 @@
+var T=(n,o,r,m)=>{let a=(t=>(...e)=>{let s=t(...e);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:m}:s})(r);switch(n){case"conditional":return(t,...e)=>a(t,...e);case"fieldReference":return(t,...e)=>a(t,...e);case"multiFieldReference":return a;case"transform":return t=>a(t);case"arrayElement":return(t,...e)=>a(t,...e);case"context":return t=>a(t);default:return a}};function l(n){let{name:o,methodName:r,allowedTypes:m,category:i,impl:a}=n;return{name:o,methodName:r,allowedTypes:m,category:i,create:()=>T(i,r,a,o)}}var u="oneOf",d=n=>Array.isArray(n)?`Value must be one of: ${n.map(r=>JSON.stringify(r)).join(", ")}`:"Value must be one of the allowed values",g=["string","number","boolean"],f=l({name:"oneOf",methodName:"oneOf",allowedTypes:g,category:"standard",impl:(n,o)=>{if(!Array.isArray(n)||n.length===0)throw new Error("oneOf requires a non-empty array of allowed values");let r=o?.code||u,m=o?.messageFactory||(e=>d(e.options)),i=Object.freeze([...n]),a=n.length>7,t=a?new Set(n):null;return{check:e=>e==null?!0:a?t.has(e):n.includes(e),code:r,getErrorMessage:(e,s)=>{let p={path:s,value:e,code:r,options:[...i]};return m(p)},params:[n,o],allowedValues:i}}});export{f as oneOfPlugin};

package/dist/plugins/optional.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @luq-plugin
+ * @name optional
+ * @category standard
+ * @description Allows a field to be undefined (but not null or empty string)
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Basic usage - field can be undefined
+ * const validator = Builder()
+ *   .use(optionalPlugin)
+ *   .for<UserProfile>()
+ *   .v("nickname", (b) => b.string.optional().min(3))
+ *   .v("age", (b) => b.number.optional().min(0))
+ *   .build();
+ *
+ * // Arrays and objects can be optional
+ * builder.v("hobbies", b => b.array.optional().minLength(1))
+ * builder.v("settings", b => b.object.optional())
+ * ```
+ * @params
+ * No parameters - this is a modifier plugin
+ * @returns Validation function that returns true and skips further validation if value is undefined
+ * @customError
+ * This plugin does not generate errors - it allows undefined values
+ * @since 0.1.0-alpha
+ */
+export declare const optionalPlugin: import("../index").TypedPlugin<"optional", "optional", () => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: any[];
+    isOptional: boolean;
+    skipForUndefined: boolean;
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "standard">;

package/dist/plugins/optional.js

@@ -0,0 +1 @@
+"use strict";var s=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var a in n)s(e,a,{get:n[a],enumerable:!0})},y=(e,n,a,l)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of T(n))!d.call(e,r)&&r!==a&&s(e,r,{get:()=>n[r],enumerable:!(l=p(n,r))||l.enumerable});return e};var c=e=>y(s({},"__esModule",{value:!0}),e);var I={};g(I,{optionalPlugin:()=>h});module.exports=c(I);var f=(e,n,a,l)=>{let o=(t=>(...i)=>{let m=t(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:l}:m})(a);switch(e){case"conditional":return(t,...i)=>o(t,...i);case"fieldReference":return(t,...i)=>o(t,...i);case"multiFieldReference":return o;case"transform":return t=>o(t);case"arrayElement":return(t,...i)=>o(t,...i);case"context":return t=>o(t);default:return o}};function u(e){let{name:n,methodName:a,allowedTypes:l,category:r,impl:o}=e;return{name:n,methodName:a,allowedTypes:l,category:r,create:()=>f(r,a,o,n)}}var C=Object.freeze({valid:!0,__skipFurtherValidation:!0}),N=["string","number","boolean","array","object","date","union"],h=u({name:"optional",methodName:"optional",allowedTypes:N,category:"standard",impl:()=>({check:e=>e!==null,code:"optional",getErrorMessage:(e,n)=>e===null?`${n} cannot be null (use undefined for optional fields)`:"Optional validation error (should not happen)",params:[],isOptional:!0,skipForUndefined:!0})});0&&(module.exports={optionalPlugin});

package/dist/plugins/optional.mjs

@@ -0,0 +1 @@
+var u=(t,r,i,l)=>{let n=(e=>(...a)=>{let o=e(...a);return o&&typeof o=="object"&&"check"in o?{...o,pluginName:l}:o})(i);switch(t){case"conditional":return(e,...a)=>n(e,...a);case"fieldReference":return(e,...a)=>n(e,...a);case"multiFieldReference":return n;case"transform":return e=>n(e);case"arrayElement":return(e,...a)=>n(e,...a);case"context":return e=>n(e);default:return n}};function s(t){let{name:r,methodName:i,allowedTypes:l,category:m,impl:n}=t;return{name:r,methodName:i,allowedTypes:l,category:m,create:()=>u(m,i,n,r)}}var g=Object.freeze({valid:!0,__skipFurtherValidation:!0}),p=["string","number","boolean","array","object","date","union"],y=s({name:"optional",methodName:"optional",allowedTypes:p,category:"standard",impl:()=>({check:t=>t!==null,code:"optional",getErrorMessage:(t,r)=>t===null?`${r} cannot be null (use undefined for optional fields)`:"Optional validation error (should not happen)",params:[],isOptional:!0,skipForUndefined:!0})});export{y as optionalPlugin};

package/dist/plugins/readOnlyWriteOnly.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @luq-plugin
+ * @name readOnlyWriteOnly
+ * @category context
+ * @description Validates fields based on read-only or write-only context
+ * @allowedTypes ["string", "number", "boolean", "date", "array", "object"]
+ * @example
+ * ```typescript
+ * // Read-only field (should not be modified after creation)
+ * const validator = Builder()
+ *   .use(readOnlyWriteOnlyPlugin)
+ *   .for<{ id: string; name: string; }>()
+ *   .v("id", (b) => b.string.readOnly())
+ *   .v("name", (b) => b.string.required())
+ *   .build();
+ *
+ * // Write-only field (e.g., password that shouldn't be read back)
+ * builder.v("password", b => b.string.writeOnly())
+ *
+ * // With operation context
+ * const result = validator.validate(data, {
+ *   context: { operation: "read" } // or "write"
+ * });
+ * ```
+ * @params
+ * - mode?: "readOnly" | "writeOnly" - The access mode for the field
+ * - options?: { errorMessage?: string } - Optional configuration
+ * @returns Validation function that checks field access based on context
+ * @since 0.1.0-alpha
+ */
+export interface ReadOnlyWriteOnlyOptions {
+    /** Custom error message */
+    errorMessage?: string;
+    /** Whether to skip validation entirely for inaccessible fields */
+    skipValidation?: boolean;
+}
+export declare const readOnlyWriteOnlyPlugin: import("../index").TypedPlugin<"readOnlyWriteOnly", "readOnly", (options?: ReadOnlyWriteOnlyOptions) => {
+    check: (value: any, allValues: any, context?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | ReadOnlyWriteOnlyOptions)[];
+}, readonly ["string", "number", "boolean", "date", "array", "object"], "validator", "context">;
+export declare const writeOnlyPlugin: import("../index").TypedPlugin<"writeOnly", "writeOnly", (options?: ReadOnlyWriteOnlyOptions) => {
+    check: (value: any, allValues: any, context?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | ReadOnlyWriteOnlyOptions)[];
+}, readonly ["string", "number", "boolean", "date", "array", "object"], "validator", "context">;

package/dist/plugins/readOnlyWriteOnly.js

@@ -0,0 +1 @@
+"use strict";var m=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var y=(n,e)=>{for(var t in e)m(n,t,{get:e[t],enumerable:!0})},g=(n,e,t,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of T(e))!d.call(n,r)&&r!==t&&m(n,r,{get:()=>e[r],enumerable:!(a=u(e,r))||a.enumerable});return n};var c=n=>g(m({},"__esModule",{value:!0}),n);var h={};y(h,{readOnlyWriteOnlyPlugin:()=>N,writeOnlyPlugin:()=>x});module.exports=c(h);var f=(n,e,t,a)=>{let i=(o=>(...l)=>{let s=o(...l);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:a}:s})(t);switch(n){case"conditional":return(o,...l)=>i(o,...l);case"fieldReference":return(o,...l)=>i(o,...l);case"multiFieldReference":return i;case"transform":return o=>i(o);case"arrayElement":return(o,...l)=>i(o,...l);case"context":return o=>i(o);default:return i}};function p(n){let{name:e,methodName:t,allowedTypes:a,category:r,impl:i}=n;return{name:e,methodName:t,allowedTypes:a,category:r,create:()=>f(r,t,i,e)}}var N=p({name:"readOnlyWriteOnly",methodName:"readOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(n={})=>({check:(e,t,a)=>!((a?.operation||"write")==="write"&&e!==void 0&&a?.isUpdate),code:"READ_ONLY",getErrorMessage:(e,t)=>n.errorMessage||`${t} is read-only and cannot be modified`,params:["readOnly",n]})}),x=p({name:"writeOnly",methodName:"writeOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(n={})=>({check:(e,t,a)=>!((a?.operation||"write")==="read"&&e!==void 0),code:"WRITE_ONLY",getErrorMessage:(e,t)=>n.errorMessage||`${t} is write-only and cannot be read`,params:["writeOnly",n]})});0&&(module.exports={readOnlyWriteOnlyPlugin,writeOnlyPlugin});

package/dist/plugins/readOnlyWriteOnly.mjs

@@ -0,0 +1 @@
+var p=(t,a,n,o)=>{let r=(e=>(...i)=>{let s=e(...i);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:o}:s})(n);switch(t){case"conditional":return(e,...i)=>r(e,...i);case"fieldReference":return(e,...i)=>r(e,...i);case"multiFieldReference":return r;case"transform":return e=>r(e);case"arrayElement":return(e,...i)=>r(e,...i);case"context":return e=>r(e);default:return r}};function m(t){let{name:a,methodName:n,allowedTypes:o,category:l,impl:r}=t;return{name:a,methodName:n,allowedTypes:o,category:l,create:()=>p(l,n,r,a)}}var d=m({name:"readOnlyWriteOnly",methodName:"readOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(t={})=>({check:(a,n,o)=>!((o?.operation||"write")==="write"&&a!==void 0&&o?.isUpdate),code:"READ_ONLY",getErrorMessage:(a,n)=>t.errorMessage||`${n} is read-only and cannot be modified`,params:["readOnly",t]})}),y=m({name:"writeOnly",methodName:"writeOnly",allowedTypes:["string","number","boolean","date","array","object"],category:"context",impl:(t={})=>({check:(a,n,o)=>!((o?.operation||"write")==="read"&&a!==void 0),code:"WRITE_ONLY",getErrorMessage:(a,n)=>t.errorMessage||`${n} is write-only and cannot be read`,params:["writeOnly",t]})});export{d as readOnlyWriteOnlyPlugin,y as writeOnlyPlugin};

package/dist/plugins/required.d.ts

@@ -0,0 +1,45 @@
+import { ValidationOptions } from "../core/plugin/types";
+/**
+ * @luq-plugin
+ * @name required
+ * @category standard
+ * @description Validates that a field is required (not null, undefined, or empty string)
+ * @allowedTypes ["string", "number", "boolean", "date", "array", "object", "tuple", "union"]
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const validator = Builder()
+ *   .use(requiredPlugin)
+ *   .for<UserProfile>()
+ *   .v("name", (b) => b.string.required())
+ *   .v("age", (b) => b.number.required())
+ *   .v("terms", (b) => b.boolean.required())
+ *   .build();
+ *
+ * // Custom error message
+ * builder.v("email", b => b.string.required({
+ *   messageFactory: ({ path }) => `${path} is required`
+ * }))
+ * ```
+ * @params
+ * - messageFactory?: (context: MessageContext) => string - Custom error message factory
+ * @returns Validation function that returns true if value exists (not null/undefined/empty string)
+ * @customError
+ * ```typescript
+ * .required({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} field is required (current value: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const requiredPlugin: import("../index").TypedPlugin<"required", "required", (options?: ValidationOptions & {
+    allowNull?: boolean;
+}) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (ValidationOptions<{}> & {
+        allowNull?: boolean;
+    })[];
+}, readonly ["array", "boolean", "number", "object", "string", "date", "union", "tuple"], "validator", "standard">;

package/dist/plugins/required.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var g=(e,t)=>{for(var r in t)l(e,r,{get:t[r],enumerable:!0})},y=(e,t,r,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of d(t))!p.call(e,o)&&o!==r&&l(e,o,{get:()=>t[o],enumerable:!(i=T(t,o))||i.enumerable});return e};var c=e=>y(l({},"__esModule",{value:!0}),e);var P={};g(P,{requiredPlugin:()=>h});module.exports=c(P);var f=(e,t,r,i)=>{let n=(a=>(...m)=>{let s=a(...m);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:i}:s})(r);switch(e){case"conditional":return(a,...m)=>n(a,...m);case"fieldReference":return(a,...m)=>n(a,...m);case"multiFieldReference":return n;case"transform":return a=>n(a);case"arrayElement":return(a,...m)=>n(a,...m);case"context":return a=>n(a);default:return n}};function u(e){let{name:t,methodName:r,allowedTypes:i,category:o,impl:n}=e;return{name:t,methodName:r,allowedTypes:i,category:o,create:()=>f(o,r,n,t)}}var N="required",x=e=>`${e} is required`,I=["array","boolean","number","object","string","date","union","tuple"],h=u({name:"required",methodName:"required",allowedTypes:I,category:"standard",impl:e=>{let t=e?.code||N,r=e?.messageFactory||(n=>x(n.field)),i=e?.fieldName,o=e?.allowNull||!1;return{check:n=>o?!(n===void 0||n===""):!(n==null||n===""),code:t,getErrorMessage:(n,a)=>r({field:i||a,path:a,value:n,code:t}),params:e?[e]:[]}}});0&&(module.exports={requiredPlugin});

package/dist/plugins/required.mjs

@@ -0,0 +1 @@
+var u=(t,r,o,i)=>{let e=(n=>(...a)=>{let s=n(...a);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:i}:s})(o);switch(t){case"conditional":return(n,...a)=>e(n,...a);case"fieldReference":return(n,...a)=>e(n,...a);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...a)=>e(n,...a);case"context":return n=>e(n);default:return e}};function l(t){let{name:r,methodName:o,allowedTypes:i,category:m,impl:e}=t;return{name:r,methodName:o,allowedTypes:i,category:m,create:()=>u(m,o,e,r)}}var T="required",d=t=>`${t} is required`,p=["array","boolean","number","object","string","date","union","tuple"],c=l({name:"required",methodName:"required",allowedTypes:p,category:"standard",impl:t=>{let r=t?.code||T,o=t?.messageFactory||(e=>d(e.field)),i=t?.fieldName,m=t?.allowNull||!1;return{check:e=>m?!(e===void 0||e===""):!(e==null||e===""),code:r,getErrorMessage:(e,n)=>o({field:i||n,path:n,value:e,code:r}),params:t?[t]:[]}}});export{c as requiredPlugin};

package/dist/plugins/requiredIf.d.ts

@@ -0,0 +1,66 @@
+import { ValidationOptions, MessageContext } from "../core/plugin/types";
+export interface RequiredIfContext extends MessageContext {
+    condition?: boolean;
+}
+/**
+ * @luq-plugin
+ * @name requiredIf
+ * @category conditional
+ * @description Makes a field required based on a dynamic condition evaluated at validation time, with support for array context validation
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Basic conditional required
+ * const validator = Builder()
+ *   .use(requiredIfPlugin)
+ *   .for<ContactForm>()
+ *   .v("email", (b) => b.string.requiredIf(values => values.contactMethod === 'email'))
+ *   .v("phone", (b) => b.string.requiredIf(values => values.contactMethod === 'phone'))
+ *   .build();
+ *
+ * // Multiple conditions
+ * builder.v("ssn", b =>
+ *   b.string.requiredIf(values =>
+ *     values.country === 'US' && values.employmentType === 'full-time'
+ *   )
+ * )
+ *
+ * // Array context validation - conditional required within array items
+ * builder.v("items[].billingAddress", b =>
+ *   b.string.requiredIf((allValues, arrayContext) => {
+ *     // arrayContext.index: current index in array
+ *     // arrayContext.item: current object at index
+ *     // arrayContext.array: full array
+ *     return arrayContext?.item?.type === 'premium';
+ *   })
+ * )
+ *
+ * // Mixed validation - access both form values and array context
+ * builder.v("orders[].shippingAddress", b =>
+ *   b.string.requiredIf((allValues, arrayContext) => {
+ *     const isInternational = allValues.country !== 'US';
+ *     const requiresShipping = arrayContext?.item?.requiresShipping;
+ *     return isInternational && requiresShipping;
+ *   })
+ * )
+ * ```
+ * @params
+ * - condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean - Condition function that receives all form values and optional array context
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that checks if field is required based on condition
+ * @customError
+ * ```typescript
+ * .requiredIf(
+ *   (values, arrayContext) => values.hasAccount && arrayContext?.item?.isActive,
+ *   { messageFactory: ({ path }) => `${path} is required when account exists and item is active` }
+ * )
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const requiredIfPlugin: import("../index").TypedPlugin<"requiredIf", "requiredIf", <TObject>(condition: (allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean, options?: ValidationOptions<RequiredIfContext>) => {
+    check: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => string;
+    params: (((allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean) | ValidationOptions<RequiredIfContext>)[];
+    evaluateCondition: (allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;

package/dist/plugins/requiredIf.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(n,t)=>{for(var o in t)l(n,o,{get:t[o],enumerable:!0})},y=(n,t,o,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of p(t))!d.call(n,e)&&e!==o&&l(n,e,{get:()=>t[e],enumerable:!(s=T(t,e))||s.enumerable});return n};var c=n=>y(l({},"__esModule",{value:!0}),n);var C={};g(C,{requiredIfPlugin:()=>P});module.exports=c(C);var f=(n,t,o,s)=>{let r=(a=>(...i)=>{let m=a(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(o);switch(n){case"conditional":return(a,...i)=>r(a,...i);case"fieldReference":return(a,...i)=>r(a,...i);case"multiFieldReference":return r;case"transform":return a=>r(a);case"arrayElement":return(a,...i)=>r(a,...i);case"context":return a=>r(a);default:return r}};function u(n){let{name:t,methodName:o,allowedTypes:s,category:e,impl:r}=n;return{name:t,methodName:o,allowedTypes:s,category:e,create:()=>f(e,o,r,t)}}var x="requiredIf",N="Field is required when condition is met";function I(n){return N}var h=["string","number","boolean","array","object","date","union"],P=u({name:"requiredIf",methodName:"requiredIf",allowedTypes:h,category:"conditional",impl:(n,t)=>{let o=t?.code||x,s=t?.messageFactory||I;return{check:(e,r,a)=>r&&n(r,a)?!(e==null||e===""):!0,code:o,getErrorMessage:(e,r,a,i)=>{let m=a?n(a,i):!1;return s({path:r,value:e,code:o,condition:m})},params:[n,t],evaluateCondition:(e,r)=>e?n(e,r):!1}}});0&&(module.exports={requiredIfPlugin});

package/dist/plugins/requiredIf.mjs

@@ -0,0 +1 @@
+var u=(a,o,i,m)=>{let e=(n=>(...r)=>{let s=n(...r);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:m}:s})(i);switch(a){case"conditional":return(n,...r)=>e(n,...r);case"fieldReference":return(n,...r)=>e(n,...r);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...r)=>e(n,...r);case"context":return n=>e(n);default:return e}};function l(a){let{name:o,methodName:i,allowedTypes:m,category:t,impl:e}=a;return{name:o,methodName:i,allowedTypes:m,category:t,create:()=>u(t,i,e,o)}}var T="requiredIf",p="Field is required when condition is met";function d(a){return p}var g=["string","number","boolean","array","object","date","union"],x=l({name:"requiredIf",methodName:"requiredIf",allowedTypes:g,category:"conditional",impl:(a,o)=>{let i=o?.code||T,m=o?.messageFactory||d;return{check:(t,e,n)=>e&&a(e,n)?!(t==null||t===""):!0,code:i,getErrorMessage:(t,e,n,r)=>{let s=n?a(n,r):!1;return m({path:e,value:t,code:i,condition:s})},params:[a,o],evaluateCondition:(t,e)=>t?a(t,e):!1}}});export{x as requiredIfPlugin};

package/dist/plugins/skip.d.ts

@@ -0,0 +1,57 @@
+import { ValidationOptions } from "../core/plugin/types";
+/**
+ * @luq-plugin
+ * @name skip
+ * @category conditional
+ * @description Completely skips validation for a field based on a dynamic condition
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Skip validation when not needed
+ * const validator = Builder()
+ *   .use(skipPlugin)
+ *   .for<FormData>()
+ *   .v("advancedOptions", b =>
+ *     b.object
+ *       .skip(values => !values.showAdvanced)
+ *       .required()
+ *   )
+ *   .build();
+ *
+ * // Skip debug fields in production
+ * builder.v("debugInfo", b =>
+ *   b.string
+ *     .skip(values => values.environment === 'production')
+ *     .min(10)
+ * )
+ *
+ * // Skip entire sections conditionally
+ * builder.v("enterpriseSettings", b =>
+ *   b.object
+ *     .skip(values => values.plan !== 'enterprise')
+ *     .recursively()
+ * )
+ * ```
+ * @params
+ * - condition: (allValues: TObject) => boolean - Function that returns true if field should be skipped
+ * - options?: ValidationOptions - Optional configuration
+ * @returns Validation function that skips field entirely when condition is true
+ * @customError
+ * ```typescript
+ * This plugin does not generate errors - it removes fields from validation
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const skipPlugin: import("../index").TypedPlugin<"skip", "skip", <TObject>(condition: (allValues: TObject) => boolean, options?: ValidationOptions) => {
+    check: (value: any, allValues?: TObject) => boolean;
+    shouldSkipAllValidation: (value: any, allValues?: TObject) => boolean;
+    code: string;
+    getErrorMessage: () => string;
+    params: (ValidationOptions<{}> | ((allValues: TObject) => boolean))[];
+    metadata: {
+        type: string;
+        category: string;
+        skipCondition: (allValues: TObject) => boolean;
+        async: boolean;
+    };
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;

package/dist/plugins/skip.js

@@ -0,0 +1 @@
+"use strict";var s=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var t in n)s(e,t,{get:n[t],enumerable:!0})},y=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of u(n))!d.call(e,o)&&o!==t&&s(e,o,{get:()=>n[o],enumerable:!(r=T(n,o))||r.enumerable});return e};var c=e=>y(s({},"__esModule",{value:!0}),e);var x={};g(x,{skipPlugin:()=>h});module.exports=c(x);var f=(e,n,t,r)=>{let i=(a=>(...l)=>{let m=a(...l);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:r}:m})(t);switch(e){case"conditional":return(a,...l)=>i(a,...l);case"fieldReference":return(a,...l)=>i(a,...l);case"multiFieldReference":return i;case"transform":return a=>i(a);case"arrayElement":return(a,...l)=>i(a,...l);case"context":return a=>i(a);default:return i}};function p(e){let{name:n,methodName:t,allowedTypes:r,category:o,impl:i}=e;return{name:n,methodName:t,allowedTypes:r,category:o,create:()=>f(o,t,i,n)}}var N=["string","number","boolean","array","object","date","union"],h=p({name:"skip",methodName:"skip",allowedTypes:N,category:"conditional",impl:(e,n)=>({check:(t,r)=>!0,shouldSkipAllValidation:(t,r)=>r?e(r):!1,code:"skip",getErrorMessage:()=>"Skip condition not met",params:[e,n],metadata:{type:"conditional",category:"skip",skipCondition:e,async:!1}})});0&&(module.exports={skipPlugin});

package/dist/plugins/skip.mjs

@@ -0,0 +1 @@
+var p=(t,i,o,a)=>{let n=(e=>(...r)=>{let l=e(...r);return l&&typeof l=="object"&&"check"in l?{...l,pluginName:a}:l})(o);switch(t){case"conditional":return(e,...r)=>n(e,...r);case"fieldReference":return(e,...r)=>n(e,...r);case"multiFieldReference":return n;case"transform":return e=>n(e);case"arrayElement":return(e,...r)=>n(e,...r);case"context":return e=>n(e);default:return n}};function s(t){let{name:i,methodName:o,allowedTypes:a,category:m,impl:n}=t;return{name:i,methodName:o,allowedTypes:a,category:m,create:()=>p(m,o,n,i)}}var T=["string","number","boolean","array","object","date","union"],g=s({name:"skip",methodName:"skip",allowedTypes:T,category:"conditional",impl:(t,i)=>({check:(o,a)=>!0,shouldSkipAllValidation:(o,a)=>a?t(a):!1,code:"skip",getErrorMessage:()=>"Skip condition not met",params:[t,i],metadata:{type:"conditional",category:"skip",skipCondition:t,async:!1}})});export{g as skipPlugin};

package/dist/plugins/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 "../core/plugin/types";
+export declare const stringBase64Plugin: import("../index").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/plugins/stringBase64.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var d=(e,t)=>{for(var o in t)l(e,o,{get:t[o],enumerable:!0})},y=(e,t,o,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of g(t))!p.call(e,a)&&a!==o&&l(e,a,{get:()=>t[a],enumerable:!(n=u(t,a))||n.enumerable});return e};var c=e=>y(l({},"__esModule",{value:!0}),e);var I={};d(I,{stringBase64Plugin:()=>h});module.exports=c(I);var f=(e,t,o,n)=>{let r=(s=>(...m)=>{let i=s(...m);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:n}:i})(o);switch(e){case"conditional":return(s,...m)=>r(s,...m);case"fieldReference":return(s,...m)=>r(s,...m);case"multiFieldReference":return r;case"transform":return s=>r(s);case"arrayElement":return(s,...m)=>r(s,...m);case"context":return s=>r(s);default:return r}};function T(e){let{name:t,methodName:o,allowedTypes:n,category:a,impl:r}=e;return{name:t,methodName:o,allowedTypes:n,category:a,create:()=>f(a,o,r,t)}}var N=/^[A-Za-z0-9+/]*={0,2}$/,x=/^[A-Za-z0-9\-_]*={0,2}$/,h=T({name:"stringBase64",methodName:"base64",allowedTypes:["string"],category:"standard",impl:e=>({check:n=>typeof n!="string"?!1:n===""?!0:n.length%4!==0?!1:(e?.urlSafe?x:N).test(n),code:"FORMAT_BASE64",getErrorMessage:(n,a)=>{let r={path:a,value:n,code:"FORMAT_BASE64"};return e?.messageFactory?.(r)||`${a} must be a valid base64 encoded string`},messageFactory:n=>e?.messageFactory?.(n)||`${n.path} must be a valid base64 encoded string`,params:[e]})});0&&(module.exports={stringBase64Plugin});

package/dist/plugins/stringBase64.mjs

@@ -0,0 +1 @@
+var T=(a,i,o,e)=>{let n=(t=>(...s)=>{let m=t(...s);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:e}:m})(o);switch(a){case"conditional":return(t,...s)=>n(t,...s);case"fieldReference":return(t,...s)=>n(t,...s);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...s)=>n(t,...s);case"context":return t=>n(t);default:return n}};function l(a){let{name:i,methodName:o,allowedTypes:e,category:r,impl:n}=a;return{name:i,methodName:o,allowedTypes:e,category:r,create:()=>T(r,o,n,i)}}var u=/^[A-Za-z0-9+/]*={0,2}$/,g=/^[A-Za-z0-9\-_]*={0,2}$/,y=l({name:"stringBase64",methodName:"base64",allowedTypes:["string"],category:"standard",impl:a=>({check:e=>typeof e!="string"?!1:e===""?!0:e.length%4!==0?!1:(a?.urlSafe?g:u).test(e),code:"FORMAT_BASE64",getErrorMessage:(e,r)=>{let n={path:r,value:e,code:"FORMAT_BASE64"};return a?.messageFactory?.(n)||`${r} must be a valid base64 encoded string`},messageFactory:e=>a?.messageFactory?.(e)||`${e.path} must be a valid base64 encoded string`,params:[a]})});export{y as stringBase64Plugin};