@lucania/schema 2.0.2 → 2.0.4

package/README.md

@@ -1,27 +1,30 @@
 # Schema
-| TECHNICAL | |
-|:-:|-|
-| _noun_ | _a representation of a plan or theory in the form of an outline or model._|
+
+| TECHNICAL |                                                                            |
+| :-------: | -------------------------------------------------------------------------- |
+|  _noun_   | _a representation of a plan or theory in the form of an outline or model._ |
 
 This library allows you to specify the schema for your data, and get compile time typings _(help from your IDE)_ and runtime validation _(throw errors if your data isn't in the right format)_.
 
 With this library, you create objects that serve as a blueprint for what your data should look like. These objects are called `Schema`s.
 
-|_Schema Type_|Description|Usage|Example Data|
-|:-:|:-|:-|:-|
-|`StringSchema`|Used to represent a string.|`$.String(required?: boolean, default?: StringSource)`|`"Moaaz"`, `"The cow jumped over the moon."`|
-|`NumberSchema`|Used to represent a number.|`$.Number(required?: boolean, default?: NumberSource)`|`-30`, `0`, `10`
-|`BooleanSchema`|Used to represent a boolean.|`$.Boolean(required?: boolean, default?: BooleanSource)`|`true`, `false`
-|`DateSchema`|Used to represent a Date.|`$.Date(required?: boolean, default?: DateSource)`|`new Date(2000, 9, 29)`, `new Date("1998-09-04")`
-|`ObjectSchema`|Used to represent an Object.|`$.Object(subschema: { <key>: Schema }, required?: boolean, default?: ObjectSource)`|`<depends on subschema>`, `{ name: "Jeremy", age: 23 }`, `{ make: "Toyota", model: "Sienna", year: 2011 }`
-|`ArraySchema`|Used to represent an array|`$.Array(subschema: Schema, required?: boolean, default?: ArraySource)`|`<depends on subschema>`, `[]`, `[1, 2, 3]`, `["Ben", "Amit", "Dean"]`
-|`EnumerationSchema`|Used to represent an enumeration value, otherwise known as a set of possible strings values.|`$.Enumeration(members: Members, required?: boolean, default?: EnumerationSource)`|`<depends on members>`, `"MAGENTA"`, `"CA"`, `"male"`
-|`OrSetSchema`|Used to represent a value that should be validated by one of many possible schemas. This is used to represent a value that is allowed to be multiple types.|`$.OrSet(members: Members, required?: boolean, default?: OrSetSource)`|`<depends on members>`
-|`DynamicObjectSchema`|Used to represent an object that could have many different keys.|`$.DynamicObject(subschema: Schema, required?: boolean, default?: DynamicObjectSource)`|`{ <any key>: <depends on subschema> }`
-|`AnySchema`|Used to represent a value that could be any type.|`$.Any(required?: boolean, default?: AnySource)`|`1`, `"Omar"`, `false`, `{}`, `[]`, `<any type>`
+|     _Schema Type_     | Description                                                                                                                                                 | Usage                                                                                   | Example Data                                                                                               |
+| :-------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- |
+|    `StringSchema`     | Used to represent a string.                                                                                                                                 | `$.String(required?: boolean, default?: StringSource)`                                  | `"Moaaz"`, `"The cow jumped over the moon."`                                                               |
+|    `NumberSchema`     | Used to represent a number.                                                                                                                                 | `$.Number(required?: boolean, default?: NumberSource)`                                  | `-30`, `0`, `10`                                                                                           |
+|    `BooleanSchema`    | Used to represent a boolean.                                                                                                                                | `$.Boolean(required?: boolean, default?: BooleanSource)`                                | `true`, `false`                                                                                            |
+|     `DateSchema`      | Used to represent a Date.                                                                                                                                   | `$.Date(required?: boolean, default?: DateSource)`                                      | `new Date(2000, 9, 29)`, `new Date("1998-09-04")`                                                          |
+|    `ObjectSchema`     | Used to represent an Object.                                                                                                                                | `$.Object(subschema: { <key>: Schema }, required?: boolean, default?: ObjectSource)`    | `<depends on subschema>`, `{ name: "Jeremy", age: 23 }`, `{ make: "Toyota", model: "Sienna", year: 2011 }` |
+|     `ArraySchema`     | Used to represent an array                                                                                                                                  | `$.Array(subschema: Schema, required?: boolean, default?: ArraySource)`                 | `<depends on subschema>`, `[]`, `[1, 2, 3]`, `["Ben", "Amit", "Dean"]`                                     |
+|  `EnumerationSchema`  | Used to represent an enumeration value, otherwise known as a set of possible strings values.                                                                | `$.Enumeration(members: Members, required?: boolean, default?: EnumerationSource)`      | `<depends on members>`, `"MAGENTA"`, `"CA"`, `"male"`                                                      |
+|     `OrSetSchema`     | Used to represent a value that should be validated by one of many possible schemas. This is used to represent a value that is allowed to be multiple types. | `$.OrSet(members: Members, required?: boolean, default?: OrSetSource)`                  | `<depends on members>`                                                                                     |
+| `DynamicObjectSchema` | Used to represent an object that could have many different keys.                                                                                            | `$.DynamicObject(subschema: Schema, required?: boolean, default?: DynamicObjectSource)` | `{ <any key>: <depends on subschema> }`                                                                    |
+|      `AnySchema`      | Used to represent a value that could be any type.                                                                                                           | `$.Any(required?: boolean, default?: AnySource)`                                        | `1`, `"Omar"`, `false`, `{}`, `[]`, `<any type>`                                                           |
 
 ## Validation
+
 The simplest possible validation:
+
 ```typescript
 import { $ } from "@lucania/schema";
 
@@ -38,7 +41,9 @@ const dataOfNumberType = numberSchema.validate(dataOfUnknownType);
 With this collection of Schemas, we can now start building more complex data structures. There are multiple way to represent different scenarios. This is done with the following constructs.
 
 ## Creating Hierarchical Schema
+
 These schemas can come together to allow you to define a blueprint for more complex data structures.
+
 ```typescript
 import { $ } from "@lucania/schema";
 
@@ -58,7 +63,6 @@ const PersonSchema = $.Object({
     age: $.Number(true).min(16, "You must be at least 16 years old!").max(100, "You must be at most 100 years old!"),
     weapon: WeaponSchema
 });
-
 ```
 
 ## Using Schema
@@ -71,6 +75,52 @@ import fs from "fs";
 const personData = JSON.parse(fs.readFileSync("person.json", "utf8"));
 const person = PersonSchema.validate(personData);
 ```
+
 `person` now has the following compile-time type annotation based on [`PersonSchema`](#creating-hierarchical-schema).
 
-At runtime, the object parsed from the `person.json` file will be validated to match this generated typing. If it does not match, a `Schema.ValidationError` will be thrown.
+At runtime, the object parsed from the `person.json` file will be validated to match this generated typing. If it does not match, a `Schema.ValidationError` will be thrown.
+
+## Additional Validation Passes
+
+Sometimes it's necessary to validate not only a type, but also specifics about the value. I.E. a value is a `$.Number` _and_ is between 0 and 100. You can add additional type-specific validation passes (I.E. `.clamp(...)`) or custom ones (`.custom(...)`):
+
+```typescript
+const numberData: any = ...;
+
+const ScoreSchema = $.Number().clamp(0, 100).custom((data, pass) => {
+    pass.assert(data % 2 === 0, "Your score must be even!");
+    return data;
+});
+
+// The above custom() validation pass can alternately be defined using the .ensure() shorthand.
+
+const ScoreSchema = $.Number().clamp(0, 100).ensure((data, pass) => data % 2 === 0, "Your score must be even!");
+
+const number: number = ScoreSchema.validate(numberData);
+```
+
+## Custom Schema Types
+
+You can define your own Schema types by creating a subclass of `BaseSchema`. But first, `BaseSchema` relies on 4 generic parameters for TypeScript's type checker to understand your Schema at compile time. These parameters are as follows:
+
+-   Source - Represents the typing for a source input to your schema.
+-   Model - Represents the typing for an output value from your schema.
+-   Required - Represents the presence optionality of your schema's Source/Model. (Is `undefined` a valid Source and Model)
+-   Default - Represents the typing for default values.
+
+Typically, when developing your own Schema types, you'll hardcode Source and Model for your specific Schema's requirements, but pass over `Required` and `Default` generics to `BaseSchema` to allow them to be inferred from your Schema definitions.
+
+```typescript
+export type CowModel = { name: string, numberOfSpots: number };
+
+export type CowSource = string | CowModel;
+
+export class CowSchema<
+    Required extends boolean, // Taking in "Required" generic.
+    Default extends DefaultValue<CowSource> // Taking in "Default" generic.
+
+    // Handing over hardcoded Source, Model and CowSchema generics to BaseSchema.
+> extends BaseSchema<CowSource, CowModel, Required, Default> { ... }
+```
+
+These declarations are enough to have the TypeScript type checker understand the compile-time typing for `CowSchema`. Next, lets implement our runtime checks.

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;
         }
     }
