zod 4.2.0-canary.20251213T203150 → 4.2.0

package/src/v4/classic/tests/from-json-schema.test.ts

@@ -0,0 +1,537 @@
+import { expect, test } from "vitest";
+import { fromJSONSchema } from "../from-json-schema.js";
+
+test("basic string schema", () => {
+  const schema = fromJSONSchema({ type: "string" });
+  expect(schema.parse("hello")).toBe("hello");
+  expect(() => schema.parse(123)).toThrow();
+});
+
+test("string with constraints", () => {
+  const schema = fromJSONSchema({
+    type: "string",
+    minLength: 3,
+    maxLength: 10,
+    pattern: "^[a-z]+$",
+  });
+  expect(schema.parse("hello")).toBe("hello");
+  expect(schema.parse("helloworld")).toBe("helloworld"); // exactly 10 chars - valid
+  expect(() => schema.parse("hi")).toThrow(); // too short
+  expect(() => schema.parse("helloworld1")).toThrow(); // too long (11 chars)
+  expect(() => schema.parse("Hello")).toThrow(); // pattern mismatch
+});
+
+test("pattern is not implicitly anchored", () => {
+  // JSON Schema patterns match anywhere in the string, not just the full string
+  const schema = fromJSONSchema({
+    type: "string",
+    pattern: "foo",
+  });
+  expect(schema.parse("foo")).toBe("foo");
+  expect(schema.parse("foobar")).toBe("foobar"); // matches at start
+  expect(schema.parse("barfoo")).toBe("barfoo"); // matches at end
+  expect(schema.parse("barfoobar")).toBe("barfoobar"); // matches in middle
+  expect(() => schema.parse("bar")).toThrow(); // no match
+});
+
+test("number schema", () => {
+  const schema = fromJSONSchema({ type: "number" });
+  expect(schema.parse(42)).toBe(42);
+  expect(() => schema.parse("42")).toThrow();
+});
+
+test("number with constraints", () => {
+  const schema = fromJSONSchema({
+    type: "number",
+    minimum: 0,
+    maximum: 100,
+    multipleOf: 5,
+  });
+  expect(schema.parse(50)).toBe(50);
+  expect(() => schema.parse(-1)).toThrow();
+  expect(() => schema.parse(101)).toThrow();
+  expect(() => schema.parse(47)).toThrow(); // not multiple of 5
+});
+
+test("integer schema", () => {
+  const schema = fromJSONSchema({ type: "integer" });
+  expect(schema.parse(42)).toBe(42);
+  expect(() => schema.parse(42.5)).toThrow();
+});
+
+test("boolean schema", () => {
+  const schema = fromJSONSchema({ type: "boolean" });
+  expect(schema.parse(true)).toBe(true);
+  expect(schema.parse(false)).toBe(false);
+  expect(() => schema.parse("true")).toThrow();
+});
+
+test("null schema", () => {
+  const schema = fromJSONSchema({ type: "null" });
+  expect(schema.parse(null)).toBe(null);
+  expect(() => schema.parse(undefined)).toThrow();
+});
+
+test("object schema", () => {
+  const schema = fromJSONSchema({
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      age: { type: "number" },
+    },
+    required: ["name"],
+  });
+  expect(schema.parse({ name: "John", age: 30 })).toEqual({ name: "John", age: 30 });
+  expect(schema.parse({ name: "John" })).toEqual({ name: "John" });
+  expect(() => schema.parse({ age: 30 })).toThrow(); // missing required
+});
+
+test("object with additionalProperties false", () => {
+  const schema = fromJSONSchema({
+    type: "object",
+    properties: {
+      name: { type: "string" },
+    },
+    additionalProperties: false,
+  });
+  expect(schema.parse({ name: "John" })).toEqual({ name: "John" });
+  expect(() => schema.parse({ name: "John", extra: "field" })).toThrow();
+});
+
+test("array schema", () => {
+  const schema = fromJSONSchema({
+    type: "array",
+    items: { type: "string" },
+  });
+  expect(schema.parse(["a", "b", "c"])).toEqual(["a", "b", "c"]);
+  expect(() => schema.parse([1, 2, 3])).toThrow();
+});
+
+test("array with constraints", () => {
+  const schema = fromJSONSchema({
+    type: "array",
+    items: { type: "number" },
+    minItems: 2,
+    maxItems: 4,
+  });
+  expect(schema.parse([1, 2])).toEqual([1, 2]);
+  expect(schema.parse([1, 2, 3, 4])).toEqual([1, 2, 3, 4]);
+  expect(() => schema.parse([1])).toThrow();
+  expect(() => schema.parse([1, 2, 3, 4, 5])).toThrow();
+});
+
+test("tuple with prefixItems (draft-2020-12)", () => {
+  const schema = fromJSONSchema({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "array",
+    prefixItems: [{ type: "string" }, { type: "number" }],
+  });
+  expect(schema.parse(["hello", 42])).toEqual(["hello", 42]);
+  expect(() => schema.parse(["hello"])).toThrow();
+  expect(() => schema.parse(["hello", "world"])).toThrow();
+});
+
+test("tuple with items array (draft-7)", () => {
+  const schema = fromJSONSchema({
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "array",
+    items: [{ type: "string" }, { type: "number" }],
+    additionalItems: false,
+  });
+  expect(schema.parse(["hello", 42])).toEqual(["hello", 42]);
+  expect(() => schema.parse(["hello", 42, "extra"])).toThrow();
+});
+
+test("enum schema", () => {
+  const schema = fromJSONSchema({
+    enum: ["red", "green", "blue"],
+  });
+  expect(schema.parse("red")).toBe("red");
+  expect(() => schema.parse("yellow")).toThrow();
+});
+
+test("const schema", () => {
+  const schema = fromJSONSchema({
+    const: "hello",
+  });
+  expect(schema.parse("hello")).toBe("hello");
+  expect(() => schema.parse("world")).toThrow();
+});
+
+test("anyOf schema", () => {
+  const schema = fromJSONSchema({
+    anyOf: [{ type: "string" }, { type: "number" }],
+  });
+  expect(schema.parse("hello")).toBe("hello");
+  expect(schema.parse(42)).toBe(42);
+  expect(() => schema.parse(true)).toThrow();
+});
+
+test("allOf schema", () => {
+  const schema = fromJSONSchema({
+    allOf: [
+      { type: "object", properties: { name: { type: "string" } }, required: ["name"] },
+      { type: "object", properties: { age: { type: "number" } }, required: ["age"] },
+    ],
+  });
+  const result = schema.parse({ name: "John", age: 30 }) as { name: string; age: number };
+  expect(result.name).toBe("John");
+  expect(result.age).toBe(30);
+});
+
+test("allOf with empty array", () => {
+  // Empty allOf without explicit type returns any
+  const schema1 = fromJSONSchema({
+    allOf: [],
+  });
+  expect(schema1.parse("hello")).toBe("hello");
+  expect(schema1.parse(123)).toBe(123);
+  expect(schema1.parse({})).toEqual({});
+
+  // Empty allOf with explicit type returns base schema
+  const schema2 = fromJSONSchema({
+    type: "string",
+    allOf: [],
+  });
+  expect(schema2.parse("hello")).toBe("hello");
+  expect(() => schema2.parse(123)).toThrow();
+});
+
+test("oneOf schema (exclusive union)", () => {
+  const schema = fromJSONSchema({
+    oneOf: [{ type: "string" }, { type: "number" }],
+  });
+  expect(schema.parse("hello")).toBe("hello");
+  expect(schema.parse(42)).toBe(42);
+  expect(() => schema.parse(true)).toThrow();
+});
+
+test("type with anyOf creates intersection", () => {
+  // type: string AND (type:string,minLength:5 OR type:string,pattern:^a)
+  const schema = fromJSONSchema({
+    type: "string",
+    anyOf: [
+      { type: "string", minLength: 5 },
+      { type: "string", pattern: "^a" },
+    ],
+  });
+  // Should pass: string AND (minLength:5 OR pattern:^a) - matches minLength
+  expect(schema.parse("hello")).toBe("hello");
+  // Should pass: string AND (minLength:5 OR pattern:^a) - matches pattern
+  expect(schema.parse("abc")).toBe("abc");
+  // Should fail: string but neither minLength nor pattern match
+  expect(() => schema.parse("hi")).toThrow();
+  // Should fail: not a string
+  expect(() => schema.parse(123)).toThrow();
+});
+
+test("type with oneOf creates intersection", () => {
+  // type: string AND (exactly one of: type:string,minLength:5 OR type:string,pattern:^a)
+  const schema = fromJSONSchema({
+    type: "string",
+    oneOf: [
+      { type: "string", minLength: 5 },
+      { type: "string", pattern: "^a" },
+    ],
+  });
+  // Should pass: string AND minLength:5 (exactly one match - "hello" length 5 >= 5, doesn't start with 'a')
+  expect(schema.parse("hello")).toBe("hello");
+  // Should pass: string AND pattern:^a (exactly one match - "abc" starts with 'a', length 3 < 5)
+  expect(schema.parse("abc")).toBe("abc");
+  // Should fail: string but neither match
+  expect(() => schema.parse("hi")).toThrow();
+  // Should fail: not a string
+  expect(() => schema.parse(123)).toThrow();
+  // Should fail: matches both (length >= 5 AND starts with 'a') - exclusive union fails
+  expect(() => schema.parse("apple")).toThrow();
+});
+
+test("unevaluatedItems throws error", () => {
+  expect(() => {
+    fromJSONSchema({
+      type: "array",
+      unevaluatedItems: false,
+    });
+  }).toThrow("unevaluatedItems is not supported");
+});
+
+test("unevaluatedProperties throws error", () => {
+  expect(() => {
+    fromJSONSchema({
+      type: "object",
+      unevaluatedProperties: false,
+    });
+  }).toThrow("unevaluatedProperties is not supported");
+});
+
+test("if/then/else throws error", () => {
+  expect(() => {
+    fromJSONSchema({
+      if: { type: "string" },
+      then: { type: "number" },
+    });
+  }).toThrow("Conditional schemas");
+});
+
+test("external $ref throws error", () => {
+  expect(() => {
+    fromJSONSchema({
+      $ref: "https://example.com/schema#/definitions/User",
+    });
+  }).toThrow("External $ref is not supported");
+});
+
+test("local $ref resolution", () => {
+  const schema = fromJSONSchema({
+    $defs: {
+      User: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+        required: ["name"],
+      },
+    },
+    $ref: "#/$defs/User",
+  });
+  expect(schema.parse({ name: "John" })).toEqual({ name: "John" });
+  expect(() => schema.parse({})).toThrow();
+});
+
+test("circular $ref with lazy", () => {
+  const schema = fromJSONSchema({
+    $defs: {
+      Node: {
+        type: "object",
+        properties: {
+          value: { type: "string" },
+          children: {
+            type: "array",
+            items: { $ref: "#/$defs/Node" },
+          },
+        },
+      },
+    },
+    $ref: "#/$defs/Node",
+  });
+  type Node = { value: string; children: Node[] };
+  const result = schema.parse({
+    value: "root",
+    children: [{ value: "child", children: [] }],
+  }) as Node;
+  expect(result.value).toBe("root");
+  expect(result.children[0]?.value).toBe("child");
+});
+
+test("patternProperties", () => {
+  const schema = fromJSONSchema({
+    type: "object",
+    patternProperties: {
+      "^S_": { type: "string" },
+    },
+  });
+  const result = schema.parse({ S_name: "John", S_age: "30" }) as Record<string, string>;
+  expect(result.S_name).toBe("John");
+  expect(result.S_age).toBe("30");
+});
+
+test("patternProperties with regular properties", () => {
+  // Note: When patternProperties is combined with properties, the intersection
+  // validates all keys against the pattern. This test uses a pattern that
+  // matches the regular property name as well.
+  const schema = fromJSONSchema({
+    type: "object",
+    properties: {
+      S_name: { type: "string" },
+    },
+    patternProperties: {
+      "^S_": { type: "string" },
+    },
+    required: ["S_name"],
+  });
+  const result = schema.parse({ S_name: "John", S_extra: "value" }) as Record<string, string>;
+  expect(result.S_name).toBe("John");
+  expect(result.S_extra).toBe("value");
+});
+
+test("multiple patternProperties", () => {
+  const schema = fromJSONSchema({
+    type: "object",
+    patternProperties: {
+      "^S_": { type: "string" },
+      "^N_": { type: "number" },
+    },
+  });
+  const result = schema.parse({ S_name: "John", N_count: 123 }) as Record<string, string | number>;
+  expect(result.S_name).toBe("John");
+  expect(result.N_count).toBe(123);
+  // Keys not matching any pattern should pass through
+  const result2 = schema.parse({ S_name: "John", N_count: 123, other: "value" }) as Record<string, string | number>;
+  expect(result2.other).toBe("value");
+});
+
+test("multiple overlapping patternProperties", () => {
+  // If a key matches multiple patterns, value must satisfy all schemas
+  const schema = fromJSONSchema({
+    type: "object",
+    patternProperties: {
+      "^S_": { type: "string" },
+      "^S_N": { type: "string", minLength: 3 },
+    },
+  });
+  // S_name matches ^S_ but not ^S_N
+  expect(schema.parse({ S_name: "John" })).toEqual({ S_name: "John" });
+  // S_N matches both patterns - must satisfy both (string with minLength 3)
+  expect(schema.parse({ S_N: "abc" })).toEqual({ S_N: "abc" });
+  expect(() => schema.parse({ S_N: "ab" })).toThrow(); // too short for ^S_N pattern
+});
+
+test("default value", () => {
+  const schema = fromJSONSchema({
+    type: "string",
+    default: "hello",
+  });
+  // Default is applied during parsing if value is missing/undefined
+  // This depends on Zod's default behavior
+  expect(schema.parse("world")).toBe("world");
+});
+
+test("description metadata", () => {
+  const schema = fromJSONSchema({
+    type: "string",
+    description: "A string value",
+  });
+  expect(schema.parse("hello")).toBe("hello");
+});
+
+test("version detection - draft-2020-12", () => {
+  const schema = fromJSONSchema({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "array",
+    prefixItems: [{ type: "string" }],
+  });
+  expect(schema.parse(["hello"])).toEqual(["hello"]);
+});
+
+test("version detection - draft-7", () => {
+  const schema = fromJSONSchema({
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "array",
+    items: [{ type: "string" }],
+  });
+  expect(schema.parse(["hello"])).toEqual(["hello"]);
+});
+
+test("version detection - draft-4", () => {
+  const schema = fromJSONSchema({
+    $schema: "http://json-schema.org/draft-04/schema#",
+    type: "array",
+    items: [{ type: "string" }],
+  });
+  expect(schema.parse(["hello"])).toEqual(["hello"]);
+});
+
+test("default version (draft-2020-12)", () => {
+  const schema = fromJSONSchema({
+    type: "array",
+    prefixItems: [{ type: "string" }],
+  });
+  expect(schema.parse(["hello"])).toEqual(["hello"]);
+});
+
+test("string format - email", () => {
+  const schema = fromJSONSchema({
+    type: "string",
+    format: "email",
+  });
+  expect(schema.parse("test@example.com")).toBe("test@example.com");
+});
+
+test("string format - uuid", () => {
+  const schema = fromJSONSchema({
+    type: "string",
+    format: "uuid",
+  });
+  const uuid = "550e8400-e29b-41d4-a716-446655440000";
+  expect(schema.parse(uuid)).toBe(uuid);
+});
+
+test("exclusiveMinimum and exclusiveMaximum", () => {
+  const schema = fromJSONSchema({
+    type: "number",
+    exclusiveMinimum: 0,
+    exclusiveMaximum: 100,
+  });
+  expect(schema.parse(50)).toBe(50);
+  expect(() => schema.parse(0)).toThrow();
+  expect(() => schema.parse(100)).toThrow();
+});
+
+test("boolean schema (true/false)", () => {
+  const trueSchema = fromJSONSchema(true);
+  expect(trueSchema.parse("anything")).toBe("anything");
+
+  const falseSchema = fromJSONSchema(false);
+  expect(() => falseSchema.parse("anything")).toThrow();
+});
+
+test("empty object schema", () => {
+  const schema = fromJSONSchema({
+    type: "object",
+  });
+  expect(schema.parse({})).toEqual({});
+  expect(schema.parse({ extra: "field" })).toEqual({ extra: "field" });
+});
+
+test("array without items", () => {
+  const schema = fromJSONSchema({
+    type: "array",
+  });
+  expect(schema.parse([1, "string", true])).toEqual([1, "string", true]);
+});
+
+test("mixed enum types", () => {
+  const schema = fromJSONSchema({
+    enum: ["string", 42, true, null],
+  });
+  expect(schema.parse("string")).toBe("string");
+  expect(schema.parse(42)).toBe(42);
+  expect(schema.parse(true)).toBe(true);
+  expect(schema.parse(null)).toBe(null);
+});
+
+test("nullable in OpenAPI 3.0", () => {
+  // General nullable case (not just enum: [null])
+  const stringSchema = fromJSONSchema(
+    {
+      type: "string",
+      nullable: true,
+    },
+    { defaultTarget: "openapi-3.0" }
+  );
+  expect(stringSchema.parse("hello")).toBe("hello");
+  expect(stringSchema.parse(null)).toBe(null);
+  expect(() => stringSchema.parse(123)).toThrow();
+
+  const numberSchema = fromJSONSchema(
+    {
+      type: "number",
+      nullable: true,
+    },
+    { defaultTarget: "openapi-3.0" }
+  );
+  expect(numberSchema.parse(42)).toBe(42);
+  expect(numberSchema.parse(null)).toBe(null);
+  expect(() => numberSchema.parse("string")).toThrow();
+
+  const objectSchema = fromJSONSchema(
+    {
+      type: "object",
+      properties: { name: { type: "string" } },
+      nullable: true,
+    },
+    { defaultTarget: "openapi-3.0" }
+  );
+  expect(objectSchema.parse({ name: "John" })).toEqual({ name: "John" });
+  expect(objectSchema.parse(null)).toBe(null);
+});

