@dzeio/schema 0.4.2 → 0.5.0

package/dist/Schema.mjs

@@ -10,10 +10,10 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/helpers.ts
-import { objectGet, objectLoop as objectLoop2, objectSet } from "@dzeio/object-util";
+import { objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
 
 // src/SchemaItem.ts
-import { objectClean } from "@dzeio/object-util";
+import { isObject, objectClean, objectSet } from "@dzeio/object-util";
 var _SchemaItem = class _SchemaItem {
   constructor(items) {
     // standard Schema V1 spec
@@ -63,25 +63,17 @@ var _SchemaItem = class _SchemaItem {
      */
     this.attributes = [];
     this.invalidError = "the field is invalid";
+    this.default = this.defaultValue;
     if (items && items.length > 0) {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
-  defaultValue(value, strict = true) {
-    this.addPreProcess((input) => {
-      if (strict && isNull(input) || !strict && !input) {
-        return value;
-      }
-      return input;
-    });
-    return this;
-  }
   in(...values) {
     this.addValidation((input) => values.includes(input));
     return this;
   }
   attrs(...attributes) {
-    this.attributes.concat(attributes);
+    this.attributes.push(...attributes);
     return this;
   }
   attr(...attributes) {
@@ -94,40 +86,87 @@ var _SchemaItem = class _SchemaItem {
   clone() {
     return Schema.fromJSON(this.toJSON());
   }
+  defaultValue(value, strict = true) {
+    return new SchemaDefault(this, value, strict);
+  }
   nullable() {
     return new SchemaNullable(this);
   }
+  or(other) {
+    return new SchemaUnion(this, other);
+  }
+  and(other) {
+    return new SchemaIntersection(this, other);
+  }
+  array() {
+    return new SchemaArray(this);
+  }
+  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
+  getSubInputs(_input) {
+    return [];
+  }
+  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
+  updateSubItemInput(path, input, value) {
+    if (path && isObject(input)) {
+      objectSet(input, path.split("."), value);
+      return input;
+    } else {
+      return value;
+    }
+  }
+  parseSubItems(input, options) {
+    const result = { errors: [], input };
+    for (const { item, value, path } of this.getSubInputs(result.input)) {
+      const parsed = item.parse(value, options);
+      if (parsed.valid) {
+        result.input = this.updateSubItemInput(path, result.input, parsed.object);
+      } else {
+        for (const error of parsed.errors) {
+          error.field = error.field ? `${path}.${error.field}` : path;
+          result.errors.push(error);
+        }
+        if (options == null ? void 0 : options.fast) {
+          break;
+        }
+      }
+    }
+    return result;
+  }
   parse(input, options) {
-    var _a;
+    var _a, _b;
     for (const preProcess of this.preProcess) {
       input = preProcess(input);
     }
+    const result = this.parseSubItems(input, options);
+    if ((_a = result.errors) == null ? void 0 : _a.length) {
+      return {
+        valid: false,
+        errors: result.errors
+      };
+    }
+    input = result.input;
     if (!this.isOfType(input)) {
       return {
         valid: false,
         errors: [{ message: "invalid type" }]
       };
     }
-    const errors = [];
+    const validationErrors = [];
     for (const validation of this.validations) {
       if (!validation.fn(input)) {
-        errors.push({
-          message: (_a = validation.error) != null ? _a : this.invalidError
+        validationErrors.push({
+          message: (_b = validation.error) != null ? _b : this.invalidError
         });
         if (options == null ? void 0 : options.fast) {
-          return {
-            valid: false,
-            object: input,
-            errors
-          };
+          break;
         }
       }
     }
-    if (errors.length > 0) {
+    if (validationErrors.length > 0) {
       return {
         valid: false,
         object: input,
-        errors
+        errors: validationErrors
       };
     }
     for (const postProcess of this.postProcess) {
@@ -162,13 +201,23 @@ var _SchemaItem = class _SchemaItem {
     this.postProcess.push(fn);
     return this;
   }
+  parseJSON() {
+    this.addPreProcess((input) => {
+      try {
+        return typeof input === "string" ? JSON.parse(input) : input;
+      } catch {
+        return input;
+      }
+    });
+    return this;
+  }
 };
 __decorateClass([
-  parceable()
-], _SchemaItem.prototype, "defaultValue", 1);
-__decorateClass([
-  parceable()
+  parsable()
 ], _SchemaItem.prototype, "in", 1);
+__decorateClass([
+  parsable()
+], _SchemaItem.prototype, "parseJSON", 1);
 var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
@@ -185,77 +234,37 @@ var SchemaArray = class extends SchemaItem {
     this.addPreProcess((it) => typeof it === "string" ? it.split(separator) : it);
     return this;
   }
-  parse(input, options) {
-    const { valid, object, errors = [] } = super.parse(input, options);
-    if (!valid) {
-      return {
-        valid,
-        object,
-        errors
-      };
-    }
-    const clone = [];
-    const errs = [];
-    for (let idx = 0; idx < object.length; idx++) {
-      const item = object[idx];
-      const res = this.values.parse(item);
-      if (res.valid) {
-        clone.push(res.object);
-        continue;
-      }
-      const errss = res.errors.map((it) => ({
-        ...it,
-        field: it.field ? `${idx}.${it.field}` : idx.toString()
-      }));
-      if (options == null ? void 0 : options.fast) {
-        return {
-          valid: false,
-          object: clone,
-          errors: errss
-        };
-      }
-      errs.push(...errss);
-    }
-    if (errs.length > 0) {
-      return {
-        valid: false,
-        object: clone,
-        errors: errs
-      };
-    }
-    return {
-      valid: true,
-      object: clone
-    };
+  getSubInputs(input) {
+    return Array.isArray(input) ? input.map((e, i) => ({ item: this.values, value: e, path: i.toString() })) : [];
   }
   unwrap() {
     return this.values;
   }
   isOfType(input) {
-    return Array.isArray(input);
+    return Array.isArray(input) && input.every((e) => this.values.isOfType(e));
   }
 };
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaArray.prototype, "unique", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaArray.prototype, "split", 1);
 
 // src/items/boolean.ts
 var SchemaBoolean = class extends SchemaItem {
   parseString(trueValue = "true", falseValue = "false") {
-    this.addPreProcess((it) => {
-      if (typeof it !== "string") {
-        return it;
+    this.addPreProcess((input) => {
+      if (typeof input !== "string") {
+        return input;
       }
-      if (it === trueValue) {
+      if (input === trueValue) {
         return true;
       }
-      if (it === falseValue) {
+      if (input === falseValue) {
         return false;
       }
-      return it;
+      return input;
     });
     return this;
   }
@@ -264,7 +273,7 @@ var SchemaBoolean = class extends SchemaItem {
   }
 };
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaBoolean.prototype, "parseString", 1);
 
 // src/items/nullable.ts
@@ -273,76 +282,46 @@ var SchemaNullable = class extends SchemaItem {
     super([child]);
     this.child = child;
   }
-  falthyAsNull() {
+  falsyAsNull() {
     this.addPreProcess((it) => !it ? void 0 : it);
     return this;
   }
   unwrap() {
     return this.child;
   }
-  parse(input, options) {
-    const res = super.parse(input, options);
-    if (!res.valid) {
-      return this.child.parse(input, options);
-    }
-    if (this.isNull(res.object)) {
-      return {
-        valid: true,
-        object: void 0
-      };
+  getSubInputs(input) {
+    return [{ value: input, item: this.child, path: void 0 }];
+  }
+  parseSubItems(input, options) {
+    if (isNull(input)) {
+      return { input: void 0 };
     }
-    return this.child.parse(input, options);
+    return super.parseSubItems(input, options);
   }
   isOfType(input) {
-    return this.isNull(input) || this.child.isOfType(input);
-  }
-  isNull(value) {
-    return typeof value === "undefined" || value === null;
+    return typeof input === "undefined" || this.child.isOfType(input);
   }
 };
 __decorateClass([
-  parceable()
-], SchemaNullable.prototype, "falthyAsNull", 1);
+  parsable()
+], SchemaNullable.prototype, "falsyAsNull", 1);
 
 // src/items/object.ts
-import { isObject, objectClone, objectLoop } from "@dzeio/object-util";
+import { isObject as isObject2, objectFind, objectMap } from "@dzeio/object-util";
 var SchemaObject = class extends SchemaItem {
   constructor(model) {
     super([model]);
     this.model = model;
     this.id = "object";
   }
-  parse(input, options) {
-    const { valid, object, errors = [] } = super.parse(input, options);
-    if (!valid) {
-      return {
-        valid,
-        object,
-        errors
-      };
-    }
-    const clone = objectClone(object);
-    const res = {};
-    objectLoop(this.model, (childSchema, key) => {
-      const childValue = clone[key];
-      const child = childSchema.parse(childValue);
-      if (!child.valid) {
-        errors.push(...child.errors.map((it) => ({
-          ...it,
-          field: it.field ? `${key}.${it.field}` : key
-        })));
-      }
-      res[key] = child.object;
-      return child.valid || !(options == null ? void 0 : options.fast);
-    });
-    return {
-      valid: errors.length === 0,
-      errors,
-      object: res
-    };
+  getSubInputs(input) {
+    return isObject2(input) ? objectMap(
+      input,
+      (v, k) => this.model[k] ? { item: this.model[k], value: v, path: k.toString() } : void 0
+    ).filter((e) => !isNull(e)) : [];
   }
   isOfType(input) {
-    return isObject(input);
+    return isObject2(input) && !objectFind(this.model, (item, k) => !item.isOfType(input[k]));
   }
 };
 
@@ -353,15 +332,16 @@ function isNull(value) {
 function parseQuery(model, query, opts) {
   const record = {};
   for (const [key, value] of query) {
-    record[key] = value;
+    const hasMultipleValues = query.getAll(key).length > 1;
+    objectSet2(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? query.getAll(key) : value);
   }
   return model.parse(record, opts);
 }
-function parseFormData(model, data, opts) {
+function parseFormData(schema, data, opts) {
   const record = {};
   for (const [key, value] of data) {
     const hasMultipleValues = data.getAll(key).length > 1;
-    objectSet(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? data.getAll(key) : value);
+    objectSet2(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? data.getAll(key) : value);
   }
   const handleBoolean = (value, keys) => {
     var _a;
@@ -378,18 +358,18 @@ function parseFormData(model, data, opts) {
       handleSchemaForBoolean(value.model, keys);
     }
     if (value instanceof SchemaBoolean) {
-      objectSet(record, keys, !!data.get(keys.join(".")));
+      objectSet2(record, keys, !!data.get(keys.join(".")));
     }
   };
-  const handleSchemaForBoolean = (modl, keys = []) => {
-    objectLoop2(modl, (value, key) => {
+  const handleSchemaForBoolean = (model, keys = []) => {
+    objectLoop(model, (value, key) => {
       handleBoolean(value, [...keys, key]);
     });
   };
-  if (model instanceof SchemaObject) {
-    handleSchemaForBoolean(model.model);
+  if (schema instanceof SchemaObject) {
+    handleSchemaForBoolean(schema.model);
   }
-  return model.parse(record, opts);
+  return schema.parse(record, opts);
 }
 function parseForm(model, form, opts) {
   return parseFormData(model, new FormData(form), opts);
@@ -397,47 +377,47 @@ function parseForm(model, form, opts) {
 
 // src/items/any.ts
 var SchemaAny = class extends SchemaItem {
-  // @ts-expect-error input while not used is necessary for the `override to work`
-  isOfType(input) {
+  isOfType(_input) {
     return true;
   }
 };
 
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
-  parseString(format = "iso8601") {
-    switch (format) {
-      case "yy-mm-dd":
-      case "iso8601": {
-        this.addPreProcess((it) => {
-          if (typeof it !== "string") {
-            return it;
-          }
-          const date = new Date(it);
-          if (isNaN(date.getDate())) {
-            return it;
-          }
-          return date;
-        });
-        break;
+  parseString(format = "default") {
+    this.addPreProcess((input) => {
+      if (typeof input !== "string") {
+        return input;
       }
-      case "jj/mm/yy": {
-        this.addPreProcess((input) => {
-          if (typeof input !== "string") {
-            return input;
+      let date = void 0;
+      switch (format) {
+        case "default": {
+          date = new Date(input);
+          break;
+        }
+        case "yy-mm-dd":
+        case "iso8601": {
+          const splitted = input.split("-").map((it) => Number.parseInt(it, 10));
+          if (splitted.length !== 3) {
+            break;
           }
+          date = new Date(splitted[2], splitted[1] - 1, splitted[0]);
+          break;
+        }
+        case "jj/mm/yy": {
           const splitted = input.split("/").map((it) => Number.parseInt(it, 10));
           if (splitted.length !== 3) {
-            return input;
-          }
-          const date = new Date(splitted[2], splitted[1] - 1, splitted[0]);
-          if (isNaN(date.getDate())) {
-            return input;
+            break;
           }
-          return date;
-        });
+          date = new Date(splitted[2], splitted[1] - 1, splitted[0]);
+          break;
+        }
       }
-    }
+      if (!date || isNaN(date.getDate())) {
+        return input;
+      }
+      return date;
+    });
     return this;
   }
   isOfType(input) {
@@ -445,49 +425,41 @@ var SchemaDate = class extends SchemaItem {
   }
 };
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaDate.prototype, "parseString", 1);
 
 // src/items/record.ts
-import { isObject as isObject2, objectLoop as objectLoop3 } from "@dzeio/object-util";
+import { isObject as isObject3, objectLoop as objectLoop2 } from "@dzeio/object-util";
 var SchemaRecord = class extends SchemaItem {
   constructor(keys, values) {
     super([keys, values]);
     this.keys = keys;
     this.values = values;
   }
-  parse(input, options) {
-    const { valid, object, errors = [] } = super.parse(input, options);
-    if (!valid) {
-      return {
-        valid,
-        object,
-        errors
-      };
+  parseSubItems(input, options) {
+    const result = { input, errors: [] };
+    if (isObject3(input)) {
+      const clone = {};
+      objectLoop2(input, (value, key) => {
+        var _a, _b;
+        const res1 = this.keys.parse(key);
+        const res2 = this.values.parse(value);
+        if (!res1.valid || !res2.valid) {
+          result.errors.push(...((_a = res1.errors) != null ? _a : []).concat(...(_b = res2.errors) != null ? _b : []).map((it) => ({
+            message: it.message,
+            field: it.field ? `${key}.${it.field}` : key.toString()
+          })));
+        } else {
+          clone[res1.object] = res2.object;
+        }
+        return result.errors.length === 0 || !(options == null ? void 0 : options.fast);
+      });
+      result.input = clone;
     }
-    const clone = {};
-    objectLoop3(object, (value, key) => {
-      var _a, _b;
-      const res1 = this.keys.parse(key);
-      const res2 = this.values.parse(value);
-      if (!res1.valid || !res2.valid) {
-        errors.push(...((_a = res1.errors) != null ? _a : []).concat(...(_b = res2.errors) != null ? _b : []).map((it) => ({
-          message: it.message,
-          field: it.field ? `${key}.${it.field}` : key.toString()
-        })));
-      } else {
-        clone[res1.object] = res2.object;
-      }
-      return errors.length === 0 || !(options == null ? void 0 : options.fast);
-    });
-    return {
-      valid: errors.length === 0,
-      errors,
-      object: clone
-    };
+    return result;
   }
   isOfType(input) {
-    return isObject2(input) && Object.prototype.toString.call(input) === "[object Object]";
+    return isObject3(input) && Object.prototype.toString.call(input) === "[object Object]";
   }
 };
 
@@ -562,9 +534,7 @@ var SchemaNumber = class extends SchemaItem {
     return this;
   }
   parseString() {
-    this.addPreProcess(
-      (input) => typeof input === "string" ? Number.parseFloat(input) : input
-    );
+    this.addPreProcess((input) => typeof input === "string" ? parseFloat(input) : input);
     return this;
   }
   isOfType(input) {
@@ -578,19 +548,19 @@ var SchemaNumber = class extends SchemaItem {
   }
 };
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaNumber.prototype, "lte", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaNumber.prototype, "gte", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaNumber.prototype, "lt", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaNumber.prototype, "gt", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaNumber.prototype, "parseString", 1);
 
 // src/items/string.ts
@@ -647,57 +617,170 @@ var SchemaString = class extends SchemaItem {
   }
 };
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaString.prototype, "min", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaString.prototype, "toCasing", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaString.prototype, "max", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaString.prototype, "notEmpty", 1);
 __decorateClass([
-  parceable()
+  parsable()
 ], SchemaString.prototype, "regex", 1);
 
 // src/items/union.ts
 var SchemaUnion = class extends SchemaItem {
   constructor(...schemas) {
-    super();
+    super(schemas);
     this.schemas = schemas;
   }
-  parse(input, options) {
-    const { valid, object, errors = [] } = super.parse(input, options);
-    if (!valid) {
-      return {
-        valid,
-        object,
-        errors
-      };
-    }
+  parseSubItems(input, options) {
+    const result = { input, errors: [] };
     for (const schema of this.schemas) {
-      const validation = schema.parse(input, options);
+      const validation = schema.parse(result.input, options);
       if (validation.valid) {
-        return validation;
+        return { input: validation.object };
       } else {
-        errors.push(...validation.errors);
+        result.errors.push(...validation.errors);
       }
     }
-    return {
-      valid: false,
-      errors,
-      object
-    };
+    return result;
   }
   isOfType(input) {
     return this.schemas.some((it) => it.isOfType(input));
   }
 };
 
+// src/items/intersection.ts
+import { isObject as isObject4 } from "@dzeio/object-util";
+var SchemaIntersection = class extends SchemaItem {
+  constructor(...schemas) {
+    super(schemas);
+    this.schemas = schemas;
+  }
+  parseSubItems(input, options) {
+    const result = { input, errors: [] };
+    for (const schema of this.schemas) {
+      const validation = schema.parse(result.input, options);
+      if (!validation.valid) {
+        result.errors.push(...validation.errors);
+        continue;
+      }
+      if (isObject4(result.input)) {
+        Object.assign(result.input, validation.object);
+      } else {
+        result.input = validation.object;
+      }
+    }
+    return result;
+  }
+  isOfType(input) {
+    return this.schemas.every((it) => it.isOfType(input));
+  }
+};
+
+// src/items/default.ts
+var SchemaDefault = class extends SchemaItem {
+  constructor(child, defaultVal, strict = true) {
+    super([child, defaultVal, strict]);
+    this.child = child;
+    this.defaultVal = defaultVal;
+    this.strict = strict;
+  }
+  unwrap() {
+    return this.child;
+  }
+  getSubInputs(input) {
+    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
+  }
+  isOfType(input) {
+    return this.child.isOfType(input);
+  }
+};
+
+// src/items/file.ts
+var SchemaFile = class extends SchemaItem {
+  constructor() {
+    super();
+    this.addPreProcess((input) => this.isOfType(input) && input.size > 0 ? input : void 0);
+  }
+  extension(ext, error) {
+    this.addValidation({ fn: (input) => {
+      var _a;
+      return (_a = input.name) == null ? void 0 : _a.endsWith(ext);
+    }, error });
+    return this;
+  }
+  maxSize(size, error) {
+    this.addValidation({ fn: (file) => file.size <= size, error });
+    return this;
+  }
+  isOfType(input) {
+    return input instanceof File;
+  }
+};
+__decorateClass([
+  parsable()
+], SchemaFile.prototype, "extension", 1);
+__decorateClass([
+  parsable()
+], SchemaFile.prototype, "maxSize", 1);
+
+// src/items/tuple.ts
+var SchemaTuple = class extends SchemaItem {
+  constructor(...children) {
+    super(children);
+    this.children = children;
+  }
+  getSubInputs(input) {
+    return Array.isArray(input) ? this.children.map((e, i) => ({ value: input[i], item: e, path: i.toString() })) : [];
+  }
+  isOfType(input) {
+    if (!Array.isArray(input) || input.length > this.items.length) {
+      return false;
+    }
+    for (const [i, item] of this.children.entries()) {
+      if (item instanceof SchemaItem && !item.isOfType(input[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/items/nullish.ts
+var SchemaUndefined = class extends SchemaItem {
+  isOfType(input) {
+    return typeof input === "undefined";
+  }
+};
+var SchemaNull = class extends SchemaItem {
+  isOfType(input) {
+    return input === null;
+  }
+};
+var SchemaVoid = class extends SchemaItem {
+  isOfType(input) {
+    return typeof input === "undefined";
+  }
+};
+var SchemaNullish = class extends SchemaItem {
+  isOfType(input) {
+    return isNull(input);
+  }
+};
+var SchemaNever = class extends SchemaItem {
+  isOfType(_input) {
+    return false;
+  }
+};
+
 // src/Schema.ts
-function parceable() {
+function parsable() {
   return (target, propertyKey, descriptor) => {
     if (!(propertyKey in target)) {
       throw new Error("property not set in object");
@@ -714,6 +797,7 @@ function parceable() {
 var Types = {
   Any: SchemaAny,
   Array: SchemaArray,
+  Tuple: SchemaTuple,
   Boolean: SchemaBoolean,
   Date: SchemaDate,
   Enum: SchemaEnum,
@@ -722,7 +806,13 @@ var Types = {
   Object: SchemaObject,
   Record: SchemaRecord,
   String: SchemaString,
-  Union: SchemaUnion
+  Union: SchemaUnion,
+  Intersection: SchemaIntersection,
+  Default: SchemaDefault,
+  Undefined: SchemaUndefined,
+  Void: SchemaVoid,
+  Null: SchemaNull,
+  Nullish: SchemaNullish
 };
 var _Schema = class _Schema extends SchemaObject {
   static register(module) {
@@ -772,9 +862,33 @@ var _Schema = class _Schema extends SchemaObject {
   static string(...inputs) {
     return new SchemaString(...inputs);
   }
+  static file(...inputs) {
+    return new SchemaFile(...inputs);
+  }
   static union(...inputs) {
     return new SchemaUnion(...inputs);
   }
+  static intersection(...inputs) {
+    return new SchemaIntersection(...inputs);
+  }
+  static tuple(...inputs) {
+    return new SchemaTuple(...inputs);
+  }
+  static undefined(...inputs) {
+    return new SchemaUndefined(...inputs);
+  }
+  static null(...inputs) {
+    return new SchemaNull(...inputs);
+  }
+  static nullish(...inputs) {
+    return new SchemaNullish(...inputs);
+  }
+  static void(...inputs) {
+    return new SchemaVoid(...inputs);
+  }
+  static never(...inputs) {
+    return new SchemaNever(...inputs);
+  }
   static fromJSON(json) {
     var _a, _b, _c, _d, _e, _f;
     const fn = this.getModule(json.i);
@@ -827,6 +941,7 @@ var _Schema = class _Schema extends SchemaObject {
 };
 _Schema.registeredModules = [
   SchemaArray,
+  SchemaTuple,
   SchemaBoolean,
   SchemaDate,
   SchemaEnum,
@@ -835,7 +950,13 @@ _Schema.registeredModules = [
   SchemaObject,
   SchemaRecord,
   SchemaString,
-  SchemaUnion
+  SchemaUnion,
+  SchemaIntersection,
+  SchemaDefault,
+  SchemaUndefined,
+  SchemaVoid,
+  SchemaNull,
+  SchemaNullish
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -844,19 +965,27 @@ export {
   SchemaArray,
   SchemaBoolean,
   SchemaDate,
+  SchemaDefault,
   SchemaEnum,
+  SchemaFile,
+  SchemaIntersection,
   SchemaItem,
   SchemaLiteral,
+  SchemaNever,
+  SchemaNull,
   SchemaNullable,
+  SchemaNullish,
   SchemaNumber,
   SchemaObject,
   SchemaRecord,
   SchemaString,
+  SchemaUndefined,
   SchemaUnion,
+  SchemaVoid,
   Types,
   Schema as default,
   isNull,
-  parceable,
+  parsable,
   parseForm,
   parseFormData,
   parseQuery,