@lucania/schema 2.0.3 → 3.0.0

package/build/builder.d.ts

@@ -1,5 +1,5 @@
 import { BaseSchemaAny } from "./typing/extended";
-import { DefaultValue, ModelValue, TypedMembers } from "./typing/toolbox";
+import { DefaultValue, ModelValue } from "./typing/toolbox";
 import { AnySchema } from "./schema/AnySchema";
 import { ArraySchema, ArraySource } from "./schema/ArraySchema";
 import { BooleanSchema, BooleanSource } from "./schema/BooleanSchema";
@@ -33,17 +33,23 @@ export declare namespace Schema {
     function Array<Subschema extends BaseSchemaAny>(subschema: Subschema): ArraySchema<Subschema, true, undefined>;
     function Array<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): ArraySchema<Subschema, Required, undefined>;
     function Array<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<ArraySource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): ArraySchema<Subschema, Required, Default>;
-    function Enumeration<Members extends string[]>(subschema: TypedMembers<Members>): EnumerationSchema<Members, true, undefined>;
-    function Enumeration<Members extends string[], Required extends boolean>(subschema: TypedMembers<Members>, required: Required): EnumerationSchema<Members, Required, undefined>;
-    function Enumeration<Members extends string[], Required extends boolean, Default extends DefaultValue<Members[number]>>(subschema: TypedMembers<Members>, required: Required, defaultValue: Default): EnumerationSchema<Members, Required, Default>;
+    function Enumeration<Member extends string>(subschema: TypedMembers<Member>): EnumerationSchema<Member, true, undefined>;
+    function Enumeration<Member extends string, Required extends boolean>(subschema: TypedMembers<Member>, required: Required): EnumerationSchema<Member, Required, undefined>;
+    function Enumeration<Member extends string, Required extends boolean, Default extends DefaultValue<Member>>(subschema: TypedMembers<Member>, required: Required, defaultValue: Default): EnumerationSchema<Member, Required, Default>;
     function DynamicObject<Subschema extends BaseSchemaAny>(subschema: Subschema): DynamicObjectSchema<Subschema, true, undefined>;
     function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): DynamicObjectSchema<Subschema, Required, undefined>;
     function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<DynamicObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): DynamicObjectSchema<Subschema, Required, Default>;
-    function OrSet<MemberSchemas extends BaseSchemaAny[]>(subschema: TypedMembers<MemberSchemas>): OrSetSchema<MemberSchemas, true, undefined>;
-    function OrSet<MemberSchemas extends BaseSchemaAny[], Required extends boolean>(subschema: TypedMembers<MemberSchemas>, required: Required): OrSetSchema<MemberSchemas, Required, undefined>;
-    function OrSet<MemberSchemas extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchemas>>>(subschema: TypedMembers<MemberSchemas>, required: Required, defaultValue: Default): OrSetSchema<MemberSchemas, Required, Default>;
-    function Members<Members extends string[]>(...members: Members): TypedMembers<Members>;
-    function Members<Members extends any[]>(...members: Members): TypedMembers<Members>;
+    function OrSet<MemberSchema extends BaseSchemaAny>(subschema: TypedMembers<MemberSchema>): OrSetSchema<MemberSchema, true, undefined>;
+    function OrSet<MemberSchema extends BaseSchemaAny, Required extends boolean>(subschema: TypedMembers<MemberSchema>, required: Required): OrSetSchema<MemberSchema, Required, undefined>;
+    function OrSet<MemberSchema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchema>>>(subschema: TypedMembers<MemberSchema>, required: Required, defaultValue: Default): OrSetSchema<MemberSchema, Required, Default>;
+    type TypedMembers<Member extends any> = {
+        $members: Member[];
+    };
+    function Members<Member extends string[]>(...members: Member): TypedMembers<Member[number]>;
+    function Members<Member extends number[]>(...members: Member): TypedMembers<Member[number]>;
+    function Members<Member extends any[]>(...members: Member): TypedMembers<Member[number]>;
+    function Keys<Object extends object>(object: Object): (keyof Object)[];
+    function Values<Object extends object>(object: Object): (Object[keyof Object])[];
     type Model<Schema extends BaseSchemaAny> = Schema extends BaseSchema<infer Source, infer Model, infer Require, infer Default> ? (ModelValue<Source, Model, Require, Default>) : never;
     type Source<Schema extends BaseSchemaAny> = Schema extends BaseSchema<infer Source, any, infer Require, infer Default> ? (SourceValue<Source, Require, Default>) : never;
 }

package/build/error/TopLevelValidationError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "./ValidationError";
+import { ValidationPass } from "./ValidationPass";
+export declare class TopLevelValidationError extends ValidationError {
+    constructor(pass: ValidationPass);
+}

package/build/error/ValidationPass.d.ts