package/src/v4/classic/tests/record.test.ts

@@ -486,3 +486,40 @@ test("partialRecord with z.literal([key, ...])", () => {
     }
   `);
 });
+
+test("looseRecord passes through non-matching keys", () => {
+  const schema = z.looseRecord(z.string().regex(/^S_/), z.string());
+
+  // Keys matching pattern are validated
+  expect(schema.parse({ S_name: "John" })).toEqual({ S_name: "John" });
+  expect(() => schema.parse({ S_name: 123 })).toThrow(); // wrong value type
+
+  // Keys not matching pattern pass through unchanged
+  expect(schema.parse({ S_name: "John", other: "value" })).toEqual({ S_name: "John", other: "value" });
+  expect(schema.parse({ S_name: "John", count: 123 })).toEqual({ S_name: "John", count: 123 });
+  expect(schema.parse({ other: "value" })).toEqual({ other: "value" });
+});
+
+test("intersection of loose records", () => {
+  const schema = z.intersection(
+    z.object({ name: z.string() }).passthrough(),
+    z.intersection(
+      z.looseRecord(z.string().regex(/^S_/), z.string()),
+      z.looseRecord(z.string().regex(/^N_/), z.number())
+    )
+  );
+
+  // Each pattern validates its matching keys
+  const result = schema.parse({ name: "John", S_foo: "bar", N_count: 123 });
+  expect(result.name).toBe("John");
+  expect(result.S_foo).toBe("bar");
+  expect(result.N_count).toBe(123);
+
+  // Keys not matching any pattern pass through
+  const result2 = schema.parse({ name: "John", S_foo: "bar", N_count: 123, other: "value" });
+  expect(result2.other).toBe("value");
+
+  // Validation errors still occur for matching keys
+  expect(() => schema.parse({ name: "John", S_foo: 123 })).toThrow(); // S_foo should be string
+  expect(() => schema.parse({ name: "John", N_count: "abc" })).toThrow(); // N_count should be number
+});

package/src/v4/classic/tests/union.test.ts

@@ -179,3 +179,41 @@ test("surface continuable errors only if they exist", () => {
     }
   `);
 });
