@cleverbrush/schema 1.1.11 → 2.0.0

package/dist/chunk-CTP4RHDG.js

@@ -0,0 +1,2 @@
+var y=Symbol("transaction"),P=[Error,RegExp,Date],R={shouldNotWrapWithTransaction:u=>!!P.find(e=>u instanceof e)},h=(u,e)=>{let r={},a=new Map;e=Object.assign({},R,e||{});let{shouldNotWrapWithTransaction:i}=e,l=()=>!!Object.keys(r).find(s=>r[s]?.[y]?r[s][y].isDirty():!0)||a.size>0,c=()=>{let s={};Object.keys(u).forEach(t=>{s[t]=u[t]}),Object.keys(r).forEach(t=>{let o=r[t];if(o[y]){let{commit:d}=o[y];s[t]=d()}else s[t]=r[t]});for(let t of a.keys())delete s[t];return r={},a=new Map,s},p=()=>{for(let s in r){let t=r[s];t&&typeof t=="object"&&t[y]&&t[y].rollback()}return r={},a=new Map,u};if(Array.isArray(u)){let s=u.map(d=>typeof d=="object"&&d&&!i(d)?h(d).object:d),t=()=>s.map(d=>d&&typeof d[y]=="object"?d[y].commit():d),o=()=>!!s.find((d,f)=>d&&typeof d[y]=="object"?d[y].isDirty():s[f]!==u[f]);return Object.defineProperty(s,y,{writable:!1,configurable:!1,value:{initial:u,object:s,commit:t,rollback:()=>u,isDirty:o}}),{object:s,commit:t,rollback:()=>u,isDirty:o}}let n=new Proxy(u,{set:(s,t,o)=>s&&s[t]===o?(delete r[t],!0):(r[t]=o,a.delete(t),!0),ownKeys:s=>[...Object.keys(s).filter(t=>!a.has(t)),...Object.keys(r).filter(t=>!(t in s))],getOwnPropertyDescriptor:(s,t)=>{if(!a.has(t))return t in r?Object.getOwnPropertyDescriptor(r,t):Object.getOwnPropertyDescriptor(s,t)},has:(s,t)=>a.has(t)?!1:t in r?!0:t in s,get:(s,t)=>{if(typeof t=="symbol")return t===y?{initial:u,object:n,commit:c,rollback:p,isDirty:l}:s[t];if(t in r)return r[t];if(!a.has(t)){if(!S(s[t])&&typeof s[t]=="object"&&s[t]&&!i(s[t])){let{object:o}=h(s[t],e);return r[t]=o,o}return s[t]}},deleteProperty:(s,t)=>(t in r&&(r[t]&&typeof r[t][y]=="object"&&r[t][y].rollback(),delete r[t]),t in s&&a.set(t,!0),!0)});return{object:n,commit:c,rollback:p,isDirty:l}},T=u=>({object:u,commit:()=>u,rollback:()=>u,isDirty:()=>!1}),S=u=>u&&typeof u=="object"&&Object.hasOwn(u,y);var m=class extends Error{errors;constructor(e){let r=e.length>0?e.map(a=>a.message).join("; "):"Validation failed";super(r),this.name="SchemaValidationError",this.errors=e}},x=Symbol(),v=Symbol();function E(u,e,r,a){return Object.defineProperties(u,{seenValue:{get:e,enumerable:!1},errors:{get:r,enumerable:!1},isValid:{get:()=>r().length===0,enumerable:!1},descriptor:{get:a,enumerable:!1}}),u}var b=class{#d=!0;#a=!1;#y=!1;#p;#e=[];#t=[];#n=!1;#h=!0;#c={};#T="base";#f="is required";#o="is required";#s=void 0;#i=void 0;#l=!1;#u;get"~standard"(){if(this.#u)return this.#u;let e=this;return this.#u={version:1,vendor:"@cleverbrush/schema",validate(r){let a=e.validate(r);return a.valid?{value:a.object}:{issues:(a.errors??[]).map(i=>({message:i.message}))}}},this.#u}get type(){return this.#T}set type(e){if(typeof e!="string"||!e)throw new Error("value should be non empty string");this.#T=e}get preprocessors(){return this.#e}get validators(){return this.#t}get isRequired(){return this.#d}get isNullable(){return this.#a}set isRequired(e){if(typeof e!="boolean")throw new Error("should be a boolean value");this.#d=e}get requiredErrorMessage(){return this.#o}get hasDefault(){return this.#s!==void 0}get hasCatch(){return this.#l}resolveCatchValue(){return typeof this.#i=="function"?this.#i():this.#i}get isReadonly(){return this.#y}resolveDefaultValue(){return typeof this.#s=="function"?this.#s():this.#s}get canSkipPreValidation(){return this.#h}get isNullRequiredViolation(){return!0}#m(e,r){let a=r?.doNotStopOnFirstError??!1,i={doNotStopOnFirstError:a,rootPropertyDescriptor:r?.rootPropertyDescriptor,currentPropertyDescriptor:r?.currentPropertyDescriptor},l=this.#n;return{doNotStopOnFirstError:a,resultingContext:i,transaction:l?h({validatedObject:e}):T({validatedObject:e}),errors:[]}}#r(e,r){return{valid:!1,errors:[e[0]].filter(a=>a),context:r}}#b(e,r,a){return Array.isArray(a)&&a.length?a:[{message:`Validator #${e}${r?` (${r})`:""} didn't pass.`}]}#P(e,r,a,i){return e.length>0?{valid:!1,errors:e.filter(l=>l).filter((l,c)=>r?!0:c===0),context:a,transaction:i}:{valid:!0,context:a,transaction:i}}preValidateSync(e,r){let a=this.#m(e,r),{doNotStopOnFirstError:i,resultingContext:l,errors:c}=a,p=a.transaction,n=p.object.validatedObject;if(this.#e.length>0){let s=0;for(let t of this.#e)try{let o=t.fn(n);if(o instanceof Promise)throw new Error(`Preprocessor #${s}${t.fn.name?` (${t.fn.name})`:""} returned a Promise. Use validateAsync() for schemas with async preprocessors.`);n=o}catch(o){if(o.message?.includes("Use validateAsync()"))throw o;if(c.push({message:`Preprocessor #${s}${t.fn.name?` (${t.fn.name})`:""} thrown an error: ${o.message}`}),!i)return this.#r(c,l)}finally{s++}p=this.#n?h({validatedObject:n}):T({validatedObject:n})}if(typeof n>"u"&&this.hasDefault&&(n=this.resolveDefaultValue(),p=this.#n?h({validatedObject:n}):T({validatedObject:n})),this.#t.length>0&&!(n==null&&!this.isRequired)&&!(n===null&&this.#a)){let s=0;for(let t of this.#t)try{let o=t.fn(n);if(o instanceof Promise)throw new Error(`Validator #${s}${t.fn.name?` (${t.fn.name})`:""} returned a Promise. Use validateAsync() for schemas with async validators.`);let{valid:d,errors:f}=o;if(!d&&(c.push(...this.#b(s,t.fn.name,f)),!i))return this.#r(c,l)}catch(o){if(o.message?.includes("Use validateAsync()"))throw o;if(c.push({message:`Validator #${s}${t.fn.name?` (${t.fn.name})`:""} thrown an error: ${o.message}`}),!i)return this.#r(c,l)}finally{s++}}return this.isRequired&&(typeof n>"u"||n===null&&this.isNullRequiredViolation&&!this.#a)&&(c.push({message:this.getValidationErrorMessageSync(this.#o,n)}),!i)?(p.rollback(),this.#r(c,l)):this.#P(c,i,l,p)}async preValidateAsync(e,r){let a=this.#m(e,r),{doNotStopOnFirstError:i,resultingContext:l,errors:c}=a,p=a.transaction,n=p.object.validatedObject;if(this.#e.length>0){let s=0;for(let t of this.#e)try{n=await Promise.resolve(t.fn(n))}catch(o){if(c.push({message:`Preprocessor #${s}${t.fn.name?` (${t.fn.name})`:""} thrown an error: ${o.message}`}),!i)return this.#r(c,l)}finally{s++}p=this.#n?h({validatedObject:n}):T({validatedObject:n})}if(typeof n>"u"&&this.hasDefault&&(n=this.resolveDefaultValue(),p=this.#n?h({validatedObject:n}):T({validatedObject:n})),this.#t.length>0&&!(n==null&&!this.isRequired)&&!(n===null&&this.#a)){let s=0;for(let t of this.#t)try{let{valid:o,errors:d}=await Promise.resolve(t.fn(n));if(!o&&(c.push(...this.#b(s,t.fn.name,d)),!i))return this.#r(c,l)}catch(o){if(c.push({message:`Validator #${s}${t.fn.name?` (${t.fn.name})`:""} thrown an error: ${o.message}`}),!i)return this.#r(c,l)}finally{s++}}return this.isRequired&&(typeof n>"u"||n===null&&this.isNullRequiredViolation&&!this.#a)&&(c.push({message:await this.getValidationErrorMessage(this.#o,n)}),!i)?(p.rollback(),this.#r(c,l)):this.#P(c,i,l,p)}preValidate(e,r){return this.preValidateAsync(e,r)}introspect(){return{type:this.type,isRequired:this.#d,isNullable:this.#a,isReadonly:this.#y,preprocessors:[...this.preprocessors],validators:[...this.validators],requiredValidationErrorMessageProvider:this.#o,extensions:{...this.#c},hasDefault:this.#s!==void 0,defaultValue:this.#s,description:this.#p,hasCatch:this.#l,catchValue:this.#i}}optional(){return this.createFromProps({...this.introspect(),isRequired:!1})}nullable(){return this.createFromProps({...this.introspect(),isNullable:!0})}notNullable(){return this.createFromProps({...this.introspect(),isNullable:!1})}default(e){return this.createFromProps({...this.introspect(),defaultValue:e})}catch(e){return this.createFromProps({...this.introspect(),catchValue:e,hasCatch:!0})}clearDefault(){return this.createFromProps({...this.introspect(),defaultValue:void 0})}describe(e){return this.createFromProps({...this.introspect(),description:e})}brand(e){return this.createFromProps({...this.introspect()})}readonly(){return this.createFromProps({...this.introspect(),isReadonly:!0})}required(e){return this.createFromProps({...this.introspect(),isRequired:!0,...e!==void 0?{requiredValidationErrorMessageProvider:this.assureValidationErrorMessageProvider(e,this.#f)}:{}})}addPreprocessor(e,r){if(typeof e!="function")throw new Error("preprocessor must be a function");return this.createFromProps({...this.introspect(),preprocessors:[...this.preprocessors,{fn:e,mutates:r?.mutates??!0}]})}clearPreprocessors(){return this.createFromProps({...this.introspect(),preprocessors:[]})}addValidator(e,r){if(typeof e!="function")throw new Error("validator must be a function");return this.createFromProps({...this.introspect(),validators:[...this.validators,{fn:e,mutates:r?.mutates??!1}]})}clearValidators(){return this.createFromProps({...this.introspect(),validators:[]})}validate(e,r){let a=this._validate(e,r);if(!a.valid&&this.#l){let i=this.resolveCatchValue(),l=this._validate(i,r);return l.valid?l:{valid:!0,object:i}}return a}async validateAsync(e,r){let a=await this._validateAsync(e,r);if(!a.valid&&this.#l){let i=this.resolveCatchValue(),l=await this._validateAsync(i,r);return l.valid?l:{valid:!0,object:i}}return a}getValidationErrorMessageSync(e,r){if(typeof e=="string")return e;if(typeof e=="function"){let a=e(r,this);if(a instanceof Promise)throw new Error("Async error message providers require validateAsync(). Use a string or sync function instead.");return a}throw new Error("Invalid error message provider must be a string or a function returning a string")}async getValidationErrorMessage(e,r){if(typeof e=="string")return e;if(typeof e=="function")return e(r,this);throw new Error("Invalid error message provider must be a string or a function returning a string or a promise of a string")}assureValidationErrorMessageProvider(e,r){return typeof e=="string"?e:typeof e=="function"?e.bind(this):typeof r=="function"?r.bind(this):r}withExtension(e,r){return this.createFromProps({...this.introspect(),extensions:{...this.#c,[e]:r}})}getExtension(e){return this.#c[e]}parse(e,r){let a=this.validate(e,r);if(!a.valid)throw new m(a.errors||[]);return a.object}async parseAsync(e,r){let a=await this.validateAsync(e,r);if(!a.valid)throw new m(a.errors||[]);return a.object}safeParse(e,r){return this.validate(e,r)}safeParseAsync(e,r){return this.validateAsync(e,r)}constructor(e){if(!(typeof e=="object"&&e))throw new Error("SchemaBuilder props must be an object");let{type:r,preprocessors:a,validators:i,isRequired:l}=e;this.type=r,typeof l=="boolean"&&(this.isRequired=l),typeof e.isNullable=="boolean"&&(this.#a=e.isNullable),typeof e.isReadonly=="boolean"&&(this.#y=e.isReadonly),Array.isArray(a)&&(this.#e=[...a]),Array.isArray(i)&&(this.#t=[...i]),this.#n=this.#e.some(c=>c.mutates)||this.#t.some(c=>c.mutates),this.#h=this.#e.length===0&&this.#t.length===0,typeof e.extensions=="object"&&e.extensions&&(this.#c={...e.extensions}),e.defaultValue!==void 0&&(this.#s=e.defaultValue),e.hasCatch&&(this.#l=!0,this.#i=e.catchValue),typeof e.description=="string"&&(this.#p=e.description),this.#o=this.assureValidationErrorMessageProvider(e.requiredValidationErrorMessageProvider,this.#f)}};export{h as a,m as b,x as c,v as d,E as e,b as f};
+//# sourceMappingURL=chunk-CTP4RHDG.js.map

package/dist/chunk-CTP4RHDG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/transaction.ts","../src/builders/SchemaBuilder.ts"],"sourcesContent":["const TRANSACTION_SYMBOL = Symbol('transaction');\n\nconst defaultNonTransactionalTypes = [Error, RegExp, Date];\n\n/**\n * Options for customizing transaction behavior.\n */\nexport type TransactionOptions = {\n    /**\n     * An optional callback returning boolean. Called for every\n     * nested object's property (recursively) which is not\n     * null `Object`. Using this function you can define if `child`\n     * should be wrapped with transaction. It is useful for\n     * some cases like Error, Map, etc. when you want to preserve a link,\n     * instead of creation of the new transaction.\n     * By default it's filtering all instances inheriting from Error and RegExp\n     * If `true` is returned from this function `child` will not be wrapped with\n     * nested transaction object.\n     */\n    shouldNotWrapWithTransaction?: (child: any) => boolean;\n};\n\nconst defaultTransactionOptions: TransactionOptions = {\n    shouldNotWrapWithTransaction: child =>\n        !!defaultNonTransactionalTypes.find(t => child instanceof t)\n};\n\n/**\n * A transaction wrapper around an object. Provides copy-on-write semantics:\n * modifications to `object` are isolated from the original until `commit()` is called.\n * Use `rollback()` to discard changes, and `isDirty()` to check for pending modifications.\n */\nexport type Transaction<T> = {\n    /**\n     * Transaction object you can modify (equals to `initial` right after the call).\n     * All changes to `object` will not be reflected to `initial` until `commit`\n     * is called.\n     */\n    object: T;\n    /**\n     * Commits transaction, all changes to `object` will be reflected to `initial`\n     * after the call of this function.\n     */\n    commit: () => T;\n    /**\n     * Rollbacks transaction moving it to the initial state (`object` will be equal to `initial`\n     * after the call of this function).\n     */\n    rollback: () => T;\n    /**\n     * Returns `true` if there are any changes to `object` which make it different from `initial`.\n     */\n    isDirty: () => boolean;\n};\n\n/**\n * Starts a transaction over the `initial` object. The returned `object` is a\n * proxy (for plain objects) or a shallow copy (for arrays) that tracks mutations\n * without modifying `initial`. Call `commit()` to apply or `rollback()` to discard changes.\n *\n * @param initial - the object or array to wrap in a transaction\n * @param options - optional configuration to control which nested values are wrapped\n * @returns a {@link Transaction} with `object`, `commit`, `rollback`, and `isDirty` members\n */\nexport const transaction = <T extends {}>(\n    initial: T,\n    options?: TransactionOptions\n): Transaction<T> => {\n    let newProperties: Record<string | symbol, any> = {};\n    let deletedProperties = new Map<keyof T, true>();\n\n    options = Object.assign({}, defaultTransactionOptions, options || {});\n\n    const { shouldNotWrapWithTransaction } =\n        options as Required<TransactionOptions>;\n\n    const isDirty = () =>\n        !!Object.keys(newProperties).find(key => {\n            if (newProperties[key]?.[TRANSACTION_SYMBOL]) {\n                return newProperties[key][TRANSACTION_SYMBOL].isDirty();\n            }\n            return true;\n        }) || ((deletedProperties.size > 0) as any);\n\n    const commit = () => {\n        const result = {} as Record<string, any>;\n        Object.keys(initial).forEach(key => {\n            result[key] = (initial as any)[key];\n        });\n\n        Object.keys(newProperties).forEach(key => {\n            const value = newProperties[key];\n            if (value[TRANSACTION_SYMBOL]) {\n                const { commit: childCommit } = value[TRANSACTION_SYMBOL];\n                result[key] = childCommit();\n            } else {\n                result[key] = newProperties[key];\n            }\n        });\n\n        for (const key of deletedProperties.keys()) {\n            delete result[key as string];\n        }\n\n        newProperties = {};\n        deletedProperties = new Map<keyof T, true>();\n\n        return result as T;\n    };\n\n    const rollback = () => {\n        for (const key in newProperties) {\n            const value = newProperties[key];\n            if (\n                value &&\n                typeof value === 'object' &&\n                value[TRANSACTION_SYMBOL]\n            ) {\n                // this is nested transaction, let's rollback it as well\n                value[TRANSACTION_SYMBOL].rollback();\n            }\n        }\n        newProperties = {};\n        deletedProperties = new Map<keyof T, true>();\n        return initial;\n    };\n\n    if (Array.isArray(initial)) {\n        const result = initial.map(el =>\n            typeof el === 'object' && el && !shouldNotWrapWithTransaction(el)\n                ? transaction(el).object\n                : el\n        );\n        const commitArray = () =>\n            result.map(el =>\n                el && typeof el[TRANSACTION_SYMBOL] === 'object'\n                    ? el[TRANSACTION_SYMBOL].commit()\n                    : el\n            );\n\n        const isDirtyArray = () => {\n            return !!result.find((val, index) => {\n                if (val && typeof val[TRANSACTION_SYMBOL] === 'object') {\n                    return val[TRANSACTION_SYMBOL].isDirty();\n                }\n                return result[index] !== initial[index];\n            });\n        };\n        Object.defineProperty(result, TRANSACTION_SYMBOL, {\n            writable: false,\n            configurable: false,\n            value: {\n                initial,\n                object: result,\n                commit: commitArray as any,\n                rollback: () => initial,\n                isDirty: isDirtyArray\n            }\n        });\n        return {\n            object: result as any,\n            commit: commitArray as any,\n            rollback: () => initial,\n            isDirty: isDirtyArray\n        };\n    }\n\n    const proxy = new Proxy<T>(initial, {\n        set: (target, property, value) => {\n            if (target && (target as any)[property] === value) {\n                delete newProperties[property];\n                return true;\n            }\n            newProperties[property] = value;\n            deletedProperties.delete(property as any);\n            return true;\n        },\n        ownKeys: target => {\n            return [\n                ...Object.keys(target).filter(\n                    (k: any) => !deletedProperties.has(k)\n                ),\n                ...Object.keys(newProperties).filter((k: any) => !(k in target))\n            ];\n        },\n        getOwnPropertyDescriptor: (target, prop: any) => {\n            if (deletedProperties.has(prop)) {\n                return undefined;\n            }\n\n            if (prop in newProperties) {\n                return Object.getOwnPropertyDescriptor(newProperties, prop);\n            }\n\n            return Object.getOwnPropertyDescriptor(target, prop);\n        },\n        has: (target, prop: any) => {\n            if (deletedProperties.has(prop)) {\n                return false;\n            }\n\n            if (prop in newProperties) {\n                return true;\n            }\n\n            return prop in target;\n        },\n        get: (target, prop) => {\n            if (typeof prop === 'symbol') {\n                if (prop === TRANSACTION_SYMBOL) {\n                    return {\n                        initial,\n                        object: proxy,\n                        commit,\n                        rollback,\n                        isDirty\n                    };\n                }\n                return (target as any)[prop];\n            }\n\n            if (prop in newProperties) {\n                return newProperties[prop];\n            }\n\n            if (deletedProperties.has(prop as any)) {\n                return undefined;\n            }\n\n            if (\n                !isTransaction((target as any)[prop]) &&\n                typeof (target as any)[prop] === 'object' &&\n                (target as any)[prop] &&\n                !shouldNotWrapWithTransaction((target as any)[prop])\n            ) {\n                const { object } = transaction((target as any)[prop], options);\n                newProperties[prop] = object;\n                return object;\n            }\n\n            return (target as any)[prop];\n        },\n        deleteProperty: (target, p) => {\n            if (p in newProperties) {\n                if (\n                    newProperties[p] &&\n                    typeof newProperties[p][TRANSACTION_SYMBOL] === 'object'\n                ) {\n                    newProperties[p][TRANSACTION_SYMBOL].rollback();\n                }\n                delete newProperties[p];\n            }\n            if (p in target) {\n                deletedProperties.set(p as any, true);\n            }\n            return true;\n        }\n    });\n\n    return {\n        object: proxy,\n        commit,\n        rollback,\n        isDirty\n    };\n};\n\n/**\n * Creates a lightweight no-op transaction that wraps the `initial` value\n * without any Proxy or copy-on-write overhead.  `commit()` and `rollback()`\n * simply return the original object, and `isDirty()` is always `false`.\n *\n * Use this when no preprocessors or validators are defined — there is no\n * risk of mutation, so the full transaction machinery can be skipped.\n */\nexport const noopTransaction = <T extends {}>(initial: T): Transaction<T> => ({\n    object: initial,\n    commit: () => initial,\n    rollback: () => initial,\n    isDirty: () => false\n});\n\n/**\n * Checks if `obj` is an instance of a transaction.\n * @param obj object to check if it's a transaction\n * @returns `true` if `obj` is a transaction, `false` otherwise\n */\nexport const isTransaction = (obj: any) =>\n    obj && typeof obj === 'object' && Object.hasOwn(obj, TRANSACTION_SYMBOL);\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport {\n    noopTransaction,\n    type Transaction,\n    transaction\n} from '../utils/transaction.js';\nimport type { ArraySchemaBuilder } from './ArraySchemaBuilder.js';\nimport type { ExternSchemaBuilder } from './ExternSchemaBuilder.js';\nimport type { ObjectSchemaBuilder } from './ObjectSchemaBuilder.js';\n\n/** @internal Symbol used as the key for the type brand on schema builders. */\ndeclare const __type: unique symbol;\n/** @internal */\nexport type SchemaTypeBrand = typeof __type;\n\n/** @internal Symbol used as the key for the default-value brand on schema builders. */\ndeclare const __hasDefault: unique symbol;\n/** @internal */\nexport type HasDefaultBrand = typeof __hasDefault;\n\n/** Symbol used as the key for branded/opaque types. */\ndeclare const __brand: unique symbol;\n/** Symbol used as the key for branded/opaque types. */\nexport type BRAND = typeof __brand;\n\n/**\n * Intersects a base type with a phantom brand tag.\n * The brand exists only at the type level — zero runtime cost.\n *\n * @example\n * ```ts\n * type Email = Brand<string, 'Email'>;\n * type UserId = Brand<number, 'UserId'>;\n * ```\n */\nexport type Brand<T, TBrand extends string | symbol> = T & {\n    readonly [K in BRAND]: TBrand;\n};\n\n/**\n * Infers the TypeScript type that a `SchemaBuilder` instance validates.\n * Takes into account type optimizations (via `optimize()`) and whether the schema is optional.\n *\n * @example\n * ```ts\n * const userSchema = object({ name: string(), age: number().optional() });\n * type User = InferType<typeof userSchema>;\n * // { name: string; age?: number }\n * ```\n */\nexport type InferType<T> = T extends {\n    optimize: (...args: any[]) => {\n        readonly [K in SchemaTypeBrand]: infer TOptimized;\n    };\n}\n    ? TOptimized\n    : T extends { readonly [K in SchemaTypeBrand]: infer TType }\n      ? TType\n      : T;\n\n/**\n * Represents a single validation error with a human-readable error message.\n */\nexport type ValidationError = { message: string };\n\n/**\n * Used to represent a validation result for nested\n * objects/properties. Contains a list of errors and\n * the value that caused them.\n */\nexport type NestedValidationResult<\n    TSchema,\n    TRootSchema extends ObjectSchemaBuilder<any, any, any, any, any>,\n    TParentPropertyDescriptor\n> = {\n    /**\n     * Value that property had and which caused error or errors\n     */\n    seenValue?: InferType<TSchema>;\n    /**\n     * A list of errors, empty if object satisfies a schema\n     */\n    errors: ReadonlyArray<string>;\n\n    /**\n     * Whether validation passed for this property and all of its children.\n     */\n    isValid: boolean;\n\n    get descriptor(): PropertyDescriptorInner<\n        TRootSchema,\n        TSchema,\n        TParentPropertyDescriptor\n    >;\n};\n\n/**\n * Utility type that makes a value `T` optional (i.e. `T | undefined`).\n * Used internally by {@link InferType} to represent optional schema fields.\n */\nexport type MakeOptional<T> = { prop?: T }['prop'];\n\n/**\n * Type of the function that provides a validation error message for\n * the given `seenValue` and `schema`. Can be a string or a function\n * returning a string or a promise of a string.\n * Should be used to provide a custom validation error message.\n */\nexport type ValidationErrorMessageProvider<\n    TSchema extends SchemaBuilder<any, any, any, any, any> = SchemaBuilder<\n        any,\n        any,\n        any,\n        any,\n        any\n    >\n> =\n    | string\n    | ((\n          seenValue: InferType<TSchema>,\n          schema: TSchema\n      ) => string | Promise<string>);\n\nexport type ValidationResult<T> = {\n    /**\n     * If `true` - object satisfies schema\n     */\n    valid: boolean;\n    /**\n     * Contains validated object. Can be different (if there are any preprocessors in the schema) from object\n     * passed to the `validate` method of the `SchemaBuilder` class.\n     */\n    object?: T;\n    errors?: ValidationError[];\n};\n\n/**\n * Error thrown by {@link SchemaBuilder.parse | parse()} and\n * {@link SchemaBuilder.parseAsync | parseAsync()} when validation fails.\n * Carries the full array of {@link ValidationError | validation errors}.\n */\nexport class SchemaValidationError extends Error {\n    public readonly errors: ValidationError[];\n\n    constructor(errors: ValidationError[]) {\n        const message =\n            errors.length > 0\n                ? errors.map(e => e.message).join('; ')\n                : 'Validation failed';\n        super(message);\n        this.name = 'SchemaValidationError';\n        this.errors = errors;\n    }\n}\n\n/**\n * Internal result returned by the `preValidate` step of `SchemaBuilder`.\n * Contains the validation context, any early errors, and the transaction\n * wrapping the (possibly preprocessed) value.\n */\nexport type PreValidationResult<T, TTransactionType> = Omit<\n    ValidationResult<T>,\n    'object'\n> & {\n    context: ValidationContext;\n    transaction?: Transaction<TTransactionType>;\n    rootPropertyDescriptor?: PropertyDescriptor<any, any, undefined>;\n};\n\ntype ValidatorResult<T> = Omit<ValidationResult<T>, 'object' | 'errors'> & {\n    errors?: ValidationError[];\n};\n\n/**\n * A function that transforms the value before validation.\n * Preprocessors run in order before validators and can modify or replace the value.\n *\n * @param object - the current value to preprocess\n * @returns the transformed value, or a Promise resolving to it\n */\nexport type Preprocessor<T> = (object: T) => Promise<T> | T;\n\n/**\n * A custom validation function that checks a value and returns a result\n * indicating whether the value is valid, along with optional error messages.\n *\n * @param object - the value to validate\n * @returns a result with `valid` boolean and optional `errors` array, or a Promise resolving to it\n */\nexport type Validator<T> = (\n    object: T\n) => Promise<ValidatorResult<T>> | ValidatorResult<T>;\n\n/**\n * Internal wrapper that pairs a preprocessor function with metadata\n * indicating whether it may mutate the value.\n */\nexport type PreprocessorEntry<T> = { fn: Preprocessor<T>; mutates: boolean };\n\n/**\n * Internal wrapper that pairs a validator function with metadata\n * indicating whether it may mutate the value.\n */\nexport type ValidatorEntry<T> = { fn: Validator<T>; mutates: boolean };\n\n/**\n * Configuration properties used to construct a `SchemaBuilder` instance.\n * Contains the schema type identifier, requirement flag, and lists of\n * preprocessors and validators.\n */\nexport type SchemaBuilderProps<T> = {\n    type: string;\n    isRequired?: boolean;\n    isNullable?: boolean;\n    isReadonly?: boolean;\n    preprocessors: PreprocessorEntry<T>[];\n    validators: ValidatorEntry<T>[];\n    requiredValidationErrorMessageProvider?: ValidationErrorMessageProvider;\n    extensions?: Record<string, unknown>;\n    defaultValue?: T | (() => T);\n    catchValue?: T | (() => T);\n    hasCatch?: boolean;\n    description?: string;\n};\n\nexport type ValidationContext<\n    TSchema extends SchemaBuilder<any, any, any, any> = SchemaBuilder<\n        any,\n        any,\n        any,\n        any\n    >\n> = {\n    /**\n     * Optional. By default validation will stop after the first validation error, in case if\n     * you want to receive all validation erors, please set this flag to `true`.\n     * You might need it to display validation errors.\n     */\n    doNotStopOnFirstError?: boolean;\n\n    /**\n     * Optional. If you define a `rootPropertyDescriptor` while validating an object,\n     * it will report all validation errors with the path starting from the root property.\n     * Normally it's used internally by the library for validation of nested objects and\n     * should not be used directly (but who knows, maybe you will find a use case for it).\n     */\n    rootPropertyDescriptor?: TSchema extends ObjectSchemaBuilder<\n        any,\n        any,\n        any,\n        any\n    >\n        ? PropertyDescriptor<TSchema, TSchema, undefined>\n        : never;\n\n    /**\n     * Optional. This is a property descriptor for the current object being validated.\n     * This descriptor is descendant of the `rootPropertyDescriptor` and is used to provide\n     * a path to the current object being validated in the root object.\n     * Normally it's used internally by the library for validation of nested objects and\n     * should not be used directly (but who knows, maybe you will find a use case for it).\n     */\n    currentPropertyDescriptor?: TSchema extends ObjectSchemaBuilder<\n        any,\n        any,\n        any\n    >\n        ? PropertyDescriptor<TSchema, TSchema, unknown>\n        : never;\n\n    /**\n     * Optional. Used along with `rootPropertyDescriptor` and `currentPropertyDescriptor` to provide\n     * a root validation object, this object will be used to retrieve the value of properties\n     * using the `rootPropertyDescriptor` because the `rootPropertyDescriptor` is a property descriptor\n     * for the root object, and it needs the root object along with the whole structure to get the\n     * value of the property.\n     *\n     * Normally it's used internally by the library for validation of nested objects and\n     * should not be used directly (but who knows, maybe you will find a use case for it).\n     */\n    rootValidationObject?: InferType<TSchema>;\n};\n\n/**\n * A symbol to mark property descriptors in the schema.\n * Normally, you should not use it directly unless you want\n * to develop some advanced features or extend the library.\n * In normal conditions it's used internally by the library.\n */\nexport const SYMBOL_SCHEMA_PROPERTY_DESCRIPTOR = Symbol();\n\n/**\n * A symbol that marks a schema as having sub-properties that can\n * participate in property descriptor trees. When a schema exposes\n * `[SYMBOL_HAS_PROPERTIES] = true` **and** its `introspect()` returns\n * a `properties` record, it will be recursed into by\n * `ObjectSchemaBuilder.getPropertiesFor()` — the same way nested\n * `ObjectSchemaBuilder` instances are.\n *\n * Currently implemented by `ObjectSchemaBuilder` (always) and\n * `ExternSchemaBuilder` (when created with an explicit property map).\n */\nexport const SYMBOL_HAS_PROPERTIES = Symbol();\n\n/**\n * Describes a property in a schema. And gives you\n * a possibility to access property value and set it.\n * suppose you have a schema like this:\n * ```ts\n * const schema = object({\n *  name: string(),\n *  address: object({\n *   city: string(),\n *   country: string()\n *  }),\n *  id: number()\n * });\n * ```\n * then you can get a property descriptor for the `address.city` property\n * like this:\n * ```ts\n * const addressCityDescriptor = object.getPropertiesFor(schema).address.city;\n * ```\n *\n * And then you can use it to get and set the value of this property having the object:\n * ```ts\n * const obj = {\n * name: 'Leo',\n * address: {\n *  city: 'Kozelsk',\n *  country: 'Russia'\n *  },\n *  id: 123\n * };\n *\n * const success = addressCityDescriptor.setValue(obj, 'Venyov');\n * // this returns you a boolean value indicating if the value was set successfully\n * ```\n */\n\nexport type PropertySetterOptions = {\n    /**\n     * If set to `true`, the method will create missing structure\n     * in the object to set the value. For example, if you have a schema\n     * and property descriptor like this:\n     * ```ts\n     * const schema = object({\n     * address: object({\n     * city: string(),\n     * country: string()\n     * }),\n     * });\n     * const addressCityDescriptor = object.getPropertiesFor(schema).address.city;\n     * ```\n     * And then you try to set a new value to the `address.city` property on the object\n     * which does not have `address` property:\n     * ```ts\n     * const obj = {\n     * name: 'Leo'\n     * };\n     * const success = addressCityDescriptor.setValue(obj, 'Venyov', { createMissingStructure: true });\n     * // success === true\n     * // obj === {\n     * // name: 'Leo',\n     * // address: {\n     * // city: 'Venyov'\n     * //  }\n     * // }\n     */\n    createMissingStructure?: boolean;\n};\n\n/**\n * Extracts the inner property descriptor type from a `PropertyDescriptor`.\n * Returns `undefined` if `T` is not a valid `PropertyDescriptor`.\n */\nexport type PropertyDescriptorInnerFromPropertyDescriptor<T> =\n    T extends PropertyDescriptor<\n        infer TSchema,\n        infer TPropertySchema,\n        infer TParentPropertyDescriptor\n    >\n        ? PropertyDescriptorInner<\n              TSchema,\n              TPropertySchema,\n              TParentPropertyDescriptor\n          >\n        : undefined;\n\nexport type PropertyDescriptorInner<\n    TSchema extends ObjectSchemaBuilder<any, any, any, any, any>,\n    TPropertySchema,\n    TParentPropertyDescriptor\n> = {\n    /**\n     * Sets a new value to the property. If the process was successful,\n     * the method returns `true`, otherwise `false`.\n     * It can return `false` if the property could not be set to the object\n     * which can happen if the `setValue` method is called with an object\n     * which does not comply with the schema.\n     * for example, if you have a schema and property descriptopr like this:\n     * ```ts\n     * const schema = object({\n     *  name: string(),\n     *  address: object({\n     *   city: string(),\n     *   country: string()\n     *  }),\n     *  id: number()\n     * });\n     *\n     * const addressCityDescriptor = object.getPropertiesFor(schema).address.city;\n     * ```\n     * And then you try to set a new value to the `address.city` property on the object\n     * which does not have `address` property:\n     * ```ts\n     * const obj = {\n     * name: 'Leo'\n     * };\n     *\n     * const success = addressCityDescriptor.setValue(obj, 'Venyov');\n     * // success === false\n     * ```\n     *\n     * @param obj Object to set the value to\n     * @param value a new value to set to the property\n     * @param options additional optional parameters to control the process\n     * @returns\n     */\n    setValue: (\n        obj: InferType<TSchema>,\n        value: InferType<TPropertySchema>,\n        options?: PropertySetterOptions\n    ) => boolean;\n    /**\n     * Gets the value of the property from the object.\n     * @param obj object to get the value from\n     * @returns an object containing a `value` and `success` properties. `value` is the value of the property\n     * if it was found in the object, `success` is a boolean value indicating if the property was found in the object.\n     */\n    getValue: (obj: InferType<TSchema>) => {\n        value?: InferType<TPropertySchema>;\n        success: boolean;\n    };\n\n    /**\n     * Gets the schema for the property described by the property descriptor.\n     * @returns a schema for the property\n     */\n    getSchema: () => TPropertySchema;\n\n    parent: PropertyDescriptorInnerFromPropertyDescriptor<TParentPropertyDescriptor>;\n    // extends PropertyDescriptor<\n    //     any,\n    //     any,\n    //     any\n    // >\n    //     ? TParentPropertyDescriptor\n    //     : never;\n};\n\n/**\n * A wrapper object keyed by {@link SYMBOL_SCHEMA_PROPERTY_DESCRIPTOR} that\n * holds a {@link PropertyDescriptorInner} for a particular property within\n * an object schema. Used to get/set property values on validated objects.\n */\nexport type PropertyDescriptor<\n    TRootSchema extends ObjectSchemaBuilder<any, any, any, any, any>,\n    TPropertySchema,\n    TParentPropertyDescriptor\n> = {\n    [SYMBOL_SCHEMA_PROPERTY_DESCRIPTOR]: PropertyDescriptorInner<\n        TRootSchema,\n        TPropertySchema,\n        TParentPropertyDescriptor\n    >;\n};\n\n/**\n * A tree of property descriptors for the schema.\n * Has a possibility to filter properties by the type (`TAssignableTo` type parameter).\n */\nexport type PropertyDescriptorTree<\n    TSchema extends ObjectSchemaBuilder<any, any, any, any, any>,\n    TRootSchema extends ObjectSchemaBuilder<any, any, any, any, any> = TSchema,\n    TAssignableTo = any,\n    TParentPropertyDescriptor = undefined\n> = PropertyDescriptor<TRootSchema, TSchema, TParentPropertyDescriptor> &\n    (TSchema extends ObjectSchemaBuilder<infer TProperties, any, any>\n        ? {\n              [K in keyof TProperties]: TProperties[K] extends ObjectSchemaBuilder<\n                  any,\n                  any,\n                  any\n              >\n                  ? PropertyDescriptorTree<\n                        TProperties[K],\n                        TRootSchema,\n                        any,\n                        PropertyDescriptor<\n                            TRootSchema,\n                            TSchema,\n                            TParentPropertyDescriptor\n                        >\n                    >\n                  : TProperties[K] extends ExternSchemaBuilder<\n                          any,\n                          any,\n                          any,\n                          any,\n                          any,\n                          any,\n                          infer TExternResult\n                      >\n                    ? PropertyDescriptor<\n                          TRootSchema,\n                          TProperties[K],\n                          PropertyDescriptor<\n                              TRootSchema,\n                              TSchema,\n                              TParentPropertyDescriptor\n                          >\n                      > &\n                          ExternOutputPropertyDescriptors<\n                              TExternResult,\n                              TRootSchema,\n                              PropertyDescriptor<\n                                  TRootSchema,\n                                  TProperties[K],\n                                  PropertyDescriptor<\n                                      TRootSchema,\n                                      TSchema,\n                                      TParentPropertyDescriptor\n                                  >\n                              >\n                          >\n                    : TProperties[K] extends ArraySchemaBuilder<\n                            infer TArrayElement,\n                            any,\n                            any\n                        >\n                      ? TArrayElement extends ObjectSchemaBuilder<\n                            any,\n                            any,\n                            any,\n                            any,\n                            any\n                        >\n                          ? PropertyDescriptor<\n                                TRootSchema,\n                                TProperties[K],\n                                PropertyDescriptor<\n                                    TRootSchema,\n                                    TSchema,\n                                    TParentPropertyDescriptor\n                                >\n                            >\n                          : InferType<TProperties[K]> extends TAssignableTo\n                            ? PropertyDescriptor<\n                                  TRootSchema,\n                                  TProperties[K],\n                                  PropertyDescriptor<\n                                      TRootSchema,\n                                      TSchema,\n                                      TParentPropertyDescriptor\n                                  >\n                              >\n                            : never\n                      : InferType<TProperties[K]> extends TAssignableTo\n                        ? PropertyDescriptor<\n                              TRootSchema,\n                              TProperties[K],\n                              PropertyDescriptor<\n                                  TRootSchema,\n                                  TSchema,\n                                  TParentPropertyDescriptor\n                              >\n                          >\n                        : never;\n          }\n        : never);\n\n/**\n * Recursively maps the keys of an extern schema's output type into\n * property descriptors.  When a value is a plain-object type its keys\n * are expanded recursively; primitives, arrays, Dates, and functions\n * are treated as leaves.\n *\n * @internal\n */\ntype ExternOutputPropertyDescriptors<\n    TOutput,\n    TRootSchema extends ObjectSchemaBuilder<any, any, any, any, any>,\n    TParentPropertyDescriptor\n> = TOutput extends\n    | Date\n    | Function\n    | readonly any[]\n    | string\n    | number\n    | boolean\n    | symbol\n    | bigint\n    | null\n    | undefined\n    ? {}\n    : TOutput extends Record<string, any>\n      ? {\n            [K in keyof TOutput]: PropertyDescriptor<\n                TRootSchema,\n                SchemaBuilder<TOutput[K], true, false, false, {}>,\n                TParentPropertyDescriptor\n            > &\n                ExternOutputPropertyDescriptors<\n                    TOutput[K],\n                    TRootSchema,\n                    PropertyDescriptor<\n                        TRootSchema,\n                        SchemaBuilder<TOutput[K], true, false, false, {}>,\n                        TParentPropertyDescriptor\n                    >\n                >;\n        }\n      : {};\n\n/**\n * Creates an array augmented with non-enumerable NestedValidationResult\n * properties (`seenValue`, `errors`, `isValid`, `descriptor`).\n * Used by UnionSchemaBuilder and ArraySchemaBuilder to return hybrid\n * arrays from `getErrorsFor()`.\n */\nexport function createHybridErrorArray<T extends any[]>(\n    items: T,\n    seenValue: () => any,\n    errors: () => ReadonlyArray<string>,\n    descriptor: () => any\n): T {\n    Object.defineProperties(items, {\n        seenValue: {\n            get: seenValue,\n            enumerable: false\n        },\n        errors: {\n            get: errors,\n            enumerable: false\n        },\n        isValid: {\n            get: () => errors().length === 0,\n            enumerable: false\n        },\n        descriptor: {\n            get: descriptor,\n            enumerable: false\n        }\n    });\n    return items;\n}\n\n/**\n * Resolves the full output type of a schema, accounting for `TRequired` and\n * `TNullable` modifiers. Mirrors the branded `[__type]` computation so that\n * the `~standard` Standard Schema property carries the correct inferred type.\n *\n * - When `TRequired = true` and `TNullable = false` the result is `TResult`.\n * - When `TRequired = true` and `TNullable = true` the result is `TResult | null`.\n * - When `TRequired = false` the result is wrapped by {@link MakeOptional},\n *   adding `| undefined` (and `| null` when also nullable).\n *\n * @internal\n */\ntype ResolvedSchemaType<\n    TResult,\n    TRequired extends boolean,\n    TNullable extends boolean\n> = TRequired extends true\n    ? TNullable extends true\n        ? TResult | null\n        : TResult\n    : MakeOptional<TNullable extends true ? TResult | null : TResult>;\n\n/**\n * Base class for all schema builders. Provides basic functionality for schema building.\n *\n * **Note:** this class is not intended to be used directly, use one of the subclasses instead.\n * @typeparam TResult Type of the object that will be returned by `validate()` method.\n * @typeparam TRequired If `true`, object will be required. If `false`, object will be optional.\n */\nexport abstract class SchemaBuilder<\n    TResult = any,\n    TRequired extends boolean = true,\n    TNullable extends boolean = false,\n    THasDefault extends boolean = false,\n    // biome-ignore lint/correctness/noUnusedVariables: used in extensions\n    TExtensions = {}\n> {\n    #isRequired = true;\n    #isNullable = false;\n    #isReadonly = false;\n    #description: string | undefined;\n    #preprocessors: PreprocessorEntry<TResult>[] = [];\n    #validators: ValidatorEntry<TResult>[] = [];\n    #hasMutating = false;\n    #canSkipPreValidation = true;\n    #extensions: Record<string, unknown> = {};\n    #type = 'base';\n    #defaultRequiredErrorMessageProvider: ValidationErrorMessageProvider =\n        'is required';\n    #requiredErrorMessageProvider: ValidationErrorMessageProvider =\n        'is required';\n    #defaultValue: TResult | (() => TResult) | undefined = undefined;\n    #catchValue: TResult | (() => TResult) | undefined = undefined;\n    #hasCatch = false;\n    /**\n     * Cached result of the first `['~standard']` access. Stored so that\n     * repeated property reads return the exact same object reference, which\n     * is required by the Standard Schema spec.\n     */\n    #standardProps:\n        | StandardSchemaV1.Props<\n              ResolvedSchemaType<TResult, TRequired, TNullable>\n          >\n        | undefined;\n\n    /**\n     * Type-level brand encoding the inferred type of this schema.\n     * Not emitted at runtime — used only by {@link InferType}.\n     * @internal\n     */\n    declare readonly [__type]: TRequired extends true\n        ? TNullable extends true\n            ? TResult | null\n            : TResult\n        : MakeOptional<TNullable extends true ? TResult | null : TResult>;\n\n    /**\n     * Type-level brand encoding whether this schema has a default value.\n     * Not emitted at runtime — used by input type inference.\n     * @internal\n     */\n    declare readonly [__hasDefault]: THasDefault;\n\n    /**\n     * Standard Schema v1 interface.\n     *\n     * Exposes this schema as a [Standard Schema v1](https://standardschema.dev/)\n     * validator, enabling out-of-the-box interoperability with any library that\n     * consumes the spec — including tRPC, TanStack Form, React Hook Form, T3 Env,\n     * Hono, Elysia, next-safe-action, and 50+ other tools.\n     *\n     * Every `SchemaBuilder` subclass (all 13 builders) inherits this property\n     * automatically — no additional setup required.\n     *\n     * **Shape of the returned object:**\n     * - `version` — always `1` (Standard Schema spec version)\n     * - `vendor` — `'@cleverbrush/schema'`\n     * - `validate(value)` — synchronous; wraps this builder's own `.validate()`\n     *   and converts its result to the Standard Schema `Result<Output>` format:\n     *   - Success: `{ value: <validated output> }`\n     *   - Failure: `{ issues: [{ message: string }, …] }`\n     *\n     * The returned object is **cached** after the first access so repeated reads\n     * return the same reference (required by the spec).\n     *\n     * @example\n     * ```ts\n     * import { object, string, number } from '@cleverbrush/schema';\n     *\n     * const UserSchema = object({\n     *   name:  string().minLength(2),\n     *   email: string().email(),\n     *   age:   number().min(18).optional(),\n     * });\n     *\n     * // Grab the Standard Schema interface\n     * const std = UserSchema['~standard'];\n     * // std.version === 1\n     * // std.vendor  === '@cleverbrush/schema'\n     *\n     * const ok = std.validate({ name: 'Alice', email: 'alice@example.com' });\n     * // { value: { name: 'Alice', email: 'alice@example.com', age: undefined } }\n     *\n     * const fail = std.validate({ name: 'A', email: 'not-an-email' });\n     * // { issues: [{ message: 'minLength' }, { message: 'email' }] }\n     *\n     * // Pass directly to TanStack Form, T3 Env, tRPC, etc.:\n     * // validators: { onChange: UserSchema, onBlur: UserSchema }\n     * ```\n     *\n     * @see https://standardschema.dev/\n     */\n    get ['~standard'](): StandardSchemaV1.Props<\n        ResolvedSchemaType<TResult, TRequired, TNullable>\n    > {\n        if (this.#standardProps) return this.#standardProps;\n        // Capture `this` for the closure so the validate callback can call\n        // the schema's own validate method.\n        const self = this;\n        this.#standardProps = {\n            version: 1 as const,\n            vendor: '@cleverbrush/schema',\n            validate(\n                value: unknown\n            ): StandardSchemaV1.Result<\n                ResolvedSchemaType<TResult, TRequired, TNullable>\n            > {\n                // Standard Schema validate accepts `unknown`, while the\n                // schema's own validate() has a typed parameter. The cast\n                // is safe because validate() performs full runtime\n                // validation regardless of the compile-time input type.\n                const result = self.validate(value as any);\n                if (result.valid) {\n                    return {\n                        value: result.object as ResolvedSchemaType<\n                            TResult,\n                            TRequired,\n                            TNullable\n                        >\n                    };\n                }\n                return {\n                    issues: (result.errors ?? []).map(e => ({\n                        message: e.message\n                    }))\n                };\n            }\n        };\n        return this.#standardProps;\n    }\n\n    /**\n     * Set type of schema explicitly. `notUsed` param is needed only for case when JS is used. E.g. when you\n     * can't call method like `schema.hasType<Date>()`, so instead you can call `schema.hasType(new Date())`\n     * with the same result.\n     */\n    public abstract hasType<T>(notUsed?: T): any;\n\n    /**\n     * Clears type set by call to `.hasType<T>()`, default schema type inference will be used\n     * for schema returned by this call.\n     */\n    public abstract clearHasType(): any;\n\n    /**\n     * Protected method used to create a new instance of the Builder\n     * defined by the `props` object. Should be used to instantiate new\n     * builders to keep builder's immutability.\n     * @param props arbitrary props object\n     */\n    protected abstract createFromProps(props: any): this;\n\n    /**\n     * The string identifier of the schema type (e.g. `'string'`, `'number'`, `'object'`).\n     */\n    protected get type() {\n        return this.#type;\n    }\n\n    /**\n     * Sets the schema type identifier. Must be a non-empty string.\n     */\n    protected set type(value: string) {\n        if (typeof value !== 'string' || !value)\n            throw new Error('value should be non empty string');\n        this.#type = value;\n    }\n\n    /**\n     * A list of preprocessors associated with\n     * the Builder\n     */\n    protected get preprocessors() {\n        return this.#preprocessors;\n    }\n\n    /**\n     * A list of validators associated with\n     * the Builder\n     */\n    protected get validators() {\n        return this.#validators;\n    }\n\n    /**\n     * Whether the schema requires a non-null/non-undefined value.\n     */\n    protected get isRequired(): TRequired {\n        return this.#isRequired as TRequired;\n    }\n\n    /**\n     * Whether `null` is an accepted value for this schema.\n     */\n    protected get isNullable(): boolean {\n        return this.#isNullable;\n    }\n\n    /**\n     * Sets the requirement flag. Must be a boolean.\n     */\n    protected set isRequired(value: boolean) {\n        if (typeof value !== 'boolean')\n            throw new Error('should be a boolean value');\n        this.#isRequired = value as any;\n    }\n\n    /**\n     * The error message provider used for the \"is required\" error.\n     * Exposed for fast-path validation in subclasses.\n     */\n    protected get requiredErrorMessage(): ValidationErrorMessageProvider {\n        return this.#requiredErrorMessageProvider;\n    }\n\n    /**\n     * Whether this schema has a default value configured via `.default()`.\n     * Exposed for fast-path validation in subclasses.\n     */\n    protected get hasDefault(): boolean {\n        return this.#defaultValue !== undefined;\n    }\n\n    /**\n     * Whether this schema has a catch/fallback value configured via `.catch()`.\n     */\n    protected get hasCatch(): boolean {\n        return this.#hasCatch;\n    }\n\n    /**\n     * Resolves the catch/fallback value. If the stored value is a factory function,\n     * it is called to produce the value (useful for mutable fallbacks like `() => []`).\n     */\n    protected resolveCatchValue(): TResult {\n        return typeof this.#catchValue === 'function'\n            ? (this.#catchValue as () => TResult)()\n            : (this.#catchValue as TResult);\n    }\n\n    /**\n     * Whether this schema is marked as readonly.\n     * Type-level only — no runtime enforcement.\n     */\n    protected get isReadonly(): boolean {\n        return this.#isReadonly;\n    }\n\n    /**\n     * Resolves the default value. If the stored default is a function,\n     * it is called to produce the value (useful for mutable defaults).\n     */\n    protected resolveDefaultValue(): TResult {\n        return typeof this.#defaultValue === 'function'\n            ? (this.#defaultValue as () => TResult)()\n            : (this.#defaultValue as TResult);\n    }\n\n    /**\n     * Whether `preValidateSync` can be skipped entirely.\n     * True when there are no preprocessors and no validators,\n     * so the only work would be the required check and wrapping\n     * in a noop transaction — which subclasses can do inline.\n     */\n    protected get canSkipPreValidation(): boolean {\n        return this.#canSkipPreValidation;\n    }\n\n    /**\n     * Whether `null` should count as a required-constraint violation.\n     *\n     * By default `null` is treated the same as `undefined` for the purposes\n     * of the required check — i.e. a required schema rejects both.\n     * Subclasses that may legally receive `null` as a value (e.g.\n     * `UnionSchemaBuilder` when a `NullSchemaBuilder` option is present)\n     * can override this to `false` so that `null` bypasses the required\n     * check and is passed directly to their option-validation logic.\n     *\n     * @protected\n     */\n    protected get isNullRequiredViolation(): boolean {\n        return true;\n    }\n\n    /**\n     * Shared setup for both {@link preValidateSync} and {@link preValidateAsync}.\n     * Builds the validation context, creates the initial transaction, and\n     * returns mutable state for the caller to drive.\n     */\n    #initPreValidation(object: any, context?: ValidationContext) {\n        const doNotStopOnFirstError = context?.doNotStopOnFirstError ?? false;\n\n        const resultingContext: ValidationContext = {\n            doNotStopOnFirstError,\n            rootPropertyDescriptor: context?.rootPropertyDescriptor,\n            currentPropertyDescriptor: context?.currentPropertyDescriptor\n        };\n\n        const needsTransaction = this.#hasMutating;\n\n        return {\n            doNotStopOnFirstError,\n            resultingContext,\n            transaction: needsTransaction\n                ? transaction({ validatedObject: object })\n                : noopTransaction({ validatedObject: object }),\n            errors: [] as ValidationError[]\n        };\n    }\n\n    /**\n     * Builds the failed early-return result used when\n     * `doNotStopOnFirstError` is false.\n     */\n    #earlyFailResult(\n        errors: ValidationError[],\n        resultingContext: ValidationContext\n    ): PreValidationResult<any, { validatedObject: any }> {\n        return {\n            valid: false,\n            errors: [errors[0]].filter(e => e),\n            context: resultingContext\n        };\n    }\n\n    /**\n     * Builds the error entries for a validator that reported `valid: false`.\n     */\n    #validatorFailureErrors(\n        index: number,\n        name: string | undefined,\n        validatorErrors: ValidationError[] | undefined\n    ): ValidationError[] {\n        if (Array.isArray(validatorErrors) && validatorErrors.length) {\n            return validatorErrors;\n        }\n        return [\n            {\n                message: `Validator #${index}${\n                    name ? ` (${name})` : ''\n                } didn't pass.`\n            }\n        ];\n    }\n\n    /**\n     * Assembles the final {@link PreValidationResult} after all preprocessors,\n     * validators, and the required check have run.\n     */\n    #buildPreValidationResult(\n        errors: ValidationError[],\n        doNotStopOnFirstError: boolean,\n        resultingContext: ValidationContext,\n        trans: Transaction<{ validatedObject: any }>\n    ): PreValidationResult<any, { validatedObject: any }> {\n        if (errors.length > 0) {\n            return {\n                valid: false,\n                errors: errors\n                    .filter(e => e)\n                    .filter((_e, i) =>\n                        doNotStopOnFirstError ? true : i === 0\n                    ),\n                context: resultingContext,\n                transaction: trans\n            };\n        }\n\n        return {\n            valid: true,\n            context: resultingContext,\n            transaction: trans\n        };\n    }\n\n    /**\n     * Synchronous version of {@link preValidateAsync}.\n     * Throws at runtime if any preprocessor or validator returns a Promise.\n     *\n     * @param object - the value to pre-validate\n     * @param context - optional validation context settings\n     * @returns a `PreValidationResult` containing the preprocessed transaction, context, and any errors\n     * @throws Error if a preprocessor or validator returns a Promise (use {@link preValidateAsync} instead)\n     */\n    protected preValidateSync(\n        object: any,\n        context?: ValidationContext\n    ): PreValidationResult<any, { validatedObject: any }> {\n        const state = this.#initPreValidation(object, context);\n        const { doNotStopOnFirstError, resultingContext, errors } = state;\n        let preprocessingTransaction = state.transaction;\n        let preprocessedObject =\n            preprocessingTransaction.object.validatedObject;\n\n        if (this.#preprocessors.length > 0) {\n            let currentPrepropIndex = 0;\n            for (const entry of this.#preprocessors) {\n                try {\n                    const result = entry.fn(preprocessedObject);\n                    if (result instanceof Promise) {\n                        throw new Error(\n                            `Preprocessor #${currentPrepropIndex}${entry.fn.name ? ` (${entry.fn.name})` : ''} returned a Promise. Use validateAsync() for schemas with async preprocessors.`\n                        );\n                    }\n                    preprocessedObject = result;\n                } catch (err) {\n                    if (\n                        (err as Error).message?.includes('Use validateAsync()')\n                    ) {\n                        throw err;\n                    }\n                    errors.push({\n                        message: `Preprocessor #${currentPrepropIndex}${\n                            entry.fn.name ? ` (${entry.fn.name})` : ''\n                        } thrown an error: ${(err as Error).message}`\n                    });\n                    if (!doNotStopOnFirstError) {\n                        return this.#earlyFailResult(errors, resultingContext);\n                    }\n                } finally {\n                    currentPrepropIndex++;\n                }\n            }\n            preprocessingTransaction = this.#hasMutating\n                ? transaction({ validatedObject: preprocessedObject })\n                : noopTransaction({ validatedObject: preprocessedObject });\n        }\n\n        if (typeof preprocessedObject === 'undefined' && this.hasDefault) {\n            preprocessedObject = this.resolveDefaultValue();\n            preprocessingTransaction = this.#hasMutating\n                ? transaction({ validatedObject: preprocessedObject })\n                : noopTransaction({ validatedObject: preprocessedObject });\n        }\n\n        if (\n            this.#validators.length > 0 &&\n            !(preprocessedObject == null && !this.isRequired) &&\n            !(preprocessedObject === null && this.#isNullable)\n        ) {\n            let currentValidatorIndex = 0;\n            for (const entry of this.#validators) {\n                try {\n                    const validatorResult = entry.fn(preprocessedObject);\n                    if (validatorResult instanceof Promise) {\n                        throw new Error(\n                            `Validator #${currentValidatorIndex}${entry.fn.name ? ` (${entry.fn.name})` : ''} returned a Promise. Use validateAsync() for schemas with async validators.`\n                        );\n                    }\n                    const { valid, errors: validatorErrors } = validatorResult;\n                    if (!valid) {\n                        errors.push(\n                            ...this.#validatorFailureErrors(\n                                currentValidatorIndex,\n                                entry.fn.name,\n                                validatorErrors\n                            )\n                        );\n                        if (!doNotStopOnFirstError) {\n                            return this.#earlyFailResult(\n                                errors,\n                                resultingContext\n                            );\n                        }\n                    }\n                } catch (err) {\n                    if (\n                        (err as Error).message?.includes('Use validateAsync()')\n                    ) {\n                        throw err;\n                    }\n                    errors.push({\n                        message: `Validator #${currentValidatorIndex}${\n                            entry.fn.name ? ` (${entry.fn.name})` : ''\n                        } thrown an error: ${(err as Error).message}`\n                    });\n                    if (!doNotStopOnFirstError) {\n                        return this.#earlyFailResult(errors, resultingContext);\n                    }\n                } finally {\n                    currentValidatorIndex++;\n                }\n            }\n        }\n\n        if (\n            this.isRequired &&\n            (typeof preprocessedObject === 'undefined' ||\n                (preprocessedObject === null &&\n                    this.isNullRequiredViolation &&\n                    !this.#isNullable))\n        ) {\n            errors.push({\n                message: this.getValidationErrorMessageSync(\n                    this.#requiredErrorMessageProvider,\n                    preprocessedObject\n                )\n            });\n            if (!doNotStopOnFirstError) {\n                preprocessingTransaction.rollback();\n                return this.#earlyFailResult(errors, resultingContext);\n            }\n        }\n\n        return this.#buildPreValidationResult(\n            errors,\n            doNotStopOnFirstError,\n            resultingContext,\n            preprocessingTransaction\n        );\n    }\n\n    /**\n     * Async version of pre-validation. Runs preprocessors, validators, and the\n     * required/optional check on `object`. Supports async preprocessors,\n     * validators, and error message providers.\n     *\n     * @param object - the value to pre-validate\n     * @param context - optional validation context settings\n     * @returns a `PreValidationResult` containing the preprocessed transaction, context, and any errors\n     */\n    protected async preValidateAsync(\n        object: any,\n        context?: ValidationContext\n    ): Promise<PreValidationResult<any, { validatedObject: any }>> {\n        const state = this.#initPreValidation(object, context);\n        const { doNotStopOnFirstError, resultingContext, errors } = state;\n        let preprocessingTransaction = state.transaction;\n        let preprocessedObject =\n            preprocessingTransaction.object.validatedObject;\n\n        if (this.#preprocessors.length > 0) {\n            let currentPrepropIndex = 0;\n            for (const entry of this.#preprocessors) {\n                try {\n                    preprocessedObject = await Promise.resolve(\n                        entry.fn(preprocessedObject)\n                    );\n                } catch (err) {\n                    errors.push({\n                        message: `Preprocessor #${currentPrepropIndex}${\n                            entry.fn.name ? ` (${entry.fn.name})` : ''\n                        } thrown an error: ${(err as Error).message}`\n                    });\n                    if (!doNotStopOnFirstError) {\n                        return this.#earlyFailResult(errors, resultingContext);\n                    }\n                } finally {\n                    currentPrepropIndex++;\n                }\n            }\n            preprocessingTransaction = this.#hasMutating\n                ? transaction({ validatedObject: preprocessedObject })\n                : noopTransaction({ validatedObject: preprocessedObject });\n        }\n\n        if (typeof preprocessedObject === 'undefined' && this.hasDefault) {\n            preprocessedObject = this.resolveDefaultValue();\n            preprocessingTransaction = this.#hasMutating\n                ? transaction({ validatedObject: preprocessedObject })\n                : noopTransaction({ validatedObject: preprocessedObject });\n        }\n\n        if (\n            this.#validators.length > 0 &&\n            !(preprocessedObject == null && !this.isRequired) &&\n            !(preprocessedObject === null && this.#isNullable)\n        ) {\n            let currentValidatorIndex = 0;\n            for (const entry of this.#validators) {\n                try {\n                    const { valid, errors: validatorErrors } =\n                        await Promise.resolve(entry.fn(preprocessedObject));\n                    if (!valid) {\n                        errors.push(\n                            ...this.#validatorFailureErrors(\n                                currentValidatorIndex,\n                                entry.fn.name,\n                                validatorErrors\n                            )\n                        );\n                        if (!doNotStopOnFirstError) {\n                            return this.#earlyFailResult(\n                                errors,\n                                resultingContext\n                            );\n                        }\n                    }\n                } catch (err) {\n                    errors.push({\n                        message: `Validator #${currentValidatorIndex}${\n                            entry.fn.name ? ` (${entry.fn.name})` : ''\n                        } thrown an error: ${(err as Error).message}`\n                    });\n                    if (!doNotStopOnFirstError) {\n                        return this.#earlyFailResult(errors, resultingContext);\n                    }\n                } finally {\n                    currentValidatorIndex++;\n                }\n            }\n        }\n\n        if (\n            this.isRequired &&\n            (typeof preprocessedObject === 'undefined' ||\n                (preprocessedObject === null &&\n                    this.isNullRequiredViolation &&\n                    !this.#isNullable))\n        ) {\n            errors.push({\n                message: await this.getValidationErrorMessage(\n                    this.#requiredErrorMessageProvider,\n                    preprocessedObject\n                )\n            });\n            if (!doNotStopOnFirstError) {\n                preprocessingTransaction.rollback();\n                return this.#earlyFailResult(errors, resultingContext);\n            }\n        }\n\n        return this.#buildPreValidationResult(\n            errors,\n            doNotStopOnFirstError,\n            resultingContext,\n            preprocessingTransaction\n        );\n    }\n\n    /**\n     * @deprecated Use {@link preValidateAsync} instead. This alias will be removed in a future version.\n     */\n    protected preValidate(\n        object: any,\n        context?: ValidationContext\n    ): Promise<PreValidationResult<any, { validatedObject: any }>> {\n        return this.preValidateAsync(object, context);\n    }\n\n    /**\n     * Generates a serializable object describing the defined schema\n     */\n    public introspect() {\n        return {\n            /**\n             * String `id` of schema type, e.g. `string', `number` or `object`.\n             */\n            type: this.type,\n            /**\n             * If set to `false`, schema will be optional (`null` or `undefined` values\n             * will be considered as valid).\n             */\n            isRequired: this.#isRequired,\n            /**\n             * If set to `true`, schema values of `null` are considered valid.\n             */\n            isNullable: this.#isNullable,\n            /**\n             * If set to `true`, the inferred type is marked as readonly.\n             * Type-level only — no runtime enforcement.\n             */\n            isReadonly: this.#isReadonly,\n            /**\n             * Array of preprocessor functions\n             */\n            preprocessors: [\n                ...this.preprocessors\n            ] as readonly PreprocessorEntry<TResult>[],\n            /**\n             * Array of validator functions\n             */\n            validators: [\n                ...this.validators\n            ] as readonly ValidatorEntry<TResult>[],\n            /**\n             * Custom error message provider for the 'is required' validation error.\n             */\n            requiredValidationErrorMessageProvider:\n                this.#requiredErrorMessageProvider,\n            /**\n             * Extension metadata. Stores custom state set by schema extensions.\n             */\n            extensions: { ...this.#extensions },\n            /**\n             * Whether a default value (or factory) has been set on this schema.\n             */\n            hasDefault: this.#defaultValue !== undefined,\n            /**\n             * The default value or factory function.\n             */\n            defaultValue: this.#defaultValue,\n            /**\n             * The human-readable description attached to this schema via `.describe()`,\n             * or `undefined` if none was set.\n             */\n            description: this.#description,\n            /**\n             * Whether a catch/fallback value has been set on this schema via `.catch()`.\n             */\n            hasCatch: this.#hasCatch,\n            /**\n             * The catch/fallback value or factory function set via `.catch()`.\n             */\n            catchValue: this.#catchValue\n        };\n    }\n\n    /**\n     * Makes schema optional (consider `null` and `undefined` as valid objects for this schema)\n     */\n    public optional() {\n        return this.createFromProps({\n            ...this.introspect(),\n            isRequired: false\n        }) as any;\n    }\n\n    /**\n     * Makes schema nullable — `null` is accepted as a valid value.\n     *\n     * Unlike `.optional()` which accepts `undefined`, `.nullable()` accepts\n     * `null`. The inferred type changes from `T` to `T | null`. Combine with\n     * `.optional()` to accept both `null` and `undefined`.\n     */\n    public nullable() {\n        return this.createFromProps({\n            ...this.introspect(),\n            isNullable: true\n        }) as any;\n    }\n\n    /**\n     * Removes the nullable mark — `null` is no longer accepted as a valid\n     * value. This is the counterpart of `.nullable()`.\n     */\n    public notNullable() {\n        return this.createFromProps({\n            ...this.introspect(),\n            isNullable: false\n        }) as any;\n    }\n\n    /**\n     * Sets a default value for this schema. When the input is `undefined`,\n     * the default value is used instead. The default is still validated\n     * against the schema's constraints.\n     *\n     * Accepts either a static value or a factory function (useful for\n     * mutable defaults like `() => new Date()` or `() => []`).\n     *\n     * @example\n     * ```ts\n     * const schema = string().default('hello');\n     * schema.validate(undefined); // { valid: true, object: 'hello' }\n     * schema.validate('world');   // { valid: true, object: 'world' }\n     * ```\n     *\n     * @example\n     * ```ts\n     * // Factory function for mutable defaults\n     * const schema = array(string()).default(() => []);\n     * ```\n     */\n    public default(value: TResult | (() => TResult)) {\n        return this.createFromProps({\n            ...this.introspect(),\n            defaultValue: value\n        }) as any;\n    }\n\n    /**\n     * Sets a fallback value for this schema. When validation **fails** for any reason,\n     * the fallback value is returned as a successful result instead of validation errors.\n     *\n     * This is useful for graceful degradation — for example, providing a safe default\n     * when parsing untrusted input that might not conform to the schema.\n     *\n     * Accepts either a static value or a factory function. Factory functions are called\n     * each time the fallback is needed (useful for mutable values like `() => []`).\n     *\n     * Unlike {@link default}, which only fires when the input is `undefined`, `.catch()`\n     * fires on **any** validation failure — type mismatch, constraint violation, etc.\n     *\n     * When `.catch()` is set, {@link parse} and {@link parseAsync} will **never throw**.\n     *\n     * @param value - the fallback value, or a factory function producing the fallback\n     *\n     * @example\n     * ```ts\n     * const schema = string().catch('unknown');\n     * schema.validate(42);        // { valid: true, object: 'unknown' }\n     * schema.validate('hello');   // { valid: true, object: 'hello' }\n     * schema.parse(42);           // 'unknown'  (no throw)\n     * ```\n     *\n     * @example\n     * ```ts\n     * // Factory function for mutable fallbacks\n     * const schema = array(string()).catch(() => []);\n     * schema.validate(null);  // { valid: true, object: [] }\n     * ```\n     *\n     * @example\n     * ```ts\n     * // Contrast with .default() — default fires only on undefined\n     * const d = string().default('anon');\n     * d.validate(undefined); // { valid: true, object: 'anon' }  ← fires\n     * d.validate(42);        // { valid: false, errors: [...] }  ← does NOT fire\n     *\n     * const c = string().catch('anon');\n     * c.validate(undefined); // { valid: true, object: 'anon' }  ← fires\n     * c.validate(42);        // { valid: true, object: 'anon' }  ← also fires\n     * ```\n     */\n    public catch(value: TResult | (() => TResult)): this {\n        return this.createFromProps({\n            ...this.introspect(),\n            catchValue: value,\n            hasCatch: true\n        }) as unknown as this;\n    }\n\n    /**\n     * Removes the default value set by a previous call to `.default()`.\n     */\n    public clearDefault() {\n        return this.createFromProps({\n            ...this.introspect(),\n            defaultValue: undefined\n        }) as any;\n    }\n\n    /**\n     * Attaches a human-readable description to this schema as runtime metadata.\n     *\n     * The description has no effect on validation — it is purely informational.\n     * It is accessible via `.introspect().description` and is emitted as the\n     * `description` field by `toJsonSchema()` from `@cleverbrush/schema-json`.\n     *\n     * Useful for documentation generation, form labels, and AI tool descriptions.\n     *\n     * @example\n     * ```ts\n     * const schema = object({\n     *   name: string().describe('The user\\'s full name'),\n     *   age:  number().optional().describe('Age in years'),\n     * }).describe('A user object');\n     *\n     * schema.introspect().description; // 'A user object'\n     * ```\n     */\n    public describe(text: string): this {\n        return this.createFromProps({\n            ...this.introspect(),\n            description: text\n        }) as unknown as this;\n    }\n\n    /**\n     * Brands the schema with a phantom type tag, preventing structural mixing\n     * of semantically different values at the type level. Zero runtime cost.\n     *\n     * The optional `_name` parameter is only needed when using plain JavaScript\n     * (where generic type parameters are unavailable). In TypeScript, prefer\n     * the generic form: `schema.brand<'Email'>()`.\n     *\n     * @example\n     * ```ts\n     * const Email = string().brand<'Email'>();\n     * const Username = string().brand<'Username'>();\n     * type Email = InferType<typeof Email>;     // string & { readonly [BRAND]: 'Email' }\n     * type Username = InferType<typeof Username>; // string & { readonly [BRAND]: 'Username' }\n     * ```\n     */\n    public brand<TBrand extends string | symbol>(_name?: TBrand) {\n        return this.createFromProps({\n            ...this.introspect()\n        }) as any;\n    }\n\n    /**\n     * Marks the inferred type as readonly. For objects, produces `Readonly<T>`.\n     * For arrays, produces `ReadonlyArray<T>`. Primitives are unchanged.\n     * Type-level only — no runtime enforcement.\n     *\n     * @example\n     * ```ts\n     * const schema = object({ name: string(), age: number() }).readonly();\n     * type T = InferType<typeof schema>; // Readonly<{ name: string; age: number }>\n     * ```\n     *\n     * @example\n     * ```ts\n     * const schema = array(string()).readonly();\n     * type T = InferType<typeof schema>; // ReadonlyArray<string>\n     * ```\n     */\n    public readonly() {\n        return this.createFromProps({\n            ...this.introspect(),\n            isReadonly: true\n        }) as any;\n    }\n\n    /**\n     * Makes schema required (consider `null` and `undefined` as invalid objects for this schema)\n     * @param errorMessage - optional custom error message or provider for the 'is required' validation error\n     */\n    public required(errorMessage?: ValidationErrorMessageProvider) {\n        return this.createFromProps({\n            ...this.introspect(),\n            isRequired: true,\n            ...(errorMessage !== undefined\n                ? {\n                      requiredValidationErrorMessageProvider:\n                          this.assureValidationErrorMessageProvider(\n                              errorMessage,\n                              this.#defaultRequiredErrorMessageProvider\n                          )\n                  }\n                : {})\n        }) as any;\n    }\n\n    /**\n     * Adds a `preprocessor` to a preprocessors list\n     */\n    public addPreprocessor(\n        preprocessor: Preprocessor<TResult>,\n        options?: { mutates?: boolean }\n    ): this {\n        if (typeof preprocessor !== 'function') {\n            throw new Error('preprocessor must be a function');\n        }\n        return this.createFromProps({\n            ...this.introspect(),\n            preprocessors: [\n                ...this.preprocessors,\n                { fn: preprocessor, mutates: options?.mutates ?? true }\n            ]\n        });\n    }\n\n    /**\n     * Remove all preprocessors for this schema.\n     */\n    public clearPreprocessors(): this {\n        return this.createFromProps({\n            ...this.introspect(),\n            preprocessors: []\n        });\n    }\n\n    /**\n     * Adds a `validator` to validators list.\n     */\n    public addValidator(\n        validator: Validator<TResult>,\n        options?: { mutates?: boolean }\n    ): this {\n        if (typeof validator !== 'function') {\n            throw new Error('validator must be a function');\n        }\n        return this.createFromProps({\n            ...this.introspect(),\n            validators: [\n                ...this.validators,\n                { fn: validator, mutates: options?.mutates ?? false }\n            ]\n        });\n    }\n\n    /**\n     * Remove all validators for this schema.\n     */\n    public clearValidators(): this {\n        return this.createFromProps({\n            ...this.introspect(),\n            validators: []\n        });\n    }\n\n    /**\n     * Perform synchronous schema validation on `object`.\n     * Throws at runtime if any preprocessor, validator, or error message\n     * provider returns a Promise — use {@link validateAsync} instead.\n     * @internal Override this in subclasses. External callers use {@link validate}.\n     */\n    protected abstract _validate(\n        object: any,\n        context?: ValidationContext\n    ): ValidationResult<any>;\n\n    /**\n     * Perform asynchronous schema validation on `object`.\n     * Supports async preprocessors, validators, and error message providers.\n     * @internal Override this in subclasses. External callers use {@link validateAsync}.\n     */\n    protected abstract _validateAsync(\n        object: any,\n        context?: ValidationContext\n    ): Promise<ValidationResult<any>>;\n\n    /**\n     * Perform synchronous schema validation on `object`.\n     * Throws at runtime if any preprocessor, validator, or error message\n     * provider returns a Promise — use {@link validateAsync} instead.\n     *\n     * If a fallback has been set via {@link catch}, a failed validation result\n     * is replaced by a successful result built from the fallback value, preserving\n     * the specialized result shape (e.g. `getErrorsFor` / `getNestedErrors` methods).\n     */\n    public validate(\n        /**\n         * Object to validate\n         */\n        object: any,\n        /**\n         * Optional `ValidationContext` settings\n         */\n        context?: ValidationContext\n    ): ValidationResult<any> {\n        const result = this._validate(object, context);\n        if (!result.valid && this.#hasCatch) {\n            const catchValue = this.resolveCatchValue();\n            // Re-validate the fallback value so the returned result has the same\n            // specialized shape as a normal successful result (e.g. getErrorsFor /\n            // getNestedErrors helper methods are present and reflect success semantics).\n            const catchResult = this._validate(catchValue, context);\n            if (catchResult.valid) {\n                return catchResult;\n            }\n            // Fallback value did not pass validation (user error) – return a plain\n            // valid result as best-effort so that .catch() still suppresses the error.\n            // Note: in this case specialized result methods such as getErrorsFor() /\n            // getNestedErrors() will NOT be present on the returned object. This is an\n            // edge case caused by the caller supplying a catch value that itself fails\n            // schema validation; the type system should prevent this under normal use.\n            return { valid: true, object: catchValue };\n        }\n        return result;\n    }\n\n    /**\n     * Perform asynchronous schema validation on `object`.\n     * Supports async preprocessors, validators, and error message providers.\n     *\n     * If a fallback has been set via {@link catch}, a failed validation result\n     * is replaced by a successful result built from the fallback value, preserving\n     * the specialized result shape (e.g. `getErrorsFor` / `getNestedErrors` methods).\n     */\n    public async validateAsync(\n        /**\n         * Object to validate\n         */\n        object: any,\n        /**\n         * Optional `ValidationContext` settings\n         */\n        context?: ValidationContext\n    ): Promise<ValidationResult<any>> {\n        const result = await this._validateAsync(object, context);\n        if (!result.valid && this.#hasCatch) {\n            const catchValue = this.resolveCatchValue();\n            // Re-validate the fallback value so the returned result has the same\n            // specialized shape as a normal successful result (e.g. getErrorsFor /\n            // getNestedErrors helper methods are present and reflect success semantics).\n            const catchResult = await this._validateAsync(catchValue, context);\n            if (catchResult.valid) {\n                return catchResult;\n            }\n            // Fallback value did not pass validation (user error) – return a plain\n            // valid result as best-effort so that .catch() still suppresses the error.\n            // Note: in this case specialized result methods such as getErrorsFor() /\n            // getNestedErrors() will NOT be present on the returned object. This is an\n            // edge case caused by the caller supplying a catch value that itself fails\n            // schema validation; the type system should prevent this under normal use.\n            return { valid: true, object: catchValue };\n        }\n        return result;\n    }\n\n    /**\n     * Synchronously resolves a `ValidationErrorMessageProvider` to a string.\n     * Throws if the provider function returns a Promise.\n     *\n     * @param provider - the error message provider (string or sync function)\n     * @param seenValue - the value that caused the validation error\n     * @returns the resolved error message string\n     * @throws Error if the provider returns a Promise (use {@link getValidationErrorMessage} with {@link validateAsync})\n     */\n    protected getValidationErrorMessageSync(\n        provider: ValidationErrorMessageProvider<any>,\n        seenValue: TResult\n    ): string {\n        if (typeof provider === 'string') {\n            return provider;\n        }\n\n        if (typeof provider === 'function') {\n            const result = provider(seenValue, this);\n            if (result instanceof Promise) {\n                throw new Error(\n                    'Async error message providers require validateAsync(). Use a string or sync function instead.'\n                );\n            }\n            return result;\n        }\n\n        throw new Error(\n            'Invalid error message provider must be a string or a function returning a string'\n        );\n    }\n\n    /**\n     * Resolves a `ValidationErrorMessageProvider` to a string error message.\n     * Handles both string providers and function providers (sync or async).\n     *\n     * @param provider - the error message provider (string or function)\n     * @param seenValue - the value that caused the validation error\n     * @returns the resolved error message string\n     */\n    protected async getValidationErrorMessage(\n        provider: ValidationErrorMessageProvider<any>,\n        seenValue: TResult\n    ): Promise<string> {\n        if (typeof provider === 'string') {\n            return provider;\n        }\n\n        if (typeof provider === 'function') {\n            return provider(seenValue, this);\n        }\n\n        throw new Error(\n            'Invalid error message provider must be a string or a function returning a string or a promise of a string'\n        );\n    }\n\n    /**\n     * Ensures a `ValidationErrorMessageProvider` is valid.\n     * If `provider` is `undefined`, falls back to `defaultValue`.\n     * Function providers are bound to `this` for access to schema state.\n     *\n     * @param provider - the provider to validate, or `undefined`\n     * @param defaultValue - fallback provider when `provider` is not supplied\n     * @returns a valid `ValidationErrorMessageProvider`\n     */\n    protected assureValidationErrorMessageProvider(\n        provider: ValidationErrorMessageProvider<any> | undefined,\n        defaultValue: ValidationErrorMessageProvider<any>\n    ): ValidationErrorMessageProvider<any> {\n        if (typeof provider === 'string') {\n            return provider;\n        }\n        if (typeof provider === 'function') {\n            return provider.bind(this);\n        }\n\n        if (typeof defaultValue === 'function') {\n            return defaultValue.bind(this);\n        }\n\n        return defaultValue;\n    }\n\n    /**\n     * Sets extension metadata by key. Returns a new schema instance with the\n     * extension data stored. The data survives fluent chaining.\n     * @internal Used by extension authors inside `defineExtension()` callbacks.\n     */\n    public withExtension(key: string, value: unknown): this {\n        return this.createFromProps({\n            ...this.introspect(),\n            extensions: {\n                ...this.#extensions,\n                [key]: value\n            }\n        });\n    }\n\n    /**\n     * Retrieves extension metadata by key.\n     * @internal Used by extension authors inside `defineExtension()` callbacks.\n     */\n    public getExtension(key: string): unknown {\n        return this.#extensions[key];\n    }\n\n    /**\n     * Synchronously validates the value and returns it if valid.\n     * Throws a {@link SchemaValidationError} if validation fails.\n     *\n     * @param object - the value to parse\n     * @param context - optional validation context\n     * @returns the validated value\n     * @throws SchemaValidationError if validation fails\n     * @throws Error if the schema contains async preprocessors, validators, or error message providers\n     */\n    public parse(object: any, context?: ValidationContext): TResult {\n        const result = this.validate(object, context);\n        if (!result.valid) {\n            throw new SchemaValidationError(result.errors || []);\n        }\n        return result.object as TResult;\n    }\n\n    /**\n     * Asynchronously validates the value and returns it if valid.\n     * Throws a {@link SchemaValidationError} if validation fails.\n     *\n     * @param object - the value to parse\n     * @param context - optional validation context\n     * @returns the validated value\n     * @throws SchemaValidationError if validation fails\n     */\n    public async parseAsync(\n        object: any,\n        context?: ValidationContext\n    ): Promise<TResult> {\n        const result = await this.validateAsync(object, context);\n        if (!result.valid) {\n            throw new SchemaValidationError(result.errors || []);\n        }\n        return result.object as TResult;\n    }\n\n    /**\n     * Alias for {@link validate}. Synchronously validates and returns a result object.\n     * Provided for familiarity with the zod API.\n     */\n    public safeParse(\n        object: any,\n        context?: ValidationContext\n    ): ValidationResult<TResult> {\n        return this.validate(object, context) as ValidationResult<TResult>;\n    }\n\n    /**\n     * Alias for {@link validateAsync}. Asynchronously validates and returns a result object.\n     * Provided for familiarity with the zod API.\n     */\n    public safeParseAsync(\n        object: any,\n        context?: ValidationContext\n    ): Promise<ValidationResult<TResult>> {\n        return this.validateAsync(object, context) as Promise<\n            ValidationResult<TResult>\n        >;\n    }\n\n    protected constructor(props: SchemaBuilderProps<TResult>) {\n        if (!(typeof props === 'object' && props))\n            throw new Error('SchemaBuilder props must be an object');\n        const { type, preprocessors, validators, isRequired } = props;\n        this.type = type;\n        if (typeof isRequired === 'boolean') this.isRequired = isRequired;\n        if (typeof props.isNullable === 'boolean')\n            this.#isNullable = props.isNullable;\n        if (typeof props.isReadonly === 'boolean')\n            this.#isReadonly = props.isReadonly;\n        if (Array.isArray(preprocessors)) {\n            this.#preprocessors = [...preprocessors];\n        }\n\n        if (Array.isArray(validators)) {\n            this.#validators = [...validators];\n        }\n\n        this.#hasMutating =\n            this.#preprocessors.some(p => p.mutates) ||\n            this.#validators.some(v => v.mutates);\n\n        this.#canSkipPreValidation =\n            this.#preprocessors.length === 0 && this.#validators.length === 0;\n\n        if (typeof props.extensions === 'object' && props.extensions) {\n            this.#extensions = { ...props.extensions };\n        }\n\n        if (props.defaultValue !== undefined) {\n            this.#defaultValue = props.defaultValue;\n        }\n\n        if (props.hasCatch) {\n            this.#hasCatch = true;\n            this.#catchValue = props.catchValue;\n        }\n\n        if (typeof props.description === 'string') {\n            this.#description = props.description;\n        }\n\n        this.#requiredErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.requiredValidationErrorMessageProvider,\n                this.#defaultRequiredErrorMessageProvider\n            );\n    }\n}\n"],"mappings":"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","names":["TRANSACTION_SYMBOL","defaultNonTransactionalTypes","defaultTransactionOptions","child","t","transaction","initial","options","newProperties","deletedProperties","shouldNotWrapWithTransaction","isDirty","key","commit","result","value","childCommit","rollback","el","commitArray","isDirtyArray","val","index","proxy","target","property","k","prop","isTransaction","object","p","noopTransaction","obj","SchemaValidationError","errors","message","e","SYMBOL_SCHEMA_PROPERTY_DESCRIPTOR","SYMBOL_HAS_PROPERTIES","createHybridErrorArray","items","seenValue","descriptor","SchemaBuilder","#isRequired","#isNullable","#isReadonly","#description","#preprocessors","#validators","#hasMutating","#canSkipPreValidation","#extensions","#type","#defaultRequiredErrorMessageProvider","#requiredErrorMessageProvider","#defaultValue","#catchValue","#hasCatch","#standardProps","self","value","result","#initPreValidation","object","context","doNotStopOnFirstError","resultingContext","needsTransaction","transaction","noopTransaction","#earlyFailResult","#validatorFailureErrors","index","name","validatorErrors","#buildPreValidationResult","trans","_e","i","state","preprocessingTransaction","preprocessedObject","currentPrepropIndex","entry","err","currentValidatorIndex","validatorResult","valid","text","_name","errorMessage","preprocessor","options","validator","catchValue","catchResult","provider","defaultValue","key","props","type","preprocessors","validators","isRequired","p","v"]}

package/dist/chunk-EUQ5AE3H.js

@@ -0,0 +1,2 @@
+import{f as l}from"./chunk-CTP4RHDG.js";var a=class i extends l{static create(e){return new i({type:"function",...e})}constructor(e){super(e)}hasType(e){return this.createFromProps({...this.introspect()})}clearHasType(){return this.createFromProps({...this.introspect()})}#e(e){let{valid:t,transaction:s,errors:u}=e;if(!t)return{valid:t,errors:u};let{object:{validatedObject:n}}=s;return typeof n>"u"&&!this.isRequired||n===null&&(!this.isRequired||this.isNullable)?{valid:!0,object:n}:typeof n!="function"?{valid:!1,errors:[{message:`expected type function, but saw ${typeof n}`}]}:{valid:!0,object:n}}validate(e,t){return super.validate(e,t)}async validateAsync(e,t){return super.validateAsync(e,t)}_validate(e,t){return this.#e(this.preValidateSync(e,t))}async _validateAsync(e,t){return this.#e(await super.preValidateAsync(e,t))}createFromProps(e){return i.create(e)}required(e){return super.required(e)}optional(){return super.optional()}default(e){return super.default(e)}clearDefault(){return super.clearDefault()}brand(e){return super.brand(e)}readonly(){return super.readonly()}nullable(){return super.nullable()}notNullable(){return super.notNullable()}},o=()=>a.create({isRequired:!0});export{a,o as b};
+//# sourceMappingURL=chunk-EUQ5AE3H.js.map

package/dist/chunk-EUQ5AE3H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/builders/FunctionSchemaBuilder.ts"],"sourcesContent":["import {\n    type BRAND,\n    SchemaBuilder,\n    type ValidationContext,\n    type ValidationErrorMessageProvider,\n    type ValidationResult\n} from './SchemaBuilder.js';\n\ntype FunctionSchemaBuilderCreateProps<R extends boolean = true> = Partial<\n    ReturnType<FunctionSchemaBuilder<R>['introspect']>\n>;\n\n/**\n * Schema builder for functions. Allows to define a schema for a function.\n * It can be: required or optional.\n *\n * **NOTE** this class is exported only to give opportunity to extend it\n * by inheriting. It is not recommended to create an instance of this class\n * directly. Use {@link func | func()} function instead.\n *\n * @example\n * ```ts\n * const schema = func();\n * const result = schema.validate(() => {});\n * // result.valid === true\n * // result.object === () => {}\n * ```\n *\n * @example\n * ```ts\n * const schema = func().optional();\n * const result = schema.validate(undefined);\n * // result.valid === true\n * // result.object === undefined\n * ```\n *\n * @see {@link func}\n */\nexport class FunctionSchemaBuilder<\n    TRequired extends boolean = true,\n    TNullable extends boolean = false,\n    TExplicitType = undefined,\n    THasDefault extends boolean = false,\n    TExtensions = {},\n    TResult = TExplicitType extends undefined\n        ? (...args: any[]) => any\n        : TExplicitType\n> extends SchemaBuilder<\n    TResult,\n    TRequired,\n    TNullable,\n    THasDefault,\n    TExtensions\n> {\n    /**\n     * @hidden\n     */\n    public static create(props: FunctionSchemaBuilderCreateProps<any>) {\n        return new FunctionSchemaBuilder({\n            type: 'function',\n            ...props\n        });\n    }\n\n    protected constructor(props: FunctionSchemaBuilderCreateProps<TRequired>) {\n        super(props as any);\n    }\n\n    /**\n     * @hidden\n     */\n    public hasType<T>(\n        _notUsed?: T\n    ): FunctionSchemaBuilder<true, TNullable, T, THasDefault, TExtensions> &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect()\n        } as any) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public clearHasType(): FunctionSchemaBuilder<\n        TRequired,\n        TNullable,\n        undefined,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect()\n        } as any) as any;\n    }\n\n    #buildResult(\n        superResult: ReturnType<FunctionSchemaBuilder['preValidateSync']>\n    ): ValidationResult<TResult> {\n        const {\n            valid,\n            transaction: preValidationTransaction,\n            errors\n        } = superResult;\n\n        if (!valid) {\n            return { valid, errors };\n        }\n\n        const {\n            object: { validatedObject: objToValidate }\n        } = preValidationTransaction!;\n\n        if (\n            (typeof objToValidate === 'undefined' && !this.isRequired) ||\n            (objToValidate === null && (!this.isRequired || this.isNullable))\n        ) {\n            return {\n                valid: true,\n                object: objToValidate\n            };\n        }\n\n        if (typeof objToValidate !== 'function') {\n            return {\n                valid: false,\n                errors: [\n                    {\n                        message: `expected type function, but saw ${typeof objToValidate}`\n                    }\n                ]\n            };\n        }\n\n        return {\n            valid: true,\n            object: objToValidate\n        };\n    }\n\n    /** {@inheritDoc SchemaBuilder.validate} */\n    public validate(\n        object: TResult,\n        context?: ValidationContext\n    ): ValidationResult<TResult> {\n        return super.validate(object, context) as ValidationResult<TResult>;\n    }\n\n    /** {@inheritDoc SchemaBuilder.validateAsync} */\n    public async validateAsync(\n        object: TResult,\n        context?: ValidationContext\n    ): Promise<ValidationResult<TResult>> {\n        return super.validateAsync(object, context) as Promise<\n            ValidationResult<TResult>\n        >;\n    }\n\n    /**\n     * Performs synchronous validation of the schema over `object`.\n     * Throws if any preprocessor, validator, or error message provider returns a Promise.\n     * @param context Optional `ValidationContext` settings.\n     */\n    protected _validate(\n        object: TResult,\n        context?: ValidationContext\n    ): ValidationResult<TResult> {\n        return this.#buildResult(this.preValidateSync(object, context));\n    }\n\n    /**\n     * Performs async validation of the schema over `object`.\n     * Supports async preprocessors, validators, and error message providers.\n     * @param context Optional `ValidationContext` settings.\n     */\n    protected async _validateAsync(\n        object: TResult,\n        context?: ValidationContext\n    ): Promise<ValidationResult<TResult>> {\n        return this.#buildResult(await super.preValidateAsync(object, context));\n    }\n\n    protected createFromProps<TReq extends boolean>(\n        props: FunctionSchemaBuilderCreateProps<TReq>\n    ): this {\n        return FunctionSchemaBuilder.create(props as any) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public required(\n        errorMessage?: ValidationErrorMessageProvider\n    ): FunctionSchemaBuilder<\n        true,\n        TNullable,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.required(errorMessage);\n    }\n\n    /**\n     * @hidden\n     */\n    public optional(): FunctionSchemaBuilder<\n        false,\n        TNullable,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.optional();\n    }\n\n    /**\n     * @hidden\n     */\n    public default(\n        value: TResult | (() => TResult)\n    ): FunctionSchemaBuilder<\n        true,\n        TNullable,\n        TExplicitType,\n        true,\n        TExtensions\n    > &\n        TExtensions {\n        return super.default(value) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public clearDefault(): FunctionSchemaBuilder<\n        TRequired,\n        TNullable,\n        TExplicitType,\n        false,\n        TExtensions\n    > &\n        TExtensions {\n        return super.clearDefault() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public brand<TBrand extends string | symbol>(\n        _name?: TBrand\n    ): FunctionSchemaBuilder<\n        TRequired,\n        TNullable,\n        TResult & { readonly [K in BRAND]: TBrand },\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.brand(_name);\n    }\n\n    /**\n     * Marks the inferred type as `Readonly<Function>`. Sets the\n     * `isReadonly` introspection flag for tooling consistency.\n     *\n     * @see {@link SchemaBuilder.readonly}\n     */\n    public readonly(): FunctionSchemaBuilder<\n        TRequired,\n        TNullable,\n        Readonly<TResult>,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.readonly();\n    }\n\n    /**\n     * @hidden\n     */\n    public nullable(): FunctionSchemaBuilder<\n        TRequired,\n        true,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.nullable() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public notNullable(): FunctionSchemaBuilder<\n        TRequired,\n        false,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.notNullable() as any;\n    }\n}\n\n/**\n * Creates a `function` schema.\n * @returns {@link FunctionSchemaBuilder}\n */\nexport const func = () =>\n    FunctionSchemaBuilder.create({\n        isRequired: true\n    }) as FunctionSchemaBuilder<true>;\n"],"mappings":"wCAsCO,IAAMA,EAAN,MAAMC,UASHC,CAMR,CAIE,OAAc,OAAOC,EAA8C,CAC/D,OAAO,IAAIF,EAAsB,CAC7B,KAAM,WACN,GAAGE,CACP,CAAC,CACL,CAEU,YAAYA,EAAoD,CACtE,MAAMA,CAAY,CACtB,CAKO,QACHC,EAEY,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,CACvB,CAAQ,CACZ,CAKO,cAOS,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,CACvB,CAAQ,CACZ,CAEAC,GACIC,EACyB,CACzB,GAAM,CACF,MAAAC,EACA,YAAaC,EACb,OAAAC,CACJ,EAAIH,EAEJ,GAAI,CAACC,EACD,MAAO,CAAE,MAAAA,EAAO,OAAAE,CAAO,EAG3B,GAAM,CACF,OAAQ,CAAE,gBAAiBC,CAAc,CAC7C,EAAIF,EAEJ,OACK,OAAOE,EAAkB,KAAe,CAAC,KAAK,YAC9CA,IAAkB,OAAS,CAAC,KAAK,YAAc,KAAK,YAE9C,CACH,MAAO,GACP,OAAQA,CACZ,EAGA,OAAOA,GAAkB,WAClB,CACH,MAAO,GACP,OAAQ,CACJ,CACI,QAAS,mCAAmC,OAAOA,CAAa,EACpE,CACJ,CACJ,EAGG,CACH,MAAO,GACP,OAAQA,CACZ,CACJ,CAGO,SACHC,EACAC,EACyB,CACzB,OAAO,MAAM,SAASD,EAAQC,CAAO,CACzC,CAGA,MAAa,cACTD,EACAC,EACkC,CAClC,OAAO,MAAM,cAAcD,EAAQC,CAAO,CAG9C,CAOU,UACND,EACAC,EACyB,CACzB,OAAO,KAAKP,GAAa,KAAK,gBAAgBM,EAAQC,CAAO,CAAC,CAClE,CAOA,MAAgB,eACZD,EACAC,EACkC,CAClC,OAAO,KAAKP,GAAa,MAAM,MAAM,iBAAiBM,EAAQC,CAAO,CAAC,CAC1E,CAEU,gBACNT,EACI,CACJ,OAAOF,EAAsB,OAAOE,CAAY,CACpD,CAKO,SACHU,EAQY,CACZ,OAAO,MAAM,SAASA,CAAY,CACtC,CAKO,UAOS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,QACHC,EAQY,CACZ,OAAO,MAAM,QAAQA,CAAK,CAC9B,CAKO,cAOS,CACZ,OAAO,MAAM,aAAa,CAC9B,CAKO,MACHC,EAQY,CACZ,OAAO,MAAM,MAAMA,CAAK,CAC5B,CAQO,UAOS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,UAOS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,aAOS,CACZ,OAAO,MAAM,YAAY,CAC7B,CACJ,EAMaC,EAAO,IAChBhB,EAAsB,OAAO,CACzB,WAAY,EAChB,CAAC","names":["FunctionSchemaBuilder","_FunctionSchemaBuilder","SchemaBuilder","props","_notUsed","#buildResult","superResult","valid","preValidationTransaction","errors","objToValidate","object","context","errorMessage","value","_name","func"]}

package/dist/chunk-FWUEUW2N.js

@@ -0,0 +1,2 @@
+import{f as o}from"./chunk-CTP4RHDG.js";var l=class a extends o{#t;#T=function(){return`is expected to have a length of at least ${this.#t} characters`};#n=this.#T;#i;#g=function(){return`is expected to have a length of no more than ${this.#i} characters`};#l=this.#g;#s;#c=function(e){return`is expected to be equal to "${this.#s}" but saw "${e}"`};#o=this.#c;#e;#m=function(){return`is expected to start with "${this.#e}"`};#u=this.#m;#r;#E=function(){return`is expected to end with "${this.#r}"`};#d=this.#E;#a;#f=function(){return`is expected to match the pattern ${this.#a}`};#h=this.#f;static create(e){return new a({type:"string",...e})}constructor(e){super(e),typeof e.minLength=="number"&&(this.#t=e.minLength),this.#n=this.assureValidationErrorMessageProvider(e.minLengthValidationErrorMessageProvider,this.#T),typeof e.maxLength=="number"&&(this.#i=e.maxLength),this.#l=this.assureValidationErrorMessageProvider(e.maxLengthValidationErrorMessageProvider,this.#g),(typeof e.equalsTo=="string"||typeof e.equalsTo>"u")&&(this.#s=e.equalsTo),this.#o=this.assureValidationErrorMessageProvider(e.equalsToValidationErrorMessageProvider,this.#c),typeof e.startsWith=="string"&&e.startsWith.length>0&&(this.#e=e.startsWith),this.#u=this.assureValidationErrorMessageProvider(e.startsWithValidationErrorMessageProvider,this.#m),typeof e.endsWith=="string"&&e.endsWith.length>0&&(this.#r=e.endsWith),this.#d=this.assureValidationErrorMessageProvider(e.endsWithValidationErrorMessageProvider,this.#E),e.matches instanceof RegExp&&(this.#a=e.matches),this.#h=this.assureValidationErrorMessageProvider(e.matchesValidationErrorMessageProvider,this.#f)}introspect(){return{...super.introspect(),minLength:this.#t,minLengthValidationErrorMessageProvider:this.#n,maxLength:this.#i,maxLengthValidationErrorMessageProvider:this.#l,equalsTo:this.#s,equalsToValidationErrorMessageProvider:this.#o,startsWith:this.#e,startsWithValidationErrorMessageProvider:this.#u,endsWith:this.#r,endsWithValidationErrorMessageProvider:this.#d,matches:this.#a,matchesValidationErrorMessageProvider:this.#h,preprocessors:this.preprocessors,validators:this.validators}}hasType(e){return this.createFromProps({...this.introspect()})}clearHasType(){return this.createFromProps({...this.introspect()})}#R(e){return typeof e!="string"?{message:`expected type string, but saw ${typeof e}`}:typeof this.#s<"u"&&e!==this.#s?{provider:this.#o}:typeof this.#e=="string"&&this.#e.length>0&&!e.startsWith(this.#e)?{provider:this.#u}:typeof this.#r=="string"&&this.#r.length>0&&!e.endsWith(this.#r)?{provider:this.#d}:typeof this.#t<"u"&&e.length<this.#t?{provider:this.#n}:typeof this.#i<"u"&&e.length>this.#i?{provider:this.#l}:this.#a instanceof RegExp&&!this.#a.test(e)?{provider:this.#h}:null}#p(e){let{valid:r,transaction:t,errors:i}=e;if(!r)return{done:!0,result:{valid:r,errors:i}};let{object:{validatedObject:s}}=t;if(typeof s>"u"&&!this.isRequired||s===null&&(!this.isRequired||this.isNullable))return{done:!0,result:{valid:!0,object:s}};let n=this.#R(s);return n?"message"in n?{done:!0,result:{valid:!1,errors:[{message:n.message}]}}:{done:!1,provider:n.provider,objToValidate:s}:{done:!0,result:{valid:!0,object:s}}}validate(e,r){return super.validate(e,r)}async validateAsync(e,r){return super.validateAsync(e,r)}_validate(e,r){if(this.canSkipPreValidation){if(typeof e>"u"||e===null)if(typeof e>"u"&&this.hasDefault)e=this.resolveDefaultValue();else return!this.isRequired||e===null&&this.isNullable?{valid:!0,object:e}:{valid:!1,errors:[{message:this.getValidationErrorMessageSync(this.requiredErrorMessage,e)}]};let i=this.#R(e);return i?"message"in i?{valid:!1,errors:[{message:i.message}]}:{valid:!1,errors:[{message:this.getValidationErrorMessageSync(i.provider,e)}]}:{valid:!0,object:e}}let t=this.#p(this.preValidateSync(e,r));return t.done?t.result:{valid:!1,errors:[{message:this.getValidationErrorMessageSync(t.provider,t.objToValidate)}]}}async _validateAsync(e,r){let t=this.#p(await super.preValidateAsync(e,r));return t.done?t.result:{valid:!1,errors:[{message:await this.getValidationErrorMessage(t.provider,t.objToValidate)}]}}createFromProps(e){return a.create(e)}equals(e,r){if(typeof e!="string")throw new Error("string expected");return this.createFromProps({...this.introspect(),equalsTo:e,equalsToValidationErrorMessageProvider:r})}clearEquals(){return this.createFromProps({...this.introspect(),equalsTo:void 0})}nullable(){return super.nullable()}notNullable(){return super.notNullable()}required(e){return super.required(e)}optional(){return super.optional()}default(e){return super.default(e)}clearDefault(){return super.clearDefault()}brand(e){return super.brand(e)}readonly(){return super.readonly()}minLength(e,r){if(typeof e!="number")throw new Error("length must be a number");return this.createFromProps({...this.introspect(),minLength:e,minLengthValidationErrorMessageProvider:r})}clearMinLength(){let e=this.introspect();return delete e.minLength,this.createFromProps({...e})}maxLength(e,r){if(typeof e!="number")throw new Error("length must be a number");return this.createFromProps({...this.introspect(),maxLength:e,maxLengthValidationErrorMessageProvider:r})}clearMaxLength(){let e=this.introspect();return delete e.maxLength,this.createFromProps({...e})}startsWith(e,r){if(typeof e!="string"||!e)throw new Error("non empty string expected");return this.createFromProps({...this.introspect(),startsWith:e,startsWithValidationErrorMessageProvider:r})}clearStartsWith(){let e=this.introspect();return delete e.startsWith,this.createFromProps({...e})}endsWith(e,r){if(typeof e!="string"||!e)throw new Error("non empty string expected");return this.createFromProps({...this.introspect(),endsWith:e,endsWithValidationErrorMessageProvider:r})}clearEndsWith(){let e=this.introspect();return delete e.endsWith,this.createFromProps({...e})}matches(e,r){if(!(e instanceof RegExp))throw new Error("regexp expected");return this.createFromProps({...this.introspect(),matches:e,matchesValidationErrorMessageProvider:r})}clearMatches(){let e=this.introspect();return delete e.matches,this.createFromProps({...e})}};function d(a,e){return typeof a=="string"?l.create({isRequired:!0,equalsTo:a,equalsToValidationErrorMessageProvider:e}):l.create({isRequired:!0})}export{l as a,d as b};
+//# sourceMappingURL=chunk-FWUEUW2N.js.map

package/dist/chunk-FWUEUW2N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/builders/StringSchemaBuilder.ts"],"sourcesContent":["import {\n    type BRAND,\n    type PreprocessorEntry,\n    SchemaBuilder,\n    type ValidationContext,\n    type ValidationErrorMessageProvider,\n    type ValidationResult,\n    type ValidatorEntry\n} from './SchemaBuilder.js';\n\ntype StringSchemaBuilderCreateProps<\n    T = string,\n    R extends boolean = true\n> = Partial<ReturnType<StringSchemaBuilder<T, R>['introspect']>>;\n\n/**\n * Allows to define a schema for a string. It can be: required or optional,\n * restricted to be equal to a certain value, restricted to have a certain\n * length, restricted to start with a certain value, restricted to end with\n * a certain value, restricted to match a certain regular expression.\n *\n * **NOTE** this class is exported only to give opportunity to extend it\n * by inheriting. It is not recommended to create an instance of this class\n * directly. Use {@link string | string()} function instead.\n *\n * @example ```ts\n * const schema = string().equals('hello');\n * const result = schema.validate('hello');\n * // result.valid === true\n * // result.object === 'hello'\n * ```\n *\n * @example ```ts\n * const schema = string().equals('hello');\n * const result = schema.validate('world');\n * // result.valid === false\n * // result.errors[0].message === \"is expected to be equal to 'hello'\"\n * ```\n *\n * @example ```ts\n * const schema = string().minLength(5);\n * const result = schema.validate('hello');\n * // result.valid === true\n * // result.object === 'hello'\n * ```\n *\n * @example ```ts\n * const schema = string().minLength(5);\n * const result = schema.validate('hi');\n * // result.valid === false\n * // result.errors[0].message === 'is expected to have a length of at least 5'\n * ```\n *\n * @example ```ts\n * const schema = string().minLength(2).maxLength(5);\n * const result = schema.validate('yes');\n * // result.valid === true\n * // result.object === 'yes'\n * ```\n *\n * @example ```ts\n * const schema = string('no');\n * const result = schema.validate('yes');\n * // result.valid === false\n * // result.errors[0].message === \"is expected to be equal to 'no'\"\n * ```\n *\n * @see {@link string}\n */\nexport class StringSchemaBuilder<\n    TResult = string,\n    TRequired extends boolean = true,\n    TNullable extends boolean = false,\n    THasDefault extends boolean = false,\n    TExtensions = {}\n> extends SchemaBuilder<\n    TResult,\n    TRequired,\n    TNullable,\n    THasDefault,\n    TExtensions\n> {\n    #minLength?: number;\n    #defaultMinLengthErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = function (this: StringSchemaBuilder) {\n        return `is expected to have a length of at least ${this.#minLength} characters`;\n    };\n    #minLengthErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = this.#defaultMinLengthErrorMessageProvider;\n\n    #maxLength?: number;\n    #defaultMaxLengthErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = function (this: StringSchemaBuilder) {\n        return `is expected to have a length of no more than ${this.#maxLength} characters`;\n    };\n    #maxLengthErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = this.#defaultMaxLengthErrorMessageProvider;\n\n    #equalsTo?: string;\n    #defaultEqualsToErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = function (this: StringSchemaBuilder, seenValue?: TResult) {\n        return `is expected to be equal to \"${this.#equalsTo}\" but saw \"${seenValue}\"`;\n    };\n    #equalsToErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = this.#defaultEqualsToErrorMessageProvider;\n\n    #startsWith?: string;\n    #defaultStartsWithErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = function (this: StringSchemaBuilder) {\n        return `is expected to start with \"${this.#startsWith}\"`;\n    };\n    #startsWithErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = this.#defaultStartsWithErrorMessageProvider;\n\n    #endsWith?: string;\n    #defaultEndsWithErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = function (this: StringSchemaBuilder) {\n        return `is expected to end with \"${this.#endsWith}\"`;\n    };\n    #endsWithErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = this.#defaultEndsWithErrorMessageProvider;\n\n    #matches?: RegExp;\n    #defaultMatchesErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = function (this: StringSchemaBuilder) {\n        return `is expected to match the pattern ${this.#matches}`;\n    };\n    #matchesErrorMessageProvider: ValidationErrorMessageProvider<\n        StringSchemaBuilder<TResult, TRequired>\n    > = this.#defaultMatchesErrorMessageProvider;\n\n    /**\n     * @hidden\n     */\n    public static create(props: StringSchemaBuilderCreateProps) {\n        return new StringSchemaBuilder({\n            type: 'string',\n            ...props\n        });\n    }\n\n    protected constructor(props: StringSchemaBuilderCreateProps) {\n        super(props as any);\n\n        if (typeof props.minLength === 'number') {\n            this.#minLength = props.minLength;\n        }\n\n        this.#minLengthErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.minLengthValidationErrorMessageProvider,\n                this.#defaultMinLengthErrorMessageProvider\n            );\n\n        if (typeof props.maxLength === 'number') {\n            this.#maxLength = props.maxLength;\n        }\n\n        this.#maxLengthErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.maxLengthValidationErrorMessageProvider,\n                this.#defaultMaxLengthErrorMessageProvider\n            );\n\n        if (\n            typeof props.equalsTo === 'string' ||\n            typeof props.equalsTo === 'undefined'\n        ) {\n            this.#equalsTo = props.equalsTo;\n        }\n\n        this.#equalsToErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.equalsToValidationErrorMessageProvider,\n                this.#defaultEqualsToErrorMessageProvider\n            );\n\n        if (\n            typeof props.startsWith === 'string' &&\n            props.startsWith.length > 0\n        ) {\n            this.#startsWith = props.startsWith;\n        }\n\n        this.#startsWithErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.startsWithValidationErrorMessageProvider,\n                this.#defaultStartsWithErrorMessageProvider\n            );\n\n        if (typeof props.endsWith === 'string' && props.endsWith.length > 0) {\n            this.#endsWith = props.endsWith;\n        }\n\n        this.#endsWithErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.endsWithValidationErrorMessageProvider,\n                this.#defaultEndsWithErrorMessageProvider\n            );\n\n        if (props.matches instanceof RegExp) {\n            this.#matches = props.matches;\n        }\n\n        this.#matchesErrorMessageProvider =\n            this.assureValidationErrorMessageProvider(\n                props.matchesValidationErrorMessageProvider,\n                this.#defaultMatchesErrorMessageProvider\n            );\n    }\n\n    public introspect() {\n        return {\n            ...super.introspect(),\n            /**\n             * Min length of the string (if defined).\n             */\n            minLength: this.#minLength,\n\n            /**\n             * Min length validation error message provider.\n             * If not provided, default error message will be used.\n             */\n            minLengthValidationErrorMessageProvider:\n                this.#minLengthErrorMessageProvider,\n\n            /**\n             * Max length of the string (if defined).\n             */\n            maxLength: this.#maxLength,\n\n            /**\n             * Max length validation error message provider.\n             * If not provided, default error message will be used.\n             */\n            maxLengthValidationErrorMessageProvider:\n                this.#maxLengthErrorMessageProvider,\n\n            /**\n             * If set, restrict object to be equal to a certain value.\n             */\n            equalsTo: this.#equalsTo,\n\n            /**\n             * Equals validation error message provider.\n             * If not provided, default error message will be used.\n             */\n            equalsToValidationErrorMessageProvider:\n                this.#equalsToErrorMessageProvider,\n\n            /**\n             * If set, restrict string to start with a certain value.\n             */\n            startsWith: this.#startsWith,\n\n            /**\n             * Starts with validation error message provider.\n             * If not provided, default error message will be used.\n             */\n            startsWithValidationErrorMessageProvider:\n                this.#startsWithErrorMessageProvider,\n\n            /**\n             * If set, restrict string to end with a certain value.\n             */\n            endsWith: this.#endsWith,\n\n            /**\n             * Ends with validation error message provider.\n             * If not provided, default error message will be used.\n             */\n            endsWithValidationErrorMessageProvider:\n                this.#endsWithErrorMessageProvider,\n\n            /**\n             * If set, restrict string to match a certain regular expression.\n             */\n            matches: this.#matches,\n\n            /**\n             * Matches validation error message provider.\n             * If not provided, default error message will be used.\n             */\n            matchesValidationErrorMessageProvider:\n                this.#matchesErrorMessageProvider,\n\n            /**\n             * Array of preprocessor functions\n             */\n            preprocessors: this.preprocessors as PreprocessorEntry<TResult>[],\n\n            /**\n             * Array of validator functions\n             */\n            validators: this.validators as ValidatorEntry<TResult>[]\n        };\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public hasType<T>(\n        _notUsed?: T\n    ): StringSchemaBuilder<T, true, TNullable, THasDefault, TExtensions> &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect()\n        } as any) as any;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public clearHasType(): StringSchemaBuilder<\n        string,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect()\n        } as any) as any;\n    }\n\n    #getConstraintViolation(\n        objToValidate: any\n    ): { message: string } | { provider: any } | null {\n        if (typeof objToValidate !== 'string') {\n            return {\n                message: `expected type string, but saw ${typeof objToValidate}`\n            };\n        }\n\n        if (\n            typeof this.#equalsTo !== 'undefined' &&\n            objToValidate !== this.#equalsTo\n        ) {\n            return { provider: this.#equalsToErrorMessageProvider };\n        }\n\n        if (\n            typeof this.#startsWith === 'string' &&\n            this.#startsWith.length > 0 &&\n            !objToValidate.startsWith(this.#startsWith)\n        ) {\n            return { provider: this.#startsWithErrorMessageProvider };\n        }\n\n        if (\n            typeof this.#endsWith === 'string' &&\n            this.#endsWith.length > 0 &&\n            !objToValidate.endsWith(this.#endsWith)\n        ) {\n            return { provider: this.#endsWithErrorMessageProvider };\n        }\n\n        if (typeof this.#minLength !== 'undefined') {\n            if (objToValidate.length < this.#minLength)\n                return { provider: this.#minLengthErrorMessageProvider };\n        }\n\n        if (typeof this.#maxLength !== 'undefined') {\n            if (objToValidate.length > this.#maxLength)\n                return { provider: this.#maxLengthErrorMessageProvider };\n        }\n\n        if (this.#matches instanceof RegExp) {\n            if (!this.#matches.test(objToValidate)) {\n                return { provider: this.#matchesErrorMessageProvider };\n            }\n        }\n\n        return null;\n    }\n\n    #buildResult(\n        superResult: ReturnType<StringSchemaBuilder['preValidateSync']>\n    ):\n        | { done: true; result: ValidationResult<TResult> }\n        | {\n              done: false;\n              provider: any;\n              objToValidate: any;\n          } {\n        const {\n            valid,\n            transaction: preValidationTransaction,\n            errors\n        } = superResult;\n\n        if (!valid) {\n            return { done: true, result: { valid, errors } };\n        }\n\n        const {\n            object: { validatedObject: objToValidate }\n        } = preValidationTransaction!;\n\n        if (\n            (typeof objToValidate === 'undefined' && !this.isRequired) ||\n            (objToValidate === null && (!this.isRequired || this.isNullable))\n        ) {\n            return {\n                done: true,\n                result: { valid: true, object: objToValidate }\n            };\n        }\n\n        const violation = this.#getConstraintViolation(objToValidate);\n\n        if (!violation) {\n            return {\n                done: true,\n                result: { valid: true, object: objToValidate as TResult }\n            };\n        }\n\n        if ('message' in violation) {\n            return {\n                done: true,\n                result: {\n                    valid: false,\n                    errors: [{ message: violation.message }]\n                }\n            };\n        }\n\n        return {\n            done: false,\n            provider: violation.provider,\n            objToValidate\n        };\n    }\n\n    /** {@inheritDoc SchemaBuilder.validate} */\n    public validate(\n        object: TResult,\n        context?: ValidationContext\n    ): ValidationResult<TResult> {\n        return super.validate(object, context) as ValidationResult<TResult>;\n    }\n\n    /** {@inheritDoc SchemaBuilder.validateAsync} */\n    public async validateAsync(\n        object: TResult,\n        context?: ValidationContext\n    ): Promise<ValidationResult<TResult>> {\n        return super.validateAsync(object, context) as Promise<\n            ValidationResult<TResult>\n        >;\n    }\n\n    /**\n     * Performs synchronous validation of string schema over `object`.\n     * Throws if any preprocessor, validator, or error message provider returns a Promise.\n     * @param context Optional `ValidationContext` settings.\n     */\n    protected _validate(\n        object: TResult,\n        context?: ValidationContext\n    ): ValidationResult<TResult> {\n        // Fast path: no preprocessors or custom validators — skip preValidateSync entirely\n        if (this.canSkipPreValidation) {\n            // Required / optional check\n            if (typeof object === 'undefined' || object === null) {\n                if (typeof object === 'undefined' && this.hasDefault) {\n                    object = this.resolveDefaultValue();\n                } else if (\n                    !this.isRequired ||\n                    (object === null && this.isNullable)\n                ) {\n                    return { valid: true, object: object };\n                } else {\n                    return {\n                        valid: false,\n                        errors: [\n                            {\n                                message: this.getValidationErrorMessageSync(\n                                    this.requiredErrorMessage,\n                                    object\n                                )\n                            }\n                        ]\n                    };\n                }\n            }\n\n            const violation = this.#getConstraintViolation(object);\n\n            if (!violation) {\n                return { valid: true, object: object as TResult };\n            }\n\n            if ('message' in violation) {\n                return {\n                    valid: false,\n                    errors: [{ message: violation.message }]\n                };\n            }\n\n            return {\n                valid: false,\n                errors: [\n                    {\n                        message: this.getValidationErrorMessageSync(\n                            violation.provider,\n                            object as TResult\n                        )\n                    }\n                ]\n            };\n        }\n\n        const r = this.#buildResult(this.preValidateSync(object, context));\n        if (r.done) return r.result;\n        return {\n            valid: false,\n            errors: [\n                {\n                    message: this.getValidationErrorMessageSync(\n                        r.provider,\n                        r.objToValidate as TResult\n                    )\n                }\n            ]\n        };\n    }\n\n    /**\n     * Performs async validation of string schema over `object`.\n     * Supports async preprocessors, validators, and error message providers.\n     * @param context Optional `ValidationContext` settings.\n     */\n    protected async _validateAsync(\n        object: TResult,\n        context?: ValidationContext\n    ): Promise<ValidationResult<TResult>> {\n        const r = this.#buildResult(\n            await super.preValidateAsync(object, context)\n        );\n        if (r.done) return r.result;\n        return {\n            valid: false,\n            errors: [\n                {\n                    message: await this.getValidationErrorMessage(\n                        r.provider,\n                        r.objToValidate as TResult\n                    )\n                }\n            ]\n        };\n    }\n\n    protected createFromProps<T, TReq extends boolean>(\n        props: StringSchemaBuilderCreateProps<T, TReq>\n    ): this {\n        return StringSchemaBuilder.create(props as any) as any;\n    }\n\n    /**\n     * Restricts string to be equal to `value`.\n     */\n    public equals<T extends string>(\n        value: T,\n        /**\n         * Custom error message provider.\n         */\n        errorMessage?: ValidationErrorMessageProvider<\n            StringSchemaBuilder<TResult, TRequired>\n        >\n    ) {\n        if (typeof value !== 'string') throw new Error('string expected');\n        return this.createFromProps({\n            ...this.introspect(),\n            equalsTo: value,\n            equalsToValidationErrorMessageProvider: errorMessage\n        }) as any as StringSchemaBuilder<\n            T,\n            TRequired,\n            TNullable,\n            THasDefault,\n            TExtensions\n        > &\n            TExtensions;\n    }\n\n    /**\n     * Cancels `equals()` call.\n     */\n    public clearEquals(): StringSchemaBuilder<\n        string,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect(),\n            equalsTo: undefined\n        }) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public nullable(): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        true,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.nullable() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public notNullable(): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        false,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.notNullable() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public required(\n        errorMessage?: ValidationErrorMessageProvider\n    ): StringSchemaBuilder<TResult, true, TNullable, THasDefault, TExtensions> &\n        TExtensions {\n        return super.required(errorMessage);\n    }\n\n    /**\n     * @hidden\n     */\n    public optional(): StringSchemaBuilder<\n        TResult,\n        false,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.optional();\n    }\n\n    /**\n     * @hidden\n     */\n    public default(\n        value: TResult | (() => TResult)\n    ): StringSchemaBuilder<TResult, true, TNullable, true, TExtensions> &\n        TExtensions {\n        return super.default(value) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public clearDefault(): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        false,\n        TExtensions\n    > &\n        TExtensions {\n        return super.clearDefault() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public brand<TBrand extends string | symbol>(\n        _name?: TBrand\n    ): StringSchemaBuilder<\n        TResult & { readonly [K in BRAND]: TBrand },\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.brand(_name);\n    }\n\n    /**\n     * Marks the inferred type as `Readonly<string>`. Since strings are\n     * already immutable this is an identity operation, but it sets the\n     * `isReadonly` introspection flag for tooling consistency.\n     *\n     * @see {@link SchemaBuilder.readonly}\n     */\n    public readonly(): StringSchemaBuilder<\n        Readonly<TResult>,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.readonly();\n    }\n\n    /**\n     * Set minimal length of the valid value for schema.\n     * @param length minimum string length\n     */\n    public minLength(\n        length: number,\n        /**\n         * Custom error message provider.\n         */\n        errorMessage?: ValidationErrorMessageProvider<\n            StringSchemaBuilder<TResult, TRequired>\n        >\n    ): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        if (typeof length !== 'number')\n            throw new Error('length must be a number');\n        return this.createFromProps({\n            ...this.introspect(),\n            minLength: length,\n            minLengthValidationErrorMessageProvider: errorMessage\n        }) as any;\n    }\n\n    /**\n     * Cancel `minLength()` call.\n     */\n    public clearMinLength(): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        const schema = this.introspect();\n        delete schema.minLength;\n        return this.createFromProps({\n            ...schema\n        }) as any;\n    }\n\n    /**\n     * Set maximal length of the valid value for schema.\n     * @param length maximum string length\n     */\n    public maxLength(\n        length: number,\n        /**\n         * Custom error message provider.\n         */\n        errorMessage?: ValidationErrorMessageProvider<\n            StringSchemaBuilder<TResult, TRequired>\n        >\n    ): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        if (typeof length !== 'number')\n            throw new Error('length must be a number');\n        return this.createFromProps({\n            ...this.introspect(),\n            maxLength: length,\n            maxLengthValidationErrorMessageProvider: errorMessage\n        }) as any;\n    }\n\n    /**\n     * Cancel `maxLength()` call.\n     */\n    public clearMaxLength(): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        const schema = this.introspect();\n        delete schema.maxLength;\n        return this.createFromProps({\n            ...schema\n        }) as any;\n    }\n\n    /**\n     * Restricts string to start with `val`.\n     */\n    public startsWith<T extends string>(\n        val: T,\n        /**\n         * Custom error message provider.\n         */\n        errorMessage?: ValidationErrorMessageProvider<\n            StringSchemaBuilder<TResult, TRequired>\n        >\n    ): StringSchemaBuilder<\n        TResult extends string ? `${T}${TResult}` : TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        if (typeof val !== 'string' || !val)\n            throw new Error('non empty string expected');\n        return this.createFromProps({\n            ...this.introspect(),\n            startsWith: val,\n            startsWithValidationErrorMessageProvider: errorMessage\n        }) as any;\n    }\n\n    /**\n     * Cancels `startsWith()` call.\n     */\n    public clearStartsWith(): StringSchemaBuilder<\n        string,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        const schema = this.introspect();\n        delete schema.startsWith;\n        return this.createFromProps({\n            ...schema\n        }) as any;\n    }\n\n    /**\n     * Restricts string to end with `val`.\n     */\n    public endsWith<T extends string>(\n        val: T,\n        /**\n         * Custom error message provider.\n         */\n        errorMessage?: ValidationErrorMessageProvider<\n            StringSchemaBuilder<TResult, TRequired>\n        >\n    ): StringSchemaBuilder<\n        TResult extends string ? `${TResult}${T}` : TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        if (typeof val !== 'string' || !val)\n            throw new Error('non empty string expected');\n        return this.createFromProps({\n            ...this.introspect(),\n            endsWith: val,\n            endsWithValidationErrorMessageProvider: errorMessage\n        }) as any;\n    }\n\n    /**\n     * Cancels `endsWith()` call.\n     */\n    public clearEndsWith(): StringSchemaBuilder<\n        string,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        const schema = this.introspect();\n        delete schema.endsWith;\n        return this.createFromProps({\n            ...schema\n        }) as any;\n    }\n\n    /**\n     * Restricts string to match `regexp`.\n     * @param regexp regular expression pattern to match against\n     */\n    public matches(\n        regexp: RegExp,\n        /**\n         * Custom error message provider.\n         */\n        errorMessage?: ValidationErrorMessageProvider<\n            StringSchemaBuilder<TResult, TRequired>\n        >\n    ): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        if (!(regexp instanceof RegExp)) throw new Error('regexp expected');\n        return this.createFromProps({\n            ...this.introspect(),\n            matches: regexp,\n            matchesValidationErrorMessageProvider: errorMessage\n        }) as any;\n    }\n\n    /**\n     * Cancels `matches()` call.\n     */\n    public clearMatches(): StringSchemaBuilder<\n        TResult,\n        TRequired,\n        TNullable,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        const schema = this.introspect();\n        delete schema.matches;\n        return this.createFromProps({\n            ...schema\n        }) as any;\n    }\n}\n\n/**\n * Creates a string schema restricted to be equal to `equals`.\n * @param equals string value the schema is restricted to\n */\nexport function string<T extends string>(\n    equals: T\n): StringSchemaBuilder<T, true>;\n\n/**\n * Creates a string schema restricted to be equal to `equals` with a custom error message.\n * @param equals string value the schema is restricted to\n */\nexport function string<T extends string>(\n    equals: T,\n    errorMessage: ValidationErrorMessageProvider<StringSchemaBuilder<T, true>>\n): StringSchemaBuilder<T, true>;\n\nexport function string(): StringSchemaBuilder<string, true>;\n\n/**\n * Creates a string schema.\n */\nexport function string(\n    equals?: string,\n    errorMessage?: ValidationErrorMessageProvider<\n        StringSchemaBuilder<string, true>\n    >\n) {\n    if (typeof equals === 'string') {\n        return StringSchemaBuilder.create({\n            isRequired: true,\n            equalsTo: equals,\n            equalsToValidationErrorMessageProvider: errorMessage\n        });\n    }\n    return StringSchemaBuilder.create({\n        isRequired: true\n    });\n}\n"],"mappings":"wCAqEO,IAAMA,EAAN,MAAMC,UAMHC,CAMR,CACEC,GACAC,GAEI,UAAqC,CACrC,MAAO,4CAA4C,KAAKD,EAAU,aACtE,EACAE,GAEI,KAAKD,GAETE,GACAC,GAEI,UAAqC,CACrC,MAAO,gDAAgD,KAAKD,EAAU,aAC1E,EACAE,GAEI,KAAKD,GAETE,GACAC,GAEI,SAAqCC,EAAqB,CAC1D,MAAO,+BAA+B,KAAKF,EAAS,cAAcE,CAAS,GAC/E,EACAC,GAEI,KAAKF,GAETG,GACAC,GAEI,UAAqC,CACrC,MAAO,8BAA8B,KAAKD,EAAW,GACzD,EACAE,GAEI,KAAKD,GAETE,GACAC,GAEI,UAAqC,CACrC,MAAO,4BAA4B,KAAKD,EAAS,GACrD,EACAE,GAEI,KAAKD,GAETE,GACAC,GAEI,UAAqC,CACrC,MAAO,oCAAoC,KAAKD,EAAQ,EAC5D,EACAE,GAEI,KAAKD,GAKT,OAAc,OAAOE,EAAuC,CACxD,OAAO,IAAIrB,EAAoB,CAC3B,KAAM,SACN,GAAGqB,CACP,CAAC,CACL,CAEU,YAAYA,EAAuC,CACzD,MAAMA,CAAY,EAEd,OAAOA,EAAM,WAAc,WAC3B,KAAKnB,GAAamB,EAAM,WAG5B,KAAKjB,GACD,KAAK,qCACDiB,EAAM,wCACN,KAAKlB,EACT,EAEA,OAAOkB,EAAM,WAAc,WAC3B,KAAKhB,GAAagB,EAAM,WAG5B,KAAKd,GACD,KAAK,qCACDc,EAAM,wCACN,KAAKf,EACT,GAGA,OAAOe,EAAM,UAAa,UAC1B,OAAOA,EAAM,SAAa,OAE1B,KAAKb,GAAYa,EAAM,UAG3B,KAAKV,GACD,KAAK,qCACDU,EAAM,uCACN,KAAKZ,EACT,EAGA,OAAOY,EAAM,YAAe,UAC5BA,EAAM,WAAW,OAAS,IAE1B,KAAKT,GAAcS,EAAM,YAG7B,KAAKP,GACD,KAAK,qCACDO,EAAM,yCACN,KAAKR,EACT,EAEA,OAAOQ,EAAM,UAAa,UAAYA,EAAM,SAAS,OAAS,IAC9D,KAAKN,GAAYM,EAAM,UAG3B,KAAKJ,GACD,KAAK,qCACDI,EAAM,uCACN,KAAKL,EACT,EAEAK,EAAM,mBAAmB,SACzB,KAAKH,GAAWG,EAAM,SAG1B,KAAKD,GACD,KAAK,qCACDC,EAAM,sCACN,KAAKF,EACT,CACR,CAEO,YAAa,CAChB,MAAO,CACH,GAAG,MAAM,WAAW,EAIpB,UAAW,KAAKjB,GAMhB,wCACI,KAAKE,GAKT,UAAW,KAAKC,GAMhB,wCACI,KAAKE,GAKT,SAAU,KAAKC,GAMf,uCACI,KAAKG,GAKT,WAAY,KAAKC,GAMjB,yCACI,KAAKE,GAKT,SAAU,KAAKC,GAMf,uCACI,KAAKE,GAKT,QAAS,KAAKC,GAMd,sCACI,KAAKE,GAKT,cAAe,KAAK,cAKpB,WAAY,KAAK,UACrB,CACJ,CAKO,QACHE,EAEY,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,CACvB,CAAQ,CACZ,CAKO,cAOS,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,CACvB,CAAQ,CACZ,CAEAC,GACIC,EAC8C,CAC9C,OAAI,OAAOA,GAAkB,SAClB,CACH,QAAS,iCAAiC,OAAOA,CAAa,EAClE,EAIA,OAAO,KAAKhB,GAAc,KAC1BgB,IAAkB,KAAKhB,GAEhB,CAAE,SAAU,KAAKG,EAA8B,EAItD,OAAO,KAAKC,IAAgB,UAC5B,KAAKA,GAAY,OAAS,GAC1B,CAACY,EAAc,WAAW,KAAKZ,EAAW,EAEnC,CAAE,SAAU,KAAKE,EAAgC,EAIxD,OAAO,KAAKC,IAAc,UAC1B,KAAKA,GAAU,OAAS,GACxB,CAACS,EAAc,SAAS,KAAKT,EAAS,EAE/B,CAAE,SAAU,KAAKE,EAA8B,EAGtD,OAAO,KAAKf,GAAe,KACvBsB,EAAc,OAAS,KAAKtB,GACrB,CAAE,SAAU,KAAKE,EAA+B,EAG3D,OAAO,KAAKC,GAAe,KACvBmB,EAAc,OAAS,KAAKnB,GACrB,CAAE,SAAU,KAAKE,EAA+B,EAG3D,KAAKW,cAAoB,QACrB,CAAC,KAAKA,GAAS,KAAKM,CAAa,EAC1B,CAAE,SAAU,KAAKJ,EAA6B,EAItD,IACX,CAEAK,GACIC,EAOI,CACJ,GAAM,CACF,MAAAC,EACA,YAAaC,EACb,OAAAC,CACJ,EAAIH,EAEJ,GAAI,CAACC,EACD,MAAO,CAAE,KAAM,GAAM,OAAQ,CAAE,MAAAA,EAAO,OAAAE,CAAO,CAAE,EAGnD,GAAM,CACF,OAAQ,CAAE,gBAAiBL,CAAc,CAC7C,EAAII,EAEJ,GACK,OAAOJ,EAAkB,KAAe,CAAC,KAAK,YAC9CA,IAAkB,OAAS,CAAC,KAAK,YAAc,KAAK,YAErD,MAAO,CACH,KAAM,GACN,OAAQ,CAAE,MAAO,GAAM,OAAQA,CAAc,CACjD,EAGJ,IAAMM,EAAY,KAAKP,GAAwBC,CAAa,EAE5D,OAAKM,EAOD,YAAaA,EACN,CACH,KAAM,GACN,OAAQ,CACJ,MAAO,GACP,OAAQ,CAAC,CAAE,QAASA,EAAU,OAAQ,CAAC,CAC3C,CACJ,EAGG,CACH,KAAM,GACN,SAAUA,EAAU,SACpB,cAAAN,CACJ,EApBW,CACH,KAAM,GACN,OAAQ,CAAE,MAAO,GAAM,OAAQA,CAAyB,CAC5D,CAkBR,CAGO,SACHO,EACAC,EACyB,CACzB,OAAO,MAAM,SAASD,EAAQC,CAAO,CACzC,CAGA,MAAa,cACTD,EACAC,EACkC,CAClC,OAAO,MAAM,cAAcD,EAAQC,CAAO,CAG9C,CAOU,UACND,EACAC,EACyB,CAEzB,GAAI,KAAK,qBAAsB,CAE3B,GAAI,OAAOD,EAAW,KAAeA,IAAW,KAC5C,GAAI,OAAOA,EAAW,KAAe,KAAK,WACtCA,EAAS,KAAK,oBAAoB,MAC/B,OACH,CAAC,KAAK,YACLA,IAAW,MAAQ,KAAK,WAElB,CAAE,MAAO,GAAM,OAAQA,CAAO,EAE9B,CACH,MAAO,GACP,OAAQ,CACJ,CACI,QAAS,KAAK,8BACV,KAAK,qBACLA,CACJ,CACJ,CACJ,CACJ,EAIR,IAAMD,EAAY,KAAKP,GAAwBQ,CAAM,EAErD,OAAKD,EAID,YAAaA,EACN,CACH,MAAO,GACP,OAAQ,CAAC,CAAE,QAASA,EAAU,OAAQ,CAAC,CAC3C,EAGG,CACH,MAAO,GACP,OAAQ,CACJ,CACI,QAAS,KAAK,8BACVA,EAAU,SACVC,CACJ,CACJ,CACJ,CACJ,EApBW,CAAE,MAAO,GAAM,OAAQA,CAAkB,CAqBxD,CAEA,IAAME,EAAI,KAAKR,GAAa,KAAK,gBAAgBM,EAAQC,CAAO,CAAC,EACjE,OAAIC,EAAE,KAAaA,EAAE,OACd,CACH,MAAO,GACP,OAAQ,CACJ,CACI,QAAS,KAAK,8BACVA,EAAE,SACFA,EAAE,aACN,CACJ,CACJ,CACJ,CACJ,CAOA,MAAgB,eACZF,EACAC,EACkC,CAClC,IAAMC,EAAI,KAAKR,GACX,MAAM,MAAM,iBAAiBM,EAAQC,CAAO,CAChD,EACA,OAAIC,EAAE,KAAaA,EAAE,OACd,CACH,MAAO,GACP,OAAQ,CACJ,CACI,QAAS,MAAM,KAAK,0BAChBA,EAAE,SACFA,EAAE,aACN,CACJ,CACJ,CACJ,CACJ,CAEU,gBACNZ,EACI,CACJ,OAAOrB,EAAoB,OAAOqB,CAAY,CAClD,CAKO,OACHa,EAIAC,EAGF,CACE,GAAI,OAAOD,GAAU,SAAU,MAAM,IAAI,MAAM,iBAAiB,EAChE,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,SAAUA,EACV,uCAAwCC,CAC5C,CAAC,CAQL,CAKO,aAOS,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,SAAU,MACd,CAAC,CACL,CAKO,UAOS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,aAOS,CACZ,OAAO,MAAM,YAAY,CAC7B,CAKO,SACHA,EAEY,CACZ,OAAO,MAAM,SAASA,CAAY,CACtC,CAKO,UAOS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,QACHD,EAEY,CACZ,OAAO,MAAM,QAAQA,CAAK,CAC9B,CAKO,cAOS,CACZ,OAAO,MAAM,aAAa,CAC9B,CAKO,MACHE,EAQY,CACZ,OAAO,MAAM,MAAMA,CAAK,CAC5B,CASO,UAOS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAMO,UACHC,EAIAF,EAUY,CACZ,GAAI,OAAOE,GAAW,SAClB,MAAM,IAAI,MAAM,yBAAyB,EAC7C,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,UAAWA,EACX,wCAAyCF,CAC7C,CAAC,CACL,CAKO,gBAOS,CACZ,IAAMG,EAAS,KAAK,WAAW,EAC/B,cAAOA,EAAO,UACP,KAAK,gBAAgB,CACxB,GAAGA,CACP,CAAC,CACL,CAMO,UACHD,EAIAF,EAUY,CACZ,GAAI,OAAOE,GAAW,SAClB,MAAM,IAAI,MAAM,yBAAyB,EAC7C,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,UAAWA,EACX,wCAAyCF,CAC7C,CAAC,CACL,CAKO,gBAOS,CACZ,IAAMG,EAAS,KAAK,WAAW,EAC/B,cAAOA,EAAO,UACP,KAAK,gBAAgB,CACxB,GAAGA,CACP,CAAC,CACL,CAKO,WACHC,EAIAJ,EAUY,CACZ,GAAI,OAAOI,GAAQ,UAAY,CAACA,EAC5B,MAAM,IAAI,MAAM,2BAA2B,EAC/C,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,WAAYA,EACZ,yCAA0CJ,CAC9C,CAAC,CACL,CAKO,iBAOS,CACZ,IAAMG,EAAS,KAAK,WAAW,EAC/B,cAAOA,EAAO,WACP,KAAK,gBAAgB,CACxB,GAAGA,CACP,CAAC,CACL,CAKO,SACHC,EAIAJ,EAUY,CACZ,GAAI,OAAOI,GAAQ,UAAY,CAACA,EAC5B,MAAM,IAAI,MAAM,2BAA2B,EAC/C,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,SAAUA,EACV,uCAAwCJ,CAC5C,CAAC,CACL,CAKO,eAOS,CACZ,IAAMG,EAAS,KAAK,WAAW,EAC/B,cAAOA,EAAO,SACP,KAAK,gBAAgB,CACxB,GAAGA,CACP,CAAC,CACL,CAMO,QACHE,EAIAL,EAUY,CACZ,GAAI,EAAEK,aAAkB,QAAS,MAAM,IAAI,MAAM,iBAAiB,EAClE,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,EACnB,QAASA,EACT,sCAAuCL,CAC3C,CAAC,CACL,CAKO,cAOS,CACZ,IAAMG,EAAS,KAAK,WAAW,EAC/B,cAAOA,EAAO,QACP,KAAK,gBAAgB,CACxB,GAAGA,CACP,CAAC,CACL,CACJ,EAwBO,SAASG,EACZC,EACAP,EAGF,CACE,OAAI,OAAOO,GAAW,SACX3C,EAAoB,OAAO,CAC9B,WAAY,GACZ,SAAU2C,EACV,uCAAwCP,CAC5C,CAAC,EAEEpC,EAAoB,OAAO,CAC9B,WAAY,EAChB,CAAC,CACL","names":["StringSchemaBuilder","_StringSchemaBuilder","SchemaBuilder","#minLength","#defaultMinLengthErrorMessageProvider","#minLengthErrorMessageProvider","#maxLength","#defaultMaxLengthErrorMessageProvider","#maxLengthErrorMessageProvider","#equalsTo","#defaultEqualsToErrorMessageProvider","seenValue","#equalsToErrorMessageProvider","#startsWith","#defaultStartsWithErrorMessageProvider","#startsWithErrorMessageProvider","#endsWith","#defaultEndsWithErrorMessageProvider","#endsWithErrorMessageProvider","#matches","#defaultMatchesErrorMessageProvider","#matchesErrorMessageProvider","props","_notUsed","#getConstraintViolation","objToValidate","#buildResult","superResult","valid","preValidationTransaction","errors","violation","object","context","r","value","errorMessage","_name","length","schema","val","regexp","string","equals"]}

package/dist/chunk-IJ6FO37G.js

@@ -0,0 +1,2 @@
+import{f as m}from"./chunk-CTP4RHDG.js";var p=class R extends m{#a;#e;static create(e){return new R({type:"record",...e})}constructor(e){super(e),e.keySchema instanceof m&&(this.#a=e.keySchema),e.valueSchema instanceof m&&(this.#e=e.valueSchema)}hasType(e){return this.createFromProps({...this.introspect()})}clearHasType(){return this.createFromProps({...this.introspect()})}createFromProps(e){return R.create(e)}required(e){return super.required(e)}optional(){return super.optional()}default(e){return super.default(e)}clearDefault(){return super.clearDefault()}brand(e){return super.brand(e)}introspect(){return{...super.introspect(),keySchema:this.#a,valueSchema:this.#e}}#s(e){let t={};for(let[n,o]of e)t[n]=o;return t}#r(e,t,n){let o=this.#e;return{errors:t,isValid:t.length===0,seenValue:n!==null&&typeof n=="object"?n[e]:void 0,descriptor:{key:e,getSchema:()=>o,getValue:r=>r!==null&&typeof r=="object"&&Object.hasOwn(r,e)?{success:!0,value:r[e]}:{success:!1},setValue:(r,d)=>r!==null&&typeof r=="object"?(r[e]=d,!0):!1}}}#n(e,t){let{valid:n,errors:o}=t,r=[],d=new Map,y=()=>this.#s(d),u=l=>{if(typeof l>"u")return{errors:r,isValid:r.length===0,seenValue:e};let i=d.get(l),s=i&&!i.valid?(i.errors??[]).map(T=>T.message):[];return this.#r(l,s,e)};if(!n){for(let l of o??[])r.push(l.message);return{earlyReturn:!0,result:{valid:n,errors:o,getNestedErrors:y,getErrorsFor:u}}}let a=t.transaction.object.validatedObject;return typeof a>"u"&&!this.isRequired||a===null&&(!this.isRequired||this.isNullable)?{earlyReturn:!0,result:{valid:!0,object:a,getNestedErrors:y,getErrorsFor:u}}:typeof a!="object"||Array.isArray(a)||a===null?(r.push("object expected"),{earlyReturn:!0,result:{valid:!1,errors:[{message:"object expected"}],getNestedErrors:y,getErrorsFor:u}}):{earlyReturn:!1,objToValidate:a,nestedKeyResults:d,getNestedErrors:y,getErrorsFor:u}}#l(e,t,n,o,r,d){return e?{valid:!0,object:n,getNestedErrors:r,getErrorsFor:d}:{valid:!1,errors:o?t:[t[0]],getNestedErrors:r,getErrorsFor:d}}validate(e,t){return super.validate(e,t)}async validateAsync(e,t){return super.validateAsync(e,t)}_validate(e,t){if(this.canSkipPreValidation&&!t?.doNotStopOnFirstError){if(typeof e>"u"||e===null)if(typeof e>"u"&&this.hasDefault)e=this.resolveDefaultValue();else if(!this.isRequired||e===null&&this.isNullable){let a=e;return{valid:!0,object:e,getNestedErrors(){return{}},getErrorsFor:l=>typeof l>"u"?{errors:[],isValid:!0,seenValue:a}:this.#r(l,[],a)}}else return this.#t(e,t);if(typeof e!="object"||Array.isArray(e)||e===null)return this.#t(e,t);let n=new Map,o={},r=null;for(let a of Object.keys(e)){let l=this.#a.validate(a);if(!l.valid){let s=l.errors&&l.errors.length>0?l.errors:[{message:`key "${a}" is invalid`}];n.set(a,{valid:!1,errors:s}),r=s[0];break}let i=this.#e.validate(e[a]);if(n.set(a,i),i.valid)o[a]=i.object;else{let s=i.errors&&i.errors.length>0?i.errors:[{message:`value for key "${a}" is invalid`}];n.set(a,{valid:!1,errors:s}),r=s[0];break}}let d=e,y=()=>this.#s(n),u=a=>{if(typeof a>"u")return{errors:[],isValid:!0,seenValue:d};let l=n.get(a),i=l&&!l.valid?(l.errors??[]).map(s=>s.message):[];return this.#r(a,i,d)};return r!==null?{valid:!1,errors:[r],getNestedErrors:y,getErrorsFor:u}:{valid:!0,object:o,getNestedErrors:y,getErrorsFor:u}}return this.#t(e,t)}#t(e,t){let n=this.#n(e,this.preValidateSync(e,t));if(n.earlyReturn)return n.result;let{objToValidate:o,nestedKeyResults:r,getNestedErrors:d,getErrorsFor:y}=n,u=t?.doNotStopOnFirstError??!1,a=!0,l={},i=[];for(let s of Object.keys(o)){let T=this.#a.validate(s);if(!T.valid){a=!1;let h=T.errors&&T.errors.length>0?T.errors:[{message:`key "${s}" is invalid`}];if(r.set(s,{valid:!1,errors:h}),i.push(...h),!u)break;continue}let c=this.#e.validate(o[s],u?{doNotStopOnFirstError:!0}:void 0);if(r.set(s,c),c.valid)l[s]=c.object;else{a=!1;let h=c.errors&&c.errors.length>0?c.errors:[{message:`value for key "${s}" is invalid`}];if(i.push(...h),!u)break}}return this.#l(a,i,l,u,d,y)}async _validateAsync(e,t){let n=this.#n(e,await this.preValidateAsync(e,t));if(n.earlyReturn)return n.result;let{objToValidate:o,nestedKeyResults:r,getNestedErrors:d,getErrorsFor:y}=n,u=t?.doNotStopOnFirstError??!1,a=!0,l={},i=[];for(let s of Object.keys(o)){let T=await this.#a.validateAsync(s);if(!T.valid){a=!1;let h=T.errors&&T.errors.length>0?T.errors:[{message:`key "${s}" is invalid`}];if(r.set(s,{valid:!1,errors:h}),i.push(...h),!u)break;continue}let c=await this.#e.validateAsync(o[s],u?{doNotStopOnFirstError:!0}:void 0);if(r.set(s,c),c.valid)l[s]=c.object;else{a=!1;let h=c.errors&&c.errors.length>0?c.errors:[{message:`value for key "${s}" is invalid`}];if(i.push(...h),!u)break}}return this.#l(a,i,l,u,d,y)}nullable(){return super.nullable()}notNullable(){return super.notNullable()}};function f(R,e){return p.create({type:"record",keySchema:R,valueSchema:e})}export{p as a,f as b};
+//# sourceMappingURL=chunk-IJ6FO37G.js.map

package/dist/chunk-IJ6FO37G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/builders/RecordSchemaBuilder.ts"],"sourcesContent":["/**\n * Schema builder for objects with dynamic string keys, where every value\n * must satisfy the same value schema.\n *\n * Equivalent to TypeScript's `Record<string, V>` (or a more constrained key\n * set when using a string-literal key schema) and Zod's `z.record()`.\n *\n * Unlike `ObjectSchemaBuilder` — which validates objects with a **known,\n * fixed set of property names** — `RecordSchemaBuilder` validates objects\n * whose keys are not known at schema-definition time (look-up tables, i18n\n * bundles, caches, etc.).\n *\n * @module\n */\nimport {\n    type BRAND,\n    type InferType,\n    type PreValidationResult,\n    SchemaBuilder,\n    type ValidationContext,\n    type ValidationError,\n    type ValidationErrorMessageProvider,\n    type ValidationResult\n} from './SchemaBuilder.js';\nimport type { StringSchemaBuilder } from './StringSchemaBuilder.js';\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/**\n * Descriptor for a single key-value entry within a validated record.\n * Provides `getValue`, `setValue`, and `getSchema` operations for the entry.\n *\n * Returned as part of {@link RecordKeyValidationResult}.\n */\nexport type RecordKeyDescriptor<\n    TRecord,\n    TValueSchema extends SchemaBuilder<any, any, any, any, any>\n> = {\n    /** The key within the record this descriptor refers to. */\n    readonly key: string;\n    /** Returns the value schema every record entry must satisfy. */\n    getSchema(): TValueSchema;\n    /**\n     * Retrieves the value at `key` from the given record object.\n     * Returns `{ success: false }` when the key is not present.\n     */\n    getValue(obj: TRecord): {\n        value?: InferType<TValueSchema>;\n        success: boolean;\n    };\n    /**\n     * Sets the value at `key` on the given record object.\n     * Returns `false` when `obj` is not a non-null object.\n     */\n    setValue(obj: TRecord, value: InferType<TValueSchema>): boolean;\n};\n\n/**\n * Validation result for a single key-value entry in a record.\n * Returned by {@link RecordSchemaValidationResult.getErrorsFor | getErrorsFor(key)}.\n */\nexport type RecordKeyValidationResult<\n    TRecord,\n    TValueSchema extends SchemaBuilder<any, any, any, any, any>\n> = {\n    /** Validation error messages for this entry; empty array when valid. */\n    readonly errors: ReadonlyArray<string>;\n    /** `true` when there are no validation errors for this entry. */\n    readonly isValid: boolean;\n    /** The value that was seen at this key during validation. */\n    readonly seenValue: InferType<TValueSchema> | undefined;\n    /** Descriptor for reading/writing the value at this key. */\n    readonly descriptor: RecordKeyDescriptor<TRecord, TValueSchema>;\n};\n\n/**\n * Root-level validation result for the record object itself.\n * Returned by {@link RecordSchemaValidationResult.getErrorsFor | getErrorsFor()} (no argument).\n */\nexport type RecordRootValidationResult<TResult> = {\n    /** Root-level error messages (e.g. `\"object expected\"`); empty when valid. */\n    readonly errors: ReadonlyArray<string>;\n    /** `true` when there are no root-level errors. */\n    readonly isValid: boolean;\n    /** The value that was being validated. */\n    readonly seenValue: TResult | undefined;\n};\n\n/**\n * Validation result type returned by `RecordSchemaBuilder.validate()`.\n *\n * Extends `ValidationResult` with:\n * - `getNestedErrors()` — a per-key map of `ValidationResult` objects.\n * - `getErrorsFor()` — root-level errors for the record container itself.\n * - `getErrorsFor(key)` — errors, seen value, and descriptor for a specific key.\n */\nexport type RecordSchemaValidationResult<\n    TResult,\n    TValueSchema extends SchemaBuilder<any, any, any, any, any>\n> = ValidationResult<TResult> & {\n    /**\n     * Returns per-key validation results as a plain object.\n     *\n     * Each key in the returned object corresponds to a key in the input that\n     * **failed** validation (in `doNotStopOnFirstError` mode) or the single\n     * first failing key (in the default stop-on-first-error mode). Keys that\n     * passed are not included.\n     *\n     * @deprecated Prefer {@link getErrorsFor} for a richer per-entry result\n     * that also includes a descriptor and `seenValue`.\n     *\n     * @example\n     * ```ts\n     * const schema = record(string(), number().positive());\n     * const result = schema.validate(\n     *   { a: 1, b: -2, c: 'oops' },\n     *   { doNotStopOnFirstError: true }\n     * );\n     *\n     * if (!result.valid) {\n     *   const nested = result.getNestedErrors();\n     *   console.log(nested['b']); // ValidationResult for key 'b'\n     *   console.log(nested['c']); // ValidationResult for key 'c'\n     * }\n     * ```\n     */\n    getNestedErrors(): Record<\n        string,\n        ValidationResult<InferType<TValueSchema>>\n    >;\n    /**\n     * Returns root-level errors for the record container itself\n     * (e.g. `\"object expected\"` when a non-object value is passed,\n     * or errors from custom validators added to the record schema).\n     *\n     * @example\n     * ```ts\n     * const schema = record(string(), number());\n     * const root = schema.validate(42 as any).getErrorsFor();\n     * // root.errors[0] === 'object expected'\n     * // root.isValid === false\n     * ```\n     */\n    getErrorsFor(): RecordRootValidationResult<TResult>;\n    /**\n     * Returns the validation result for the entry with the given key,\n     * including error messages, the seen value, and a descriptor for\n     * accessing and modifying the value at that key.\n     *\n     * If the key was not reached during validation (e.g. an earlier key\n     * already failed in stop-on-first-error mode), an empty result with\n     * `isValid: true` and no errors is returned.\n     *\n     * @param key - the key whose validation result to retrieve\n     *\n     * @example\n     * ```ts\n     * const schema = record(string(), number().min(0));\n     * const result = schema.validate(\n     *   { a: 5, b: -2 },\n     *   { doNotStopOnFirstError: true }\n     * );\n     *\n     * const bErrors = result.getErrorsFor('b');\n     * // bErrors.isValid === false\n     * // bErrors.errors[0] === 'the value must be >= 0'\n     * // bErrors.seenValue === -2\n     * // bErrors.descriptor.key === 'b'\n     * // bErrors.descriptor.getSchema() === valueSchema\n     * ```\n     */\n    getErrorsFor(key: string): RecordKeyValidationResult<TResult, TValueSchema>;\n};\n\ntype RecordSchemaBuilderCreateProps<\n    TKeySchema extends StringSchemaBuilder<any, any, any, any>,\n    TValueSchema extends SchemaBuilder<any, any, any, any, any>,\n    R extends boolean = true\n> = Partial<\n    ReturnType<RecordSchemaBuilder<TKeySchema, TValueSchema, R>['introspect']>\n>;\n\n// ---------------------------------------------------------------------------\n// Builder class\n// ---------------------------------------------------------------------------\n\n/**\n * Schema builder for objects with dynamic string keys.\n *\n * Every key in the validated object must be accepted by `keySchema` (a\n * `StringSchemaBuilder`) and every value must satisfy `valueSchema`.\n *\n * The inferred TypeScript type mirrors `Record<K, V>` where `K` is the\n * string type produced by `keySchema` and `V` is the type produced by\n * `valueSchema`.\n *\n * **NOTE** — this class is exported to allow extension by inheritance. Use\n * the {@link record | record()} factory function instead of instantiating it\n * directly.\n *\n * @example\n * ```ts\n * import { record, string, number } from '@cleverbrush/schema';\n *\n * // Basic: string keys, number values\n * const scores = record(string(), number().min(0));\n * // InferType<typeof scores> → Record<string, number>\n *\n * scores.validate({ alice: 95, bob: 87 }); // valid\n * scores.validate({ alice: 95, bob: -1 }); // invalid (negative)\n * ```\n *\n * @example\n * ```ts\n * // Restrict keys to a specific set of literals with .equals()\n * const locales = record(\n *   string().matches(/^[a-z]{2}(-[A-Z]{2})?$/),\n *   string().nonempty()\n * );\n * // accepts: { en: 'Hello', fr: 'Bonjour' }\n * // rejects: { 123: 'oops' }  ← key doesn't match pattern\n * ```\n *\n * @see {@link record}\n */\nexport class RecordSchemaBuilder<\n    TKeySchema extends StringSchemaBuilder<any, any, any, any>,\n    TValueSchema extends SchemaBuilder<any, any, any, any, any>,\n    TRequired extends boolean = true,\n    TNullable extends boolean = false,\n    TExplicitType = undefined,\n    THasDefault extends boolean = false,\n    TExtensions = {},\n    TResult = TExplicitType extends undefined\n        ? Record<InferType<TKeySchema>, InferType<TValueSchema>>\n        : TExplicitType\n> extends SchemaBuilder<\n    TResult,\n    TRequired,\n    TNullable,\n    THasDefault,\n    TExtensions\n> {\n    #keySchema!: TKeySchema;\n    #valueSchema!: TValueSchema;\n\n    /**\n     * @hidden\n     */\n    public static create(props: RecordSchemaBuilderCreateProps<any, any, any>) {\n        return new RecordSchemaBuilder({\n            type: 'record',\n            ...props\n        } as any);\n    }\n\n    protected constructor(\n        props: RecordSchemaBuilderCreateProps<\n            TKeySchema,\n            TValueSchema,\n            TRequired\n        >\n    ) {\n        super(props as any);\n\n        if (props.keySchema instanceof SchemaBuilder) {\n            this.#keySchema = props.keySchema as TKeySchema;\n        }\n        if (props.valueSchema instanceof SchemaBuilder) {\n            this.#valueSchema = props.valueSchema as TValueSchema;\n        }\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public hasType<T>(\n        _notUsed?: T\n    ): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        true,\n        TNullable,\n        T,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect()\n        } as any) as any;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public clearHasType(): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        TRequired,\n        TNullable,\n        undefined,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return this.createFromProps({\n            ...this.introspect()\n        } as any) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    protected createFromProps<TReq extends boolean>(\n        props: RecordSchemaBuilderCreateProps<TKeySchema, TValueSchema, TReq>\n    ): this {\n        return RecordSchemaBuilder.create(props as any) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public required(\n        errorMessage?: ValidationErrorMessageProvider\n    ): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        true,\n        TNullable,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.required(errorMessage);\n    }\n\n    /**\n     * @hidden\n     */\n    public optional(): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        false,\n        TNullable,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.optional();\n    }\n\n    /**\n     * @hidden\n     */\n    public default(\n        value: TResult | (() => TResult)\n    ): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        true,\n        TNullable,\n        TExplicitType,\n        true,\n        TExtensions\n    > &\n        TExtensions {\n        return super.default(value) as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public clearDefault(): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        TRequired,\n        TNullable,\n        TExplicitType,\n        false,\n        TExtensions\n    > &\n        TExtensions {\n        return super.clearDefault() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public brand<TBrand extends string | symbol>(\n        _name?: TBrand\n    ): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        TRequired,\n        TNullable,\n        TResult & { readonly [K in BRAND]: TBrand },\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.brand(_name);\n    }\n\n    /**\n     * Returns an introspection object describing the record schema.\n     */\n    public introspect() {\n        return {\n            ...super.introspect(),\n            /**\n             * The schema every key must satisfy (a `StringSchemaBuilder`).\n             */\n            keySchema: this.#keySchema,\n            /**\n             * The schema every value must satisfy.\n             */\n            valueSchema: this.#valueSchema\n        };\n    }\n\n    // -----------------------------------------------------------------------\n    // Validation helpers\n    // -----------------------------------------------------------------------\n\n    #buildNestedErrors(\n        keyResults: Map<string, ValidationResult<any>>\n    ): Record<string, ValidationResult<InferType<TValueSchema>>> {\n        const out: Record<string, ValidationResult<any>> = {};\n        for (const [k, v] of keyResults) {\n            out[k] = v;\n        }\n        return out;\n    }\n\n    /**\n     * Creates a {@link RecordKeyValidationResult} for `key` with the given\n     * error message strings. Captures `rootObject` so the returned descriptor\n     * can lazily read/write the value at that key.\n     */\n    #makeKeyResult(\n        key: string,\n        errors: string[],\n        rootObject: TResult\n    ): RecordKeyValidationResult<TResult, TValueSchema> {\n        const valueSchema = this.#valueSchema;\n        return {\n            errors: errors as ReadonlyArray<string>,\n            isValid: errors.length === 0,\n            seenValue:\n                rootObject !== null && typeof rootObject === 'object'\n                    ? (rootObject as any)[key]\n                    : undefined,\n            descriptor: {\n                key,\n                getSchema: () => valueSchema,\n                getValue: (obj: TResult) => {\n                    if (\n                        obj !== null &&\n                        typeof obj === 'object' &&\n                        Object.hasOwn(obj as any, key)\n                    ) {\n                        return { success: true, value: (obj as any)[key] };\n                    }\n                    return { success: false };\n                },\n                setValue: (obj: TResult, val: InferType<TValueSchema>) => {\n                    if (obj !== null && typeof obj === 'object') {\n                        (obj as any)[key] = val;\n                        return true;\n                    }\n                    return false;\n                }\n            }\n        };\n    }\n\n    /**\n     * Shared setup for {@link #validateFull} and {@link _validateAsync}.\n     * Runs pre-validation guards (null / undefined / type checks) and\n     * builds the `getNestedErrors` / `getErrorsFor` closures.\n     *\n     * Returns either an early result (when validation can short-circuit)\n     * or the data needed for the per-entry loop.\n     */\n    #createValidationSetup(\n        object: TResult,\n        superResult: PreValidationResult<any, { validatedObject: any }>\n    ):\n        | {\n              earlyReturn: true;\n              result: RecordSchemaValidationResult<TResult, TValueSchema>;\n          }\n        | {\n              earlyReturn: false;\n              objToValidate: any;\n              nestedKeyResults: Map<\n                  string,\n                  ValidationResult<InferType<TValueSchema>>\n              >;\n              getNestedErrors: () => Record<\n                  string,\n                  ValidationResult<InferType<TValueSchema>>\n              >;\n              getErrorsFor: (key?: string) => any;\n          } {\n        const { valid, errors } = superResult;\n\n        const rootErrorMsgs: string[] = [];\n        const nestedKeyResults = new Map<\n            string,\n            ValidationResult<InferType<TValueSchema>>\n        >();\n        const getNestedErrors = () => this.#buildNestedErrors(nestedKeyResults);\n        const getErrorsFor = (key?: string): any => {\n            if (typeof key === 'undefined') {\n                return {\n                    errors: rootErrorMsgs as ReadonlyArray<string>,\n                    isValid: rootErrorMsgs.length === 0,\n                    seenValue: object\n                };\n            }\n            const nestedResult = nestedKeyResults.get(key);\n            const errMsgs =\n                nestedResult && !nestedResult.valid\n                    ? (nestedResult.errors ?? []).map(\n                          (e: ValidationError) => e.message\n                      )\n                    : [];\n            return this.#makeKeyResult(key, errMsgs, object);\n        };\n\n        if (!valid) {\n            for (const e of errors ?? []) rootErrorMsgs.push(e.message);\n            return {\n                earlyReturn: true,\n                result: {\n                    valid,\n                    errors,\n                    getNestedErrors,\n                    getErrorsFor\n                } as any\n            };\n        }\n\n        const objToValidate = superResult.transaction!.object\n            .validatedObject as any;\n\n        if (\n            (typeof objToValidate === 'undefined' && !this.isRequired) ||\n            (objToValidate === null && (!this.isRequired || this.isNullable))\n        ) {\n            return {\n                earlyReturn: true,\n                result: {\n                    valid: true,\n                    object: objToValidate,\n                    getNestedErrors,\n                    getErrorsFor\n                } as any\n            };\n        }\n\n        if (\n            typeof objToValidate !== 'object' ||\n            Array.isArray(objToValidate) ||\n            objToValidate === null\n        ) {\n            rootErrorMsgs.push('object expected');\n            return {\n                earlyReturn: true,\n                result: {\n                    valid: false,\n                    errors: [{ message: 'object expected' }],\n                    getNestedErrors,\n                    getErrorsFor\n                } as any\n            };\n        }\n\n        return {\n            earlyReturn: false,\n            objToValidate,\n            nestedKeyResults,\n            getNestedErrors,\n            getErrorsFor\n        };\n    }\n\n    /**\n     * Builds the final validation result from the per-entry loop outcome.\n     */\n    #buildEntryResult(\n        allValid: boolean,\n        allErrors: ValidationError[],\n        result: Record<string, any>,\n        doNotStop: boolean,\n        getNestedErrors: () => Record<\n            string,\n            ValidationResult<InferType<TValueSchema>>\n        >,\n        getErrorsFor: (key?: string) => any\n    ): RecordSchemaValidationResult<TResult, TValueSchema> {\n        if (!allValid) {\n            return {\n                valid: false,\n                errors: doNotStop ? allErrors : [allErrors[0]],\n                getNestedErrors,\n                getErrorsFor\n            } as any;\n        }\n\n        return {\n            valid: true,\n            object: result as TResult,\n            getNestedErrors,\n            getErrorsFor\n        } as any;\n    }\n\n    /**\n     * Core sync validation. {@inheritDoc SchemaBuilder.validate}\n     */\n    public validate(\n        object: TResult,\n        context?: ValidationContext\n    ): RecordSchemaValidationResult<TResult, TValueSchema> {\n        return super.validate(object, context) as RecordSchemaValidationResult<\n            TResult,\n            TValueSchema\n        >;\n    }\n\n    /**\n     * Core async validation. {@inheritDoc SchemaBuilder.validateAsync}\n     */\n    public async validateAsync(\n        object: TResult,\n        context?: ValidationContext\n    ): Promise<RecordSchemaValidationResult<TResult, TValueSchema>> {\n        return super.validateAsync(object, context) as Promise<\n            RecordSchemaValidationResult<TResult, TValueSchema>\n        >;\n    }\n\n    /**\n     * Core sync validation. Returns `{ valid, object, errors, getNestedErrors, getErrorsFor }`.\n     */\n    protected _validate(\n        object: TResult,\n        context?: ValidationContext\n    ): RecordSchemaValidationResult<TResult, TValueSchema> {\n        // Fast path: skip pre-validation when no preprocessors/validators.\n        if (this.canSkipPreValidation && !context?.doNotStopOnFirstError) {\n            if (typeof object === 'undefined' || object === null) {\n                if (typeof object === 'undefined' && this.hasDefault) {\n                    object = this.resolveDefaultValue();\n                } else if (\n                    !this.isRequired ||\n                    (object === null && this.isNullable)\n                ) {\n                    const capturedObj = object;\n                    return {\n                        valid: true,\n                        object,\n                        getNestedErrors() {\n                            return {};\n                        },\n                        getErrorsFor: (key?: string): any => {\n                            if (typeof key === 'undefined') {\n                                return {\n                                    errors: [] as ReadonlyArray<string>,\n                                    isValid: true,\n                                    seenValue: capturedObj\n                                };\n                            }\n                            return this.#makeKeyResult(\n                                key,\n                                [],\n                                capturedObj as TResult\n                            );\n                        }\n                    } as any;\n                } else {\n                    return this.#validateFull(object, context);\n                }\n            }\n\n            if (\n                typeof object !== 'object' ||\n                Array.isArray(object) ||\n                object === null\n            ) {\n                return this.#validateFull(object, context);\n            }\n\n            // Validate every entry inline, collecting per-key results as we go.\n            const nestedKeyResults = new Map<string, ValidationResult<any>>();\n            const result: Record<string, any> = {};\n            let firstError: ValidationError | null = null;\n\n            for (const key of Object.keys(object as any)) {\n                const keyResult = this.#keySchema.validate(key);\n                if (!keyResult.valid) {\n                    const keyErrors =\n                        keyResult.errors && keyResult.errors.length > 0\n                            ? keyResult.errors\n                            : [{ message: `key \"${key}\" is invalid` }];\n                    nestedKeyResults.set(key, {\n                        valid: false,\n                        errors: keyErrors\n                    });\n                    firstError = keyErrors[0];\n                    break;\n                }\n\n                const valueResult = this.#valueSchema.validate(\n                    (object as any)[key]\n                );\n                nestedKeyResults.set(key, valueResult as any);\n\n                if (!valueResult.valid) {\n                    const valErrors =\n                        valueResult.errors && valueResult.errors.length > 0\n                            ? valueResult.errors\n                            : [\n                                  {\n                                      message: `value for key \"${key}\" is invalid`\n                                  }\n                              ];\n                    nestedKeyResults.set(key, {\n                        valid: false,\n                        errors: valErrors\n                    });\n                    firstError = valErrors[0];\n                    break;\n                } else {\n                    result[key] = valueResult.object;\n                }\n            }\n\n            const capturedInput = object;\n            const getNestedErrors = () =>\n                this.#buildNestedErrors(nestedKeyResults);\n            const getErrorsFor = (key?: string): any => {\n                if (typeof key === 'undefined') {\n                    return {\n                        errors: [] as ReadonlyArray<string>,\n                        isValid: true,\n                        seenValue: capturedInput\n                    };\n                }\n                const nestedResult = nestedKeyResults.get(key);\n                const errMsgs =\n                    nestedResult && !nestedResult.valid\n                        ? (nestedResult.errors ?? []).map(\n                              (e: ValidationError) => e.message\n                          )\n                        : [];\n                return this.#makeKeyResult(key, errMsgs, capturedInput);\n            };\n\n            if (firstError !== null) {\n                return {\n                    valid: false,\n                    errors: [firstError],\n                    getNestedErrors,\n                    getErrorsFor\n                } as any;\n            }\n\n            return {\n                valid: true,\n                object: result as TResult,\n                getNestedErrors,\n                getErrorsFor\n            } as any;\n        }\n\n        return this.#validateFull(object, context);\n    }\n\n    /**\n     * Full validation path — processes preprocessors, validators, and collects\n     * all per-entry results.\n     */\n    #validateFull(\n        object: TResult,\n        context?: ValidationContext\n    ): RecordSchemaValidationResult<TResult, TValueSchema> {\n        const setup = this.#createValidationSetup(\n            object,\n            this.preValidateSync(object, context)\n        );\n        if (setup.earlyReturn) return setup.result;\n\n        const {\n            objToValidate,\n            nestedKeyResults,\n            getNestedErrors,\n            getErrorsFor\n        } = setup;\n        const doNotStop = context?.doNotStopOnFirstError ?? false;\n        let allValid = true;\n        const result: Record<string, any> = {};\n        const allErrors: ValidationError[] = [];\n\n        for (const key of Object.keys(objToValidate)) {\n            const keyResult = this.#keySchema.validate(key);\n            if (!keyResult.valid) {\n                allValid = false;\n                const keyErrors =\n                    keyResult.errors && keyResult.errors.length > 0\n                        ? keyResult.errors\n                        : [{ message: `key \"${key}\" is invalid` }];\n                nestedKeyResults.set(key, {\n                    valid: false,\n                    errors: keyErrors\n                });\n                allErrors.push(...keyErrors);\n                if (!doNotStop) break;\n                continue;\n            }\n\n            const valueResult = this.#valueSchema.validate(\n                objToValidate[key],\n                doNotStop ? { doNotStopOnFirstError: true } : undefined\n            );\n            nestedKeyResults.set(key, valueResult as any);\n\n            if (!valueResult.valid) {\n                allValid = false;\n                const valueErrors =\n                    valueResult.errors && valueResult.errors.length > 0\n                        ? valueResult.errors\n                        : [{ message: `value for key \"${key}\" is invalid` }];\n                allErrors.push(...valueErrors);\n                if (!doNotStop) break;\n            } else {\n                result[key] = valueResult.object;\n            }\n        }\n\n        return this.#buildEntryResult(\n            allValid,\n            allErrors,\n            result,\n            doNotStop,\n            getNestedErrors,\n            getErrorsFor\n        );\n    }\n\n    /**\n     * Performs async validation of the record schema.\n     *\n     * Supports async preprocessors, validators, and error message providers.\n     *\n     * @param object - the value to validate\n     * @param context - optional `ValidationContext` settings\n     */\n    protected async _validateAsync(\n        object: TResult,\n        context?: ValidationContext\n    ): Promise<RecordSchemaValidationResult<TResult, TValueSchema>> {\n        const setup = this.#createValidationSetup(\n            object,\n            await this.preValidateAsync(object, context)\n        );\n        if (setup.earlyReturn) return setup.result;\n\n        const {\n            objToValidate,\n            nestedKeyResults,\n            getNestedErrors,\n            getErrorsFor\n        } = setup;\n        const doNotStop = context?.doNotStopOnFirstError ?? false;\n        let allValid = true;\n        const result: Record<string, any> = {};\n        const allErrors: ValidationError[] = [];\n\n        for (const key of Object.keys(objToValidate)) {\n            const keyResult = await this.#keySchema.validateAsync(key);\n            if (!keyResult.valid) {\n                allValid = false;\n                const keyErrors =\n                    keyResult.errors && keyResult.errors.length > 0\n                        ? keyResult.errors\n                        : [{ message: `key \"${key}\" is invalid` }];\n                nestedKeyResults.set(key, {\n                    valid: false,\n                    errors: keyErrors\n                });\n                allErrors.push(...keyErrors);\n                if (!doNotStop) break;\n                continue;\n            }\n\n            const valueResult = await this.#valueSchema.validateAsync(\n                objToValidate[key],\n                doNotStop ? { doNotStopOnFirstError: true } : undefined\n            );\n            nestedKeyResults.set(key, valueResult as any);\n\n            if (!valueResult.valid) {\n                allValid = false;\n                const valueErrors =\n                    valueResult.errors && valueResult.errors.length > 0\n                        ? valueResult.errors\n                        : [{ message: `value for key \"${key}\" is invalid` }];\n                allErrors.push(...valueErrors);\n                if (!doNotStop) break;\n            } else {\n                result[key] = valueResult.object;\n            }\n        }\n\n        return this.#buildEntryResult(\n            allValid,\n            allErrors,\n            result,\n            doNotStop,\n            getNestedErrors,\n            getErrorsFor\n        );\n    }\n\n    /**\n     * @hidden\n     */\n    public nullable(): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        TRequired,\n        true,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.nullable() as any;\n    }\n\n    /**\n     * @hidden\n     */\n    public notNullable(): RecordSchemaBuilder<\n        TKeySchema,\n        TValueSchema,\n        TRequired,\n        false,\n        TExplicitType,\n        THasDefault,\n        TExtensions\n    > &\n        TExtensions {\n        return super.notNullable() as any;\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Factory function\n// ---------------------------------------------------------------------------\n\n/**\n * Creates a schema for objects with dynamic string keys, where every key\n * must satisfy `keySchema` and every value must satisfy `valueSchema`.\n *\n * The inferred TypeScript type is `Record<K, V>` where `K` is derived from\n * `keySchema` and `V` from `valueSchema`.\n *\n * @param keySchema  - a `StringSchemaBuilder` that each key must satisfy\n * @param valueSchema - a `SchemaBuilder` that each value must satisfy\n *\n * @example\n * ```ts\n * import { record, string, number } from '@cleverbrush/schema';\n *\n * // Look-up table: string keys → number scores\n * const scores = record(string(), number().min(0).max(100));\n * // InferType<typeof scores> → Record<string, number>\n *\n * scores.validate({ alice: 95, bob: 87 }); // { valid: true }\n * scores.validate({ alice: 95, bob: -1 }); // { valid: false }\n * ```\n *\n * @example\n * ```ts\n * // i18n bundle: locale code keys → non-empty strings\n * const bundle = record(\n *   string().matches(/^[a-z]{2}(-[A-Z]{2})?$/),\n *   string().nonempty()\n * );\n *\n * bundle.validate({ en: 'Hello', 'fr-FR': 'Bonjour' }); // valid\n * bundle.validate({ en: '' });                            // invalid (empty value)\n * bundle.validate({ '123': 'hi' });                      // invalid (bad key)\n * ```\n *\n * @example\n * ```ts\n * // Optional record with a factory default\n * const cache = record(string(), number())\n *   .optional()\n *   .default(() => ({}));\n * ```\n *\n * @example\n * ```ts\n * // Nested record — values are objects\n * import { record, string, object, number } from '@cleverbrush/schema';\n *\n * const userMap = record(\n *   string(),\n *   object({ name: string(), age: number() })\n * );\n * ```\n */\nexport function record<\n    TKeySchema extends StringSchemaBuilder<any, any, any, any>,\n    TValueSchema extends SchemaBuilder<any, any, any, any, any>\n>(\n    keySchema: TKeySchema,\n    valueSchema: TValueSchema\n): RecordSchemaBuilder<TKeySchema, TValueSchema> {\n    return RecordSchemaBuilder.create({\n        type: 'record',\n        keySchema,\n        valueSchema\n    } as any) as any;\n}\n"],"mappings":"wCAmOO,IAAMA,EAAN,MAAMC,UAWHC,CAMR,CACEC,GACAC,GAKA,OAAc,OAAOC,EAAsD,CACvE,OAAO,IAAIJ,EAAoB,CAC3B,KAAM,SACN,GAAGI,CACP,CAAQ,CACZ,CAEU,YACNA,EAKF,CACE,MAAMA,CAAY,EAEdA,EAAM,qBAAqBH,IAC3B,KAAKC,GAAaE,EAAM,WAExBA,EAAM,uBAAuBH,IAC7B,KAAKE,GAAeC,EAAM,YAElC,CAKO,QACHC,EAUY,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,CACvB,CAAQ,CACZ,CAKO,cASS,CACZ,OAAO,KAAK,gBAAgB,CACxB,GAAG,KAAK,WAAW,CACvB,CAAQ,CACZ,CAKU,gBACND,EACI,CACJ,OAAOJ,EAAoB,OAAOI,CAAY,CAClD,CAKO,SACHE,EAUY,CACZ,OAAO,MAAM,SAASA,CAAY,CACtC,CAKO,UASS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,QACHC,EAUY,CACZ,OAAO,MAAM,QAAQA,CAAK,CAC9B,CAKO,cASS,CACZ,OAAO,MAAM,aAAa,CAC9B,CAKO,MACHC,EAUY,CACZ,OAAO,MAAM,MAAMA,CAAK,CAC5B,CAKO,YAAa,CAChB,MAAO,CACH,GAAG,MAAM,WAAW,EAIpB,UAAW,KAAKN,GAIhB,YAAa,KAAKC,EACtB,CACJ,CAMAM,GACIC,EACyD,CACzD,IAAMC,EAA6C,CAAC,EACpD,OAAW,CAACC,EAAGC,CAAC,IAAKH,EACjBC,EAAIC,CAAC,EAAIC,EAEb,OAAOF,CACX,CAOAG,GACIC,EACAC,EACAC,EACgD,CAChD,IAAMC,EAAc,KAAKf,GACzB,MAAO,CACH,OAAQa,EACR,QAASA,EAAO,SAAW,EAC3B,UACIC,IAAe,MAAQ,OAAOA,GAAe,SACtCA,EAAmBF,CAAG,EACvB,OACV,WAAY,CACR,IAAAA,EACA,UAAW,IAAMG,EACjB,SAAWC,GAEHA,IAAQ,MACR,OAAOA,GAAQ,UACf,OAAO,OAAOA,EAAYJ,CAAG,EAEtB,CAAE,QAAS,GAAM,MAAQI,EAAYJ,CAAG,CAAE,EAE9C,CAAE,QAAS,EAAM,EAE5B,SAAU,CAACI,EAAcC,IACjBD,IAAQ,MAAQ,OAAOA,GAAQ,UAC9BA,EAAYJ,CAAG,EAAIK,EACb,IAEJ,EAEf,CACJ,CACJ,CAUAC,GACIC,EACAC,EAkBI,CACJ,GAAM,CAAE,MAAAC,EAAO,OAAAR,CAAO,EAAIO,EAEpBE,EAA0B,CAAC,EAC3BC,EAAmB,IAAI,IAIvBC,EAAkB,IAAM,KAAKlB,GAAmBiB,CAAgB,EAChEE,EAAgBb,GAAsB,CACxC,GAAI,OAAOA,EAAQ,IACf,MAAO,CACH,OAAQU,EACR,QAASA,EAAc,SAAW,EAClC,UAAWH,CACf,EAEJ,IAAMO,EAAeH,EAAiB,IAAIX,CAAG,EACvCe,EACFD,GAAgB,CAACA,EAAa,OACvBA,EAAa,QAAU,CAAC,GAAG,IACvBE,GAAuBA,EAAE,OAC9B,EACA,CAAC,EACX,OAAO,KAAKjB,GAAeC,EAAKe,EAASR,CAAM,CACnD,EAEA,GAAI,CAACE,EAAO,CACR,QAAWO,KAAKf,GAAU,CAAC,EAAGS,EAAc,KAAKM,EAAE,OAAO,EAC1D,MAAO,CACH,YAAa,GACb,OAAQ,CACJ,MAAAP,EACA,OAAAR,EACA,gBAAAW,EACA,aAAAC,CACJ,CACJ,CACJ,CAEA,IAAMI,EAAgBT,EAAY,YAAa,OAC1C,gBAEL,OACK,OAAOS,EAAkB,KAAe,CAAC,KAAK,YAC9CA,IAAkB,OAAS,CAAC,KAAK,YAAc,KAAK,YAE9C,CACH,YAAa,GACb,OAAQ,CACJ,MAAO,GACP,OAAQA,EACR,gBAAAL,EACA,aAAAC,CACJ,CACJ,EAIA,OAAOI,GAAkB,UACzB,MAAM,QAAQA,CAAa,GAC3BA,IAAkB,MAElBP,EAAc,KAAK,iBAAiB,EAC7B,CACH,YAAa,GACb,OAAQ,CACJ,MAAO,GACP,OAAQ,CAAC,CAAE,QAAS,iBAAkB,CAAC,EACvC,gBAAAE,EACA,aAAAC,CACJ,CACJ,GAGG,CACH,YAAa,GACb,cAAAI,EACA,iBAAAN,EACA,gBAAAC,EACA,aAAAC,CACJ,CACJ,CAKAK,GACIC,EACAC,EACAC,EACAC,EACAV,EAIAC,EACmD,CACnD,OAAKM,EASE,CACH,MAAO,GACP,OAAQE,EACR,gBAAAT,EACA,aAAAC,CACJ,EAbW,CACH,MAAO,GACP,OAAQS,EAAYF,EAAY,CAACA,EAAU,CAAC,CAAC,EAC7C,gBAAAR,EACA,aAAAC,CACJ,CASR,CAKO,SACHN,EACAgB,EACmD,CACnD,OAAO,MAAM,SAAShB,EAAQgB,CAAO,CAIzC,CAKA,MAAa,cACThB,EACAgB,EAC4D,CAC5D,OAAO,MAAM,cAAchB,EAAQgB,CAAO,CAG9C,CAKU,UACNhB,EACAgB,EACmD,CAEnD,GAAI,KAAK,sBAAwB,CAACA,GAAS,sBAAuB,CAC9D,GAAI,OAAOhB,EAAW,KAAeA,IAAW,KAC5C,GAAI,OAAOA,EAAW,KAAe,KAAK,WACtCA,EAAS,KAAK,oBAAoB,UAElC,CAAC,KAAK,YACLA,IAAW,MAAQ,KAAK,WAC3B,CACE,IAAMiB,EAAcjB,EACpB,MAAO,CACH,MAAO,GACP,OAAAA,EACA,iBAAkB,CACd,MAAO,CAAC,CACZ,EACA,aAAeP,GACP,OAAOA,EAAQ,IACR,CACH,OAAQ,CAAC,EACT,QAAS,GACT,UAAWwB,CACf,EAEG,KAAKzB,GACRC,EACA,CAAC,EACDwB,CACJ,CAER,CACJ,KACI,QAAO,KAAKC,GAAclB,EAAQgB,CAAO,EAIjD,GACI,OAAOhB,GAAW,UAClB,MAAM,QAAQA,CAAM,GACpBA,IAAW,KAEX,OAAO,KAAKkB,GAAclB,EAAQgB,CAAO,EAI7C,IAAMZ,EAAmB,IAAI,IACvBU,EAA8B,CAAC,EACjCK,EAAqC,KAEzC,QAAW1B,KAAO,OAAO,KAAKO,CAAa,EAAG,CAC1C,IAAMoB,EAAY,KAAKxC,GAAW,SAASa,CAAG,EAC9C,GAAI,CAAC2B,EAAU,MAAO,CAClB,IAAMC,EACFD,EAAU,QAAUA,EAAU,OAAO,OAAS,EACxCA,EAAU,OACV,CAAC,CAAE,QAAS,QAAQ3B,CAAG,cAAe,CAAC,EACjDW,EAAiB,IAAIX,EAAK,CACtB,MAAO,GACP,OAAQ4B,CACZ,CAAC,EACDF,EAAaE,EAAU,CAAC,EACxB,KACJ,CAEA,IAAMC,EAAc,KAAKzC,GAAa,SACjCmB,EAAeP,CAAG,CACvB,EAGA,GAFAW,EAAiB,IAAIX,EAAK6B,CAAkB,EAEvCA,EAAY,MAgBbR,EAAOrB,CAAG,EAAI6B,EAAY,WAhBN,CACpB,IAAMC,EACFD,EAAY,QAAUA,EAAY,OAAO,OAAS,EAC5CA,EAAY,OACZ,CACI,CACI,QAAS,kBAAkB7B,CAAG,cAClC,CACJ,EACVW,EAAiB,IAAIX,EAAK,CACtB,MAAO,GACP,OAAQ8B,CACZ,CAAC,EACDJ,EAAaI,EAAU,CAAC,EACxB,KACJ,CAGJ,CAEA,IAAMC,EAAgBxB,EAChBK,EAAkB,IACpB,KAAKlB,GAAmBiB,CAAgB,EACtCE,EAAgBb,GAAsB,CACxC,GAAI,OAAOA,EAAQ,IACf,MAAO,CACH,OAAQ,CAAC,EACT,QAAS,GACT,UAAW+B,CACf,EAEJ,IAAMjB,EAAeH,EAAiB,IAAIX,CAAG,EACvCe,EACFD,GAAgB,CAACA,EAAa,OACvBA,EAAa,QAAU,CAAC,GAAG,IACvBE,GAAuBA,EAAE,OAC9B,EACA,CAAC,EACX,OAAO,KAAKjB,GAAeC,EAAKe,EAASgB,CAAa,CAC1D,EAEA,OAAIL,IAAe,KACR,CACH,MAAO,GACP,OAAQ,CAACA,CAAU,EACnB,gBAAAd,EACA,aAAAC,CACJ,EAGG,CACH,MAAO,GACP,OAAQQ,EACR,gBAAAT,EACA,aAAAC,CACJ,CACJ,CAEA,OAAO,KAAKY,GAAclB,EAAQgB,CAAO,CAC7C,CAMAE,GACIlB,EACAgB,EACmD,CACnD,IAAMS,EAAQ,KAAK1B,GACfC,EACA,KAAK,gBAAgBA,EAAQgB,CAAO,CACxC,EACA,GAAIS,EAAM,YAAa,OAAOA,EAAM,OAEpC,GAAM,CACF,cAAAf,EACA,iBAAAN,EACA,gBAAAC,EACA,aAAAC,CACJ,EAAImB,EACEV,EAAYC,GAAS,uBAAyB,GAChDJ,EAAW,GACTE,EAA8B,CAAC,EAC/BD,EAA+B,CAAC,EAEtC,QAAWpB,KAAO,OAAO,KAAKiB,CAAa,EAAG,CAC1C,IAAMU,EAAY,KAAKxC,GAAW,SAASa,CAAG,EAC9C,GAAI,CAAC2B,EAAU,MAAO,CAClBR,EAAW,GACX,IAAMS,EACFD,EAAU,QAAUA,EAAU,OAAO,OAAS,EACxCA,EAAU,OACV,CAAC,CAAE,QAAS,QAAQ3B,CAAG,cAAe,CAAC,EAMjD,GALAW,EAAiB,IAAIX,EAAK,CACtB,MAAO,GACP,OAAQ4B,CACZ,CAAC,EACDR,EAAU,KAAK,GAAGQ,CAAS,EACvB,CAACN,EAAW,MAChB,QACJ,CAEA,IAAMO,EAAc,KAAKzC,GAAa,SAClC6B,EAAcjB,CAAG,EACjBsB,EAAY,CAAE,sBAAuB,EAAK,EAAI,MAClD,EAGA,GAFAX,EAAiB,IAAIX,EAAK6B,CAAkB,EAEvCA,EAAY,MASbR,EAAOrB,CAAG,EAAI6B,EAAY,WATN,CACpBV,EAAW,GACX,IAAMc,EACFJ,EAAY,QAAUA,EAAY,OAAO,OAAS,EAC5CA,EAAY,OACZ,CAAC,CAAE,QAAS,kBAAkB7B,CAAG,cAAe,CAAC,EAE3D,GADAoB,EAAU,KAAK,GAAGa,CAAW,EACzB,CAACX,EAAW,KACpB,CAGJ,CAEA,OAAO,KAAKJ,GACRC,EACAC,EACAC,EACAC,EACAV,EACAC,CACJ,CACJ,CAUA,MAAgB,eACZN,EACAgB,EAC4D,CAC5D,IAAMS,EAAQ,KAAK1B,GACfC,EACA,MAAM,KAAK,iBAAiBA,EAAQgB,CAAO,CAC/C,EACA,GAAIS,EAAM,YAAa,OAAOA,EAAM,OAEpC,GAAM,CACF,cAAAf,EACA,iBAAAN,EACA,gBAAAC,EACA,aAAAC,CACJ,EAAImB,EACEV,EAAYC,GAAS,uBAAyB,GAChDJ,EAAW,GACTE,EAA8B,CAAC,EAC/BD,EAA+B,CAAC,EAEtC,QAAWpB,KAAO,OAAO,KAAKiB,CAAa,EAAG,CAC1C,IAAMU,EAAY,MAAM,KAAKxC,GAAW,cAAca,CAAG,EACzD,GAAI,CAAC2B,EAAU,MAAO,CAClBR,EAAW,GACX,IAAMS,EACFD,EAAU,QAAUA,EAAU,OAAO,OAAS,EACxCA,EAAU,OACV,CAAC,CAAE,QAAS,QAAQ3B,CAAG,cAAe,CAAC,EAMjD,GALAW,EAAiB,IAAIX,EAAK,CACtB,MAAO,GACP,OAAQ4B,CACZ,CAAC,EACDR,EAAU,KAAK,GAAGQ,CAAS,EACvB,CAACN,EAAW,MAChB,QACJ,CAEA,IAAMO,EAAc,MAAM,KAAKzC,GAAa,cACxC6B,EAAcjB,CAAG,EACjBsB,EAAY,CAAE,sBAAuB,EAAK,EAAI,MAClD,EAGA,GAFAX,EAAiB,IAAIX,EAAK6B,CAAkB,EAEvCA,EAAY,MASbR,EAAOrB,CAAG,EAAI6B,EAAY,WATN,CACpBV,EAAW,GACX,IAAMc,EACFJ,EAAY,QAAUA,EAAY,OAAO,OAAS,EAC5CA,EAAY,OACZ,CAAC,CAAE,QAAS,kBAAkB7B,CAAG,cAAe,CAAC,EAE3D,GADAoB,EAAU,KAAK,GAAGa,CAAW,EACzB,CAACX,EAAW,KACpB,CAGJ,CAEA,OAAO,KAAKJ,GACRC,EACAC,EACAC,EACAC,EACAV,EACAC,CACJ,CACJ,CAKO,UASS,CACZ,OAAO,MAAM,SAAS,CAC1B,CAKO,aASS,CACZ,OAAO,MAAM,YAAY,CAC7B,CACJ,EA4DO,SAASqB,EAIZC,EACAhC,EAC6C,CAC7C,OAAOnB,EAAoB,OAAO,CAC9B,KAAM,SACN,UAAAmD,EACA,YAAAhC,CACJ,CAAQ,CACZ","names":["RecordSchemaBuilder","_RecordSchemaBuilder","SchemaBuilder","#keySchema","#valueSchema","props","_notUsed","errorMessage","value","_name","#buildNestedErrors","keyResults","out","k","v","#makeKeyResult","key","errors","rootObject","valueSchema","obj","val","#createValidationSetup","object","superResult","valid","rootErrorMsgs","nestedKeyResults","getNestedErrors","getErrorsFor","nestedResult","errMsgs","e","objToValidate","#buildEntryResult","allValid","allErrors","result","doNotStop","context","capturedObj","#validateFull","firstError","keyResult","keyErrors","valueResult","valErrors","capturedInput","setup","valueErrors","record","keySchema"]}

package/dist/chunk-KESLT5EE.js

@@ -0,0 +1,2 @@
+import{f as l}from"./chunk-CTP4RHDG.js";var n=class i extends l{#e;#b=function(){return`expected to be at least ${this.#e}`};#a=this.#b;#r;#N=function(){return`expected to be no more than or equal to ${this.#r}`};#u=this.#N;#s;#E=function(){return`expected to be equal to ${this.#s}`};#n=this.#E;#t=!0;#l=function(){return"is not expected to be NaN"};#o=this.#l;#d=!0;#T=function(){return"is expected to be a finite number"};#m=this.#T;#h=!0;#i=function(){return"is expected to be an integer"};#c=this.#i;static create(e){return new i({type:"number",...e})}constructor(e){super(e),typeof e.min=="number"&&(this.#e=e.min),this.#a=this.assureValidationErrorMessageProvider(e.minValidationErrorMessageProvider,this.#b),typeof e.max=="number"&&(this.#r=e.max),this.#u=this.assureValidationErrorMessageProvider(e.maxValidationErrorMessageProvider,this.#N),typeof e.ensureNotNaN=="boolean"&&(this.#t=e.ensureNotNaN),this.#o=this.assureValidationErrorMessageProvider(e.ensureNotNaNErrorMessageProvider,this.#l),typeof e.ensureIsFinite=="boolean"&&(this.#d=e.ensureIsFinite),this.#m=this.assureValidationErrorMessageProvider(e.ensureIsFiniteErrorMessageProvider,this.#T),typeof e.isInteger=="boolean"&&(this.#h=e.isInteger),this.#c=this.assureValidationErrorMessageProvider(e.ensureIsIntegerErrorMessageProvider,this.#i),(typeof e.equalsTo=="number"||typeof e.equalsTo>"u")&&(this.#s=e.equalsTo),this.#n=this.assureValidationErrorMessageProvider(e.equalsToValidationErrorMessageProvider,this.#E)}introspect(){return{...super.introspect(),min:this.#e,minValidationErrorMessageProvider:this.#a,max:this.#r,maxValidationErrorMessageProvider:this.#u,ensureNotNaN:this.#t,ensureNotNaNErrorMessageProvider:this.#o,ensureIsFinite:this.#d,ensureIsFiniteErrorMessageProvider:this.#m,equalsTo:this.#s,equalsToValidationErrorMessageProvider:this.#n,isInteger:this.#h,ensureIsIntegerErrorMessageProvider:this.#c,preprocessors:this.preprocessors,validators:this.validators}}hasType(e){return this.createFromProps({...this.introspect()})}clearHasType(){return this.createFromProps({...this.introspect()})}#f(e){return typeof e!="number"?{message:`expected type number, but saw ${typeof e}`}:typeof this.#s<"u"&&e!==this.#s?{provider:this.#n}:this.#t&&Number.isNaN(e)?{provider:this.#o}:this.#d&&!Number.isFinite(e)&&this.#t&&!Number.isNaN(e)?{provider:this.#m}:this.#h&&!Number.isNaN(e)&&Number.isFinite(e)&&!Number.isInteger(e)?{provider:this.#c}:typeof this.#e<"u"&&e<this.#e?{provider:this.#a}:typeof this.#r<"u"&&e>this.#r?{provider:this.#u}:null}#R(e){let{valid:r,transaction:s,errors:t}=e;if(!r)return{done:!0,result:{valid:r,errors:t}};let{object:{validatedObject:a}}=s;if(typeof a>"u"&&!this.isRequired||a===null&&(!this.isRequired||this.isNullable))return{done:!0,result:{valid:!0,object:a}};let u=this.#f(a);return u?"message"in u?{done:!0,result:{valid:!1,errors:[{message:u.message}]}}:{done:!1,provider:u.provider,objToValidate:a}:{done:!0,result:{valid:!0,object:s.commit().validatedObject}}}validate(e,r){return super.validate(e,r)}async validateAsync(e,r){return super.validateAsync(e,r)}_validate(e,r){if(this.canSkipPreValidation){if(typeof e>"u"||e===null)if(typeof e>"u"&&this.hasDefault)e=this.resolveDefaultValue();else return!this.isRequired||e===null&&this.isNullable?{valid:!0,object:e}:{valid:!1,errors:[{message:this.getValidationErrorMessageSync(this.requiredErrorMessage,e)}]};let t=this.#f(e);return t?"message"in t?{valid:!1,errors:[{message:t.message}]}:{valid:!1,errors:[{message:this.getValidationErrorMessageSync(t.provider,e)}]}:{valid:!0,object:e}}let s=this.#R(this.preValidateSync(e,r));return s.done?s.result:{valid:!1,errors:[{message:this.getValidationErrorMessageSync(s.provider,s.objToValidate)}]}}async _validateAsync(e,r){let s=this.#R(await super.preValidateAsync(e,r));return s.done?s.result:{valid:!1,errors:[{message:await this.getValidationErrorMessage(s.provider,s.objToValidate)}]}}createFromProps(e){return i.create(e)}equals(e,r){if(typeof e!="number")throw new Error("number expected");return this.createFromProps({...this.introspect(),equalsTo:e,equalsToValidationErrorMessageProvider:r})}clearEquals(){return this.createFromProps({...this.introspect(),equalsTo:void 0})}isFloat(){return this.createFromProps({...this.introspect(),isInteger:!1,ensureIsIntegerErrorMessageProvider:this.#i})}clearIsInteger(){return this.createFromProps({...this.introspect(),isInteger:!1,ensureIsIntegerErrorMessageProvider:this.#i})}isInteger(e){return this.createFromProps({...this.introspect(),isInteger:!0,ensureIsIntegerErrorMessageProvider:e})}required(e){return super.required(e)}optional(){return super.optional()}default(e){return super.default(e)}clearDefault(){return super.clearDefault()}brand(e){return super.brand(e)}readonly(){return super.readonly()}notNaN(e){return this.createFromProps({...this.introspect(),ensureNotNaN:!0,ensureNotNaNErrorMessageProvider:e})}canBeNaN(){return this.createFromProps({...this.introspect(),ensureNotNaN:!1,ensureNotNaNErrorMessageProvider:this.#l})}isFinite(e){return this.createFromProps({...this.introspect(),ensureIsFinite:!0,ensureIsFiniteErrorMessageProvider:e})}canBeInfinite(){return this.createFromProps({...this.introspect(),ensureIsFinite:!1,ensureIsFiniteErrorMessageProvider:this.#T})}min(e,r){if(typeof e!="number")throw new Error("minValue must be a number");return this.createFromProps({...this.introspect(),min:e,minValidationErrorMessageProvider:r})}clearMin(){let e=this.introspect();return delete e.min,this.createFromProps({...e})}max(e,r){if(typeof e!="number")throw new Error("maxValue must be a number");return this.createFromProps({...this.introspect(),max:e,maxValidationErrorMessageProvider:r})}clearMax(){let e=this.introspect();return delete e.max,this.createFromProps({...e})}nullable(){return super.nullable()}notNullable(){return super.notNullable()}};function d(i){return typeof i=="number"?n.create({isRequired:!0,equalsTo:i}):n.create({isRequired:!0})}export{n as a,d as b};
+//# sourceMappingURL=chunk-KESLT5EE.js.map