@amazon/vinyl-validation 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1325 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArraySchema: () => ArraySchema,
+  FunctionSchema: () => FunctionSchema,
+  NumberSchema: () => NumberSchema,
+  ObjectSchema: () => ObjectSchema,
+  RecordSchema: () => RecordSchema,
+  SchemaBase: () => SchemaBase,
+  SetSchema: () => SetSchema,
+  StringSchema: () => StringSchema,
+  ValueSchema: () => ValueSchema,
+  andValidators: () => andValidators,
+  any: () => any,
+  array: () => array,
+  arrayValidators: () => arrayValidators,
+  boolean: () => boolean,
+  createDeepValidator: () => createDeepValidator,
+  createValidationExpectationMessage: () => createValidationExpectationMessage,
+  createValidator: () => createValidator,
+  custom: () => custom,
+  enumOf: () => enumOf,
+  exactlyNull: () => exactlyNull,
+  exactlyUndefined: () => exactlyUndefined,
+  func: () => func,
+  functionValidators: () => functionValidators,
+  instanceOf: () => instanceOf,
+  isOneOf: () => isOneOf,
+  isValidatorWithPartial: () => isValidatorWithPartial,
+  maybeToDeepPartial: () => maybeToDeepPartial,
+  maybeToPartial: () => maybeToPartial,
+  nullish: () => nullish,
+  number: () => number,
+  numberValidators: () => numberValidators,
+  object: () => object,
+  objectValidators: () => objectValidators,
+  orValidators: () => orValidators,
+  record: () => record,
+  recordValidators: () => recordValidators,
+  recordValues: () => recordValues,
+  set: () => set,
+  setValidators: () => setValidators,
+  string: () => string,
+  stringValidators: () => stringValidators,
+  symbol: () => symbol,
+  tuple: () => tuple,
+  typeOfValidators: () => typeOfValidators,
+  valueValidators: () => valueValidators
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/validation/validators.ts
+var import_vinyl_util14 = require("@amazon/vinyl-util");
+
+// src/validation/ArraySchema.ts
+var import_vinyl_util6 = require("@amazon/vinyl-util");
+
+// src/validation/andValidators.ts
+var import_vinyl_util3 = require("@amazon/vinyl-util");
+
+// src/validation/Validator.ts
+var import_vinyl_util = require("@amazon/vinyl-util");
+var import_vinyl_util2 = require("@amazon/vinyl-util");
+var validatorLocale = {
+  /**
+   * The expectation template string with the following replacement tokens:
+   *
+   * `{expected}` - The expected description.
+   * `{actual}` - The actual value.
+   * `{path}` - The path, dot separated.
+   */
+  template: "Expected: {expected}, but was: {actual}. At: {path}"
+};
+function createValidationExpectationMessage(expectationMessage, input, path, inputStringify = (input2) => (0, import_vinyl_util2.stringifyForPrint)(input2, 500)) {
+  return (0, import_vinyl_util2.substitute)(validatorLocale.template, {
+    expected: expectationMessage,
+    actual: inputStringify(input),
+    path: path.join(".")
+  });
+}
+function createValidator(expectationMessage, isValid, inputStringify = (input) => (0, import_vinyl_util2.stringifyForPrint)(input, 500)) {
+  return {
+    description: expectationMessage,
+    isValid(input) {
+      return isValid(input);
+    },
+    validate(input, _, path = []) {
+      if (!isValid(input)) {
+        return [
+          {
+            message: createValidationExpectationMessage(
+              expectationMessage,
+              input,
+              path,
+              inputStringify
+            ),
+            path
+          }
+        ];
+      }
+      return [];
+    },
+    assert: (input, origin, path = []) => {
+      if (!isValid(input)) {
+        throw new import_vinyl_util.ValidationError(
+          createValidationExpectationMessage(
+            expectationMessage,
+            input,
+            path,
+            inputStringify
+          ),
+          origin,
+          path
+        );
+      }
+    }
+  };
+}
+function createDeepValidator(description, validate) {
+  return {
+    description,
+    isValid(input) {
+      return validate(input, { all: false }, []).length === 0;
+    },
+    validate(input, options, path = []) {
+      return validate(input, options != null ? options : { all: false }, path);
+    },
+    assert: (input, origin, path = []) => {
+      const errors = validate(input, { all: false }, path);
+      if (errors.length) {
+        const error = errors[0];
+        throw new import_vinyl_util.ValidationError(error.message, origin, error.path);
+      }
+    }
+  };
+}
+
+// src/validation/andValidators.ts
+var locale = {
+  /**
+   * {value} The child validators' descriptions, joined with `separator`.
+   *
+   * groupings of and validators is unimportant,
+   * and(and(a, b), c) is the same as and(a, and(b, c)), so `a & b & c` is an accurate
+   * representation for either.
+   */
+  template: "{value}",
+  /**
+   * The separator with which to join child validator descriptions.
+   */
+  separator: " & "
+};
+function andValidators(...validators) {
+  return createDeepValidator(
+    (0, import_vinyl_util3.substitute)(locale.template, {
+      value: validators.map((v) => v.description).join(locale.separator)
+    }),
+    (input, options, path) => {
+      for (const validator of validators) {
+        const errors = validator.validate(input, options, path);
+        if (errors.length) return errors;
+      }
+      return [];
+    }
+  );
+}
+
+// src/validation/orValidators.ts
+var import_vinyl_util4 = require("@amazon/vinyl-util");
+var locale2 = {
+  /**
+   * {value} - The child validators' descriptions, joined with `separator`.
+   */
+  template: "({value})",
+  /**
+   * The separator with which to join child validator descriptions.
+   */
+  separator: " | "
+};
+function orValidators(...validators) {
+  const description = (0, import_vinyl_util4.substitute)(locale2.template, {
+    value: validators.map((v) => v.description).join(locale2.separator)
+  });
+  return createDeepValidator(description, (input, options, path) => {
+    let longestErrors = [];
+    let longestPath = 0;
+    for (const validator of validators) {
+      const errors = validator.validate(input, options, path);
+      if (!errors.length) return errors;
+      const pathLength = errors.reduce(
+        (max, m) => Math.max(m.path.length, max),
+        0
+      );
+      if (pathLength >= longestPath) {
+        longestErrors = errors;
+        longestPath = pathLength;
+      }
+    }
+    return longestPath > path.length ? longestErrors : [
+      {
+        message: createValidationExpectationMessage(
+          description,
+          input,
+          path
+        ),
+        path
+      }
+    ];
+  });
+}
+
+// src/validation/SchemaBase.ts
+var import_vinyl_util5 = require("@amazon/vinyl-util");
+var requiredValidationOptions = {
+  optional: false
+};
+var SchemaBase = class {
+  constructor(currentValidator, previousSchema, operation) {
+    this.currentValidator = currentValidator;
+    this.previousSchema = previousSchema;
+    this.operation = operation;
+    __publicField(this, "__type", /* @__PURE__ */ (0, import_vinyl_util5.invariant)());
+    __publicField(this, "validator");
+    __publicField(this, "_options", requiredValidationOptions);
+    __publicField(this, "assert", (input, origin, path) => {
+      this.validator.assert(input, origin, path);
+    });
+    __publicField(this, "isValid", (input) => this.validator.isValid(input));
+    __publicField(this, "validate", (input, options, path) => this.validator.validate(input, options, path));
+    this.validator = operation == null ? currentValidator : operation(previousSchema, currentValidator);
+  }
+  get options() {
+    return this._options;
+  }
+  get description() {
+    return this.validator.description;
+  }
+  /**
+   * Clones this schema, transforming all validators with the given mutator.
+   *
+   * @param transform A transformer which takes an existing validator in the chain and returns
+   * a new one. Validators should be considered to be immutable; transform should not change the
+   * input but instead return a new validator.
+   */
+  clone(transform = (v) => v) {
+    const cloned = this.operation ? this.self(
+      transform(this.currentValidator),
+      this.previousSchema.clone(transform),
+      this.operation
+    ) : this.self(transform(this.currentValidator));
+    cloned._options = this._options;
+    return cloned;
+  }
+  self(current, previous, operation) {
+    if (this.constructor.length > 3) {
+      throw new import_vinyl_util5.IllegalArgumentError(
+        "constructor should have at most three required arguments"
+      );
+    }
+    return new this.constructor(current, previous, operation);
+  }
+  /**
+   * Constructs a new schema with a validator chaining the current validator with the
+   * provided next in an AND operation.
+   *
+   * @param nextValidator The validator to run after the current.
+   * @return Returns a new Schema instance the same class with a new validator chaining the
+   * current validator with the given next in an AND operation.
+   */
+  chain(nextValidator) {
+    return this.self(nextValidator, this, andValidators);
+  }
+  optional() {
+    const cloned = this.clone();
+    cloned._options = __spreadProps(__spreadValues({}, cloned.options), {
+      optional: true
+    });
+    return cloned;
+  }
+  required() {
+    const cloned = this.clone();
+    cloned._options = __spreadProps(__spreadValues({}, cloned.options), {
+      optional: false
+    });
+    return cloned;
+  }
+};
+
+// src/validation/ValueSchema.ts
+var locale3 = {
+  null: "null",
+  nullish: "nullish",
+  undefined: "undefined"
+};
+var valueValidators = {
+  any() {
+    return createValidator("", () => true);
+  },
+  /**
+   * Creates a validator that asserts that the input is nullish.
+   */
+  nullish() {
+    return createValidator(locale3.nullish, (input) => input == null);
+  },
+  /**
+   * Creates a validator that asserts that the input is strictly null.
+   */
+  null() {
+    return createValidator(locale3.null, (input) => input === null);
+  },
+  /**
+   * Creates a validator that asserts that the input is strictly undefined.
+   */
+  undefined() {
+    return createValidator(locale3.undefined, (input) => input === void 0);
+  }
+};
+var ValueSchema = class _ValueSchema extends SchemaBase {
+  /**
+   * Prepends this validator allowing for null or undefined.
+   */
+  maybe() {
+    return this.or(valueValidators.nullish());
+  }
+  /**
+   * Prepends this validator allowing for null.
+   */
+  orNull() {
+    return this.or(valueValidators.null());
+  }
+  /**
+   * Prepends this validator allowing for undefined.
+   */
+  orUndefined() {
+    return this.or(valueValidators.undefined());
+  }
+  /**
+   * Returns a validator that asserts if this validator and the next passes.
+   *
+   * @see andValidators
+   *
+   * @param nextValidator The validator to run after the current.
+   * @return Returns a new ValueSchema intersecting this validator and the next.
+   */
+  and(nextValidator) {
+    return new _ValueSchema(nextValidator, this, andValidators);
+  }
+  /**
+   * Returns a validator that asserts if this validator or the next passes.
+   *
+   * Implementation note:
+   * subclasses should not change the schema instance returned unless all chainable validators
+   * accept input type 'unknown'.
+   *
+   * @param nextValidator The validator to run after the current.
+   * @return Returns a new ValueSchema providing the union of this validator and the next.
+   */
+  or(nextValidator) {
+    return new _ValueSchema(nextValidator, this, orValidators);
+  }
+};
+
+// src/validation/ArraySchema.ts
+var locale4 = {
+  array: "array",
+  minLength: "at least {value} elements",
+  maxLength: "at most {value} elements",
+  exactlyLength: "exactly {value} elements",
+  actualLength: "length {value}",
+  withElements: "({value})[]",
+  tuple: "[{value}]"
+};
+var arrayValidators = {
+  /**
+   * Creates a validator that asserts that the input is an array.
+   *
+   * Note: arrays can only be readonly by type system, there is no native readonly
+   * js array. This validator assumes mutability, use the ArraySchema readonly() method
+   * to cast to a readonly array.
+   */
+  isArray() {
+    return createValidator(
+      locale4.array,
+      (input) => Array.isArray(input)
+    );
+  },
+  /**
+   * Creates a validator that asserts that every element passes the given validator.
+   *
+   * @param elementValidator
+   */
+  withElements(elementValidator) {
+    return createDeepValidator(
+      (0, import_vinyl_util6.substitute)(locale4.withElements, {
+        value: elementValidator.description
+      }),
+      (input, options, path) => {
+        const errors = [];
+        for (let i = 0; i < input.length; i++) {
+          const element = input[i];
+          errors.push(
+            ...elementValidator.validate(
+              element,
+              options,
+              path.concat(i.toString())
+            )
+          );
+          if (!options.all && errors.length) return errors;
+        }
+        return errors;
+      }
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input array is a tuple whose elements match
+   * the given validators.
+   *
+   * @param validators
+   */
+  tuple(...validators) {
+    const lengthValidator = createValidator(
+      (0, import_vinyl_util6.substitute)(locale4.exactlyLength, {
+        value: validators.length
+      }),
+      (length) => length === validators.length
+    );
+    return createDeepValidator(
+      (0, import_vinyl_util6.substitute)(locale4.tuple, { value: validators.join(", ") }),
+      (input, options, path) => {
+        const errors = [];
+        errors.push(
+          ...lengthValidator.validate(input.length, options, path)
+        );
+        if (!options.all && errors.length) return errors;
+        const n = Math.min(validators.length, input.length);
+        for (let i = 0; i < n; i++) {
+          const element = input[i];
+          const validator = validators[i];
+          errors.push(
+            ...validator.validate(
+              element,
+              options,
+              path.concat(i.toString())
+            )
+          );
+          if (!options.all && errors.length) return errors;
+        }
+        return errors;
+      }
+    );
+  },
+  /**
+   * Creates a validator that validates the input array has the given minimum length.
+   * @param min The minimum number of elements (inclusive)
+   */
+  minLength(min) {
+    return createValidator(
+      (0, import_vinyl_util6.substitute)(locale4.minLength, { value: min }),
+      (input) => input.length >= min,
+      (input) => (0, import_vinyl_util6.substitute)(locale4.actualLength, { value: input.length })
+    );
+  },
+  /**
+   *
+   * Creates a validator that validates the input array has the given maximum length.
+   * @param max The maximum number of elements (inclusive)
+   */
+  maxLength(max) {
+    return createValidator(
+      (0, import_vinyl_util6.substitute)(locale4.maxLength, { value: max }),
+      (input) => input.length <= max,
+      (input) => (0, import_vinyl_util6.substitute)(locale4.actualLength, { value: input.length })
+    );
+  }
+};
+var _ArraySchema = class _ArraySchema extends ValueSchema {
+  /**
+   * The base ArraySchema instance validating that the input is an Array.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _ArraySchema(arrayValidators.isArray());
+    return this._base;
+  }
+  /**
+   * Creates a validator that asserts that every element passes the given validator.
+   *
+   * @param elementValidator
+   */
+  withElements(elementValidator) {
+    return this.chain(arrayValidators.withElements(elementValidator));
+  }
+  /**
+   * Creates a validator that asserts that the input array is a tuple whose elements match
+   * the given validators.
+   *
+   * @param validators
+   */
+  tuple(...validators) {
+    return this.chain(arrayValidators.tuple(...validators));
+  }
+  /**
+   * Creates a validator that validates the input array has the given minimum length.
+   * @param min The minimum number of elements (inclusive)
+   */
+  minLength(min) {
+    return this.chain(arrayValidators.minLength(min));
+  }
+  /**
+   *
+   * Creates a validator that validates the input array has the given maximum length.
+   * @param max The maximum number of elements (inclusive)
+   */
+  maxLength(max) {
+    return this.chain(arrayValidators.maxLength(max));
+  }
+  /**
+   * Casts to a readonly array.
+   * This is a shallow cast, elements of the array will not be changed.
+   */
+  readonly() {
+    return this;
+  }
+  /**
+   * Casts the type parameter.
+   */
+  cast() {
+    return this;
+  }
+};
+__publicField(_ArraySchema, "_base", null);
+var ArraySchema = _ArraySchema;
+
+// src/validation/FunctionSchema.ts
+var import_vinyl_util8 = require("@amazon/vinyl-util");
+
+// src/validation/typeOfValidators.ts
+var import_vinyl_util7 = require("@amazon/vinyl-util");
+var locale5 = {
+  template: "type {value}"
+};
+function typeOfValidator(expected) {
+  return createValidator(
+    (0, import_vinyl_util7.substitute)(locale5.template, { value: expected }),
+    (input) => {
+      return input != null && typeof input === expected;
+    }
+  );
+}
+var typeOfValidatorCache = {};
+function cachedTypeOfValidator(type) {
+  if (!(type in typeOfValidatorCache)) {
+    typeOfValidatorCache[type] = typeOfValidator(type);
+  }
+  return typeOfValidatorCache[type];
+}
+var typeOfValidators = {
+  get boolean() {
+    return cachedTypeOfValidator("boolean");
+  },
+  get func() {
+    return cachedTypeOfValidator("function");
+  },
+  get number() {
+    return cachedTypeOfValidator("number");
+  },
+  get object() {
+    return cachedTypeOfValidator("object");
+  },
+  get string() {
+    return cachedTypeOfValidator("string");
+  },
+  get symbol() {
+    return cachedTypeOfValidator("symbol");
+  }
+};
+
+// src/validation/FunctionSchema.ts
+var locale6 = {
+  length: "at most {value} arguments",
+  actualLength: "{value} arguments"
+};
+var functionValidators = {
+  length(max) {
+    return createValidator(
+      (0, import_vinyl_util8.substitute)(locale6.length, { value: max }),
+      (input) => input.length <= max,
+      (input) => (0, import_vinyl_util8.substitute)(locale6.actualLength, { value: input.length })
+    );
+  }
+};
+var _FunctionSchema = class _FunctionSchema extends ValueSchema {
+  /**
+   * The base Function validator validating that the input is a function.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _FunctionSchema(typeOfValidators.func);
+    return this._base;
+  }
+  length(max) {
+    return this.chain(functionValidators.length(max));
+  }
+  /**
+   * Casts the function signature.
+   * Function signatures, except for their required number of parameters, cannot be
+   * meaningfully validated.
+   */
+  cast() {
+    return this;
+  }
+};
+__publicField(_FunctionSchema, "_base", null);
+var FunctionSchema = _FunctionSchema;
+
+// src/validation/SetSchema.ts
+var import_vinyl_util9 = require("@amazon/vinyl-util");
+var locale7 = {
+  set: "Set",
+  withElements: "Set<{value}>"
+};
+var setValidators = {
+  /**
+   * Creates a validator that asserts that the input is a set.
+   */
+  isSet() {
+    return createValidator(
+      locale7.set,
+      (input) => input instanceof Set
+    );
+  },
+  /**
+   * Creates a validator that asserts that every element passes the given validator.
+   *
+   * @param elementValidator
+   */
+  withElements(elementValidator) {
+    return createDeepValidator(
+      (0, import_vinyl_util9.substitute)(locale7.withElements, {
+        value: elementValidator.description
+      }),
+      (input, options, path) => {
+        const errors = [];
+        let i = 0;
+        for (const element of input) {
+          errors.push(
+            ...elementValidator.validate(
+              element,
+              options,
+              path.concat(i.toString())
+            )
+          );
+          if (!options.all && errors.length) return errors;
+          i++;
+        }
+        return errors;
+      }
+    );
+  }
+};
+var _SetSchema = class _SetSchema extends ValueSchema {
+  /**
+   * The base SetSchema instance validating that the input is a Set.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _SetSchema(setValidators.isSet());
+    return this._base;
+  }
+  /**
+   * Creates a validator that asserts that every element passes the given validator.
+   *
+   * @param elementValidator
+   */
+  withElements(elementValidator) {
+    return this.chain(setValidators.withElements(elementValidator));
+  }
+  /**
+   * Casts to a readonly set.
+   * This is a shallow cast, elements of the array will not be changed.
+   */
+  readonly() {
+    return this;
+  }
+  /**
+   * Casts the parameter type.
+   */
+  cast() {
+    return this;
+  }
+};
+__publicField(_SetSchema, "_base", null);
+var SetSchema = _SetSchema;
+
+// src/validation/NumberSchema.ts
+var import_vinyl_util10 = require("@amazon/vinyl-util");
+var locale8 = {
+  gte: "at least {value}",
+  gt: "greater than {value}",
+  lte: "at most {value}",
+  lt: "less than {value}",
+  within: "within {min} and {max}",
+  safeInteger: "safe integer",
+  finite: "finite"
+};
+var numberValidators = {
+  /**
+   * Creates a validator that asserts that the input number is at least the provided minimum
+   * value.
+   *
+   * @param min The minimum (inclusive) the value may be.
+   */
+  gte(min) {
+    return createValidator(
+      (0, import_vinyl_util10.substitute)(locale8.gte, { value: min }),
+      (input) => input >= min
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input number is greater than the provided minimum
+   * value.
+   *
+   * @param min The minimum (exclusive) the value may be.
+   */
+  gt(min) {
+    return createValidator(
+      (0, import_vinyl_util10.substitute)(locale8.gt, { value: min }),
+      (input) => input > min
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input number is at most the provided maximum
+   * value.
+   *
+   * @param max The maximum (inclusive) the value may be.
+   */
+  lte(max) {
+    return createValidator(
+      (0, import_vinyl_util10.substitute)(locale8.lte, { value: max }),
+      (input) => input <= max
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input number is less than the provided maximum
+   * value.
+   *
+   * @param max The maximum (exclusive) the value may be.
+   */
+  lt(max) {
+    return createValidator(
+      (0, import_vinyl_util10.substitute)(locale8.lt, { value: max }),
+      (input) => input < max
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input number is at least the provided minimum
+   * and at most the provided maximum values.
+   *
+   * @param min The minimum (inclusive) value the input may be.
+   * @param max The maximum (inclusive) value the input may be.
+   */
+  within(min, max) {
+    return createValidator(
+      (0, import_vinyl_util10.substitute)(locale8.within, { min, max }),
+      (input) => input >= min && input <= max
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input number is finite.
+   */
+  finite() {
+    return createValidator(locale8.finite, (input) => Number.isFinite(input));
+  },
+  /**
+   * Creates a validator that asserts that the input number is a safe integer.
+   */
+  safeInteger() {
+    return createValidator(
+      locale8.safeInteger,
+      (input) => Number.isSafeInteger(input)
+    );
+  }
+};
+var _NumberSchema = class _NumberSchema extends ValueSchema {
+  /**
+   * The base Object validator validating that the input is an object.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _NumberSchema(typeOfValidators.number);
+    return this._base;
+  }
+  /**
+   * Creates a validator that asserts that the input number is at least the provided minimum
+   * value.
+   *
+   * @param min The minimum (inclusive) the value may be.
+   */
+  gte(min) {
+    return this.chain(numberValidators.gte(min));
+  }
+  /**
+   * Creates a validator that asserts that the input number is greater than the provided minimum
+   * value.
+   *
+   * @param min The minimum (exclusive) the value may be.
+   */
+  gt(min) {
+    return this.chain(numberValidators.gt(min));
+  }
+  /**
+   * Creates a validator that asserts that the input number is at most the provided maximum
+   * value.
+   *
+   * @param max The maximum (inclusive) the value may be.
+   */
+  lte(max) {
+    return this.chain(numberValidators.lte(max));
+  }
+  /**
+   * Creates a validator that asserts that the input number is less than the provided maximum
+   * value.
+   *
+   * @param max The maximum (exclusive) the value may be.
+   */
+  lt(max) {
+    return this.chain(numberValidators.lt(max));
+  }
+  /**
+   * Creates a validator that asserts that the input number is at least the provided minimum
+   * and at most the provided maximum values.
+   *
+   * @param min The minimum (inclusive) value the input may be.
+   * @param max The maximum (inclusive) value the input may be.
+   */
+  within(min, max) {
+    return this.chain(numberValidators.within(min, max));
+  }
+  /**
+   * Creates a validator that asserts that the input number is finite.
+   */
+  finite() {
+    return this.chain(numberValidators.finite());
+  }
+  /**
+   * Creates a validator that asserts that the input number is a safe integer.
+   */
+  safeInteger() {
+    return this.chain(numberValidators.safeInteger());
+  }
+};
+__publicField(_NumberSchema, "_base", null);
+var NumberSchema = _NumberSchema;
+
+// src/validation/ObjectSchema.ts
+var import_vinyl_util11 = require("@amazon/vinyl-util");
+
+// src/validation/ValidatorWithPartial.ts
+function isValidatorWithPartial(validator) {
+  return "partial" in validator && "partialDeep" in validator;
+}
+function maybeToDeepPartial(validator) {
+  return isValidatorWithPartial(validator) ? validator.partialDeep() : validator;
+}
+function maybeToPartial(validator) {
+  return isValidatorWithPartial(validator) ? validator.partial() : validator;
+}
+
+// src/validation/ObjectSchema.ts
+var locale9 = {
+  extend: "{\n{body}\n}",
+  prop: "{key}: {value}",
+  propSeparator: ",\n",
+  indent: "  ",
+  required: `property '{key}' is required`
+};
+var objectValidators = {
+  /**
+   * Creates a validator that validates the input has properties that pass their respective
+   * validators.
+   *
+   * @param propertyValidators
+   */
+  properties(propertyValidators) {
+    const propertiesDescriptions = [];
+    const keys = (0, import_vinyl_util11.ownKeys)(propertyValidators);
+    for (const key of keys) {
+      const validator2 = propertyValidators[key];
+      propertiesDescriptions.push(
+        (0, import_vinyl_util11.substitute)(locale9.prop, {
+          key: String(key) + (validator2.options.optional ? "?" : ""),
+          value: validator2.description
+        })
+      );
+    }
+    const description = (0, import_vinyl_util11.substitute)(locale9.extend, {
+      body: propertiesDescriptions.join(locale9.propSeparator).split("\n").map((line) => locale9.indent + line).join("\n")
+    });
+    const validator = createDeepValidator(
+      description,
+      (input, options, path) => {
+        const errors = [];
+        for (const key of keys) {
+          const validator2 = propertyValidators[key];
+          if (key in input) {
+            const value = input[key];
+            errors.push(
+              ...validator2.validate(
+                value,
+                options,
+                path.concat(String(key))
+              )
+            );
+          } else {
+            if (!validator2.options.optional) {
+              errors.push({
+                message: (0, import_vinyl_util11.substitute)(locale9.required, { key }),
+                path: path.concat(String(key))
+              });
+            }
+          }
+          if (!options.all && errors.length) return errors;
+        }
+        return errors;
+      }
+    );
+    return (0, import_vinyl_util11.merge)(validator, {
+      partial() {
+        const optionalPropertyValidators = {};
+        for (const key of keys) {
+          optionalPropertyValidators[key] = propertyValidators[key].optional();
+        }
+        return objectValidators.properties(
+          optionalPropertyValidators
+        );
+      },
+      partialDeep() {
+        const optionalPropertyValidators = {};
+        for (const key of keys) {
+          optionalPropertyValidators[key] = maybeToDeepPartial(
+            propertyValidators[key].optional()
+          );
+        }
+        return objectValidators.properties(
+          optionalPropertyValidators
+        );
+      }
+    });
+  }
+};
+var _ObjectSchema = class _ObjectSchema extends ValueSchema {
+  /**
+   * The base Object validator validating that the input is an object.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _ObjectSchema(typeOfValidators.object);
+    return this._base;
+  }
+  /**
+   * Creates a validator that validates the input has properties that pass their respective
+   * validators.
+   *
+   * @param propertyValidators
+   */
+  extend(propertyValidators) {
+    return this.chain(objectValidators.properties(propertyValidators));
+  }
+  /**
+   * Allows all properties to be undefined.
+   */
+  partial() {
+    return this.clone(maybeToPartial);
+  }
+  /**
+   * Allows all recursive properties to be undefined.
+   */
+  partialDeep() {
+    return this.clone(maybeToDeepPartial);
+  }
+  /**
+   * Casts the type parameter.
+   */
+  cast() {
+    return this;
+  }
+};
+__publicField(_ObjectSchema, "_base", null);
+var ObjectSchema = _ObjectSchema;
+
+// src/validation/RecordSchema.ts
+var import_vinyl_util13 = require("@amazon/vinyl-util");
+
+// src/validation/StringSchema.ts
+var import_vinyl_util12 = require("@amazon/vinyl-util");
+var locale10 = {
+  notEmpty: "not empty",
+  minLength: "at least {value} characters",
+  maxLength: "at most {value} characters",
+  noWhitespace: "no whitespace characters",
+  matches: "matches {value}"
+};
+var stringValidators = {
+  /**
+   * Creates a validator that asserts that the input is not empty.
+   */
+  notEmpty() {
+    return createValidator(locale10.notEmpty, (input) => input !== "");
+  },
+  /**
+   * Creates a validator that asserts that the input string has at least the given minimum
+   * length.
+   *
+   * @param min The string must be at least this length.
+   */
+  minLength(min) {
+    return createValidator(
+      (0, import_vinyl_util12.substitute)(locale10.minLength, { value: min }),
+      (input) => input.length >= min
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input string has at most the given maximum
+   * length.
+   *
+   * @param max The string must be at most this length.
+   */
+  maxLength(max) {
+    return createValidator(
+      (0, import_vinyl_util12.substitute)(locale10.maxLength, { value: max }),
+      (input) => input.length <= max
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input string has no whitespace characters.
+   * Whitespace characters include space, new line, carriage return, and tab.
+   */
+  noWhitespace() {
+    return createValidator(
+      locale10.noWhitespace,
+      (input) => input.search(/\s/g) === -1
+    );
+  },
+  /**
+   * Creates a validator that asserts that the input string matches the given regex.
+   * @param regex
+   */
+  matches(regex) {
+    return createValidator(
+      (0, import_vinyl_util12.substitute)(locale10.matches, { value: regex.toString() }),
+      (input) => {
+        return regex.test(input);
+      }
+    );
+  }
+};
+var _StringSchema = class _StringSchema extends ValueSchema {
+  /**
+   * The base SetSchema instance validating that the input is a Set.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _StringSchema(typeOfValidators.string);
+    return this._base;
+  }
+  /**
+   * Creates a validator that asserts that the input is not empty.
+   */
+  notEmpty() {
+    return this.chain(stringValidators.notEmpty());
+  }
+  /**
+   * Creates a validator that asserts that the input string has at least the given minimum
+   * length.
+   *
+   * @param min The string must be at least this length.
+   */
+  minLength(min) {
+    return this.chain(stringValidators.minLength(min));
+  }
+  /**
+   * Creates a validator that asserts that the input string has at most the given maximum
+   * length.
+   *
+   * @param max The string must be at most this length.
+   */
+  maxLength(max) {
+    return this.chain(stringValidators.maxLength(max));
+  }
+  /**
+   * Creates a validator that asserts that the input string has no whitespace characters.
+   * Whitespace characters include space, new line, carriage return, and tab.
+   */
+  noWhitespace() {
+    return this.chain(stringValidators.noWhitespace());
+  }
+  /**
+   * Creates a validator that asserts that the input string matches the given regex.
+   * @param regex
+   */
+  matches(regex) {
+    return this.chain(stringValidators.matches(regex));
+  }
+};
+__publicField(_StringSchema, "_base", null);
+var StringSchema = _StringSchema;
+
+// src/validation/RecordSchema.ts
+var locale11 = {
+  record: "{ [key: {key}]: {value} }"
+};
+var recordValidators = {
+  /**
+   * Returns a validator that asserts that the object's own enumerable properties has keys and
+   * values that match their respective validators.
+   *
+   * Prototype members are not included.
+   * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+   * to the key validator as '0'.
+   *
+   * @param keyValidator Validates each key.
+   * @param valueValidator Validates each value.
+   */
+  record(keyValidator, valueValidator) {
+    return createDeepValidator(
+      (0, import_vinyl_util13.substitute)(locale11.record, {
+        key: keyValidator.description,
+        value: valueValidator.description
+      }),
+      (input, options, path) => {
+        const errors = [];
+        for (const key of (0, import_vinyl_util13.ownKeys)(input)) {
+          const keyStr = String(key);
+          errors.push(
+            ...keyValidator.validate(
+              key,
+              options,
+              path.concat(`[${keyStr}]`)
+            )
+          );
+          if (!options.all && errors.length) return errors;
+          const value = input[key];
+          errors.push(
+            ...valueValidator.validate(
+              value,
+              options,
+              path.concat(keyStr)
+            )
+          );
+          if (!options.all && errors.length) return errors;
+        }
+        return errors;
+      }
+    );
+  }
+};
+var _RecordSchema = class _RecordSchema extends ValueSchema {
+  /**
+   * The base Object validator validating that the input is an object.
+   */
+  static get base() {
+    if (this._base == null)
+      this._base = new _RecordSchema(typeOfValidators.object);
+    return this._base;
+  }
+  static get defaultKeyValidator() {
+    return StringSchema.base;
+  }
+  /**
+   * Returns a validator that asserts that the object's own enumerable properties has keys and
+   * values that match their respective validators.
+   *
+   * Prototype members are not included.
+   * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+   * to the key validator as '0'.
+   *
+   * @param keyValidator Validates each key.
+   * @param valueValidator Validates each value.
+   */
+  record(keyValidator, valueValidator) {
+    return this.chain(recordValidators.record(keyValidator, valueValidator));
+  }
+  /**
+   * Returns a validator that asserts that the object's own enumerable properties has
+   * string keys and values that match the given validator.
+   *
+   * Prototype members are not included.
+   *
+   * @param valueValidator Validates each value.
+   */
+  recordValues(valueValidator) {
+    return this.record(_RecordSchema.defaultKeyValidator, valueValidator);
+  }
+  /**
+   * Casts to a ReadonlyRecord
+   */
+  readonly() {
+    return this;
+  }
+  /**
+   * Casts the type parameter.
+   */
+  cast() {
+    return this;
+  }
+};
+__publicField(_RecordSchema, "_base", null);
+var RecordSchema = _RecordSchema;
+
+// src/validation/validators.ts
+var locale12 = {
+  isOneOf: "one of: {value}",
+  instanceOf: "instance of {value}",
+  oneOfSeparator: " | "
+};
+function any() {
+  return new ValueSchema(valueValidators.any());
+}
+function array(elementValidator) {
+  if (!elementValidator) return ArraySchema.base;
+  else return ArraySchema.base.withElements(elementValidator);
+}
+function boolean() {
+  return new ValueSchema(typeOfValidators.boolean);
+}
+function func() {
+  return FunctionSchema.base;
+}
+function instanceOf(clazz) {
+  return new ValueSchema(
+    createValidator(
+      (0, import_vinyl_util14.substitute)(locale12.instanceOf, { value: clazz.name }),
+      (input) => input instanceof clazz
+    )
+  );
+}
+function isOneOf(...possibleValues) {
+  return new ValueSchema(
+    createValidator(
+      (0, import_vinyl_util14.substitute)(locale12.isOneOf, {
+        value: possibleValues.join(locale12.oneOfSeparator)
+      }),
+      (input) => possibleValues.includes(input)
+    )
+  );
+}
+function enumOf(enumObject) {
+  return isOneOf(...Object.values(enumObject));
+}
+function exactlyNull() {
+  return valueValidators.null();
+}
+function nullish() {
+  return valueValidators.nullish();
+}
+function number() {
+  return NumberSchema.base;
+}
+function object(propertyValidators) {
+  return ObjectSchema.base.extend(propertyValidators);
+}
+function record(keyValidator, valueValidator) {
+  return RecordSchema.base.record(keyValidator, valueValidator);
+}
+function recordValues(valueValidator) {
+  return RecordSchema.base.recordValues(valueValidator);
+}
+function set(elementValidator) {
+  return SetSchema.base.withElements(elementValidator);
+}
+function string() {
+  return StringSchema.base;
+}
+function tuple(...validators) {
+  return ArraySchema.base.tuple(...validators);
+}
+function symbol() {
+  return new ValueSchema(typeOfValidators.symbol);
+}
+function exactlyUndefined() {
+  return new ValueSchema(valueValidators.undefined());
+}
+function custom(expectationMessage, isValid, inputStringify = (input) => (0, import_vinyl_util14.stringifyForPrint)(input, 500)) {
+  return new ValueSchema(
+    createValidator(expectationMessage, isValid, inputStringify)
+  );
+}
+//# sourceMappingURL=index.cjs.map