+
+// z.xor() tests
+test("z.xor() - exactly one match succeeds", () => {
+  const schema = z.xor([z.string(), z.number()]);
+  expect(schema.parse("hello")).toBe("hello");
+  expect(schema.parse(42)).toBe(42);
+});
+
+test("z.xor() - zero matches fails", () => {
+  const schema = z.xor([z.string(), z.number()]);
+  const result = schema.safeParse(true);
+  expect(result.success).toBe(false);
+});
+
+test("z.xor() - multiple matches fails", () => {
+  const schema = z.xor([z.string(), z.any()]);
+  const result = schema.safeParse("hello");
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    expect(result.error.issues[0].code).toBe("invalid_union");
+    expect((result.error.issues[0] as any).inclusive).toBe(false);
+  }
+});
+
+test("z.xor() with custom error message", () => {
+  const schema = z.xor([z.string(), z.number()], "Expected exactly one of string or number");
+  const result = schema.safeParse(true);
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    expect(result.error.issues[0].message).toBe("Expected exactly one of string or number");
+  }
+});
+
+test("z.xor() type inference", () => {
+  const schema = z.xor([z.string(), z.number(), z.boolean()]);
+  type Result = z.infer<typeof schema>;
+  expectTypeOf<Result>().toEqualTypeOf<string | number | boolean>();
+});