@@ -51,12 +52,10 @@
     }
 
     class BaseSchema {
-        type;
         _required;
         _default;
         _additionalValidationPasses;
-        constructor(type, required, defaultValue, additionalValidationPasses) {
-            this.type = type;
+        constructor(required, defaultValue, additionalValidationPasses) {
             this._required = required;
             this._default = defaultValue;
             this._additionalValidationPasses = additionalValidationPasses === undefined ? {
@@ -82,16 +81,18 @@
                 if (BaseSchema.getType(result) !== this.type) {
                     result = this.convert(result, pass);
                 }
+                result = this._validate(result, pass);
                 result = this._executeAdditionalValidator(result, pass, "afterConversion");
             }
             else {
-                result = this._executeAdditionalValidator(result, pass, "afterConversion");
                 if (this._required) {
                     throw pass.getError(pass.path.length > 0 ? `Missing required value at "${pass.path.join(".")}".` : "Missing required value.");
                 }
                 else {
                     result = undefined;
                 }
+                result = this._validate(result, pass);
+                result = this._executeAdditionalValidator(result, pass, "afterConversion");
             }
             if (this._required || result !== undefined) {
                 result = this._executeAdditionalValidator(result, pass, "afterAll");
@@ -102,6 +103,15 @@
             this._additionalValidationPasses[type].push(additionalValidator);
             return this;
         }
+        /**
+         * Ensures a condition is true during the associated schema's validation pass.
+         *
+         * @note See {@link EnsureValidator EnsureValidator}.
+         *
+         * @param ensureValidator A validator to ensure a condition is passed.
+         * @param message The message to use for a thrown {@link ValidationError ValidationError} if ensureValidator fails.
+         * @returns The schema instance for chaining.
+         */
         ensure(ensureValidator, message) {
             this.custom((value, pass) => {
                 pass.assert(ensureValidator(value, pass), message === undefined ? `Failed to ensure value.` : message);
@@ -132,6 +142,13 @@
         _getValueDisplay(value) {
             return String(value);
         }
+        getJsonSchema() {
+            console.warn(`"getJsonSchema" is not implemented in the "${this.constructor.name}" schema class!`);
+            return {
+                type: "unknown",
+                description: `"getJsonSchema" is not implemented in the "${this.constructor.name}" schema class!`,
+            };
+        }
         _getJsonSchemaDescription() {
             const pass = new ValidationPass(this, this._default);
             const descriptionPieces = [];
@@ -166,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.
@@ -198,8 +238,9 @@
     }
 
     class AnySchema extends BaseSchema {
-        constructor(required, defaultValue) {
-            super("any", required, defaultValue);
+        get type() { return "any"; }
+        _validate(source, pass) {
+            return source;
         }
         convert(value, pass) {
             return value;
@@ -207,21 +248,36 @@
         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("array", required, defaultValue);
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.subschema = subschema;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            const result = 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));
+        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) {
+            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));
                 }
             }
             return result;
@@ -244,11 +300,18 @@
                 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 {
-        constructor(required, defaultValue) {
-            super("boolean", required, defaultValue);
+        get type() { return "boolean"; }
+        _validate(source, pass) {
+            return source;
         }
         convert(value, pass) {
             if (typeof value === "number") {
@@ -269,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",
@@ -279,8 +345,9 @@
 
     const StandardDate = globalThis.Date;
     class DateSchema extends BaseSchema {
-        constructor(required, defaultValue) {
-            super("Date", required, defaultValue);
+        get type() { return "Date"; }
+        _validate(source, pass) {
+            return source;
         }
         convert(value, pass) {
             if (typeof value === "string") {
@@ -327,6 +394,9 @@
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new DateSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "string",
@@ -337,13 +407,25 @@
 
     class DynamicObjectSchema extends BaseSchema {
         subschema;
-        constructor(subschema, required, defaultValue) {
-            super("object", required, defaultValue);
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.subschema = subschema;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            const result = super.validate(source, pass);
+        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) {
+            const result = source;
             if (result !== undefined) {
                 for (const key in result) {
                     const nestedValue = result[key];
@@ -367,23 +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("string", required, defaultValue);
+        constructor(members, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.members = members;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            const result = super.validate(source, pass);
-            pass.assert(this.members.includes(result), `"${result}" is not a valid enumeration value (Expected: ${this.members.join(", ")}).`);
+        get type() { return "string"; }
+        _validate(source, pass) {
+            const result = source;
+            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",
@@ -394,8 +489,9 @@
     }
 
     class NumberSchema extends BaseSchema {
-        constructor(required, defaultValue) {
-            super("number", required, defaultValue);
+        get type() { return "number"; }
+        _validate(source, pass) {
+            return source;
         }
         convert(value, pass) {
             if (typeof value === "bigint") {
@@ -438,6 +534,9 @@
                 return model;
             }, "afterAll");
         }
+        clone() {
+            return new NumberSchema(this._required, this._default, this._additionalValidationPasses);
+        }
         getJsonSchema() {
             return {
                 type: "number",
@@ -448,23 +547,26 @@
 
     class ObjectSchema extends BaseSchema {
         subschema;
-        constructor(subschema, required, defaultValue) {
-            super("object", required, defaultValue);
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.subschema = subschema;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            const result = super.validate(source, pass);
-            if (result !== undefined) {
+        get type() { return "object"; }
+        _validate(source, pass) {
+            const input = source;
+            let output = input;
+            if (typeof input === "object" && input !== null) {
+                output = {};
                 for (const key in this.subschema) {
                     const nestedSchema = this.subschema[key];
-                    const nestedValue = result[key];
-                    result[key] = this.subschema[key].validate(result[key], pass.next([...pass.path, key], nestedSchema, nestedValue));
+                    const nestedValue = input[key];
+                    output[key] = this.subschema[key].validate(input[key], pass.next([...pass.path, key], nestedSchema, nestedValue));
                 }
             }
-            return result;
+            return output;
         }
         convert(value, pass) {
+            pass.assert(typeof value === "object", `Unable to convert ${ObjectSchema.getType(value)} to object.`);
             const model = {};
             for (const key in this.subschema) {
                 const nestedSchema = this.subschema[key];
@@ -499,25 +601,48 @@
                 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("string", required, defaultValue);
+        constructor(schemas, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
             this.schemas = schemas;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            let result = super.validate(source, pass);
+        get type() {
+            return "string";
+        }
+        _validate(source, pass) {
+            let result = source;
             if (result !== undefined) {
                 let done = false;
                 const failureMessages = [];
                 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) {
@@ -526,28 +651,36 @@
                         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()) };
         }
     }
 
     class StringSchema extends BaseSchema {
-        constructor(required, defaultValue, additionalValidationPasses) {
-            super("string", required, defaultValue, additionalValidationPasses);
-        }
+        get type() { return "string"; }
         // Not sure if these will be needed with constructor option. If they are required, it adds a lot of boilerplate to all of the Schema classes.
         // 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) {
+            return source;
+        }
         convert(value, pass) {
             if (value instanceof Date) {
                 return value.toISOString();
@@ -560,20 +693,46 @@
             }
             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;
-                pass.assert(model.length > minimum, messageA === undefined ? `String "${model}: failed minimum length check. (${minimum})` : messageA);
-                pass.assert(model.length < maximum, messageB === undefined ? `String "${model}: failed maximum length check. (${maximum})` : messageB);
+                pass.assert(model.length >= minimum, messageA === undefined ? `String "${model}: failed minimum length check. (${minimum})` : messageA);
+                pass.assert(model.length <= maximum, messageB === undefined ? `String "${model}: failed maximum length check. (${maximum})` : messageB);
                 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",
@@ -625,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,8 +1,10 @@
-import { DefaultValue } 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> {
-    constructor(required: Required, defaultValue: Default);
+    get type(): string;
+    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,13 +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);
-    validate(source: SourceValue<ArraySource<Subschema>, Required, Default>, pass?: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<ArraySource<Subschema>, ArrayModel<Subschema>>);
+    get type(): string;
+    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,16 +1,27 @@
 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>> {
-    readonly type: string;
     protected readonly _required: Required;
     protected readonly _default: Default;
     protected readonly _additionalValidationPasses: AdditionalValidationPasses<Source, Model>;
-    constructor(type: string, required: Required, defaultValue: Default, 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: 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;
     custom(additionalValidator: AdditionalValidator<Model>): this;
+    /**
+     * Ensures a condition is true during the associated schema's validation pass.
+     *
+     * @note See {@link EnsureValidator EnsureValidator}.
+     *
+     * @param ensureValidator A validator to ensure a condition is passed.
+     * @param message The message to use for a thrown {@link ValidationError ValidationError} if ensureValidator fails.
+     * @returns The schema instance for chaining.
+     */
     ensure(ensureValidator: EnsureValidator<Model>, message?: string): this;
     isRequired(): Required;
     hasDefault(): boolean;
@@ -19,10 +30,22 @@ export declare abstract class BaseSchema<Source, Model, Required extends boolean
     };
     getDefault(pass: ValidationPass): Source;
     protected _getValueDisplay(value: Model): string;
-    abstract getJsonSchema(): object;
+    getJsonSchema(): object;
     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,9 +1,11 @@
-import { DefaultValue } 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> {
-    constructor(required: Required, defaultValue: Default);
+    get type(): string;
+    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,11 +1,12 @@
-import { DefaultValue } 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> {
-    constructor(required: Required, defaultValue: Default);
+    get type(): string;
+    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;
@@ -17,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,8 +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);
-    validate(source: SourceValue<DynamicObjectSource<Subschema>, Required, Default>, pass?: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>>);
+    get type(): string;
+    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,10 +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);
-    validate(source: SourceValue<Members[number], Required, Default>, pass?: ValidationPass): ModelValue<Members[number], Members[number], Required, Default>;
-    convert(value: Members[number], pass: ValidationPass): Members[number];
+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;
+    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,9 +1,10 @@
-import { DefaultValue } 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> {
-    constructor(required: Required, defaultValue: Default);
+    get type(): string;
+    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;
@@ -11,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,9 +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);
-    validate(source: SourceValue<ObjectSource<Subschema>, Required, Default>, pass?: ValidationPass): ModelValue<ObjectSource<Subschema>, ObjectModel<Subschema>, Required, Default>;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<ObjectSource<Subschema>, ObjectModel<Subschema>>);
+    get type(): string;
+    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,17 +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);
-    validate(source: SourceValue<OrSetSchemaSource<MemberSchemas>, Required, Default>, pass?: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default>;
-    convert(value: OrSetSchemaSource<MemberSchemas>, pass: ValidationPass): OrSetSchemaModel<MemberSchemas>;
+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;
+    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,13 +1,43 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { AdditionalValidationPasses, DefaultValue } 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> {
-    constructor(required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<StringSource, string>);
+    get type(): string;
+    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");
 /**
@@ -21,9 +18,21 @@ export type AdditionalValidatorAfterType = ("beforeConversion" | "afterConversio
  *  - afterAll: Validator executed after "afterConversion" and as the last task in the validation pipeline.
  */
 export type AdditionalValidatorType = AdditionalValidatorBeforeType | AdditionalValidatorAfterType;
+/**
+ * Represents a custom pass allowing any additional value specificity code, or value augmentations.
+ *
+ * @note Use "{@link ValidationPass pass}.assert" and/or "throw {@link ValidationPass pass}.getError" to build your value specificity checks.
+ *
+ * @param {Type} data The data being validated.
+ * @param {ValidationPass} pass A reference to the current validation pass. Used to interact with the validation pass.
+ * @returns `data` with any desired augmentations.
+ */
 export type AdditionalValidator<Type> = (data: Type, pass: ValidationPass) => Type;
 /**
- * Represents a pass to ensure that your data meets a condition. Return true if your data is ensured to meet condition, false otherwise.
+ * Represents a pass to ensure that your data meets conditions.
+ * @param data The data being validated.
+ * @param pass A reference to the current validation pass. Used to interact with the validation pass.
+ * @returns `true` if your data meets the desired conditions, `false` otherwise.
  */
 export type EnsureValidator<Type> = (data: Type, pass: ValidationPass) => boolean;
 export type AdditionalValidationPasses<Source, Model> = {
@@ -34,4 +43,7 @@ export type AdditionalValidationPasses<Source, Model> = {
     afterConversion: AdditionalValidator<Model>[];
     afterAll: AdditionalValidator<Model>[];
 };
-export type Merge<ObjectA, ObjectB> = (keyof ObjectA extends never ? ObjectB : keyof ObjectB extends never ? ObjectA : ObjectA & ObjectB);
+/**
+ * Intersects two types.
+ */
+export type Merge<A, B> = (keyof A extends never ? B : keyof B extends never ? A : A & B);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "2.0.2",
+    "version": "2.0.4",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -29,12 +29,12 @@
     },
     "homepage": "https://github.com/lucania-software/schema#readme",
     "devDependencies": {
-        "@babel/preset-env": "^7.23.5",
-        "@rollup/plugin-typescript": "^11.1.5",
-        "@types/node": "^20.10.4",
-        "nodemon": "^3.0.2",
-        "rollup": "^4.6.1",
-        "tslib": "^2.6.2",
-        "typescript": "^5.3.3"
+        "@babel/preset-env": "^7.24.7",
+        "@rollup/plugin-typescript": "^11.1.6",
+        "@types/node": "^20.14.2",
+        "nodemon": "^3.1.3",
+        "rollup": "^4.18.0",
+        "tslib": "^2.6.3",
+        "typescript": "^5.4.5"
     }
 }