@@ -4,14 +4,19 @@ import { ValidationError } from "./ValidationError";
 export declare class ValidationPass {
     readonly originalSchema: BaseSchemaAny;
     readonly originalSource: SourceValue<any, boolean, DefaultValue<any>>;
+    private _parent;
     private _path;
     private _schema;
     private _source;
-    constructor(originalSchema: BaseSchemaAny, originalSource: SourceValue<any, boolean, DefaultValue<any>>);
+    private _errors;
+    constructor(originalSchema: BaseSchemaAny, originalSource: SourceValue<any, boolean, DefaultValue<any>>, parent: ValidationPass | undefined);
     get path(): string[];
     get schema(): BaseSchemaAny;
     get source(): any;
     next(path: string[], schema: BaseSchemaAny, source: SourceValue<any, boolean, DefaultValue<any>>): ValidationPass;
     assert(condition: boolean, message: string): void;
-    getError(message?: string): ValidationError;
+    causeError(message?: string): ValidationError;
+    addError(error: ValidationError): void;
+    get errors(): ValidationError[];
+    get topLevel(): boolean;
 }

package/build/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./builder";
-export { Schema as $ } from "./builder";
 export * from "./error/ValidationError";
 export * from "./error/ValidationPass";
 export * from "./schema/AnySchema";
@@ -15,3 +14,4 @@ export * from "./schema/OrSetSchema";
 export * from "./schema/StringSchema";
 export * from "./typing/extended";
 export * from "./typing/toolbox";
+export { Schema as $ } from "./builder";

package/build/index.js

@@ -8,28 +8,39 @@
         pass;
         constructor(pass, message) {
             super(message);
+            this.name = ValidationError.name;
             this.pass = pass;
         }
     }
 