package/src/v4/core/api.ts

@@ -1093,6 +1093,21 @@ export function _union<const T extends readonly schemas.$ZodObject[]>(
   }) as any;
 }
 
+// ZodXor
+export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
+export function _xor<const T extends readonly schemas.$ZodObject[]>(
+  Class: util.SchemaClass<schemas.$ZodXor>,
+  options: T,
+  params?: string | $ZodXorParams
+): schemas.$ZodXor<T> {
+  return new Class({
+    type: "union",
+    options,
+    inclusive: false,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
 // ZodDiscriminatedUnion
 export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
   propValues: util.PropValues;

package/src/v4/core/errors.ts

@@ -62,13 +62,24 @@ export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
   readonly input?: Record<string, unknown>;
 }
 
-export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
   readonly code: "invalid_union";
   readonly errors: $ZodIssue[][];
   readonly input?: unknown;
   readonly discriminator?: string | undefined;
+  readonly inclusive?: true;
 }
 
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
+}
+
+export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
+
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_key";
   readonly origin: "map" | "record";

package/src/v4/core/json-schema-processors.ts

@@ -333,16 +333,16 @@ export const objectProcessor: Processor<schemas.$ZodObject> = (schema, ctx, _jso
 
 export const unionProcessor: Processor<schemas.$ZodUnion> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodUnionDef;
-  // Discriminated unions use oneOf (exactly one match) instead of anyOf (one or more matches)
-  // because the discriminator field ensures mutual exclusivity between options in JSON Schema
-  const isDiscriminated = (def as any).discriminator !== undefined;
+  // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
+  // This includes both z.xor() and discriminated unions
+  const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) =>
     process(x, ctx as any, {
       ...params,
-      path: [...params.path, isDiscriminated ? "oneOf" : "anyOf", i],
+      path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
     })
   );
-  if (isDiscriminated) {
+  if (isExclusive) {
     json.oneOf = options;
   } else {
     json.anyOf = options;