@lucania/schema 3.0.4 → 3.1.0

package/README.md

@@ -1,126 +1,126 @@
-# Schema
-
-| 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>`                                                           |
-
-## Validation
-
-The simplest possible validation:
-
-```typescript
-import { $ } from "@lucania/schema";
-
-// Create a Schema to represent a number.
-const numberSchema = $.Number();
-
-// Some data with an unknown type, likely coming from a file, network or untyped library.
-const dataOfUnknownType: any = 123;
-
-// Using our number Schema to validate that our untyped data is what we expect it to be, a number. "dataOfNumberType" now has the "number" type.
-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";
-
-const WeaponSchema = $.Object({
-    damage: $.Number(true).clamp(0, 100),
-    forged: $.Date(false),
-    affixtures: $.DynamicObject($.String())
-});
-
-const PersonSchema = $.Object({
-    name: $.Object({
-        first: $.String(true),
-        middle: $.String(false),
-        last: $.String(true)
-    }),
-    favoriteNumber: $.Number(true).ensure((data, pass) => data % 2 === 0, "Your favorite number must be a multiple of 2!"),
-    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
-
-With the schema definitions created, they can be used to validate data where the types are unknown. This data might come from fetch requests, information read from disk, or even JavaScript libraries that don't export their own type definitions, just to name a few examples.
-
-```typescript
-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.
-
-## 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.
+# Schema
+
+| 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>`                                                           |
+
+## Validation
+
+The simplest possible validation:
+
+```typescript
+import { $ } from "@lucania/schema";
+
+// Create a Schema to represent a number.
+const numberSchema = $.Number();
+
+// Some data with an unknown type, likely coming from a file, network or untyped library.
+const dataOfUnknownType: any = 123;
+
+// Using our number Schema to validate that our untyped data is what we expect it to be, a number. "dataOfNumberType" now has the "number" type.
+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";
+
+const WeaponSchema = $.Object({
+    damage: $.Number(true).clamp(0, 100),
+    forged: $.Date(false),
+    affixtures: $.DynamicObject($.String())
+});
+
+const PersonSchema = $.Object({
+    name: $.Object({
+        first: $.String(true),
+        middle: $.String(false),
+        last: $.String(true)
+    }),
+    favoriteNumber: $.Number(true).ensure((data, pass) => data % 2 === 0, "Your favorite number must be a multiple of 2!"),
+    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
+
+With the schema definitions created, they can be used to validate data where the types are unknown. This data might come from fetch requests, information read from disk, or even JavaScript libraries that don't export their own type definitions, just to name a few examples.
+
+```typescript
+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.
+
+## 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,18 +1,18 @@
-import { BaseSchema, SourceValue } from ".";
 import { AnySchema } from "./schema/AnySchema";
 import { ArraySchema, ArraySource } from "./schema/ArraySchema";
+import { BaseSchema } from "./schema/BaseSchema";
 import { BooleanSchema, BooleanSource } from "./schema/BooleanSchema";
 import { ConstantSchema, ConstantSource } from "./schema/ConstantSchema";
 import { DateSchema, DateSource } from "./schema/DateSchema";
 import { DynamicObjectSchema, DynamicObjectSource } from "./schema/DynamicObjectSchema";
-import { EnumerationSchema } from "./schema/EnumerationSchema";
+import { EnumerationSchema, EnumerationSource } from "./schema/EnumerationSchema";
 import { LenientObjectModel, LenientObjectSchema, LenientObjectSource, LenientObjectSubschema } from "./schema/LenientObject";
 import { NumberSchema, NumberSource } from "./schema/NumberSchema";
 import { ObjectSchema, ObjectSource, ObjectSubschema } from "./schema/ObjectSchema";
 import { OrSetSchema, OrSetSchemaSource } from "./schema/OrSetSchema";
 import { StringSchema, StringSource } from "./schema/StringSchema";
 import { BaseSchemaAny } from "./typing/extended";
-import { DefaultValue, ModelValue } from "./typing/toolbox";
+import { DefaultValue, ModelValue, SourceValue } from "./typing/toolbox";
 /**
  * A collection of helper functions used to create the standard set of schemas.
  */
@@ -144,21 +144,19 @@ 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<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 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>;
+    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<EnumerationSource<Members>>>(subschema: TypedMembers<Members>, required: Required, defaultValue: Default): EnumerationSchema<Members, 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 Constant<Constant extends ConstantSource>(constant: Constant): ConstantSchema<Constant, true, undefined>;
     function Constant<Constant extends ConstantSource, Required extends boolean>(constant: Constant, required: Required): ConstantSchema<Constant, Required, undefined>;
     function Constant<Constant extends ConstantSource, Required extends boolean, Default extends DefaultValue<Constant>>(constant: Constant, required: Required, defaultValue: Default): ConstantSchema<Constant, Required, Default>;
-    type TypedMembers<Member extends any> = {
-        $members: Member[];
+    type TypedMembers<Members extends readonly any[]> = {
+        $members: Members;
     };
-    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 Members<const Members extends any[]>(...members: Members): TypedMembers<Members>;
     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;

package/build/index.js

@@ -755,7 +755,7 @@
             this.schemas = schemas;
         }
         get type() {
-            return "string";
+            return "OrSet";
         }
         _validate(source, options, pass) {
             const errors = {};
@@ -775,35 +775,6 @@
             throw pass.causeError(`Provided value (${BaseSchema.getType(source)}) matched no schemas ` +
                 `(${this.schemas.map((schema) => schema.type).join(", ")}).\n` +
                 `${errorMessages.join("\n")}`);
-            // let result = source;
-            // 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 {
-            //             if (BaseSchema.getType(result) === schema.type) {
-            //                 result = schema.validate(result, options, pass);
-            //                 done = true;
-            //             }
-            //         } catch (error) {
-            //             if (error instanceof Error) {
-            //                 failureMessages.push(`Schema #${i + 1}: ${error.message}`);
-            //             } else {
-            //                 failureMessages.push(`Schema #${i + 1}: ${String(error)}`);
-            //             }
-            //         }
-            //     }
-            //     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;
@@ -926,12 +897,12 @@
             return new ArraySchema(subschema, required, defaultValue);
         }
         Schema.Array = Array;
-        function Enumeration(members, required = true, defaultValue = undefined) {
-            return new EnumerationSchema(members.$members, required, defaultValue);
+        function Enumeration({ $members }, required = true, defaultValue = undefined) {
+            return new EnumerationSchema($members, required, defaultValue);
         }
         Schema.Enumeration = Enumeration;
-        function OrSet(members, required = true, defaultValue = undefined) {
-            return new OrSetSchema(members.$members, required, defaultValue);
+        function OrSet({ $members }, required = true, defaultValue = undefined) {
+            return new OrSetSchema($members, required, defaultValue);
         }
         Schema.OrSet = OrSet;
         function Constant(value, required = true, defaultValue = undefined) {
@@ -939,15 +910,6 @@
         }
         Schema.Constant = Constant;
         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;

package/build/schema/EnumerationSchema.d.ts

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

package/build/schema/OrSetSchema.d.ts

@@ -2,14 +2,14 @@ import { ValidationPass } from "../error/ValidationPass";
 import { BaseSchemaAny } from "../typing/extended";
 import { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
 import { BaseSchema } from "./BaseSchema";
-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>>);
+export type OrSetSchemaSource<MemberSchemas extends BaseSchemaAny[]> = (MemberSchemas[number] extends infer MemberSchema ? (MemberSchema extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never) : never);
+export type OrSetSchemaModel<MemberSchemas extends BaseSchemaAny[]> = (MemberSchemas[number] extends infer MemberSchema ? (MemberSchema extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never) : never);
+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, additionalValidationPasses?: AdditionalValidationPasses<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>>);
     get type(): string;
-    protected _validate(source: ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchema>, OrSetSchemaModel<MemberSchema>, Required, Default>;
-    convert(value: OrSetSchemaSource<MemberSchema>, pass: ValidationPass): OrSetSchemaModel<MemberSchema>;
-    clone(): OrSetSchema<MemberSchema, Required, Default>;
+    protected _validate(source: ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<OrSetSchemaSource<MemberSchemas>, OrSetSchemaModel<MemberSchemas>, Required, Default>;
+    convert(value: OrSetSchemaSource<MemberSchemas>, pass: ValidationPass): OrSetSchemaModel<MemberSchemas>;
+    clone(): OrSetSchema<MemberSchemas, Required, Default>;
     getJsonSchema(): object;
 }

package/build/schema/TupleSchema.d.ts

@@ -0,0 +1,20 @@
+import { ValidationPass } from "../error/ValidationPass";
+import { BaseSchemaAny } from "../typing/extended";
+import { AdditionalValidationPasses, DefaultValue, ModelValue, SourceValue, ValidationOptions } from "../typing/toolbox";
+import { BaseSchema } from "./BaseSchema";
+export type TupleSubschema = BaseSchemaAny[];
+export type TupleSource<Subschema extends TupleSubschema> = ({
+    [Key in keyof Subschema]: (Subschema[Key] extends BaseSchema<infer Source, any, infer Required, infer Default> ? (SourceValue<Source, Required, Default>) : never);
+});
+export type TupleModel<Subschema extends TupleSubschema> = ({
+    [Key in keyof Subschema]: (Subschema[Key] extends BaseSchema<infer Source, infer Model, infer Required, infer Default> ? (ModelValue<Source, Model, Required, Default>) : never);
+});
+export declare class TupleSchema<Subschema extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<TupleSource<Subschema>>> extends BaseSchema<TupleSource<Subschema>, TupleModel<Subschema>, Required, Default> {
+    readonly subschema: Subschema;
+    constructor(subschema: Subschema, required: Required, defaultValue: Default, additionalValidationPasses?: AdditionalValidationPasses<TupleSource<Subschema>, TupleModel<Subschema>>);
+    get type(): string;
+    protected _validate(source: ModelValue<TupleSource<Subschema>, TupleModel<Subschema>, Required, Default>, options: ValidationOptions, pass: ValidationPass): ModelValue<TupleSource<Subschema>, TupleModel<Subschema>, Required, Default>;
+    convert(value: TupleSource<Subschema>, pass: ValidationPass): TupleModel<Subschema>;
+    clone(): TupleSchema<Subschema, Required, Default>;
+    getJsonSchema(): object;
+}

package/build/typing/extended.d.ts

@@ -4,4 +4,4 @@ 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>>;
-export type EnumerationSchemaAny = EnumerationSchema<string, boolean, DefaultValue<any>>;
+export type EnumerationSchemaAny = EnumerationSchema<string[], boolean, DefaultValue<any>>;

package/package.json

@@ -1,40 +1,40 @@
-{
-    "name": "@lucania/schema",
-    "version": "3.0.4",
-    "description": "A schema module for compile-time and runtime type checking.",
-    "main": "./build/index.js",
-    "types": "./build/index.d.ts",
-    "files": [
-        "/build"
-    ],
-    "scripts": {
-        "setup": "npm install",
-        "clean": "erase /F /S /Q build",
-        "build": "npx rollup --bundleConfigAsCjs --config rollup.config.js",
-        "build:clean": "npm run clean && npm run build",
-        "build:watch": "npx rollup --watch --bundleConfigAsCjs --config rollup.config.js",
-        "push": "npm run build:clean && npm publish --access public"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/lucania-software/schema.git"
-    },
-    "keywords": [
-        "Schema"
-    ],
-    "author": "Jeremy Bankes",
-    "license": "GPL-3.0-or-later",
-    "bugs": {
-        "url": "https://github.com/lucania-software/schema/issues"
-    },
-    "homepage": "https://github.com/lucania-software/schema#readme",
-    "devDependencies": {
-        "@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"
-    }
-}
+{
+    "name": "@lucania/schema",
+    "version": "3.1.0",
+    "description": "A schema module for compile-time and runtime type checking.",
+    "main": "./build/index.js",
+    "types": "./build/index.d.ts",
+    "files": [
+        "/build"
+    ],
+    "scripts": {
+        "setup": "npm install",
+        "clean": "rm -rf build",
+        "build": "npx rollup --bundleConfigAsCjs --config rollup.config.js",
+        "build:clean": "npm run clean && npm run build",
+        "build:watch": "npx rollup --watch --bundleConfigAsCjs --config rollup.config.js",
+        "push": "npm run build:clean && npm publish --access public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/lucania-software/schema.git"
+    },
+    "keywords": [
+        "Schema"
+    ],
+    "author": "Jeremy Bankes",
+    "license": "GPL-3.0-or-later",
+    "bugs": {
+        "url": "https://github.com/lucania-software/schema/issues"
+    },
+    "homepage": "https://github.com/lucania-software/schema#readme",
+    "devDependencies": {
+        "@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"
+    }
+}