openai 7.4.0 → 7.6.0

package/src/_vendor/zod-to-json-schema/parseDef.ts

@@ -1,36 +1,61 @@
-import { ZodFirstPartyTypeKind, ZodTypeDef } from 'zod/v3';
-import { JsonSchema7AnyType, parseAnyDef } from './parsers/any';
-import { JsonSchema7ArrayType, parseArrayDef } from './parsers/array';
-import { JsonSchema7BigintType, parseBigintDef } from './parsers/bigint';
-import { JsonSchema7BooleanType, parseBooleanDef } from './parsers/boolean';
+import type { ZodTypeDef } from 'zod/v3';
+import { ZodFirstPartyTypeKind } from 'zod/v3';
+import { hasOwn } from '../../internal/utils/values';
+import type { JsonSchema7AnyType } from './parsers/any';
+import { parseAnyDef } from './parsers/any';
+import type { JsonSchema7ArrayType } from './parsers/array';
+import { parseArrayDef } from './parsers/array';
+import type { JsonSchema7BigintType } from './parsers/bigint';
+import { parseBigintDef } from './parsers/bigint';
+import type { JsonSchema7BooleanType } from './parsers/boolean';
+import { parseBooleanDef } from './parsers/boolean';
 import { parseBrandedDef } from './parsers/branded';
 import { parseCatchDef } from './parsers/catch';
-import { JsonSchema7DateType, parseDateDef } from './parsers/date';
+import type { JsonSchema7DateType } from './parsers/date';
+import { parseDateDef } from './parsers/date';
 import { parseDefaultDef } from './parsers/default';
 import { parseEffectsDef } from './parsers/effects';
-import { JsonSchema7EnumType, parseEnumDef } from './parsers/enum';
-import { JsonSchema7AllOfType, parseIntersectionDef } from './parsers/intersection';
-import { JsonSchema7LiteralType, parseLiteralDef } from './parsers/literal';
-import { JsonSchema7MapType, parseMapDef } from './parsers/map';
-import { JsonSchema7NativeEnumType, parseNativeEnumDef } from './parsers/nativeEnum';
-import { JsonSchema7NeverType, parseNeverDef } from './parsers/never';
-import { JsonSchema7NullType, parseNullDef } from './parsers/null';
-import { JsonSchema7NullableType, parseNullableDef } from './parsers/nullable';
-import { JsonSchema7NumberType, parseNumberDef } from './parsers/number';
-import { JsonSchema7ObjectType, parseObjectDef } from './parsers/object';
+import type { JsonSchema7EnumType } from './parsers/enum';
+import { parseEnumDef } from './parsers/enum';
+import type { JsonSchema7AllOfType } from './parsers/intersection';
+import { parseIntersectionDef } from './parsers/intersection';
+import type { JsonSchema7LiteralType } from './parsers/literal';
+import { parseLiteralDef } from './parsers/literal';
+import type { JsonSchema7MapType } from './parsers/map';
+import { parseMapDef } from './parsers/map';
+import type { JsonSchema7NativeEnumType } from './parsers/nativeEnum';
+import { parseNativeEnumDef } from './parsers/nativeEnum';
+import type { JsonSchema7NeverType } from './parsers/never';
+import { parseNeverDef } from './parsers/never';
+import type { JsonSchema7NullType } from './parsers/null';
+import { parseNullDef } from './parsers/null';
+import type { JsonSchema7NullableType } from './parsers/nullable';
+import { parseNullableDef } from './parsers/nullable';
+import type { JsonSchema7NumberType } from './parsers/number';
+import { parseNumberDef } from './parsers/number';
+import type { JsonSchema7ObjectType } from './parsers/object';
+import { parseObjectDef } from './parsers/object';
 import { parseOptionalDef } from './parsers/optional';
 import { parsePipelineDef } from './parsers/pipeline';
 import { parsePromiseDef } from './parsers/promise';
