@serum-enterprises/schema 3.1.0-beta.0 → 3.3.0-beta.0

package/build/index.js

@@ -120,14 +120,8 @@ var require_Option = __commonJS({
   "node_modules/@serum-enterprises/option/build/Option.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.None = exports2.Some = exports2.Option = void 0;
-    var Option6 = class _Option {
-      static Some(value) {
-        return new Some(value);
-      }
-      static None() {
-        return new None();
-      }
+    exports2.Option = exports2.None = exports2.Some = void 0;
+    var BaseOption = class {
       isSome() {
         return this instanceof Some;
       }
@@ -145,7 +139,7 @@ var require_Option = __commonJS({
         return this;
       }
       map(fn) {
-        return this.match((value) => _Option.Some(fn(value)), () => _Option.None());
+        return this.match((value) => exports2.Option.Some(fn(value)), () => exports2.Option.None());
       }
       match(onSome, onNone) {
         if (this.isSome())
@@ -153,28 +147,40 @@ var require_Option = __commonJS({
         else
           return onNone();
       }
+      equals(other, fn = (a, b) => Object.is(a, b)) {
+        if (this.isNone() && other.isNone())
+          return true;
+        if (this.isSome() && other.isSome())
+          return fn(this.value, other.value);
+        return false;
+      }
     };
-    exports2.Option = Option6;
-    var Some = class extends Option6 {
-      _value;
+    var Some = class extends BaseOption {
+      value;
       constructor(value) {
         super();
-        this._value = value;
-      }
-      get value() {
-        return this._value;
+        this.value = value;
       }
     };
     exports2.Some = Some;
-    var None = class extends Option6 {
+    var None = class extends BaseOption {
     };
     exports2.None = None;
+    exports2.Option = {
+      Some(value) {
+        return new Some(value);
+      },
+      None() {
+        return new None();
+      }
+    };
   }
 });
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Builders: () => Builders,
   Schema: () => Schema,
   Validator: () => Validator,
   Validators: () => Validators
@@ -200,7 +206,7 @@ var Validator = class {
 // src/lib/fromJSON.ts
 var import_json7 = __toESM(require_build());
 
-// src/validators/JSON.ts
+// src/Validators/JSON.ts
 var import_json = __toESM(require_build());
 
 // src/lib/util.ts
@@ -209,7 +215,7 @@ var AssertError = class extends Error {
 var DefinitionError = class extends Error {
 };
 
-// src/validators/JSON.ts
+// src/Validators/JSON.ts
 var JSONValidator = class _JSONValidator extends Validator {
   static fromJSON(_definition, _path = "definition") {
     return new _JSONValidator();
@@ -231,7 +237,7 @@ var JSONValidator = class _JSONValidator extends Validator {
   }
 };
 
-// src/validators/Boolean.ts
+// src/Validators/Boolean.ts
 var import_json2 = __toESM(require_build());
 var import_option = __toESM(require_Option());
 var BooleanValidator = class _BooleanValidator extends Validator {
@@ -240,25 +246,18 @@ var BooleanValidator = class _BooleanValidator extends Validator {
     if ("nullable" in definition) {
       if (!import_json2.JSON.isBoolean(definition["nullable"]))
         throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
+      if (definition["nullable"])
+        validatorInstance._nullable = import_option.Option.Some(null);
     }
     if ("equals" in definition) {
       if (!import_json2.JSON.isBoolean(definition["equals"]))
         throw new DefinitionError(`Expected ${path}.equals to be a Boolean`);
-      validatorInstance.equals(definition["equals"]);
+      validatorInstance._equals = import_option.Option.Some(definition["equals"]);
     }
     return validatorInstance;
   }
   _nullable = import_option.Option.None();
   _equals = import_option.Option.None();
-  nullable(flag) {
-    this._nullable = flag ?? true ? import_option.Option.Some(null) : import_option.Option.None();
-    return this;
-  }
-  equals(value) {
-    this._equals = import_option.Option.Some(value);
-    return this;
-  }
   assert(data, path = "data") {
     if (import_json2.JSON.isBoolean(data)) {
       if (this._equals.isSome() && this._equals.value !== data)
@@ -287,13 +286,7 @@ var BooleanValidator = class _BooleanValidator extends Validator {
   isEquals(other) {
     if (!(other instanceof _BooleanValidator))
       return false;
-    if (this._nullable.isSome() !== other._nullable.isSome())
-      return false;
-    if (this._equals.isSome() !== other._equals.isSome())
-      return false;
-    if (this._equals.isSome() && other._equals.isSome() && this._equals.value !== other._equals.value)
-      return false;
-    return true;
+    return this._nullable.equals(other._nullable) && this._equals.equals(other._equals);
   }
   toJSON() {
     const definition = {
@@ -307,7 +300,7 @@ var BooleanValidator = class _BooleanValidator extends Validator {
   }
 };
 
-// src/validators/Number.ts
+// src/Validators/Number.ts
 var import_json3 = __toESM(require_build());
 var import_option2 = __toESM(require_Option());
 var NumberValidator = class _NumberValidator extends Validator {
@@ -316,71 +309,37 @@ var NumberValidator = class _NumberValidator extends Validator {
     if ("nullable" in definition) {
       if (!import_json3.JSON.isBoolean(definition["nullable"]))
         throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
+      if (definition["nullable"])
+        validatorInstance._nullable = import_option2.Option.Some(null);
     }
     if ("equals" in definition) {
       if (!import_json3.JSON.isNumber(definition["equals"]))
         throw new DefinitionError(`Expected ${path}.equals to be a Number`);
-      validatorInstance.equals(definition["equals"], `${path}.equals`);
+      validatorInstance._equals = import_option2.Option.Some(definition["equals"]);
     }
     if ("integer" in definition) {
       if (!import_json3.JSON.isBoolean(definition["integer"]))
         throw new DefinitionError(`Expected ${path}.integer to be a Boolean`);
-      validatorInstance.integer(definition["integer"], `${path}.integer`);
+      if (definition["integer"])
+        validatorInstance._integer = import_option2.Option.Some(null);
     }
     if ("min" in definition) {
       if (!import_json3.JSON.isNumber(definition["min"]))
         throw new DefinitionError(`Expected ${path}.min to be a Number`);
-      validatorInstance.min(definition["min"], `${path}.min`);
+      validatorInstance._min = import_option2.Option.Some(definition["min"]);
     }
     if ("max" in definition) {
       if (!import_json3.JSON.isNumber(definition["max"]))
         throw new DefinitionError(`Expected ${path}.max to be a Number`);
-      validatorInstance.max(definition["max"], `${path}.max`);
+      validatorInstance._max = import_option2.Option.Some(definition["max"]);
     }
     return validatorInstance;
   }
   _nullable = import_option2.Option.None();
-  _equals = import_option2.Option.None();
   _integer = import_option2.Option.None();
   _min = import_option2.Option.None();
   _max = import_option2.Option.None();
-  nullable(flag) {
-    this._nullable = flag ?? true ? import_option2.Option.Some(null) : import_option2.Option.None();
-    return this;
-  }
-  equals(value, path = "equals") {
-    if (this._integer.isSome() && !Number.isSafeInteger(value))
-      throw new DefinitionError(`Expected Equals Rule to be an Integer according to the Integer Rule at Path ${path}`);
-    if (this._min.isSome() && this._min.value > value)
-      throw new DefinitionError(`Expected Equals Rule to be larger than or equal to the Minimum Rule at Path ${path}`);
-    if (this._max.isSome() && this._max.value < value)
-      throw new DefinitionError(`Expected Equals Rule to be smaller than or equal to the Maximum Rule at Path ${path}`);
-    this._equals = import_option2.Option.Some(value);
-    return this;
-  }
-  integer(flag = true, path = "integer") {
-    if (flag && this._equals.isSome() && !Number.isSafeInteger(this._equals.value))
-      throw new DefinitionError(`Expected Integer Rule to be a false due to the Equals Rule being a Float at Path ${path}`);
-    this._integer = flag ? import_option2.Option.Some(null) : import_option2.Option.None();
-    return this;
-  }
-  min(value, path = "min") {
-    if (this._max.isSome() && this._max.value < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Maximum Rule at Path ${path}`);
-    if (this._equals.isSome() && this._equals.value < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to the Equals Rule at Path ${path}`);
-    this._min = import_option2.Option.Some(value);
-    return this;
-  }
-  max(value, path = "max") {
-    if (this._min.isSome() && this._min.value > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
-    if (this._equals.isSome() && this._equals.value > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to the Equals Rule at Path ${path}`);
-    this._max = import_option2.Option.Some(value);
-    return this;
-  }
+  _equals = import_option2.Option.None();
   assert(data, path = "data") {
     if (import_json3.JSON.isNumber(data)) {
       if (this._equals.isSome() && this._equals.value !== data)
@@ -428,23 +387,7 @@ var NumberValidator = class _NumberValidator extends Validator {
   isEquals(other) {
     if (!(other instanceof _NumberValidator))
       return false;
-    if (this._nullable.isSome() !== other._nullable.isSome())
-      return false;
-    if (this._integer.isSome() !== other._integer.isSome())
-      return false;
-    if (this._equals.isSome() !== other._equals.isSome())
-      return false;
-    if (this._equals.isSome() && other._equals.isSome() && this._equals.value !== other._equals.value)
-      return false;
-    if (this._min.isSome() !== other._min.isSome())
-      return false;
-    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
-      return false;
-    if (this._max.isSome() !== other._max.isSome())
-      return false;
-    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
-      return false;
-    return true;
+    return this._nullable.equals(other._nullable) && this._integer.equals(other._integer) && this._min.equals(other._min) && this._max.equals(other._max) && this._equals.equals(other._equals);
   }
   toJSON() {
     const definition = {
@@ -464,7 +407,7 @@ var NumberValidator = class _NumberValidator extends Validator {
   }
 };
 
-// src/validators/String.ts
+// src/Validators/String.ts
 var import_json4 = __toESM(require_build());
 var import_option3 = __toESM(require_Option());
 var StringValidator = class _StringValidator extends Validator {
@@ -473,61 +416,30 @@ var StringValidator = class _StringValidator extends Validator {
     if ("nullable" in definition) {
       if (!import_json4.JSON.isBoolean(definition["nullable"]))
         throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
+      if (definition["nullable"])
+        validatorInstance._nullable = import_option3.Option.Some(null);
     }
     if ("equals" in definition) {
       if (!import_json4.JSON.isString(definition["equals"]))
         throw new DefinitionError(`Expected ${path}.equals to be a String`);
-      validatorInstance.equals(definition["equals"], `${path}.equals`);
+      validatorInstance._equals = import_option3.Option.Some(definition["equals"]);
     }
     if ("min" in definition) {
       if (!import_json4.JSON.isNumber(definition["min"]))
-        throw new DefinitionError(`Expected ${path}.min to be a positive Integer`);
-      validatorInstance.min(definition["min"], `${path}.min`);
+        throw new DefinitionError(`Expected ${path}.min to be a Number`);
+      validatorInstance._min = import_option3.Option.Some(definition["min"]);
     }
     if ("max" in definition) {
       if (!import_json4.JSON.isNumber(definition["max"]))
-        throw new DefinitionError(`Expected ${path}.max to be a positive Integer`);
-      validatorInstance.max(definition["max"], `${path}.max`);
+        throw new DefinitionError(`Expected ${path}.max to be a Number`);
+      validatorInstance._max = import_option3.Option.Some(definition["max"]);
     }
     return validatorInstance;
   }
   _nullable = import_option3.Option.None();
-  _equals = import_option3.Option.None();
   _min = import_option3.Option.None();
   _max = import_option3.Option.None();
-  nullable(flag) {
-    this._nullable = flag ?? true ? import_option3.Option.Some(null) : import_option3.Option.None();
-    return this;
-  }
-  equals(value, path = "equals") {
-    if (this._min.isSome() && this._min.value > value.length)
-      throw new DefinitionError(`Expected the Equals Rules Length to be larger than or equal to the Minimum Rule at Path ${path}`);
-    if (this._max.isSome() && this._max.value < value.length)
-      throw new DefinitionError(`Expected the Equals Rules Length to be smaller than or equal to the Maximum Rule at Path ${path}`);
-    this._equals = import_option3.Option.Some(value);
-    return this;
-  }
-  min(value, path = "min") {
-    if (!Number.isSafeInteger(value) || value < 0)
-      throw new DefinitionError(`Expected ${path}.min to be a positive Integer`);
-    if (this._max.isSome() && this._max.value < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Maximum Rule at Path ${path}`);
-    if (this._equals.isSome() && this._equals.value.length < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to the Equals Rules Length at Path ${path}`);
-    this._min = import_option3.Option.Some(value);
-    return this;
-  }
-  max(value, path = "max") {
-    if (!Number.isSafeInteger(value) || value < 0)
-      throw new DefinitionError(`Expected ${path}.max to be a positive Integer`);
-    if (this._min.isSome() && this._min.value > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
-    if (this._equals.isSome() && this._equals.value.length > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to the Equals Rules Length at Path ${path}`);
-    this._max = import_option3.Option.Some(value);
-    return this;
-  }
+  _equals = import_option3.Option.None();
   assert(data, path = "data") {
     if (import_json4.JSON.isString(data)) {
       if (this._equals.isSome() && this._equals.value !== data)
@@ -569,21 +481,7 @@ var StringValidator = class _StringValidator extends Validator {
   isEquals(other) {
     if (!(other instanceof _StringValidator))
       return false;
-    if (this._nullable.isSome() !== other._nullable.isSome())
-      return false;
-    if (this._equals.isSome() !== other._equals.isSome())
-      return false;
-    if (this._equals.isSome() && other._equals.isSome() && this._equals.value !== other._equals.value)
-      return false;
-    if (this._min.isSome() !== other._min.isSome())
-      return false;
-    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
-      return false;
-    if (this._max.isSome() !== other._max.isSome())
-      return false;
-    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
-      return false;
-    return true;
+    return this._nullable.equals(other._nullable) && this._min.equals(other._min) && this._max.equals(other._max) && this._equals.equals(other._equals);
   }
   toJSON() {
     const definition = {
@@ -601,41 +499,199 @@ var StringValidator = class _StringValidator extends Validator {
   }
 };
 
-// src/validators/Array.ts
-var import_json6 = __toESM(require_build());
-var import_option5 = __toESM(require_Option());
-
-// src/validators/Object.ts
+// src/Validators/Array.ts
 var import_json5 = __toESM(require_build());
 var import_option4 = __toESM(require_Option());
+var ArrayValidator = class _ArrayValidator extends Validator {
+  static fromJSON(definition, path = "definition") {
+    const validatorInstance = new _ArrayValidator();
+    if ("nullable" in definition) {
+      if (!import_json5.JSON.isBoolean(definition["nullable"]))
+        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
+      if (definition["nullable"])
+        validatorInstance._nullable = import_option4.Option.Some(null);
+    }
+    if ("min" in definition) {
+      if (!import_json5.JSON.isNumber(definition["min"]))
+        throw new DefinitionError(`Expected ${path}.min to be a Number`);
+      validatorInstance._min = import_option4.Option.Some(definition["min"]);
+    }
+    if ("max" in definition) {
+      if (!import_json5.JSON.isNumber(definition["max"]))
+        throw new DefinitionError(`Expected ${path}.max to be a Number`);
+      validatorInstance._max = import_option4.Option.Some(definition["max"]);
+    }
+    if ("every" in definition)
+      validatorInstance._every = import_option4.Option.Some(fromJSON(definition["every"], `${path}.every`));
+    if ("tuple" in definition) {
+      if (!import_json5.JSON.isShallowArray(definition["tuple"]))
+        throw new DefinitionError(`Expected ${path}.tuple to be an Array`);
+      const tupleSchemas = [];
+      const errors = [];
+      definition["tuple"].forEach((tupleDef, index) => {
+        try {
+          tupleSchemas.push(fromJSON(tupleDef, `${path}.tuple[${index}]`));
+        } catch (e) {
+          if (!(e instanceof DefinitionError))
+            throw new DefinitionError(`Fatal Error: Undefined Error thrown by Domain.fromJSON at ${path}`);
+          errors.push(e);
+        }
+      });
+      if (errors.length > 0)
+        throw new DefinitionError(`Multiple Definition Errors detected at ${path} (see cause)`, { cause: errors });
+      validatorInstance._tuple = import_option4.Option.Some(tupleSchemas);
+    }
+    return validatorInstance;
+  }
+  _nullable = import_option4.Option.None();
+  _every = import_option4.Option.None();
+  _tuple = import_option4.Option.None();
+  _min = import_option4.Option.None();
+  _max = import_option4.Option.None();
+  assert(data, path = "data") {
+    if (import_json5.JSON.isShallowArray(data)) {
+      if (this._min.isSome() && this._min.value > data.length)
+        throw new AssertError(`Expected ${path} to be at least ${this._min.value} Elements long`);
+      if (this._max.isSome() && this._max.value < data.length)
+        throw new AssertError(`Expected ${path} to be at most ${this._max.value} Elements long`);
+      const errors = [];
+      if (this._every.isSome()) {
+        const validator = this._every.value;
+        data.forEach((value, index) => {
+          try {
+            validator.assert(value, `${path}[${index}]`);
+          } catch (e) {
+            if (!(e instanceof AssertError))
+              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
+            errors.push(e);
+          }
+        });
+      }
+      if (this._tuple.isSome()) {
+        if (data.length < this._tuple.value.length)
+          throw new AssertError(`Expected ${path} to be at least ${this._tuple.value.length} Elements long (Tuple Constraint)`);
+        this._tuple.value.forEach((validator, index) => {
+          try {
+            validator.assert(data[index], `${path}[${index}]`);
+          } catch (e) {
+            if (!(e instanceof AssertError))
+              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
+            errors.push(e);
+          }
+        });
+      }
+      if (errors.length > 0)
+        throw new AssertError(`Multiple Errors while asserting ${path} (see cause)`, { cause: errors });
+    } else if (import_json5.JSON.isNull(data)) {
+      if (!this._nullable.isSome())
+        throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
+    } else
+      throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
+  }
+  isSubset(other) {
+    if (other instanceof JSONValidator)
+      return true;
+    if (!(other instanceof _ArrayValidator))
+      return false;
+    if (this._nullable.isSome() && !other._nullable.isSome())
+      return false;
+    const thisTupleLen = this._tuple.isSome() ? this._tuple.value.length : 0;
+    const otherTupleLen = other._tuple.isSome() ? other._tuple.value.length : 0;
+    const thisMin = this._min.isSome() ? this._min.value : 0;
+    const otherMin = other._min.isSome() ? other._min.value : 0;
+    const thisMax = this._max.isSome() ? this._max.value : Infinity;
+    const otherMax = other._max.isSome() ? other._max.value : Infinity;
+    const thisEffectiveMin = Math.max(thisMin, thisTupleLen);
+    const otherEffectiveMin = Math.max(otherMin, otherTupleLen);
+    if (thisEffectiveMin < otherEffectiveMin)
+      return false;
+    if (thisMax > otherMax)
+      return false;
+    const indexConjuncts = (i) => {
+      const conjuncts = [];
+      if (this._every.isSome())
+        conjuncts.push(this._every.value);
+      if (this._tuple.isSome() && i < this._tuple.value.length)
+        conjuncts.push(this._tuple.value[i]);
+      return conjuncts;
+    };
+    const conjunctsSubset = (conjuncts, target) => {
+      if (conjuncts.length === 0)
+        return false;
+      return conjuncts.some((c) => c.isSubset(target));
+    };
+    if (other._tuple.isSome()) {
+      for (let i = 0; i < other._tuple.value.length; i++) {
+        const aConj = indexConjuncts(i);
+        if (!conjunctsSubset(aConj, other._tuple.value[i]))
+          return false;
+        if (other._every.isSome() && !conjunctsSubset(aConj, other._every.value))
+          return false;
+      }
+    }
+    return !(other._every.isSome() && (thisMax === Infinity ? true : thisMax > Math.max(thisTupleLen, otherTupleLen)) && (!this._every.isSome() || !this._every.value.isSubset(other._every.value)));
+  }
+  isEquals(other) {
+    if (!(other instanceof _ArrayValidator))
+      return false;
+    return this._nullable.equals(other._nullable) && this._min.equals(other._min) && this._max.equals(other._max) && this._every.equals(other._every, (a, b) => a.isEquals(b)) && this._tuple.equals(other._tuple, (a, b) => {
+      if (a.length !== b.length)
+        return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!a[i].isEquals(b[i]))
+          return false;
+      }
+      return true;
+    });
+  }
+  toJSON() {
+    const definition = { type: "array" };
+    if (this._nullable.isSome())
+      definition.nullable = true;
+    if (this._min.isSome())
+      definition.min = this._min.value;
+    if (this._max.isSome())
+      definition.max = this._max.value;
+    if (this._every.isSome())
+      definition.every = this._every.value.toJSON();
+    if (this._tuple.isSome())
+      definition.tuple = this._tuple.value.map((validator) => validator.toJSON());
+    return definition;
+  }
+};
+
+// src/Validators/Object.ts
+var import_json6 = __toESM(require_build());
+var import_option5 = __toESM(require_Option());
 var ObjectValidator = class _ObjectValidator extends Validator {
   static fromJSON(definition, path = "definition") {
     const validatorInstance = new _ObjectValidator();
     if ("nullable" in definition) {
-      if (!import_json5.JSON.isBoolean(definition["nullable"]))
+      if (!import_json6.JSON.isBoolean(definition["nullable"]))
         throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
+      if (definition["nullable"])
+        validatorInstance._nullable = import_option5.Option.Some(null);
     }
     if ("exact" in definition) {
-      if (!import_json5.JSON.isBoolean(definition["exact"]))
+      if (!import_json6.JSON.isBoolean(definition["exact"]))
         throw new DefinitionError(`Expected ${path}.exact to be a Boolean`);
-      validatorInstance.exact(definition["exact"], `${path}.exact`);
+      if (definition["exact"])
+        validatorInstance._exact = import_option5.Option.Some(null);
     }
     if ("min" in definition) {
-      if (!import_json5.JSON.isNumber(definition["min"]))
+      if (!import_json6.JSON.isNumber(definition["min"]))
         throw new DefinitionError(`Expected ${path}.min to be a Number`);
-      validatorInstance.min(definition["min"], `${path}.min`);
+      validatorInstance._min = import_option5.Option.Some(definition["min"]);
     }
     if ("max" in definition) {
-      if (!import_json5.JSON.isNumber(definition["max"]))
+      if (!import_json6.JSON.isNumber(definition["max"]))
         throw new DefinitionError(`Expected ${path}.max to be a Number`);
-      validatorInstance.max(definition["max"], `${path}.max`);
-    }
-    if ("every" in definition) {
-      validatorInstance.every(fromJSON(definition["every"], `${path}.every`));
+      validatorInstance._max = import_option5.Option.Some(definition["max"]);
     }
+    if ("every" in definition)
+      validatorInstance._every = import_option5.Option.Some(fromJSON(definition["every"], `${path}.every`));
     if ("shape" in definition) {
-      if (!import_json5.JSON.isShallowObject(definition["shape"]))
+      if (!import_json6.JSON.isShallowObject(definition["shape"]))
         throw new DefinitionError(`Expected ${path}.shape to be an Object`);
       const shape = {};
       const errors = [];
@@ -651,68 +707,18 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       if (errors.length > 0) {
         throw new DefinitionError(`Multiple Definition Errors detected at ${path}.shape (see cause)`, { cause: errors });
       }
-      validatorInstance.shape(shape, `${path}.shape`);
+      validatorInstance._shape = import_option5.Option.Some(shape);
     }
     return validatorInstance;
   }
-  _nullable = import_option4.Option.None();
-  _min = import_option4.Option.None();
-  _max = import_option4.Option.None();
-  _every = import_option4.Option.None();
-  _shape = import_option4.Option.None();
-  _exact = import_option4.Option.None();
-  nullable(flag) {
-    this._nullable = flag ?? true ? import_option4.Option.Some(null) : import_option4.Option.None();
-    return this;
-  }
-  min(value, path = "min") {
-    if (this._max.isSome() && this._max.value < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Maximum Rule at Path ${path}`);
-    if (this._shape.isSome() && value < Object.keys(this._shape.value).length)
-      throw new DefinitionError(`Expected Minimum Rule to be larger than or equal to Shape Key Count at Path ${path}`);
-    if (this._exact.isSome() && this._shape.isSome() && value > Object.keys(this._shape.value).length)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Shape Key Count due to Exact Rule at Path ${path}`);
-    this._min = import_option4.Option.Some(value);
-    return this;
-  }
-  max(value, path = "max") {
-    if (this._min.isSome() && this._min.value > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
-    if (this._shape.isSome() && value < Object.keys(this._shape.value).length)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Shape Key Count at Path ${path}`);
-    this._max = import_option4.Option.Some(value);
-    return this;
-  }
-  every(validator) {
-    this._every = import_option4.Option.Some(validator);
-    return this;
-  }
-  shape(value, path = "shape") {
-    const shapeKeyCount = Object.keys(value).length;
-    if (this._min.isSome() && this._min.value < shapeKeyCount)
-      throw new DefinitionError(`Expected Shape Key Count to be smaller than or equal to Minimum Rule at Path ${path}`);
-    if (this._max.isSome() && this._max.value < shapeKeyCount)
-      throw new DefinitionError(`Expected Shape Key Count to be smaller than or equal to Maximum Rule at Path ${path}`);
-    if (this._exact.isSome() && this._min.isSome() && this._min.value > shapeKeyCount)
-      throw new DefinitionError(`Expected Shape Key Count to be larger than or equal to Minimum Rule due to Exact Rule at Path ${path}`);
-    if (this._exact.isSome() && this._max.isSome() && this._max.value < shapeKeyCount)
-      throw new DefinitionError(`Expected Shape Key Count to be smaller than or equal to Maximum Rule due to Exact Rule at Path ${path}`);
-    this._shape = import_option4.Option.Some(value);
-    return this;
-  }
-  exact(flag, path = "exact") {
-    if ((flag ?? true) && this._shape.isSome()) {
-      const shapeKeyCount = Object.keys(this._shape.value).length;
-      if (this._min.isSome() && this._min.value > shapeKeyCount)
-        throw new DefinitionError(`Expected Exact Rule to be false due to Minimum Rule requiring more Properties than Shape defines at Path ${path}`);
-      if (this._max.isSome() && this._max.value < shapeKeyCount)
-        throw new DefinitionError(`Expected Exact Rule to be false due to Maximum Rule allowing fewer Properties than Shape defines at Path ${path}`);
-    }
-    this._exact = flag ?? true ? import_option4.Option.Some(null) : import_option4.Option.None();
-    return this;
-  }
+  _nullable = import_option5.Option.None();
+  _min = import_option5.Option.None();
+  _max = import_option5.Option.None();
+  _every = import_option5.Option.None();
+  _shape = import_option5.Option.None();
+  _exact = import_option5.Option.None();
   assert(data, path = "data") {
-    if (import_json5.JSON.isShallowObject(data)) {
+    if (import_json6.JSON.isShallowObject(data)) {
       const keys = Object.keys(data);
       if (this._min.isSome() && keys.length < this._min.value)
         throw new AssertError(`Expected ${path} to have at least ${this._min.value} Properties`);
@@ -752,7 +758,7 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       }
       if (errors.length > 0)
         throw new AssertError(`Multiple Errors while asserting ${path} (see cause)`, { cause: errors });
-    } else if (import_json5.JSON.isNull(data)) {
+    } else if (import_json6.JSON.isNull(data)) {
       if (!this._nullable.isSome())
         throw new AssertError(`Expected ${path} to be an Object${this._nullable.isSome() ? " or Null" : ""}`);
     } else
@@ -827,35 +833,17 @@ var ObjectValidator = class _ObjectValidator extends Validator {
   isEquals(other) {
     if (!(other instanceof _ObjectValidator))
       return false;
-    if (this._nullable.isSome() !== other._nullable.isSome())
-      return false;
-    if (this._min.isSome() !== other._min.isSome())
-      return false;
-    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
-      return false;
-    if (this._max.isSome() !== other._max.isSome())
-      return false;
-    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
-      return false;
-    if (this._every.isSome() !== other._every.isSome())
-      return false;
-    if (this._every.isSome() && other._every.isSome())
-      return isEquals(this._every.value, other._every.value);
-    if (this._shape.isSome() !== other._shape.isSome())
-      return false;
-    if (this._shape.isSome() && other._shape.isSome()) {
-      if (Object.keys(this._shape.value).length !== Object.keys(other._shape.value).length)
+    return this._nullable.equals(other._nullable) && this._min.equals(other._min) && this._max.equals(other._max) && this._exact.equals(other._exact) && this._every.equals(other._every, (a, b) => a.isEquals(b)) && this._shape.equals(other._shape, (a, b) => {
+      const keysA = Object.keys(a);
+      const keysB = Object.keys(b);
+      if (keysA.length !== keysB.length)
         return false;
-      for (const [k, v] of Object.entries(this._shape.value)) {
-        if (!(other._shape.value[k] instanceof Validator))
-          return false;
-        if (!isEquals(v, other._shape.value[k]))
+      for (const key of keysA) {
+        if (!(key in b) || !a[key]?.isEquals(b[key]))
           return false;
       }
-    }
-    if (this._exact.isSome() !== other._exact.isSome())
-      return false;
-    return true;
+      return true;
+    });
   }
   toJSON() {
     const schema = { type: "object" };
@@ -878,238 +866,6 @@ var ObjectValidator = class _ObjectValidator extends Validator {
   }
 };
 
-// src/lib/isEquals.ts
-function isEquals(a, b) {
-  if (a instanceof JSONValidator)
-    return a.isEquals(b);
-  if (a instanceof BooleanValidator)
-    return a.isEquals(b);
-  if (a instanceof NumberValidator)
-    return a.isEquals(b);
-  if (a instanceof StringValidator)
-    return a.isEquals(b);
-  if (a instanceof ArrayValidator)
-    return a.isEquals(b);
-  if (a instanceof ObjectValidator)
-    return a.isEquals(b);
-  return false;
-}
-
-// src/validators/Array.ts
-var ArrayValidator = class _ArrayValidator extends Validator {
-  static fromJSON(definition, path = "definition") {
-    const validatorInstance = new _ArrayValidator();
-    if ("nullable" in definition) {
-      if (!import_json6.JSON.isBoolean(definition["nullable"]))
-        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
-    }
-    if ("min" in definition) {
-      if (!import_json6.JSON.isNumber(definition["min"]))
-        throw new DefinitionError(`Expected ${path}.min to be a Number`);
-      validatorInstance.min(definition["min"], `${path}.min`);
-    }
-    if ("max" in definition) {
-      if (!import_json6.JSON.isNumber(definition["max"]))
-        throw new DefinitionError(`Expected ${path}.max to be a Number`);
-      validatorInstance.max(definition["max"], `${path}.max`);
-    }
-    if ("every" in definition) {
-      if (!import_json6.JSON.isObject(definition["every"]))
-        throw new DefinitionError(`Expected ${path}.every to be an Object`);
-      validatorInstance.every(
-        fromJSON(definition["every"], `${path}.every`)
-      );
-    }
-    if ("tuple" in definition) {
-      if (!import_json6.JSON.isShallowArray(definition["tuple"]))
-        throw new DefinitionError(`Expected ${path}.tuple to be an Array`);
-      const tupleSchemas = [];
-      const errors = [];
-      definition["tuple"].forEach((tupleDef, index) => {
-        try {
-          tupleSchemas.push(fromJSON(tupleDef, `${path}.tuple[${index}]`));
-        } catch (e) {
-          if (!(e instanceof DefinitionError))
-            throw new DefinitionError(`Fatal Error: Undefined Error thrown by Domain.fromJSON at ${path}`);
-          errors.push(e);
-        }
-      });
-      if (errors.length > 0)
-        throw new DefinitionError(`Multiple Definition Errors detected at ${path} (see cause)`, { cause: errors });
-      validatorInstance.tuple(tupleSchemas, `${path}.tuple`);
-    }
-    return validatorInstance;
-  }
-  _nullable = import_option5.Option.None();
-  _every = import_option5.Option.None();
-  _tuple = import_option5.Option.None();
-  _min = import_option5.Option.None();
-  _max = import_option5.Option.None();
-  nullable(flag) {
-    this._nullable = flag ?? true ? import_option5.Option.Some(null) : import_option5.Option.None();
-    return this;
-  }
-  min(value, path = "min") {
-    if (this._max.isSome() && this._max.value < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Maximum Rule at Path ${path}`);
-    if (this._tuple.isSome() && value < this._tuple.value.length)
-      throw new DefinitionError(`Expected Minimum Rule to be larger than or equal to Tuple Length at Path ${path}`);
-    this._min = import_option5.Option.Some(value);
-    return this;
-  }
-  max(value, path = "max") {
-    if (this._min.isSome() && this._min.value > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
-    if (this._tuple.isSome() && value < this._tuple.value.length)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Tuple Length at Path ${path}`);
-    this._max = import_option5.Option.Some(value);
-    return this;
-  }
-  every(validator) {
-    this._every = import_option5.Option.Some(validator);
-    return this;
-  }
-  /**
-   * Applies ONLY to prefix indices [0..validators.length - 1]
-   * If every() is set, prefix elements are effectively `T[i] & E`.
-   */
-  tuple(validators, path = "tuple") {
-    if (this._min.isSome() && this._min.value < validators.length)
-      throw new DefinitionError(`Expected Tuple Length to be smaller than or equal to Minimum Rule at Path ${path}`);
-    if (this._max.isSome() && this._max.value < validators.length)
-      throw new DefinitionError(`Expected Tuple Length to be smaller than or equal to Maximum Rule at Path ${path}`);
-    this._tuple = import_option5.Option.Some(validators);
-    return this;
-  }
-  assert(data, path = "data") {
-    if (import_json6.JSON.isShallowArray(data)) {
-      if (this._min.isSome() && this._min.value > data.length)
-        throw new AssertError(`Expected ${path} to be at least ${this._min.value} Elements long`);
-      if (this._max.isSome() && this._max.value < data.length)
-        throw new AssertError(`Expected ${path} to be at most ${this._max.value} Elements long`);
-      const errors = [];
-      if (this._every.isSome()) {
-        const validator = this._every.value;
-        data.forEach((value, index) => {
-          try {
-            validator.assert(value, `${path}[${index}]`);
-          } catch (e) {
-            if (!(e instanceof AssertError))
-              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
-            errors.push(e);
-          }
-        });
-      }
-      if (this._tuple.isSome()) {
-        if (data.length < this._tuple.value.length)
-          throw new AssertError(`Expected ${path} to be at least ${this._tuple.value.length} Elements long (Tuple Constraint)`);
-        this._tuple.value.forEach((validator, index) => {
-          try {
-            validator.assert(data[index], `${path}[${index}]`);
-          } catch (e) {
-            if (!(e instanceof AssertError))
-              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
-            errors.push(e);
-          }
-        });
-      }
-      if (errors.length > 0)
-        throw new AssertError(`Multiple Errors while asserting ${path} (see cause)`, { cause: errors });
-    } else if (import_json6.JSON.isNull(data)) {
-      if (!this._nullable.isSome())
-        throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
-    } else
-      throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
-  }
-  isSubset(other) {
-    if (other instanceof JSONValidator)
-      return true;
-    if (!(other instanceof _ArrayValidator))
-      return false;
-    if (this._nullable.isSome() && !other._nullable.isSome())
-      return false;
-    const thisTupleLen = this._tuple.isSome() ? this._tuple.value.length : 0;
-    const otherTupleLen = other._tuple.isSome() ? other._tuple.value.length : 0;
-    const thisMin = this._min.isSome() ? this._min.value : 0;
-    const otherMin = other._min.isSome() ? other._min.value : 0;
-    const thisMax = this._max.isSome() ? this._max.value : Infinity;
-    const otherMax = other._max.isSome() ? other._max.value : Infinity;
-    const thisEffectiveMin = Math.max(thisMin, thisTupleLen);
-    const otherEffectiveMin = Math.max(otherMin, otherTupleLen);
-    if (thisEffectiveMin < otherEffectiveMin)
-      return false;
-    if (thisMax > otherMax)
-      return false;
-    const indexConjuncts = (i) => {
-      const conjuncts = [];
-      if (this._every.isSome())
-        conjuncts.push(this._every.value);
-      if (this._tuple.isSome() && i < this._tuple.value.length)
-        conjuncts.push(this._tuple.value[i]);
-      return conjuncts;
-    };
-    const conjunctsSubset = (conjuncts, target) => {
-      if (conjuncts.length === 0)
-        return false;
-      return conjuncts.some((c) => c.isSubset(target));
-    };
-    if (other._tuple.isSome()) {
-      for (let i = 0; i < other._tuple.value.length; i++) {
-        const aConj = indexConjuncts(i);
-        if (!conjunctsSubset(aConj, other._tuple.value[i]))
-          return false;
-        if (other._every.isSome() && !conjunctsSubset(aConj, other._every.value))
-          return false;
-      }
-    }
-    return !(other._every.isSome() && (thisMax === Infinity ? true : thisMax > Math.max(thisTupleLen, otherTupleLen)) && (!this._every.isSome() || !this._every.value.isSubset(other._every.value)));
-  }
-  isEquals(other) {
-    if (!(other instanceof _ArrayValidator))
-      return false;
-    if (this._nullable.isSome() !== other._nullable.isSome())
-      return false;
-    if (this._min.isSome() !== other._min.isSome())
-      return false;
-    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
-      return false;
-    if (this._max.isSome() !== other._max.isSome())
-      return false;
-    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
-      return false;
-    if (this._every.isSome() !== other._every.isSome())
-      return false;
-    if (this._every.isSome() && other._every.isSome() && !isEquals(this._every.value, other._every.value))
-      return false;
-    if (this._tuple.isSome() !== other._tuple.isSome())
-      return false;
-    if (this._tuple.isSome() && other._tuple.isSome()) {
-      if (this._tuple.value.length !== other._tuple.value.length)
-        return false;
-      for (let i = 0; i < this._tuple.value.length; i++) {
-        if (!isEquals(this._tuple.value[i], other._tuple.value[i]))
-          return false;
-      }
-    }
-    return true;
-  }
-  toJSON() {
-    const definition = { type: "array" };
-    if (this._nullable.isSome())
-      definition.nullable = true;
-    if (this._min.isSome())
-      definition.min = this._min.value;
-    if (this._max.isSome())
-      definition.max = this._max.value;
-    if (this._every.isSome())
-      definition.every = this._every.value.toJSON();
-    if (this._tuple.isSome())
-      definition.tuple = this._tuple.value.map((validator) => validator.toJSON());
-    return definition;
-  }
-};
-
 // src/lib/fromJSON.ts
 function fromJSON(definition, path) {
   if (!import_json7.JSON.isShallowObject(definition))
@@ -1134,31 +890,165 @@ function fromJSON(definition, path) {
   }
 }
 
+// src/Builders/JSON.ts
+var JSONBuilder = class extends JSONValidator {
+};
+
+// src/Builders/Boolean.ts
+var import_option6 = __toESM(require_Option());
+var BooleanBuilder = class extends BooleanValidator {
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option6.Option.Some(null) : import_option6.Option.None();
+    return this;
+  }
+  equals(value) {
+    this._equals = import_option6.Option.Some(value);
+    return this;
+  }
+};
+
+// src/Builders/Number.ts
+var import_option7 = __toESM(require_Option());
+var NumberBuilder = class extends NumberValidator {
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option7.Option.Some(null) : import_option7.Option.None();
+    return this;
+  }
+  equals(value) {
+    this._equals = import_option7.Option.Some(value);
+    return this;
+  }
+  integer(flag = true) {
+    this._integer = flag ? import_option7.Option.Some(null) : import_option7.Option.None();
+    return this;
+  }
+  min(value) {
+    this._min = import_option7.Option.Some(value);
+    return this;
+  }
+  max(value) {
+    this._max = import_option7.Option.Some(value);
+    return this;
+  }
+};
+
+// src/Builders/String.ts
+var import_option8 = __toESM(require_Option());
+var StringBuilder = class extends StringValidator {
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option8.Option.Some(null) : import_option8.Option.None();
+    return this;
+  }
+  equals(value) {
+    this._equals = import_option8.Option.Some(value);
+    return this;
+  }
+  min(value) {
+    this._min = import_option8.Option.Some(value);
+    return this;
+  }
+  max(value) {
+    this._max = import_option8.Option.Some(value);
+    return this;
+  }
+};
+
+// src/Builders/Array.ts
+var import_option9 = __toESM(require_Option());
+var ArrayBuilder = class extends ArrayValidator {
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option9.Option.Some(null) : import_option9.Option.None();
+    return this;
+  }
+  min(value) {
+    this._min = import_option9.Option.Some(value);
+    return this;
+  }
+  max(value) {
+    this._max = import_option9.Option.Some(value);
+    return this;
+  }
+  every(validator) {
+    this._every = import_option9.Option.Some(validator);
+    return this;
+  }
+  tuple(validators) {
+    this._tuple = import_option9.Option.Some(validators);
+    return this;
+  }
+};
+
+// src/Builders/Object.ts
+var import_option10 = __toESM(require_Option());
+var ObjectBuilder = class extends ObjectValidator {
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option10.Option.Some(null) : import_option10.Option.None();
+    return this;
+  }
+  min(value) {
+    this._min = import_option10.Option.Some(value);
+    return this;
+  }
+  max(value) {
+    this._max = import_option10.Option.Some(value);
+    return this;
+  }
+  every(validator) {
+    this._every = import_option10.Option.Some(validator);
+    return this;
+  }
+  shape(value) {
+    this._shape = import_option10.Option.Some(value);
+    return this;
+  }
+  exact(flag) {
+    this._exact = flag ?? true ? import_option10.Option.Some(null) : import_option10.Option.None();
+    return this;
+  }
+};
+
 // src/index.ts
 var Schema = class {
+  // Static Factories for Builders
   static get JSON() {
-    return new JSONValidator();
+    return new JSONBuilder();
   }
   static get Boolean() {
-    return new BooleanValidator();
+    return new BooleanBuilder();
   }
   static get Number() {
-    return new NumberValidator();
+    return new NumberBuilder();
   }
   static get String() {
-    return new StringValidator();
+    return new StringBuilder();
   }
   static get Array() {
-    return new ArrayValidator();
+    return new ArrayBuilder();
   }
   static get Object() {
-    return new ObjectValidator();
+    return new ObjectBuilder();
   }
+  // Static fromJSON. Returns a basic Validator with no Type Inference
   static fromJSON(definition, path = "definition") {
     return fromJSON(definition, path);
   }
-  static isEquals(a, b) {
-    return isEquals(a, b);
+  // Utility Method for Checking if a variable holds a valid Definition
+  static assertDefinition(definition, path = "definition") {
+    this.fromJSON(definition, path);
+  }
+  // Utility Method for validating a Definition
+  static validateDefinition(definition, path = "definition") {
+    this.assertDefinition(definition, path);
+    return definition;
+  }
+  // Utility Method for Type-Guarding a Definition
+  static isDefinition(definition, path = "definition") {
+    try {
+      this.assertDefinition(definition, path);
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
 };
 var Validators = {
@@ -1169,8 +1059,17 @@ var Validators = {
   Array: ArrayValidator,
   Object: ObjectValidator
 };
+var Builders = {
+  JSON: JSONBuilder,
+  Boolean: BooleanBuilder,
+  Number: NumberBuilder,
+  String: StringBuilder,
+  Array: ArrayBuilder,
+  Object: ObjectBuilder
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Builders,
   Schema,
   Validator,
   Validators