@amazon/vinyl-validation 1.2.0 → 2.0.4

package/dist/index.cjs

@@ -66,6 +66,7 @@ __export(index_exports, {
   isValidatorWithPartial: () => isValidatorWithPartial,
   maybeToDeepPartial: () => maybeToDeepPartial,
   maybeToPartial: () => maybeToPartial,
+  mergeJsonSchema: () => mergeJsonSchema,
   nullish: () => nullish,
   number: () => number,
   numberValidators: () => numberValidators,
@@ -80,20 +81,15 @@ __export(index_exports, {
   string: () => string,
   stringValidators: () => stringValidators,
   symbol: () => symbol,
+  toJsonSchema: () => toJsonSchema,
   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");
+var import_vinyl_util4 = require("@amazon/vinyl-util");
 
 // src/validation/Validator.ts
 var import_vinyl_util = require("@amazon/vinyl-util");
@@ -115,9 +111,10 @@ function createValidationExpectationMessage(expectationMessage, input, path, inp
     path: path.join(".")
   });
 }
-function createValidator(expectationMessage, isValid, inputStringify = (input) => (0, import_vinyl_util2.stringifyForPrint)(input, 500)) {
+function createValidator(expectationMessage, isValid, inputStringify = (input) => (0, import_vinyl_util2.stringifyForPrint)(input, 500), jsonSchema) {
   return {
     description: expectationMessage,
+    jsonSchema,
     isValid(input) {
       return isValid(input);
     },
@@ -153,9 +150,10 @@ function createValidator(expectationMessage, isValid, inputStringify = (input) =
     }
   };
 }
-function createDeepValidator(description, validate) {
+function createDeepValidator(description, validate, jsonSchema) {
   return {
     description,
+    jsonSchema,
     isValid(input) {
       return validate(input, { all: false }, []).length === 0;
     },
@@ -172,6 +170,39 @@ function createDeepValidator(description, validate) {
   };
 }
 
+// src/validation/JsonSchema.ts
+var import_vinyl_util3 = require("@amazon/vinyl-util");
+function mergeJsonSchema(...fragments) {
+  var _a;
+  const merged = {};
+  for (const fragment of fragments) {
+    if (fragment == null) continue;
+    for (const key of (0, import_vinyl_util3.ownKeys)(fragment)) {
+      if (fragment[key] === void 0) continue;
+      if (key === "properties") {
+        merged.properties = __spreadValues(__spreadValues({}, merged.properties), fragment.properties);
+      } else if (key === "required") {
+        merged.required = [
+          .../* @__PURE__ */ new Set([
+            ...(_a = merged.required) != null ? _a : [],
+            ...fragment.required
+          ])
+        ];
+      } else {
+        merged[key] = fragment[key];
+      }
+    }
+  }
+  return merged;
+}
+function toJsonSchema(source) {
+  const provider = source;
+  if (typeof provider.toJsonSchema === "function") {
+    return provider.toJsonSchema();
+  }
+  return __spreadValues({}, source.jsonSchema);
+}
+
 // src/validation/andValidators.ts
 var locale = {
   /**
@@ -189,7 +220,7 @@ var locale = {
 };
 function andValidators(...validators) {
   return createDeepValidator(
-    (0, import_vinyl_util3.substitute)(locale.template, {
+    (0, import_vinyl_util4.substitute)(locale.template, {
       value: validators.map((v) => v.description).join(locale.separator)
     }),
     (input, options, path) => {
@@ -198,12 +229,16 @@ function andValidators(...validators) {
         if (errors.length) return errors;
       }
       return [];
-    }
+    },
+    mergeJsonSchema(...validators.map((v) => v.jsonSchema))
   );
 }
 
+// src/validation/ArraySchema.ts
+var import_vinyl_util7 = require("@amazon/vinyl-util");
+
 // src/validation/orValidators.ts
-var import_vinyl_util4 = require("@amazon/vinyl-util");
+var import_vinyl_util5 = require("@amazon/vinyl-util");
 var locale2 = {
   /**
    * {value} - The child validators' descriptions, joined with `separator`.
@@ -214,40 +249,50 @@ var locale2 = {
    */
   separator: " | "
 };
+function unionJsonSchema(validators) {
+  const branches = validators.map((v) => v.jsonSchema).filter((fragment) => fragment != null);
+  if (branches.length === 0) return void 0;
+  if (branches.length === 1) return branches[0];
+  return { anyOf: branches };
+}
 function orValidators(...validators) {
-  const description = (0, import_vinyl_util4.substitute)(locale2.template, {
+  const description = (0, import_vinyl_util5.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 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,
+      return longestPath > path.length ? longestErrors : [
+        {
+          message: createValidationExpectationMessage(
+            description,
+            input,
+            path
+          ),
           path
-        ),
-        path
-      }
-    ];
-  });
+        }
+      ];
+    },
+    unionJsonSchema(validators)
+  );
 }
 
 // src/validation/SchemaBase.ts
-var import_vinyl_util5 = require("@amazon/vinyl-util");
+var import_vinyl_util6 = require("@amazon/vinyl-util");
 var requiredValidationOptions = {
   optional: false
 };
@@ -256,9 +301,10 @@ var SchemaBase = class {
     __publicField(this, "currentValidator", currentValidator);
     __publicField(this, "previousSchema", previousSchema);
     __publicField(this, "operation", operation);
-    __publicField(this, "__type", /* @__PURE__ */ (0, import_vinyl_util5.invariant)());
+    __publicField(this, "__type", /* @__PURE__ */ (0, import_vinyl_util6.invariant)());
     __publicField(this, "validator");
     __publicField(this, "_options", requiredValidationOptions);
+    __publicField(this, "_jsonSchemaDescription");
     __publicField(this, "assert", (input, origin, path) => {
       this.validator.assert(input, origin, path);
     });
@@ -272,6 +318,39 @@ var SchemaBase = class {
   get description() {
     return this.validator.description;
   }
+  /**
+   * The composed JSON Schema fragment for this schema, including any {@link describe} description.
+   * Composes through chaining the same way {@link description} does; serialize a complete
+   * definition with {@link toJsonSchema}.
+   */
+  get jsonSchema() {
+    const base = this.validator.jsonSchema;
+    if (this._jsonSchemaDescription == null) return base;
+    return mergeJsonSchema(base, {
+      description: this._jsonSchemaDescription
+    });
+  }
+  /**
+   * Attaches a human-readable description to this schema, akin to zod's `describe`.
+   * The description is metadata only; it does not affect validation, and surfaces in the output
+   * of {@link toJsonSchema}.
+   *
+   * @param description The description to attach.
+   * @return A clone of this schema carrying the description.
+   */
+  describe(description) {
+    const cloned = this.clone();
+    cloned._jsonSchemaDescription = description;
+    return cloned;
+  }
+  /**
+   * Serializes this schema to a JSON Schema definition, suitable for describing the shape to an
+   * LLM or other consumer. Works similarly to zod-to-json-schema.
+   */
+  toJsonSchema() {
+    var _a;
+    return (_a = this.jsonSchema) != null ? _a : {};
+  }
   /**
    * Clones this schema, transforming all validators with the given mutator.
    *
@@ -286,11 +365,12 @@ var SchemaBase = class {
       this.operation
     ) : this.self(transform(this.currentValidator));
     cloned._options = this._options;
+    cloned._jsonSchemaDescription = this._jsonSchemaDescription;
     return cloned;
   }
   self(current, previous, operation) {
     if (this.constructor.length > 3) {
-      throw new import_vinyl_util5.IllegalArgumentError(
+      throw new import_vinyl_util6.IllegalArgumentError(
         "constructor should have at most three required arguments"
       );
     }
@@ -335,15 +415,30 @@ var valueValidators = {
   },
   /**
    * Creates a validator that asserts that the input is nullish.
+   * JSON Schema has no representation for `undefined`, so only `null` is expressed.
    */
   nullish() {
-    return createValidator(locale3.nullish, (input) => input == null);
+    return createValidator(
+      locale3.nullish,
+      (input) => input == null,
+      void 0,
+      {
+        type: "null"
+      }
+    );
   },
   /**
    * Creates a validator that asserts that the input is strictly null.
    */
   null() {
-    return createValidator(locale3.null, (input) => input === null);
+    return createValidator(
+      locale3.null,
+      (input) => input === null,
+      void 0,
+      {
+        type: "null"
+      }
+    );
   },
   /**
    * Creates a validator that asserts that the input is strictly undefined.
@@ -418,7 +513,9 @@ var arrayValidators = {
   isArray() {
     return createValidator(
       locale4.array,
-      (input) => Array.isArray(input)
+      (input) => Array.isArray(input),
+      void 0,
+      { type: "array" }
     );
   },
   /**
@@ -428,7 +525,7 @@ var arrayValidators = {
    */
   withElements(elementValidator) {
     return createDeepValidator(
-      (0, import_vinyl_util6.substitute)(locale4.withElements, {
+      (0, import_vinyl_util7.substitute)(locale4.withElements, {
         value: elementValidator.description
       }),
       (input, options, path) => {
@@ -445,7 +542,8 @@ var arrayValidators = {
           if (!options.all && errors.length) return errors;
         }
         return errors;
-      }
+      },
+      { type: "array", items: toJsonSchema(elementValidator) }
     );
   },
   /**
@@ -456,13 +554,13 @@ var arrayValidators = {
    */
   tuple(...validators) {
     const lengthValidator = createValidator(
-      (0, import_vinyl_util6.substitute)(locale4.exactlyLength, {
+      (0, import_vinyl_util7.substitute)(locale4.exactlyLength, {
         value: validators.length
       }),
       (length) => length === validators.length
     );
     return createDeepValidator(
-      (0, import_vinyl_util6.substitute)(locale4.tuple, { value: validators.join(", ") }),
+      (0, import_vinyl_util7.substitute)(locale4.tuple, { value: validators.join(", ") }),
       (input, options, path) => {
         const errors = [];
         errors.push(
@@ -483,6 +581,13 @@ var arrayValidators = {
           if (!options.all && errors.length) return errors;
         }
         return errors;
+      },
+      {
+        type: "array",
+        items: validators.map((v) => toJsonSchema(v)),
+        minItems: validators.length,
+        maxItems: validators.length,
+        additionalItems: false
       }
     );
   },
@@ -492,9 +597,10 @@ var arrayValidators = {
    */
   minLength(min) {
     return createValidator(
-      (0, import_vinyl_util6.substitute)(locale4.minLength, { value: min }),
+      (0, import_vinyl_util7.substitute)(locale4.minLength, { value: min }),
       (input) => input.length >= min,
-      (input) => (0, import_vinyl_util6.substitute)(locale4.actualLength, { value: input.length })
+      (input) => (0, import_vinyl_util7.substitute)(locale4.actualLength, { value: input.length }),
+      { minItems: min }
     );
   },
   /**
@@ -504,9 +610,10 @@ var arrayValidators = {
    */
   maxLength(max) {
     return createValidator(
-      (0, import_vinyl_util6.substitute)(locale4.maxLength, { value: max }),
+      (0, import_vinyl_util7.substitute)(locale4.maxLength, { value: max }),
       (input) => input.length <= max,
-      (input) => (0, import_vinyl_util6.substitute)(locale4.actualLength, { value: input.length })
+      (input) => (0, import_vinyl_util7.substitute)(locale4.actualLength, { value: input.length }),
+      { maxItems: max }
     );
   }
 };
@@ -569,19 +676,29 @@ __publicField(_ArraySchema, "_base", null);
 var ArraySchema = _ArraySchema;
 
 // src/validation/FunctionSchema.ts
-var import_vinyl_util8 = require("@amazon/vinyl-util");
+var import_vinyl_util9 = require("@amazon/vinyl-util");
 
 // src/validation/typeOfValidators.ts
-var import_vinyl_util7 = require("@amazon/vinyl-util");
+var import_vinyl_util8 = require("@amazon/vinyl-util");
 var locale5 = {
   template: "type {value}"
 };
+var jsonSchemaTypeByTypeof = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  object: "object"
+};
 function typeOfValidator(expected) {
+  const jsonType = jsonSchemaTypeByTypeof[expected];
+  const jsonSchema = jsonType == null ? void 0 : { type: jsonType };
   return createValidator(
-    (0, import_vinyl_util7.substitute)(locale5.template, { value: expected }),
+    (0, import_vinyl_util8.substitute)(locale5.template, { value: expected }),
     (input) => {
       return input != null && typeof input === expected;
-    }
+    },
+    void 0,
+    jsonSchema
   );
 }
 var typeOfValidatorCache = {};
@@ -620,9 +737,9 @@ var locale6 = {
 var functionValidators = {
   length(max) {
     return createValidator(
-      (0, import_vinyl_util8.substitute)(locale6.length, { value: max }),
+      (0, import_vinyl_util9.substitute)(locale6.length, { value: max }),
       (input) => input.length <= max,
-      (input) => (0, import_vinyl_util8.substitute)(locale6.actualLength, { value: input.length })
+      (input) => (0, import_vinyl_util9.substitute)(locale6.actualLength, { value: input.length })
     );
   }
 };
@@ -650,88 +767,9 @@ var _FunctionSchema = class _FunctionSchema extends ValueSchema {
 __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 = {
+var locale7 = {
   gte: "at least {value}",
   gt: "greater than {value}",
   lte: "at most {value}",
@@ -749,8 +787,10 @@ var numberValidators = {
    */
   gte(min) {
     return createValidator(
-      (0, import_vinyl_util10.substitute)(locale8.gte, { value: min }),
-      (input) => input >= min
+      (0, import_vinyl_util10.substitute)(locale7.gte, { value: min }),
+      (input) => input >= min,
+      void 0,
+      { minimum: min }
     );
   },
   /**
@@ -761,8 +801,10 @@ var numberValidators = {
    */
   gt(min) {
     return createValidator(
-      (0, import_vinyl_util10.substitute)(locale8.gt, { value: min }),
-      (input) => input > min
+      (0, import_vinyl_util10.substitute)(locale7.gt, { value: min }),
+      (input) => input > min,
+      void 0,
+      { exclusiveMinimum: min }
     );
   },
   /**
@@ -773,8 +815,10 @@ var numberValidators = {
    */
   lte(max) {
     return createValidator(
-      (0, import_vinyl_util10.substitute)(locale8.lte, { value: max }),
-      (input) => input <= max
+      (0, import_vinyl_util10.substitute)(locale7.lte, { value: max }),
+      (input) => input <= max,
+      void 0,
+      { maximum: max }
     );
   },
   /**
@@ -785,8 +829,10 @@ var numberValidators = {
    */
   lt(max) {
     return createValidator(
-      (0, import_vinyl_util10.substitute)(locale8.lt, { value: max }),
-      (input) => input < max
+      (0, import_vinyl_util10.substitute)(locale7.lt, { value: max }),
+      (input) => input < max,
+      void 0,
+      { exclusiveMaximum: max }
     );
   },
   /**
@@ -798,23 +844,27 @@ var numberValidators = {
    */
   within(min, max) {
     return createValidator(
-      (0, import_vinyl_util10.substitute)(locale8.within, { min, max }),
-      (input) => input >= min && input <= max
+      (0, import_vinyl_util10.substitute)(locale7.within, { min, max }),
+      (input) => input >= min && input <= max,
+      void 0,
+      { minimum: min, maximum: max }
     );
   },
   /**
    * Creates a validator that asserts that the input number is finite.
    */
   finite() {
-    return createValidator(locale8.finite, (input) => Number.isFinite(input));
+    return createValidator(locale7.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)
+      locale7.safeInteger,
+      (input) => Number.isSafeInteger(input),
+      void 0,
+      { type: "integer" }
     );
   }
 };
@@ -904,7 +954,7 @@ function maybeToPartial(validator) {
 }
 
 // src/validation/ObjectSchema.ts
-var locale9 = {
+var locale8 = {
   extend: "{\n{body}\n}",
   prop: "{key}: {value}",
   propSeparator: ",\n",
@@ -921,18 +971,26 @@ var objectValidators = {
   properties(propertyValidators) {
     const propertiesDescriptions = [];
     const keys = (0, import_vinyl_util11.ownKeys)(propertyValidators);
+    const jsonProperties = {};
+    const requiredKeys = [];
     for (const key of keys) {
       const validator2 = propertyValidators[key];
       propertiesDescriptions.push(
-        (0, import_vinyl_util11.substitute)(locale9.prop, {
+        (0, import_vinyl_util11.substitute)(locale8.prop, {
           key: String(key) + (validator2.options.optional ? "?" : ""),
           value: validator2.description
         })
       );
+      jsonProperties[String(key)] = toJsonSchema(validator2);
+      if (!validator2.options.optional) requiredKeys.push(String(key));
     }
-    const description = (0, import_vinyl_util11.substitute)(locale9.extend, {
-      body: propertiesDescriptions.join(locale9.propSeparator).split("\n").map((line) => locale9.indent + line).join("\n")
+    const description = (0, import_vinyl_util11.substitute)(locale8.extend, {
+      body: propertiesDescriptions.join(locale8.propSeparator).split("\n").map((line) => locale8.indent + line).join("\n")
     });
+    const jsonSchema = __spreadValues({
+      type: "object",
+      properties: jsonProperties
+    }, requiredKeys.length ? { required: requiredKeys } : {});
     const validator = createDeepValidator(
       description,
       (input, options, path) => {
@@ -951,7 +1009,7 @@ var objectValidators = {
           } else {
             if (!validator2.options.optional) {
               errors.push({
-                message: (0, import_vinyl_util11.substitute)(locale9.required, { key }),
+                message: (0, import_vinyl_util11.substitute)(locale8.required, { key }),
                 path: path.concat(String(key))
               });
             }
@@ -959,7 +1017,8 @@ var objectValidators = {
           if (!options.all && errors.length) return errors;
         }
         return errors;
-      }
+      },
+      jsonSchema
     );
     return (0, import_vinyl_util11.merge)(validator, {
       partial() {
@@ -1030,7 +1089,7 @@ var import_vinyl_util13 = require("@amazon/vinyl-util");
 
 // src/validation/StringSchema.ts
 var import_vinyl_util12 = require("@amazon/vinyl-util");
-var locale10 = {
+var locale9 = {
   notEmpty: "not empty",
   minLength: "at least {value} characters",
   maxLength: "at most {value} characters",
@@ -1042,7 +1101,12 @@ var stringValidators = {
    * Creates a validator that asserts that the input is not empty.
    */
   notEmpty() {
-    return createValidator(locale10.notEmpty, (input) => input !== "");
+    return createValidator(
+      locale9.notEmpty,
+      (input) => input !== "",
+      void 0,
+      { minLength: 1 }
+    );
   },
   /**
    * Creates a validator that asserts that the input string has at least the given minimum
@@ -1052,8 +1116,10 @@ var stringValidators = {
    */
   minLength(min) {
     return createValidator(
-      (0, import_vinyl_util12.substitute)(locale10.minLength, { value: min }),
-      (input) => input.length >= min
+      (0, import_vinyl_util12.substitute)(locale9.minLength, { value: min }),
+      (input) => input.length >= min,
+      void 0,
+      { minLength: min }
     );
   },
   /**
@@ -1064,8 +1130,10 @@ var stringValidators = {
    */
   maxLength(max) {
     return createValidator(
-      (0, import_vinyl_util12.substitute)(locale10.maxLength, { value: max }),
-      (input) => input.length <= max
+      (0, import_vinyl_util12.substitute)(locale9.maxLength, { value: max }),
+      (input) => input.length <= max,
+      void 0,
+      { maxLength: max }
     );
   },
   /**
@@ -1074,7 +1142,7 @@ var stringValidators = {
    */
   noWhitespace() {
     return createValidator(
-      locale10.noWhitespace,
+      locale9.noWhitespace,
       (input) => input.search(/\s/g) === -1
     );
   },
@@ -1084,10 +1152,12 @@ var stringValidators = {
    */
   matches(regex) {
     return createValidator(
-      (0, import_vinyl_util12.substitute)(locale10.matches, { value: regex.toString() }),
+      (0, import_vinyl_util12.substitute)(locale9.matches, { value: regex.toString() }),
       (input) => {
         return regex.test(input);
-      }
+      },
+      void 0,
+      { pattern: regex.source }
     );
   }
 };
@@ -1143,7 +1213,7 @@ __publicField(_StringSchema, "_base", null);
 var StringSchema = _StringSchema;
 
 // src/validation/RecordSchema.ts
-var locale11 = {
+var locale10 = {
   record: "{ [key: {key}]: {value} }"
 };
 var recordValidators = {
@@ -1160,7 +1230,7 @@ var recordValidators = {
    */
   record(keyValidator, valueValidator) {
     return createDeepValidator(
-      (0, import_vinyl_util13.substitute)(locale11.record, {
+      (0, import_vinyl_util13.substitute)(locale10.record, {
         key: keyValidator.description,
         value: valueValidator.description
       }),
@@ -1187,6 +1257,10 @@ var recordValidators = {
           if (!options.all && errors.length) return errors;
         }
         return errors;
+      },
+      {
+        type: "object",
+        additionalProperties: toJsonSchema(valueValidator)
       }
     );
   }
@@ -1244,7 +1318,94 @@ var _RecordSchema = class _RecordSchema extends ValueSchema {
 __publicField(_RecordSchema, "_base", null);
 var RecordSchema = _RecordSchema;
 
+// src/validation/SetSchema.ts
+var import_vinyl_util14 = require("@amazon/vinyl-util");
+var locale11 = {
+  set: "Set",
+  withElements: "Set<{value}>"
+};
+var setValidators = {
+  /**
+   * Creates a validator that asserts that the input is a set.
+   */
+  isSet() {
+    return createValidator(
+      locale11.set,
+      (input) => input instanceof Set,
+      void 0,
+      { type: "array", uniqueItems: true }
+    );
+  },
+  /**
+   * Creates a validator that asserts that every element passes the given validator.
+   *
+   * @param elementValidator
+   */
+  withElements(elementValidator) {
+    return createDeepValidator(
+      (0, import_vinyl_util14.substitute)(locale11.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;
+      },
+      {
+        type: "array",
+        uniqueItems: true,
+        items: toJsonSchema(elementValidator)
+      }
+    );
+  }
+};
+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/validators.ts
+var import_vinyl_util15 = require("@amazon/vinyl-util");
 var locale12 = {
   isOneOf: "one of: {value}",
   instanceOf: "instance of {value}",
@@ -1266,7 +1427,7 @@ function func() {
 function instanceOf(clazz) {
   return new ValueSchema(
     createValidator(
-      (0, import_vinyl_util14.substitute)(locale12.instanceOf, { value: clazz.name }),
+      (0, import_vinyl_util15.substitute)(locale12.instanceOf, { value: clazz.name }),
       (input) => input instanceof clazz
     )
   );
@@ -1274,10 +1435,12 @@ function instanceOf(clazz) {
 function isOneOf(...possibleValues) {
   return new ValueSchema(
     createValidator(
-      (0, import_vinyl_util14.substitute)(locale12.isOneOf, {
+      (0, import_vinyl_util15.substitute)(locale12.isOneOf, {
         value: possibleValues.join(locale12.oneOfSeparator)
       }),
-      (input) => possibleValues.includes(input)
+      (input) => possibleValues.includes(input),
+      void 0,
+      { enum: [...possibleValues] }
     )
   );
 }
@@ -1317,7 +1480,7 @@ function symbol() {
 function exactlyUndefined() {
   return new ValueSchema(valueValidators.undefined());
 }
-function custom(expectationMessage, isValid, inputStringify = (input) => (0, import_vinyl_util14.stringifyForPrint)(input, 500)) {
+function custom(expectationMessage, isValid, inputStringify = (input) => (0, import_vinyl_util15.stringifyForPrint)(input, 500)) {
   return new ValueSchema(
     createValidator(expectationMessage, isValid, inputStringify)
   );