-import { JsonSchema7RecordType, parseRecordDef } from './parsers/record';
-import { JsonSchema7SetType, parseSetDef } from './parsers/set';
-import { JsonSchema7StringType, parseStringDef } from './parsers/string';
-import { JsonSchema7TupleType, parseTupleDef } from './parsers/tuple';
-import { JsonSchema7UndefinedType, parseUndefinedDef } from './parsers/undefined';
-import { JsonSchema7UnionType, parseUnionDef } from './parsers/union';
-import { JsonSchema7UnknownType, parseUnknownDef } from './parsers/unknown';
-import { Refs, Seen } from './Refs';
+import type { JsonSchema7RecordType } from './parsers/record';
+import { parseRecordDef } from './parsers/record';
+import type { JsonSchema7SetType } from './parsers/set';
+import { parseSetDef } from './parsers/set';
+import type { JsonSchema7StringType } from './parsers/string';
+import { parseStringDef } from './parsers/string';
+import type { JsonSchema7TupleType } from './parsers/tuple';
+import { parseTupleDef } from './parsers/tuple';
+import type { JsonSchema7UndefinedType } from './parsers/undefined';
+import { parseUndefinedDef } from './parsers/undefined';
+import type { JsonSchema7UnionType } from './parsers/union';
+import { parseUnionDef } from './parsers/union';
+import type { JsonSchema7UnknownType } from './parsers/unknown';
+import { parseUnknownDef } from './parsers/unknown';
+import type { Refs, Seen } from './Refs';
 import { parseReadonlyDef } from './parsers/readonly';
 import { ignoreOverride } from './Options';
