@serum-enterprises/schema 3.2.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();
@@ -221,6 +227,9 @@ var JSONValidator = class _JSONValidator extends Validator {
   isSubset(other) {
     return other instanceof _JSONValidator;
   }
+  isEquals(other) {
+    return other instanceof _JSONValidator;
+  }
   toJSON() {
     return {
       type: "json"
@@ -228,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 {
@@ -237,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)
@@ -281,6 +283,11 @@ var BooleanValidator = class _BooleanValidator extends Validator {
     }
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _BooleanValidator))
+      return false;
+    return this._nullable.equals(other._nullable) && this._equals.equals(other._equals);
+  }
   toJSON() {
     const definition = {
       type: "boolean"
@@ -293,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 {
@@ -302,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)
@@ -411,6 +384,11 @@ var NumberValidator = class _NumberValidator extends Validator {
       return false;
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _NumberValidator))
+      return false;
+    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 = {
       type: "number"
@@ -429,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 {
@@ -438,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)
@@ -531,6 +478,11 @@ var StringValidator = class _StringValidator extends Validator {
       return false;
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _StringValidator))
+      return false;
+    return this._nullable.equals(other._nullable) && this._min.equals(other._min) && this._max.equals(other._max) && this._equals.equals(other._equals);
+  }
   toJSON() {
     const definition = {
       type: "string"
@@ -547,7 +499,7 @@ var StringValidator = class _StringValidator extends Validator {
   }
 };
 
-// src/validators/Array.ts
+// src/Validators/Array.ts
 var import_json5 = __toESM(require_build());
 var import_option4 = __toESM(require_Option());
 var ArrayValidator = class _ArrayValidator extends Validator {
@@ -556,25 +508,21 @@ var ArrayValidator = class _ArrayValidator extends Validator {
     if ("nullable" in definition) {
       if (!import_json5.JSON.isBoolean(definition["nullable"]))
         throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
+      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(definition["min"], `${path}.min`);
+      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(definition["max"], `${path}.max`);
-    }
-    if ("every" in definition) {
-      if (!import_json5.JSON.isObject(definition["every"]))
-        throw new DefinitionError(`Expected ${path}.every to be an Object`);
-      validatorInstance.every(
-        fromJSON(definition["every"], `${path}.every`)
-      );
+      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`);
@@ -591,7 +539,7 @@ var ArrayValidator = class _ArrayValidator extends Validator {
       });
       if (errors.length > 0)
         throw new DefinitionError(`Multiple Definition Errors detected at ${path} (see cause)`, { cause: errors });
-      validatorInstance.tuple(tupleSchemas, `${path}.tuple`);
+      validatorInstance._tuple = import_option4.Option.Some(tupleSchemas);
     }
     return validatorInstance;
   }
@@ -600,42 +548,6 @@ var ArrayValidator = class _ArrayValidator extends Validator {
   _tuple = import_option4.Option.None();
   _min = import_option4.Option.None();
   _max = 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._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_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._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_option4.Option.Some(value);
-    return this;
-  }
-  every(validator) {
-    this._every = import_option4.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_option4.Option.Some(validators);
-    return this;
-  }
   assert(data, path = "data") {
     if (import_json5.JSON.isShallowArray(data)) {
       if (this._min.isSome() && this._min.value > data.length)
@@ -719,6 +631,19 @@ var ArrayValidator = class _ArrayValidator extends Validator {
     }
     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())
@@ -735,7 +660,7 @@ var ArrayValidator = class _ArrayValidator extends Validator {
   }
 };
 
-// src/validators/Object.ts
+// src/Validators/Object.ts
 var import_json6 = __toESM(require_build());
 var import_option5 = __toESM(require_Option());
 var ObjectValidator = class _ObjectValidator extends Validator {
@@ -744,26 +669,27 @@ var ObjectValidator = class _ObjectValidator extends Validator {
     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 (definition["nullable"])
+        validatorInstance._nullable = import_option5.Option.Some(null);
     }
     if ("exact" in definition) {
       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_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_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_json6.JSON.isShallowObject(definition["shape"]))
         throw new DefinitionError(`Expected ${path}.shape to be an Object`);
@@ -781,7 +707,7 @@ 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;
   }
@@ -791,56 +717,6 @@ var ObjectValidator = class _ObjectValidator extends Validator {
   _every = import_option5.Option.None();
   _shape = import_option5.Option.None();
   _exact = 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._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_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._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_option5.Option.Some(value);
-    return this;
-  }
-  every(validator) {
-    this._every = import_option5.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_option5.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_option5.Option.Some(null) : import_option5.Option.None();
-    return this;
-  }
   assert(data, path = "data") {
     if (import_json6.JSON.isShallowObject(data)) {
       const keys = Object.keys(data);
@@ -954,6 +830,21 @@ var ObjectValidator = class _ObjectValidator extends Validator {
     }
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _ObjectValidator))
+      return false;
+    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 key of keysA) {
+        if (!(key in b) || !a[key]?.isEquals(b[key]))
+          return false;
+      }
+      return true;
+    });
+  }
   toJSON() {
     const schema = { type: "object" };
     if (this._nullable.isSome())
@@ -999,36 +890,158 @@ 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);
   }
+  // 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);
@@ -1046,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