+    class TopLevelValidationError extends ValidationError {
+        constructor(pass) {
+            super(pass, `Encountered ${pass.errors.length} error(s).\n * ${pass.errors.map((error) => error.message).join("\n * ")}`);
+        }
+    }
+
     class ValidationPass {
         originalSchema;
         originalSource;
+        _parent;
         _path;
         _schema;
         _source;
-        constructor(originalSchema, originalSource) {
+        _errors;
+        constructor(originalSchema, originalSource, parent) {
+            this._parent = parent;
             this.originalSchema = originalSchema;
             this.originalSource = originalSource;
             this._path = [];
             this._schema = originalSchema;
             this._source = originalSource;
+            this._errors = [];
         }
         get path() { return this._path; }
         get schema() { return this._schema; }
         get source() { return this._source; }
         next(path, schema, source) {
-            const nextPass = new ValidationPass(this.originalSchema, this.originalSource);
+            const nextPass = new ValidationPass(this.originalSchema, this.originalSource, this);
             nextPass._path = path;
             nextPass._source = source;
             nextPass._schema = schema;
@@ -37,17 +48,31 @@
         }
         assert(condition, message) {
             if (!condition) {
-                throw this.getError(message);
+                throw this.causeError(message);
             }
         }
-        getError(message) {
+        causeError(message) {
             if (message === undefined) {
-                return this.getError(`Validation failed.`);
+                return this.causeError(`Validation failed.`);
             }
             else {
-                return new ValidationError(this, message);
+                const error = new ValidationError(this, message);
+                this.addError(error);
+                if (this._parent !== undefined) {
+                    this._parent.causeError(error.message);
+                }
+                return error;
             }
         }
+        addError(error) {
+            this._errors.push(error);
+        }
+        get errors() {
+            return this._errors;
+        }
+        get topLevel() {
+            return this._parent === undefined;
+        }
     }
 
     class BaseSchema {
@@ -66,35 +91,49 @@
                 afterAll: []
             } : additionalValidationPasses;
         }
-        validate(source, pass) {
+        validate(source, options, pass) {
             pass = this._ensurePass(source, pass);
             let result = source;
-            result = this._executeAdditionalValidator(result, pass, "beforeAll");
-            result = this._executeAdditionalValidator(result, pass, "beforeDefault");
-            if (!BaseSchema.isPresent(result) && this.hasDefault()) {
-                result = this.getDefault(pass);
-            }
-            result = this._executeAdditionalValidator(result, pass, "afterDefault");
-            result = this._executeAdditionalValidator(result, pass, "beforeConversion");
-            if (BaseSchema.isPresent(result)) {
-                if (BaseSchema.getType(result) !== this.type) {
-                    result = this.convert(result, pass);
+            const presentOptions = {
+                collectErrors: options?.collectErrors || false
+            };
+            try {
+                result = this._executeAdditionalValidator(result, pass, "beforeAll");
+                result = this._executeAdditionalValidator(result, pass, "beforeDefault");
+                if (!BaseSchema.isPresent(result) && this.hasDefault()) {
+                    result = this.getDefault(pass);
                 }
-                result = this._validate(result, pass);
-                result = this._executeAdditionalValidator(result, pass, "afterConversion");
-            }
-            else {
-                if (this._required) {
-                    throw pass.getError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
+                result = this._executeAdditionalValidator(result, pass, "afterDefault");
+                result = this._executeAdditionalValidator(result, pass, "beforeConversion");
+                if (BaseSchema.isPresent(result)) {
+                    if (BaseSchema.getType(result) !== this.type) {
+                        result = this.convert(result, pass);
+                    }
+                    result = this._validate(result, presentOptions, pass);
+                    result = this._executeAdditionalValidator(result, pass, "afterConversion");
                 }
                 else {
+                    if (this._required) {
+                        throw pass.causeError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
+                    }
+                    else {
+                        result = undefined;
+                    }
+                }
+                if (this._required || result !== undefined) {
+                    result = this._executeAdditionalValidator(result, pass, "afterAll");
+                }
+            }
+            catch (error) {
+                if (error instanceof ValidationError && presentOptions.collectErrors) {
                     result = undefined;
                 }
-                result = this._validate(result, pass);
-                result = this._executeAdditionalValidator(result, pass, "afterConversion");
+                else {
+                    throw error;
+                }
             }
-            if (this._required || result !== undefined) {
-                result = this._executeAdditionalValidator(result, pass, "afterAll");
+            if (pass.topLevel && pass.errors.length > 0) {
+                throw new TopLevelValidationError(pass);
             }
             return result;
         }
@@ -135,7 +174,7 @@
                 return this._default;
             }
             else {
-                throw pass.getError(`Failed to get default. Invalid default value.`);
+                throw pass.causeError(`Failed to get default. Invalid default value.`);
             }
         }
         _getValueDisplay(value) {
@@ -149,7 +188,7 @@
             };
         }
         _getJsonSchemaDescription() {
-            const pass = new ValidationPass(this, this._default);
+            const pass = new ValidationPass(this, this._default, undefined);
             const descriptionPieces = [];
             descriptionPieces.push(`A ${this._required ? "required" : "optional"} ${this.type}`);
             if (this.hasDefault()) {
@@ -172,7 +211,7 @@
         }
         _ensurePass(source, pass) {
             if (pass === undefined) {
-                pass = new ValidationPass(this, source);
+                pass = new ValidationPass(this, source, undefined);
             }
             return pass;
         }
@@ -182,6 +221,29 @@
             }
             return source;
         }
+        /**
+         * Converts this schema to a informational string representing this schema.
+         *
+         * @note Details about this schema will be displayed in [square brackets].
+         * * [R] Indicates this schema is required.
+         * * [D] Indicates this schema has a default value.
+         *
+         * @param level The nesting level. You needn't specify this externally.
+         * @returns A string representation of this schema.
+         */
+        toString(level = 0) {
+            const modifiers = [];
+            if (this._required)
+                modifiers.push("R");
+            if (this._default !== undefined)
+                modifiers.push("D");
+            if (modifiers.length > 0) {
+                return `${this.constructor.name}[${modifiers.join("")}]`;
+            }
+            else {
+                return this.constructor.name;
+            }
+        }
         /**
          * Checks to see if a value is present. (Not null or undefined)
          * @param value The value to check the presence of.
@@ -215,7 +277,7 @@
 
     class AnySchema extends BaseSchema {
         get type() { return "any"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -224,33 +286,24 @@
         getJsonSchema() {
             return { description: this._getJsonSchemaDescription() };
         }
+        clone() {
+            return new AnySchema(this._required, this._default, this._additionalValidationPasses);
+        }
     }
 
     class ArraySchema extends BaseSchema {
         subschema;
-        constructor(subschema, required, defaultValue) {
-            super(required, defaultValue);
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.subschema = subschema;
         }
         get type() { return "array"; }
-        // public validate(source: SourceValue<ArraySource<Subschema>, Required, Default>, pass?: ValidationPass):
-        //     ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     const result: any = super.validate(source, pass);
-        //     if (result !== undefined) {
-        //         for (const key in result) {
-        //             const nestedValue = result[key];
-        //             result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
-        //         }
-        //     }
-        //     return result;
-        // }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const result = [];
             if (source !== undefined) {
                 for (const key in source) {
                     const nestedValue = source[key];
-                    result[key] = this.subschema.validate(source[key], pass.next([...pass.path, key], this.subschema, nestedValue));
+                    result[key] = this.subschema.validate(source[key], options, pass.next([...pass.path, key], this.subschema, nestedValue));
                 }
             }
             return result;
@@ -263,7 +316,7 @@
                 return [value];
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to array.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to array.`);
             }
         }
         getJsonSchema() {
@@ -273,11 +326,17 @@
                 items: this.subschema.getJsonSchema()
             };
         }
+        clone() {
+            return new ArraySchema(this.subschema.clone(), this._required, this._default, this._additionalValidationPasses);
+        }
+        toString(level = 0) {
+            return `${super.toString(level)}(${this.subschema.toString(level)}[])`;
+        }
     }
 
     class BooleanSchema extends BaseSchema {
         get type() { return "boolean"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -296,9 +355,12 @@
                 return false;
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to boolean.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to boolean.`);
             }
         }
+        clone() {
+            return new BooleanSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "boolean",
@@ -310,7 +372,7 @@
     const StandardDate = globalThis.Date;
     class DateSchema extends BaseSchema {
         get type() { return "Date"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -321,7 +383,7 @@
                 return new StandardDate(value);
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to Date.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to Date.`);
             }
         }
         before(date, message) {
@@ -358,6 +420,9 @@
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new DateSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "string",
@@ -368,29 +433,17 @@
 
     class DynamicObjectSchema extends BaseSchema {
         subschema;
-        constructor(subschema, required, defaultValue) {
-            super(required, defaultValue);
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.subschema = subschema;
         }
         get type() { return "object"; }
-        // public validate(source: SourceValue<DynamicObjectSource<Subschema>, Required, Default>, pass?: ValidationPass):
-        //     ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     const result: any = super.validate(source, pass);
-        //     if (result !== undefined) {
-        //         for (const key in result) {
-        //             const nestedValue = result[key];
-        //             result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
-        //         }
-        //     }
-        //     return result;
-        // }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const result = source;
             if (result !== undefined) {
                 for (const key in result) {
                     const nestedValue = result[key];
-                    result[key] = this.subschema.validate(result[key], pass.next([...pass.path, key], this.subschema, nestedValue));
+                    result[key] = this.subschema.validate(result[key], options, pass.next([...pass.path, key], this.subschema, nestedValue));
                 }
             }
             return result;
@@ -410,23 +463,24 @@
                 additionalProperties: this.subschema.getJsonSchema()
             };
         }
+        clone() {
+            return new DynamicObjectSchema(this.subschema.clone(), this._required, this._default, this._additionalValidationPasses);
+        }
+        toString(level = 0) {
+            const indent = "  ";
+            const prefix = indent.repeat(level);
+            return `${super.toString(level)}({\n${prefix}${indent}[string]: ${this.subschema.toString(level)}\n${prefix}})`;
+        }
     }
 
     class EnumerationSchema extends BaseSchema {
         members;
-        constructor(members, required, defaultValue) {
-            super(required, defaultValue);
+        constructor(members, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.members = members;
         }
         get type() { return "string"; }
-        // public validate(source: SourceValue<Members[number], Required, Default>, pass?: ValidationPass):
-        //     ModelValue<Members[number], Members[number], Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     const result: any = super.validate(source, pass);
-        //     pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
-        //     return result;
-        // }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const result = source;
             pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
             return result;
@@ -434,6 +488,9 @@
         convert(value, pass) {
             return value;
         }
+        clone() {
+            return new EnumerationSchema([...this.members], this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "string",
@@ -445,7 +502,7 @@
 
     class NumberSchema extends BaseSchema {
         get type() { return "number"; }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -465,18 +522,18 @@
                 return value.getTime();
             }
             else {
-                throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to number.`);
+                throw pass.causeError(`Unable to convert ${BaseSchema.getType(value)} to number.`);
             }
         }
         min(minimum, message) {
             return this.custom((model, pass) => {
-                pass.assert(model >= minimum, message === undefined ? `Number ${model} failed minimum check. (${minimum})` : message);
+                pass.assert(model >= minimum, message === undefined ? `Number ${model} failed minimum check. (Must be >= ${minimum})` : message);
                 return model;
             }, "afterAll");
         }
         max(maximum, message) {
             return this.custom((model, pass) => {
-                pass.assert(model <= maximum, message === undefined ? `Number ${model} failed maximum check. (${maximum})` : message);
+                pass.assert(model <= maximum, message === undefined ? `Number ${model} failed maximum check. (Must be <= ${maximum})` : message);
                 return model;
             }, "afterAll");
         }
@@ -489,6 +546,9 @@
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new NumberSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "number",
@@ -499,27 +559,12 @@
 
     class ObjectSchema extends BaseSchema {
         subschema;
-        constructor(subschema, required, defaultValue) {
-            super(required, defaultValue);
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.subschema = subschema;
         }
         get type() { return "object"; }
-        // public validate(source: SourceValue<ObjectSource<Subschema>, Required, Default>, pass?: ValidationPass):
-        //     ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     const input: any = super.validate(source, pass);
-        //     let output: any = input;
-        //     if (typeof input === "object" && input !== null) {
-        //         output = {};
-        //         for (const key in this.subschema) {
-        //             const nestedSchema = this.subschema[key];
-        //             const nestedValue = input[key];
-        //             output[key] = this.subschema[key].validate(input[key], pass.next([...pass.path, key], nestedSchema, nestedValue));
-        //         }
-        //     }
-        //     return output;
-        // }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             const input = source;
             let output = input;
             if (typeof input === "object" && input !== null) {
@@ -527,7 +572,7 @@
                 for (const key in this.subschema) {
                     const nestedSchema = this.subschema[key];
                     const nestedValue = input[key];
-                    output[key] = this.subschema[key].validate(input[key], pass.next([...pass.path, key], nestedSchema, nestedValue));
+                    output[key] = this.subschema[key].validate(input[key], options, pass.next([...pass.path, key], nestedSchema, nestedValue));
                 }
             }
             return output;
@@ -568,40 +613,37 @@
                 properties
             };
         }
+        clone() {
+            const subschema = {};
+            for (const key in this.subschema) {
+                subschema[key] = this.subschema[key].clone();
+            }
+            return new ObjectSchema(subschema, this._required, this._default, this._additionalValidationPasses);
+        }
+        toString(level = 0) {
+            const indent = "  ";
+            const prefix = indent.repeat(level);
+            const pieces = [];
+            pieces.push(`${super.toString()}({\n`);
+            for (const schemaKey in this.subschema) {
+                const subschema = this.subschema[schemaKey];
+                pieces.push(`${prefix}${indent}${schemaKey}: ${subschema.toString(level + 1)}\n`);
+            }
+            pieces.push(`${prefix}})`);
+            return pieces.join("");
+        }
     }
 
     class OrSetSchema extends BaseSchema {
         schemas;
-        constructor(schemas, required, defaultValue) {
-            super(required, defaultValue);
+        constructor(schemas, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.schemas = schemas;
         }
-        get type() { return "string"; }
-        // public validate(source: SourceValue<OrSetSchemaSource<MemberSchemas>, Required, Default>, pass?: ValidationPass):
-        //     ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default> {
-        //     pass = this._ensurePass(source, pass);
-        //     let result: any = super.validate(source, pass);
-        //     if (result !== undefined) {
-        //         let done = false;
-        //         const failureMessages: string[] = [];
-        //         for (let i = 0; i < this.schemas.length && !done; i++) {
-        //             const schema = this.schemas[i];
-        //             try {
-        //                 result = schema.validate(result, pass);
-        //                 done = true;
-        //             } catch (error) {
-        //                 if (error instanceof Error) {
-        //                     failureMessages.push(`Schema #${i + 1}: ${error.message}`);
-        //                 } else {
-        //                     failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
-        //                 }
-        //                 pass.assert(failureMessages.length !== this.schemas.length, `Supplied value didn't match any schemas in or-set.\n${failureMessages.join("\n")}`);
-        //             }
-        //         }
-        //     }
-        //     return result;
-        // }
-        _validate(source, pass) {
+        get type() {
+            return "string";
+        }
+        _validate(source, options, pass) {
             let result = source;
             if (result !== undefined) {
                 let done = false;
@@ -609,8 +651,10 @@
                 for (let i = 0; i < this.schemas.length && !done; i++) {
                     const schema = this.schemas[i];
                     try {
-                        result = schema.validate(result, pass);
-                        done = true;
+                        if (BaseSchema.getType(result) === schema.type) {
+                            result = schema.validate(result, options, pass);
+                            done = true;
+                        }
                     }
                     catch (error) {
                         if (error instanceof Error) {
@@ -619,15 +663,22 @@
                         else {
                             failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
                         }
-                        pass.assert(failureMessages.length !== this.schemas.length, `Supplied value didn't match any schemas in or-set.\n${failureMessages.join("\n")}`);
                     }
                 }
+                if (!done) {
+                    failureMessages.push(`Conversions for schemas in an OrSet are disabled.`);
+                }
+                pass.assert(failureMessages.length === 0, `Provided value (${BaseSchema.getType(result)}) matched no schemas ` +
+                    `(${this.schemas.map((schema) => schema.type).join(", ")}).\n${failureMessages.join("\n")}`);
             }
             return result;
         }
         convert(value, pass) {
             return value;
         }
+        clone() {
+            return new OrSetSchema(this.schemas.map((schema) => schema.clone()), this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return { oneOf: this.schemas.map((schema) => schema.getJsonSchema()) };
         }
@@ -639,7 +690,7 @@
         // public required() { return new StringSchema(true, this._default, this._additionalValidationPasses); }
         // public optional() { return new StringSchema(false, this._default, this._additionalValidationPasses); }
         // public default<Default extends DefaultValue<StringSource>>(defaultValue: Default) { return new StringSchema(this._required, defaultValue, this._additionalValidationPasses); }
-        _validate(source, pass) {
+        _validate(source, options, pass) {
             return source;
         }
         convert(value, pass) {
@@ -654,6 +705,25 @@
             }
             return value.toString();
         }
+        /**
+         * Trims strings validated by this schema.
+         * @see {@link String.trim}
+         */
+        trim() {
+            return this.custom((model) => model.trim());
+        }
+        /**
+         * Makes strings validated by this schema lowercase.
+         */
+        lower() {
+            return this.custom((model) => model.toLowerCase());
+        }
+        /**
+         * Makes strings validated by this schema uppercase.
+         */
+        upper() {
+            return this.custom((model) => model.toUpperCase());
+        }
         length(minimum, maximum, messageA, messageB) {
             return this.custom((model, pass) => {
                 messageB = messageB === undefined ? messageA : messageB;
@@ -662,12 +732,19 @@
                 return model;
             }, "afterAll");
         }
+        /**
+         * Ensures a string validated by this schema matches a given regular expression.
+         * With an optional custom error message.
+         */
         regex(expression, message) {
             return this.custom((model, pass) => {
                 pass.assert(expression.test(model), message === undefined ? `String "${model}" failed regular expression check. (${expression})` : message);
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new StringSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "string",
@@ -719,9 +796,26 @@
         }
         Schema.OrSet = OrSet;
         function Members(...members) {
+            /*
+             * HACK START: The hermes JS engine doesn't use globalThis.Array when interpreting `...members`
+             * It uses `Array`, which is already defined in this namespace.
+             */
+            if (!globalThis.Array.isArray(members)) {
+                const validArrayEntries = globalThis.Object.entries(members).filter(([key]) => !isNaN(key));
+                members = validArrayEntries.map(([_, value]) => value);
+            }
+            /* HACK END */
             return { $members: members };
         }
         Schema.Members = Members;
+        function Keys(object) {
+            return globalThis.Object.keys(object);
+        }
+        Schema.Keys = Keys;
+        function Values(object) {
+            return globalThis.Object.values(object);
+        }
+        Schema.Values = Values;
     })(exports.Schema || (exports.Schema = {}));
 
     exports.$ = exports.Schema;

package/build/schema/AnySchema.d.ts

@@ -1,9 +1,10 @@
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export declare class AnySchema<Required extends boolean, Default extends DefaultValue<any>> extends BaseSchema<any, any, Required, Default> {
     get type(): string;
-    protected _validate(source: SourceValue<any, Required, Default>, pass: ValidationPass): ModelValue<any, any, Required, Default>;
+    protected _validate(source: ModelValue<any, any, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<any, any, Required, Default>;
     convert(value: any, pass: ValidationPass): any;
     getJsonSchema(): object;
+    clone(): AnySchema<Required, Default>;
 }

package/build/schema/ArraySchema.d.ts

@@ -1,14 +1,16 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import type { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type ArraySource<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>[]) : never);
 export type ArrayModel<Subschema extends BaseSchemaAny> = (Subschema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>[]) : never);
 export declare class ArraySchema<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<ArraySource<Subschema>>> extends BaseSchema<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default> {
     readonly subschema: Subschema;
-    constructor(subschema: Subschema, required: Required, defaultValue: Default);
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<ArraySource<Subschema>, ArrayModel<Subschema>>);
     get type(): string;
-    protected _validate(source: SourceValue<ArraySource<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
+    protected _validate(source: ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
     convert(value: ArraySource<Subschema>, pass: ValidationPass): ArrayModel<Subschema>;
     getJsonSchema(): object;
+    clone(): ArraySchema<Subschema, Required, Default>;
+    toString(level?: number): string;
 }

package/build/schema/BaseSchema.d.ts

@@ -1,13 +1,14 @@
 import { ValidationPass } from "../error/ValidationPass";
-import type { AdditionalValidationPasses, AdditionalValidator, AdditionalValidatorAfterType, AdditionalValidatorBeforeType, DefaultValue, EnsureValidator, ModelValue, SourceValue } from "../typing/toolbox";
+import { BaseSchemaAny } from "../typing/extended";
+import type { AdditionalValidationPasses, AdditionalValidator, AdditionalValidatorAfterType, AdditionalValidatorBeforeType, DefaultValue, EnsureValidator, ModelValue, OptionalValidationOptions, SourceValue, ValidationOptions } from "../typing/toolbox";
 export declare abstract class BaseSchema<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> {
     protected readonly _required: Required;
     protected readonly _default: Default;
     protected readonly _additionalValidationPasses: AdditionalValidationPasses<Source, Model>;
     constructor(required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Source, Model>);
     abstract get type(): string;
-    validate(source: SourceValue<Source, Required, Default>, pass?: ValidationPass): ModelValue<Source, Model, Required, Default>;
-    protected abstract _validate(source: SourceValue<Source, Required, Default>, pass: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    validate(source: SourceValue<Source, Required, Default>, options?: OptionalValidationOptions, pass?: ValidationPass): ModelValue<Source, Model, Required, Default>;
+    protected abstract _validate(source: ModelValue<Source, Model, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Source, Model, Required, Default>;
     abstract convert(value: Source, pass: ValidationPass): Model;
     custom(additionalValidator: AdditionalValidator<SourceValue<Source, Required, Default>>, type: AdditionalValidatorBeforeType): this;
     custom(additionalValidator: AdditionalValidator<Model>, type: AdditionalValidatorAfterType): this;
@@ -33,6 +34,18 @@ export declare abstract class BaseSchema<Source, Model, Required extends boolean
     protected _getJsonSchemaDescription(): string;
     protected _ensurePass(source: SourceValue<Source, Required, Default>, pass?: ValidationPass): ValidationPass;
     private _executeAdditionalValidator;
+    abstract clone(): BaseSchemaAny;
+    /**
+     * Converts this schema to a informational string representing this schema.
+     *
+     * @note Details about this schema will be displayed in [square brackets].
+     * * [R] Indicates this schema is required.
+     * * [D] Indicates this schema has a default value.
+     *
+     * @param level The nesting level. You needn't specify this externally.
+     * @returns A string representation of this schema.
+     */
+    toString(level?: number): string;
     /**
      * Checks to see if a value is present. (Not null or undefined)
      * @param value The value to check the presence of.

package/build/schema/BooleanSchema.d.ts

@@ -1,10 +1,11 @@
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type BooleanSource = boolean | number | string | null | undefined;
 export declare class BooleanSchema<Required extends boolean, Default extends DefaultValue<BooleanSource>> extends BaseSchema<BooleanSource, boolean, Required, Default> {
     get type(): string;
-    protected _validate(source: SourceValue<BooleanSource, Required, Default>, pass: ValidationPass): ModelValue<BooleanSource, boolean, Required, Default>;
+    protected _validate(source: ModelValue<BooleanSource, boolean, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<BooleanSource, boolean, Required, Default>;
     convert(value: BooleanSource, pass: ValidationPass): boolean;
+    clone(): BooleanSchema<Required, Default>;
     getJsonSchema(): object;
 }

package/build/schema/DateSchema.d.ts

@@ -1,12 +1,12 @@
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 type StandardDate = globalThis.Date;
 declare const StandardDate: DateConstructor;
 export type DateSource = string | number | StandardDate;
 export declare class DateSchema<Required extends boolean, Default extends DefaultValue<DateSource>> extends BaseSchema<DateSource, StandardDate, Required, Default> {
     get type(): string;
-    protected _validate(source: SourceValue<DateSource, Required, Default>, pass: ValidationPass): ModelValue<DateSource, Date, Required, Default>;
+    protected _validate(source: ModelValue<DateSource, Date, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<DateSource, Date, Required, Default>;
     convert(value: DateSource, pass: ValidationPass): StandardDate;
     before(date: Date, message?: string): this;
     after(date: Date, message?: string): this;
@@ -18,6 +18,7 @@ export declare class DateSchema<Required extends boolean, Default extends Defaul
     * @param duration milliseconds
     */
     lessThanAgo(duration: number, message?: string): this;
+    clone(): DateSchema<Required, Default>;
     getJsonSchema(): object;
 }
 export {};

package/build/schema/DynamicObjectSchema.d.ts

@@ -1,6 +1,6 @@
-import type { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
+import type { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type DynamicObjectSource<Subschema extends BaseSchemaAny> = ({
     [Key: string]: (Subschema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
@@ -10,9 +10,11 @@ export type DynamicObjectModel<Subschema extends BaseSchemaAny> = ({
 });
 export declare class DynamicObjectSchema<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<DynamicObjectSource<Subschema>>> extends BaseSchema<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default> {
     readonly subschema: Subschema;
-    constructor(subschema: Subschema, required: Required, defaultValue: Default);
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>>);
     get type(): string;
-    _validate(source: SourceValue<DynamicObjectSource<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
+    protected _validate(source: ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
     convert(source: DynamicObjectSource<Subschema>, pass: ValidationPass): DynamicObjectModel<Subschema>;
     getJsonSchema(): object;
+    clone(): DynamicObjectSchema<Subschema, Required, Default>;
+    toString(level?: number): string;
 }

package/build/schema/EnumerationSchema.d.ts

@@ -1,11 +1,12 @@
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
+import { AdditionalValidationPasses, DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
-export declare class EnumerationSchema<Members extends string[], Required extends boolean, Default extends DefaultValue<Members[number]>> extends BaseSchema<Members[number], Members[number], Required, Default> {
-    readonly members: Members;
-    constructor(members: Members, required: Required, defaultValue: Default);
+export declare class EnumerationSchema<Members extends string, Required extends boolean, Default extends DefaultValue<Members>> extends BaseSchema<Members, Members, Required, Default> {
+    readonly members: Members[];
+    constructor(members: Members[], required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<Members, Members>);
     get type(): string;
-    _validate(source: SourceValue<Members[number], Required, Default>, pass: ValidationPass): ModelValue<Members[number], Members[number], Required, Default>;
-    convert(value: Members[number], pass: ValidationPass): Members[number];
+    protected _validate(source: ModelValue<Members, Members, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<Members, Members, Required, Default>;
+    convert(value: Members, pass: ValidationPass): Members;
+    clone(): EnumerationSchema<Members, Required, Default>;
     getJsonSchema(): object;
 }

package/build/schema/NumberSchema.d.ts

@@ -1,10 +1,10 @@
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type NumberSource = number | bigint | string | boolean | null | undefined | Date;
 export declare class NumberSchema<Required extends boolean, Default extends DefaultValue<NumberSource>> extends BaseSchema<NumberSource, number, Required, Default> {
     get type(): string;
-    protected _validate(source: SourceValue<NumberSource, Required, Default>, pass: ValidationPass): ModelValue<NumberSource, number, Required, Default>;
+    protected _validate(source: ModelValue<NumberSource, number, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<NumberSource, number, Required, Default>;
     convert(value: NumberSource, pass: ValidationPass): number;
     min(minimum: number, message?: string): this;
     max(maximum: number, message?: string): this;
@@ -12,5 +12,6 @@ export declare class NumberSchema<Required extends boolean, Default extends Defa
     clamp(minimum: number, maximum: number, message: string): this;
     clamp(minimum: number, maximum: number, tooShortMessage: string, tooLongMessage: string): this;
     validNumber(notANumber?: boolean, message?: string): this;
+    clone(): NumberSchema<Required, Default>;
     getJsonSchema(): object;
 }

package/build/schema/ObjectSchema.d.ts

@@ -1,6 +1,6 @@
-import type { DefaultValue, Merge, ModelRequirement, ModelValue, SourceRequirement, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
+import type { AdditionalValidationPasses, DefaultValue, Merge, ModelRequirement, ModelValue, SourceRequirement, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type ObjectSubschema = {
     [Key: string]: BaseSchemaAny;
@@ -17,10 +17,12 @@ export type ObjectModel<Subschema extends ObjectSubschema> = (Merge<{
 }>);
 export declare class ObjectSchema<Subschema extends ObjectSubschema, Required extends boolean, Default extends DefaultValue<ObjectSource<Subschema>>> extends BaseSchema<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default> {
     readonly subschema: Subschema;
-    constructor(subschema: Subschema, required: Required, defaultValue: Default);
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<ObjectSource<Subschema>, ObjectModel<Subschema>>);
     get type(): string;
-    protected _validate(source: SourceValue<ObjectSource<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
+    protected _validate(source: ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
     convert(value: ObjectSource<Subschema>, pass: ValidationPass): ObjectModel<Subschema>;
     extend<ExtensionSubschema extends ObjectSubschema, ExtensionDefault extends DefaultValue<ObjectSource<ExtensionSubschema>>>(schema: ObjectSchema<ExtensionSubschema, Required, ExtensionDefault>): ObjectSchema<Subschema & ExtensionSubschema, Required, any>;
     getJsonSchema(): object;
+    clone(): ObjectSchema<Subschema, Required, Default>;
+    toString(level?: number): string;
 }

package/build/schema/OrSetSchema.d.ts

@@ -1,18 +1,15 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
-export type OrSetSchemaSource<MemberSchemas extends BaseSchemaAny[]> = {
-    [Key in keyof MemberSchemas]: (MemberSchemas[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
-}[number];
-export type OrSetSchemaModel<MemberSchemas extends BaseSchemaAny[]> = ({
-    [Key in keyof MemberSchemas]: (MemberSchemas[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
-})[number];
-export declare class OrSetSchema<MemberSchemas extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchemas>>> extends BaseSchema<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default> {
-    readonly schemas: MemberSchemas;
-    constructor(schemas: MemberSchemas, required: Required, defaultValue: Default);
+export type OrSetSchemaSource<MemberSchema extends BaseSchemaAny> = (MemberSchema extends BaseSchema<infer Source, any, infer Required, infer Default> ? SourceValue<Source, Required, Default> : never);
+export type OrSetSchemaModel<MemberSchema extends BaseSchemaAny> = (MemberSchema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? ModelValue<Source, Model, Required, Default> : never);
+export declare class OrSetSchema<MemberSchema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchema>>> extends BaseSchema<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default> {
+    readonly schemas: MemberSchema[];
+    constructor(schemas: MemberSchema[], required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>>);
     get type(): string;
-    _validate(source: SourceValue<OrSetSchemaSource<MemberSchemas>, Required, Default>, pass: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default>;
-    convert(value: OrSetSchemaSource<MemberSchemas>, pass: ValidationPass): OrSetSchemaModel<MemberSchemas>;
+    protected _validate(source: ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>;
+    convert(value: OrSetSchemaSource<MemberSchema>, pass: ValidationPass): OrSetSchemaModel<MemberSchema>;
+    clone(): OrSetSchema<MemberSchema, Required, Default>;
     getJsonSchema(): object;
 }

package/build/schema/StringSchema.d.ts

@@ -1,14 +1,43 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
 export type StringSource = string | number | boolean | null | undefined | Date;
 export declare class StringSchema<Required extends boolean, Default extends DefaultValue<StringSource>> extends BaseSchema<StringSource, string, Required, Default> {
     get type(): string;
-    protected _validate(source: SourceValue<StringSource, Required, Default>, pass: ValidationPass): ModelValue<StringSource, string, Required, Default>;
+    protected _validate(source: ModelValue<StringSource, string, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<StringSource, string, Required, Default>;
     convert(value: StringSource, pass: ValidationPass): string;
+    /**
+     * Trims strings validated by this schema.
+     * @see {@link String.trim}
+     */
+    trim(): this;
+    /**
+     * Makes strings validated by this schema lowercase.
+     */
+    lower(): this;
+    /**
+     * Makes strings validated by this schema uppercase.
+     */
+    upper(): this;
+    /**
+     * Ensures that a string validated by this schema has a minimum (inclusive) and maximum (inclusive) length.
+     */
     length(minimum: number, maximum: number): this;
+    /**
+     * Ensures that a string validated by this schema has a minimum (inclusive) and maximum (inclusive) length.
+     * With a custom error message.
+     */
     length(minimum: number, maximum: number, message: string): this;
+    /**
+     * Ensures that a string validated by this schema has a minimum (inclusive) and maximum (inclusive) length.
+     * With custom error messages for too long, and too short.
+     */
     length(minimum: number, maximum: number, tooShortMessage: string, tooLongMessage: string): this;
+    /**
+     * Ensures a string validated by this schema matches a given regular expression.
+     * With an optional custom error message.
+     */
     regex(expression: RegExp, message?: string): this;
+    clone(): StringSchema<Required, Default>;
     getJsonSchema(): object;
 }

package/build/typing/toolbox.d.ts

@@ -1,14 +1,15 @@
 import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchema } from "../schema/BaseSchema";
 import { BaseSchemaAny } from "./extended";
+export type ValidationOptions = {
+    collectErrors: boolean;
+};
+export type OptionalValidationOptions = Partial<ValidationOptions>;
 export type SourceRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (Default extends undefined ? true : false) : (false)) : never);
 export type SourceValue<Source, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? (undefined extends Default ? (Source) : (Source | undefined)) : Source | undefined);
 export type ModelRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (true) : (Default extends undefined ? false : true)) : never);
 export type ModelValue<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? Model : Default extends undefined ? Model | undefined : Model);
 export type DefaultValue<Type> = undefined | Type | ((pass: ValidationPass) => Type);
-export type TypedMembers<Members> = {
-    $members: Members;
-};
 export type AdditionalValidatorBeforeType = ("beforeAll" | "beforeDefault" | "afterDefault");
 export type AdditionalValidatorAfterType = ("beforeConversion" | "afterConversion" | "afterAll");
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "2.0.3",
+    "version": "3.0.0",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -37,4 +37,4 @@
         "tslib": "^2.6.3",
         "typescript": "^5.4.5"
     }
-}
+}