@lucania/schema 2.0.3 → 2.0.4

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/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,6 +8,7 @@
         pass;
         constructor(pass, message) {
             super(message);
+            this.name = ValidationError.name;
             this.pass = pass;
         }
     }
@@ -182,6 +183,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.
@@ -224,12 +248,15 @@
         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"; }
@@ -273,6 +300,12 @@
                 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 {
@@ -299,6 +332,9 @@
                 throw pass.getError(`Unable to convert ${BaseSchema.getType(value)} to boolean.`);
             }
         }
+        clone() {
+            return new BooleanSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "boolean",
@@ -358,6 +394,9 @@
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new DateSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "string",
@@ -368,8 +407,8 @@
 
     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"; }
@@ -410,30 +449,36 @@
                 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) {
             const result = source;
-            pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
+            if (this._required) {
+                pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
+            }
             return result;
         }
         convert(value, pass) {
             return value;
         }
+        clone() {
+            return new EnumerationSchema([...this.members], this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "string",
@@ -489,6 +534,9 @@
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new NumberSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "number",
@@ -499,26 +547,11 @@
 
     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) {
             const input = source;
             let output = input;
@@ -568,39 +601,36 @@
                 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;
-        // }
+        get type() {
+            return "string";
+        }
         _validate(source, pass) {
             let result = source;
             if (result !== undefined) {
@@ -609,8 +639,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, pass);
+                            done = true;
+                        }
                     }
                     catch (error) {
                         if (error instanceof Error) {
@@ -619,15 +651,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()) };
         }
@@ -654,6 +693,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 +720,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 +784,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 } 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>, 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 } 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>, 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,4 +1,5 @@
 import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
 import type { AdditionalValidationPasses, AdditionalValidator, AdditionalValidatorAfterType, AdditionalValidatorBeforeType, DefaultValue, EnsureValidator, ModelValue, SourceValue } from "../typing/toolbox";
 export declare abstract class BaseSchema<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> {
     protected readonly _required: Required;
@@ -7,7 +8,7 @@ export declare abstract class BaseSchema<Source, Model, Required extends boolean
     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>;
+    protected abstract _validate(source: ModelValue<Source, Model, Required, Default>, 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 } 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>, 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 } 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>, 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 } 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>, 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 } 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>, 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 } 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>, 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 } 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>, 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 } 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>, 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 } 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>, 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

@@ -6,9 +6,6 @@ export type SourceValue<Source, Required extends boolean, Default extends Defaul
 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": "2.0.4",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",