@lucania/schema 2.0.1 → 2.0.3

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

@@ -42,6 +42,7 @@ export declare namespace Schema {
     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>;
     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.js

@@ -51,12 +51,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 +80,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 +102,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);
@@ -109,6 +118,9 @@
             });
             return this;
         }
+        isRequired() {
+            return this._required;
+        }
         hasDefault() {
             return this._default !== undefined && this._default !== null;
         }
@@ -129,6 +141,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 = [];
@@ -195,8 +214,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;
@@ -209,16 +229,28 @@
     class ArraySchema extends BaseSchema {
         subschema;
         constructor(subschema, required, defaultValue) {
-            super("array", required, defaultValue);
+            super(required, defaultValue);
             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,8 +276,9 @@
     }
 
     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") {
@@ -276,8 +309,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") {
@@ -335,12 +369,24 @@
     class DynamicObjectSchema extends BaseSchema {
         subschema;
         constructor(subschema, required, defaultValue) {
-            super("object", required, defaultValue);
+            super(required, defaultValue);
             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];
@@ -369,12 +415,19 @@
     class EnumerationSchema extends BaseSchema {
         members;
         constructor(members, required, defaultValue) {
-            super("string", required, defaultValue);
+            super(required, defaultValue);
             this.members = members;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            const result = super.validate(source, pass);
+        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(", ")}).`);
             return result;
         }
@@ -391,8 +444,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") {
@@ -446,22 +500,40 @@
     class ObjectSchema extends BaseSchema {
         subschema;
         constructor(subschema, required, defaultValue) {
-            super("object", required, defaultValue);
+            super(required, defaultValue);
             this.subschema = subschema;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            const result = super.validate(source, pass);
-            if (result !== undefined) {
+        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;
+            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];
@@ -501,12 +573,36 @@
     class OrSetSchema extends BaseSchema {
         schemas;
         constructor(schemas, required, defaultValue) {
-            super("string", required, defaultValue);
+            super(required, defaultValue);
             this.schemas = schemas;
         }
-        validate(source, pass) {
-            pass = this._ensurePass(source, pass);
-            let result = super.validate(source, pass);
+        get type() { return "string"; }
+        // public validate(source: SourceValue<OrSetSchemaSource<MemberSchemas>, Required, Default>, pass?: ValidationPass):
+        //     ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default> {
+        //     pass = this._ensurePass(source, pass);
+        //     let result: any = super.validate(source, pass);
+        //     if (result !== undefined) {
+        //         let done = false;
+        //         const failureMessages: string[] = [];
+        //         for (let i = 0; i < this.schemas.length && !done; i++) {
+        //             const schema = this.schemas[i];
+        //             try {
+        //                 result = schema.validate(result, pass);
+        //                 done = true;
+        //             } catch (error) {
+        //                 if (error instanceof Error) {
+        //                     failureMessages.push(`Schema #${i + 1}: ${error.message}`);
+        //                 } else {
+        //                     failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
+        //                 }
+        //                 pass.assert(failureMessages.length !== this.schemas.length, `Supplied value didn't match any schemas in or-set.\n${failureMessages.join("\n")}`);
+        //             }
+        //         }
+        //     }
+        //     return result;
+        // }
+        _validate(source, pass) {
+            let result = source;
             if (result !== undefined) {
                 let done = false;
                 const failureMessages = [];
@@ -538,13 +634,14 @@
     }
 
     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,8 +657,8 @@
         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");
         }
@@ -610,7 +707,7 @@
         }
         Schema.Array = Array;
         function Enumeration(members, required = true, defaultValue = undefined) {
-            return new EnumerationSchema(members.data, required, defaultValue);
+            return new EnumerationSchema(members.$members, required, defaultValue);
         }
         Schema.Enumeration = Enumeration;
         function DynamicObject(subschema, required = true, defaultValue = undefined) {
@@ -618,11 +715,11 @@
         }
         Schema.DynamicObject = DynamicObject;
         function OrSet(members, required = true, defaultValue = undefined) {
-            return new OrSetSchema(members.data, required, defaultValue);
+            return new OrSetSchema(members.$members, required, defaultValue);
         }
         Schema.OrSet = OrSet;
         function Members(...members) {
-            return { data: members };
+            return { $members: members };
         }
         Schema.Members = Members;
     })(exports.Schema || (exports.Schema = {}));

package/build/schema/AnySchema.d.ts