+import { zodDef } from './util';
 
 type JsonSchema7RefType = { $ref: string };
 type JsonSchema7Meta = {
@@ -128,8 +153,9 @@ const get$ref = (
   | {}
   | undefined => {
   switch (refs.$refStrategy) {
-    case 'root':
+    case 'root': {
       return { $ref: item.path.join('/') };
+    }
     // this case is needed as OpenAI strict mode doesn't support top-level `$ref`s, i.e.
     // the top-level schema *must* be `{"type": "object", "properties": {...}}` but if we ever
     // need to define a `$ref`, relative `$ref`s aren't supported, so we need to extract
@@ -138,24 +164,48 @@ const get$ref = (
     // e.g. if we need to reference a schema at
     // `["#","definitions","contactPerson","properties","person1","properties","name"]`
     // then we'll extract it out to `contactPerson_properties_person1_properties_name`
-    case 'extract-to-root':
-      const name = item.path
+    case 'extract-to-root': {
+      const baseName = item.path
         .slice(refs.basePath.length + 1)
         // The first part is either the root schema name or an extracted definition
         // name that is being materialized. Keep it stable so recursive definitions
         // do not generate a new name each time they are resolved.
         .map((part, index) => (index === 0 ? part : encodeDefinitionPathPart(part)))
         .join('_');
+      let name = baseName;
 
       // we don't need to extract the root schema in this case, as it's already
       // been added to the definitions
-      if (name !== refs.name && refs.nameStrategy === 'duplicate-ref') {
-        refs.definitions[name] = item.def;
+      const isRootSchema =
+        name === refs.name &&
+        item.path.length === refs.basePath.length + 2 &&
+        item.path[refs.basePath.length] === refs.definitionPath;
+
+      if (!isRootSchema && refs.nameStrategy === 'duplicate-ref') {
+        const hasDifferentDefinition = (definitionName: string): boolean => {
+          if (!hasOwn(refs.definitions, definitionName)) {
+            return false;
+          }
+
+          const existingDefinition = refs.definitions[definitionName];
+          return existingDefinition === undefined || zodDef(existingDefinition) !== item.def;
+        };
+        let suffix = 0;
+        while (name === refs.name || hasDifferentDefinition(name)) {
+          suffix += 1;
+          name = `${baseName}_${suffix}`;
+        }
+
+        if (!hasOwn(refs.definitions, name)) {
+          refs.definitions[name] = item.def;
+        }
       }
 
       return { $ref: [...refs.basePath, refs.definitionPath, name].join('/') };
-    case 'relative':
+    }
+    case 'relative': {
       return { $ref: getRelativePath(refs.currentPath, item.path) };
+    }
     case 'none':
     case 'seen': {
       if (
@@ -181,6 +231,7 @@ const encodeDefinitionPathPart = (part: string) => {
 
   let encoded = encodedDefinitionPathPartPrefix;
   for (let i = 0; i < part.length; i++) {
+    // oxlint-disable-next-line unicorn/prefer-code-point -- preserve UTF-16 code-unit encoding
     encoded += part.charCodeAt(i).toString(16).padStart(4, '0');
   }
   return encoded;
@@ -189,7 +240,9 @@ const encodeDefinitionPathPart = (part: string) => {
 const getRelativePath = (pathA: string[], pathB: string[]) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i]) break;
+    if (pathA[i] !== pathB[i]) {
+      break;
+    }
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
 };
@@ -201,76 +254,109 @@ const selectParser = (
   forceResolution: boolean,
 ): JsonSchema7Type | undefined => {
   switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodString:
+    case ZodFirstPartyTypeKind.ZodString: {
       return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNumber:
+    }
+    case ZodFirstPartyTypeKind.ZodNumber: {
       return parseNumberDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodObject:
+    }
+    case ZodFirstPartyTypeKind.ZodObject: {
       return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBigInt:
+    }
+    case ZodFirstPartyTypeKind.ZodBigInt: {
       return parseBigintDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBoolean:
+    }
+    case ZodFirstPartyTypeKind.ZodBoolean: {
       return parseBooleanDef();
-    case ZodFirstPartyTypeKind.ZodDate:
+    }
+    case ZodFirstPartyTypeKind.ZodDate: {
       return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUndefined:
+    }
+    case ZodFirstPartyTypeKind.ZodUndefined: {
       return parseUndefinedDef();
-    case ZodFirstPartyTypeKind.ZodNull:
+    }
+    case ZodFirstPartyTypeKind.ZodNull: {
       return parseNullDef(refs);
-    case ZodFirstPartyTypeKind.ZodArray:
+    }
+    case ZodFirstPartyTypeKind.ZodArray: {
       return parseArrayDef(def, refs);
+    }
     case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
       return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodIntersection:
+    }
+    case ZodFirstPartyTypeKind.ZodIntersection: {
       return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodTuple:
+    }
+    case ZodFirstPartyTypeKind.ZodTuple: {
       return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodRecord:
+    }
+    case ZodFirstPartyTypeKind.ZodRecord: {
       return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLiteral:
+    }
+    case ZodFirstPartyTypeKind.ZodLiteral: {
       return parseLiteralDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodEnum:
+    }
+    case ZodFirstPartyTypeKind.ZodEnum: {
       return parseEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNativeEnum:
+    }
+    case ZodFirstPartyTypeKind.ZodNativeEnum: {
       return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNullable:
+    }
+    case ZodFirstPartyTypeKind.ZodNullable: {
       return parseNullableDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodOptional:
+    }
+    case ZodFirstPartyTypeKind.ZodOptional: {
       return parseOptionalDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodMap:
+    }
+    case ZodFirstPartyTypeKind.ZodMap: {
       return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodSet:
+    }
+    case ZodFirstPartyTypeKind.ZodSet: {
       return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLazy:
+    }
+    case ZodFirstPartyTypeKind.ZodLazy: {
       return parseDef(def.getter()._def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodPromise:
+    }
+    case ZodFirstPartyTypeKind.ZodPromise: {
       return parsePromiseDef(def, refs, forceResolution);
+    }
     case ZodFirstPartyTypeKind.ZodNaN:
-    case ZodFirstPartyTypeKind.ZodNever:
+    case ZodFirstPartyTypeKind.ZodNever: {
       return parseNeverDef();
-    case ZodFirstPartyTypeKind.ZodEffects:
+    }
+    case ZodFirstPartyTypeKind.ZodEffects: {
       return parseEffectsDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodAny:
+    }
+    case ZodFirstPartyTypeKind.ZodAny: {
       return parseAnyDef();
-    case ZodFirstPartyTypeKind.ZodUnknown:
+    }
+    case ZodFirstPartyTypeKind.ZodUnknown: {
       return parseUnknownDef();
-    case ZodFirstPartyTypeKind.ZodDefault:
+    }
+    case ZodFirstPartyTypeKind.ZodDefault: {
       return parseDefaultDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodBranded:
+    }
+    case ZodFirstPartyTypeKind.ZodBranded: {
       return parseBrandedDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodReadonly:
+    }
+    case ZodFirstPartyTypeKind.ZodReadonly: {
       return parseReadonlyDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodCatch:
+    }
+    case ZodFirstPartyTypeKind.ZodCatch: {
       return parseCatchDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodPipeline:
+    }
+    case ZodFirstPartyTypeKind.ZodPipeline: {
       return parsePipelineDef(def, refs, forceResolution);
+    }
     case ZodFirstPartyTypeKind.ZodFunction:
     case ZodFirstPartyTypeKind.ZodVoid:
-    case ZodFirstPartyTypeKind.ZodSymbol:
+    case ZodFirstPartyTypeKind.ZodSymbol: {
       return undefined;
-    default:
+    }
+    default: {
       return ((_: never) => undefined)(typeName);
+    }
   }
 };
 

package/src/_vendor/zod-to-json-schema/parsers/array.ts

@@ -1,7 +1,10 @@
-import { ZodArrayDef, ZodFirstPartyTypeKind } from 'zod/v3';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodArrayDef } from 'zod/v3';
+import { ZodFirstPartyTypeKind } from 'zod/v3';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export type JsonSchema7ArrayType = {
   type: 'array';
@@ -15,7 +18,7 @@ export function parseArrayDef(def: ZodArrayDef, refs: Refs) {
   const res: JsonSchema7ArrayType = {
     type: 'array',
   };
-  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny || refs.openaiStrictMode) {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, 'items'],

package/src/_vendor/zod-to-json-schema/parsers/bigint.ts

@@ -1,15 +1,16 @@
-import { ZodBigIntDef } from 'zod/v3';
-import { Refs } from '../Refs';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import type { ZodBigIntDef } from 'zod/v3';
+import type { Refs } from '../Refs';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
 
 export type JsonSchema7BigintType = {
   type: 'integer';
   format: 'int64';
-  minimum?: BigInt;
-  exclusiveMinimum?: BigInt;
-  maximum?: BigInt;
-  exclusiveMaximum?: BigInt;
-  multipleOf?: BigInt;
+  minimum?: bigint;
+  exclusiveMinimum?: bigint;
+  maximum?: bigint;
+  exclusiveMaximum?: bigint;
+  multipleOf?: bigint;
   errorMessage?: ErrorMessages<JsonSchema7BigintType>;
 };
 
@@ -19,11 +20,13 @@ export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7Bigint
     format: 'int64',
   };
 
-  if (!def.checks) return res;
+  if (!def.checks) {
+    return res;
+  }
 
   for (const check of def.checks) {
     switch (check.kind) {
-      case 'min':
+      case 'min': {
         if (refs.target === 'jsonSchema7') {
           if (check.inclusive) {
             setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
@@ -37,7 +40,8 @@ export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7Bigint
           setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
         }
         break;
-      case 'max':
+      }
+      case 'max': {
         if (refs.target === 'jsonSchema7') {
           if (check.inclusive) {
             setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
@@ -51,9 +55,11 @@ export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7Bigint
           setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
         }
         break;
-      case 'multipleOf':
+      }
+      case 'multipleOf': {
         setResponseValueAndErrors(res, 'multipleOf', check.value, check.message, refs);
         break;
+      }
     }
   }
   return res;

package/src/_vendor/zod-to-json-schema/parsers/branded.ts

@@ -1,6 +1,6 @@
-import { ZodBrandedDef } from 'zod/v3';
+import type { ZodBrandedDef } from 'zod/v3';
 import { parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { Refs } from '../Refs';
 
 export function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs, forceResolution: boolean) {
   return parseDef(_def.type._def, refs, forceResolution);

package/src/_vendor/zod-to-json-schema/parsers/catch.ts

@@ -1,7 +1,6 @@
-import { ZodCatchDef } from 'zod/v3';
+import type { ZodCatchDef } from 'zod/v3';
 import { parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { Refs } from '../Refs';
 
-export const parseCatchDef = (def: ZodCatchDef<any>, refs: Refs, forceResolution: boolean) => {
-  return parseDef(def.innerType._def, refs, forceResolution);
-};
+export const parseCatchDef = (def: ZodCatchDef<any>, refs: Refs, forceResolution: boolean) =>
+  parseDef(def.innerType._def, refs, forceResolution);

package/src/_vendor/zod-to-json-schema/parsers/date.ts

@@ -1,8 +1,9 @@
-import { ZodDateDef } from 'zod/v3';
-import { Refs } from '../Refs';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7NumberType } from './number';
-import { DateStrategy } from '../Options';
+import type { ZodDateDef } from 'zod/v3';
+import type { Refs } from '../Refs';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
+import type { JsonSchema7NumberType } from './number';
+import type { DateStrategy } from '../Options';
 
 export type JsonSchema7DateType =
   | {
@@ -31,18 +32,21 @@ export function parseDateDef(
 
   switch (strategy) {
     case 'string':
-    case 'format:date-time':
+    case 'format:date-time': {
       return {
         type: 'string',
         format: 'date-time',
       };
-    case 'format:date':
+    }
+    case 'format:date': {
       return {
         type: 'string',
         format: 'date',
       };
-    case 'integer':
+    }
+    case 'integer': {
       return integerDateParser(def, refs);
+    }
   }
 }
 
@@ -58,7 +62,7 @@ const integerDateParser = (def: ZodDateDef, refs: Refs) => {
 
   for (const check of def.checks) {
     switch (check.kind) {
-      case 'min':
+      case 'min': {
         setResponseValueAndErrors(
           res,
           'minimum',
@@ -67,7 +71,8 @@ const integerDateParser = (def: ZodDateDef, refs: Refs) => {
           refs,
         );
         break;
-      case 'max':
+      }
+      case 'max': {
         setResponseValueAndErrors(
           res,
           'maximum',
@@ -76,6 +81,7 @@ const integerDateParser = (def: ZodDateDef, refs: Refs) => {
           refs,
         );
         break;
+      }
     }
   }
 

package/src/_vendor/zod-to-json-schema/parsers/default.ts

@@ -1,6 +1,7 @@
-import { ZodDefaultDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodDefaultDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export function parseDefaultDef(
   _def: ZodDefaultDef,

package/src/_vendor/zod-to-json-schema/parsers/effects.ts

@@ -1,6 +1,7 @@
-import { ZodEffectsDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodEffectsDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export function parseEffectsDef(
   _def: ZodEffectsDef,

package/src/_vendor/zod-to-json-schema/parsers/enum.ts

@@ -1,4 +1,4 @@
-import { ZodEnumDef } from 'zod/v3';
+import type { ZodEnumDef } from 'zod/v3';
 
 export type JsonSchema7EnumType = {
   type: 'string';

package/src/_vendor/zod-to-json-schema/parsers/intersection.ts

@@ -1,7 +1,8 @@
-import { ZodIntersectionDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7StringType } from './string';
+import type { ZodIntersectionDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7StringType } from './string';
 
 export type JsonSchema7AllOfType = {
   allOf: JsonSchema7Type[];
@@ -11,7 +12,9 @@ export type JsonSchema7AllOfType = {
 const isJsonSchema7AllOfType = (
   type: JsonSchema7Type | JsonSchema7StringType,
 ): type is JsonSchema7AllOfType => {
-  if ('type' in type && type.type === 'string') return false;
+  if ('type' in type && type.type === 'string') {
+    return false;
+  }
   return 'allOf' in type;
 };
 
@@ -35,7 +38,7 @@ export function parseIntersectionDef(
 
   const mergedAllOf: JsonSchema7Type[] = [];
   // If either of the schemas is an allOf, merge them into a single allOf
-  allOf.forEach((schema) => {
+  for (const schema of allOf) {
     if (isJsonSchema7AllOfType(schema)) {
       mergedAllOf.push(...schema.allOf);
       if (schema.unevaluatedProperties === undefined) {
@@ -54,9 +57,9 @@ export function parseIntersectionDef(
       }
       mergedAllOf.push(nestedSchema);
     }
-  });
-  return mergedAllOf.length ?
-      {
+  }
+  return mergedAllOf.length
+    ? {
         allOf: mergedAllOf,
         ...unevaluatedProperties,
       }

package/src/_vendor/zod-to-json-schema/parsers/literal.ts

@@ -1,16 +1,25 @@
-import { ZodLiteralDef } from 'zod/v3';
-import { Refs } from '../Refs';
+import type { ZodLiteralDef } from 'zod/v3';
+import type { Refs } from '../Refs';
+import { parseNullDef } from './null';
 
 export type JsonSchema7LiteralType =
   | {
       type: 'string' | 'number' | 'integer' | 'boolean';
       const: string | number | boolean;
     }
+  | {
+      type: 'null';
+      const?: null;
+    }
   | {
       type: 'object' | 'array';
     };
 
 export function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType {
+  if (def.value === null) {
+    return refs.target === 'openApi3' ? parseNullDef(refs) : { type: 'null', const: null };
+  }
+
   const parsedType = typeof def.value;
   if (
     parsedType !== 'bigint' &&

package/src/_vendor/zod-to-json-schema/parsers/map.ts

@@ -1,7 +1,9 @@
-import { ZodMapDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7RecordType, parseRecordDef } from './record';
+import type { ZodMapDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7RecordType } from './record';
+import { parseRecordDef } from './record';
 
 export type JsonSchema7MapType = {
   type: 'array';

package/src/_vendor/zod-to-json-schema/parsers/nativeEnum.ts

@@ -1,4 +1,4 @@
-import { ZodNativeEnumDef } from 'zod/v3';
+import type { ZodNativeEnumDef } from 'zod/v3';
 
 export type JsonSchema7NativeEnumType = {
   type: 'string' | 'number' | ['string', 'number'];
@@ -7,21 +7,20 @@ export type JsonSchema7NativeEnumType = {
 
 export function parseNativeEnumDef(def: ZodNativeEnumDef): JsonSchema7NativeEnumType {
   const object = def.values;
-  const actualKeys = Object.keys(def.values).filter((key: string) => {
-    return typeof object[object[key]!] !== 'number';
-  });
+  const actualKeys = Object.keys(def.values).filter(
+    (key: string) => typeof object[object[key]!] !== 'number',
+  );
 
   const actualValues = actualKeys.map((key: string) => object[key]!);
 
-  const parsedTypes = Array.from(new Set(actualValues.map((values: string | number) => typeof values)));
+  const parsedTypes = [...new Set(actualValues.map((values: string | number) => typeof values))];
+  let type: 'string' | 'number' | ['string', 'number'] = ['string', 'number'];
+  if (parsedTypes.length === 1) {
+    type = parsedTypes[0] === 'string' ? 'string' : 'number';
+  }
 
   return {
-    type:
-      parsedTypes.length === 1 ?
-        parsedTypes[0] === 'string' ?
-          'string'
-        : 'number'
-      : ['string', 'number'],
+    type,
     enum: actualValues,
   };
 }