@@ -1,8 +1,9 @@
-import { DefaultValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
 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: SourceValue<any, Required, Default>, pass: ValidationPass): ModelValue<any, any, Required, Default>;
     convert(value: any, pass: ValidationPass): any;
     getJsonSchema(): object;
 }

package/build/schema/ArraySchema.d.ts

@@ -7,7 +7,8 @@ export type ArrayModel<Subschema extends BaseSchemaAny> = (Subschema extends Bas
 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>;
+    get type(): string;
+    protected _validate(source: SourceValue<ArraySource<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<ArraySource<Subschema>, ArrayModel<Subschema>, Required, Default>;
     convert(value: ArraySource<Subschema>, pass: ValidationPass): ArrayModel<Subschema>;
     getJsonSchema(): object;
 }

package/build/schema/BaseSchema.d.ts

@@ -1,24 +1,35 @@
 import { ValidationPass } from "../error/ValidationPass";
 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: SourceValue<Source, 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;
     isDefaultRuntimeEvaluated(): this is {
         _default: Function;
     };
     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;

package/build/schema/BooleanSchema.d.ts

@@ -1,9 +1,10 @@
-import { DefaultValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
 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: SourceValue<BooleanSource, Required, Default>, pass: ValidationPass): ModelValue<BooleanSource, boolean, Required, Default>;
     convert(value: BooleanSource, pass: ValidationPass): boolean;
     getJsonSchema(): object;
 }

package/build/schema/DateSchema.d.ts

@@ -1,11 +1,12 @@
-import { DefaultValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
 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: SourceValue<DateSource, 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;

package/build/schema/DynamicObjectSchema.d.ts

@@ -11,7 +11,8 @@ 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>;
+    get type(): string;
+    _validate(source: SourceValue<DynamicObjectSource<Subschema>, Required, Default>, pass: ValidationPass): ModelValue<DynamicObjectSource<Subschema>, DynamicObjectModel<Subschema>, Required, Default>;
     convert(source: DynamicObjectSource<Subschema>, pass: ValidationPass): DynamicObjectModel<Subschema>;
     getJsonSchema(): object;
 }

package/build/schema/EnumerationSchema.d.ts

@@ -4,7 +4,8 @@ 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>;
+    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];
     getJsonSchema(): object;
 }

package/build/schema/NumberSchema.d.ts

@@ -1,9 +1,10 @@
-import { DefaultValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, SourceValue } from "../typing/toolbox";
 import { ValidationPass } from "../error/ValidationPass";
 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: SourceValue<NumberSource, 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;

package/build/schema/ObjectSchema.d.ts

@@ -18,7 +18,8 @@ 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>;
+    get type(): string;
+    protected _validate(source: SourceValue<ObjectSource<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;

package/build/schema/OrSetSchema.d.ts

@@ -11,7 +11,8 @@ export type OrSetSchemaModel<MemberSchemas extends BaseSchemaAny[]> = ({
 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>;
+    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>;
     getJsonSchema(): object;
 }

package/build/schema/StringSchema.d.ts

@@ -1,9 +1,10 @@
 import { ValidationPass } from "../error/ValidationPass";
-import { AdditionalValidationPasses, DefaultValue } from "../typing/toolbox";
+import { DefaultValue, ModelValue, SourceValue } 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: SourceValue<StringSource, Required, Default>, pass: ValidationPass): ModelValue<StringSource, string, Required, Default>;
     convert(value: StringSource, pass: ValidationPass): string;
     length(minimum: number, maximum: number): this;
     length(minimum: number, maximum: number, message: string): this;

package/build/typing/extended.d.ts

@@ -1,3 +1,5 @@
 import { BaseSchema } from "../schema/BaseSchema";
+import { ObjectSchema } from "../schema/ObjectSchema";
 import { DefaultValue } from "./toolbox";
 export type BaseSchemaAny = BaseSchema<any, any, boolean, DefaultValue<any>>;
+export type ObjectSchemaAny = ObjectSchema<any, boolean, DefaultValue<any>>;

package/build/typing/toolbox.d.ts

@@ -7,7 +7,7 @@ export type ModelRequirement<Layout extends BaseSchemaAny> = (Layout extends Bas
 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> = {
-    data: Members;
+    $members: Members;
 };
 export type AdditionalValidatorBeforeType = ("beforeAll" | "beforeDefault" | "afterDefault");
 export type AdditionalValidatorAfterType = ("beforeConversion" | "afterConversion" | "afterAll");
@@ -21,9 +21,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 +46,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.1",
+    "version": "2.0.3",
     "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"
     }
 }