zod-openapi 2.15.1 → 2.16.0

package/README.md

@@ -512,7 +512,7 @@ For example in `z.string().nullable()` will be rendered differently
   - `string` `type` mapping by default
 - ZodDefault
 - ZodDiscriminatedUnion
-  - `discriminator` mapping when all schemas in the union contain a `ref`.
+  - `discriminator` mapping when all schemas in the union are [registered](#creating-components). The discriminator must be a `ZodLiteral`, `ZodEnum` or `ZodNativeEnum` with string values. Only values wrapped in `ZodBranded`, `ZodReadOnly` and `ZodCatch` are supported.
 - ZodEffects
   - `transform` support for request schemas. See [Zod Effects](#zod-effects) for how to enable response schema support
   - `pre-process` support. We assume that the input type is the same as the output type. Otherwise pipe and transform can be used instead.
@@ -541,9 +541,10 @@ For example in `z.string().nullable()` will be rendered differently
 - ZodSet
   - Treated as an array with `uniqueItems` (you may need to add a pre-process)
 - ZodString
-  - `format` mapping for `.url()`, `.uuid()`, `.email()`, `.datetime()`
+  - `format` mapping for `.url()`, `.uuid()`, `.email()`, `.datetime()`, `.date()`, `.time()`, `.duration()`
   - `minLength`/`maxLength` mapping for `.length()`, `.min()`, `.max()`
   - `pattern` mapping for `.regex()`, `.startsWith()`, `.endsWith()`, `.includes()`
+  - `contentEncoding` mapping for `.base64()` for OpenAPI 3.1.0+
 - ZodTuple
   - `items` mapping for `.rest()`
   - `prefixItems` mapping for OpenAPI 3.1.0+

package/lib-commonjs/index.js

@@ -108,6 +108,67 @@ var createDefaultSchema = (zodDefault, state) => {
   });
 };
 
+// src/openapi.ts
+var openApiVersions = [
+  "3.0.0",
+  "3.0.1",
+  "3.0.2",
+  "3.0.3",
+  "3.1.0"
+];
+var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
+
+// src/create/schema/parsers/nativeEnum.ts
+var createNativeEnumSchema = (zodEnum, state) => {
+  const enumValues = getValidEnumValues(zodEnum._def.values);
+  const { numbers, strings } = sortStringsAndNumbers(enumValues);
+  if (strings.length && numbers.length) {
+    if (satisfiesVersion(state.components.openapi, "3.1.0"))
+      return {
+        type: "schema",
+        schema: {
+          type: ["string", "number"],
+          enum: [...strings, ...numbers]
+        }
+      };
+    return {
+      type: "schema",
+      schema: {
+        oneOf: [
+          { type: "string", enum: strings },
+          { type: "number", enum: numbers }
+        ]
+      }
+    };
+  }
+  if (strings.length) {
+    return {
+      type: "schema",
+      schema: {
+        type: "string",
+        enum: strings
+      }
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      type: "number",
+      enum: numbers
+    }
+  };
+};
+var getValidEnumValues = (enumValues) => {
+  const keys = Object.keys(enumValues).filter(
+    (key) => typeof enumValues[enumValues[key]] !== "number"
+  );
+  return keys.map((key) => enumValues[key]);
+};
+var sortStringsAndNumbers = (values) => ({
+  strings: values.filter((value) => typeof value === "string"),
+  numbers: values.filter((value) => typeof value === "number")
+});
+
 // src/create/schema/parsers/transform.ts
 var createTransformSchema = (zodTransform, state) => {
   if (zodTransform._def.openapi?.effectType === "output") {
@@ -290,6 +351,33 @@ var createDiscriminatedUnionSchema = (zodDiscriminatedUnion, state) => {
     effects: flattenEffects(schemas.map((schema) => schema.effects))
   };
 };
+var unwrapLiterals = (zodType, state) => {
+  if (isZodType(zodType, "ZodLiteral")) {
+    if (typeof zodType._def.value !== "string") {
+      return void 0;
+    }
+    return [zodType._def.value];
+  }
+  if (isZodType(zodType, "ZodNativeEnum")) {
+    const schema = createNativeEnumSchema(zodType, state);
+    if (schema.type === "schema" && schema.schema.type === "string") {
+      return schema.schema.enum;
+    }
+  }
+  if (isZodType(zodType, "ZodEnum")) {
+    return zodType._def.values;
+  }
+  if (isZodType(zodType, "ZodBranded")) {
+    return unwrapLiterals(zodType._def.type, state);
+  }
+  if (isZodType(zodType, "ZodReadonly")) {
+    return unwrapLiterals(zodType._def.innerType, state);
+  }
+  if (isZodType(zodType, "ZodCatch")) {
+    return unwrapLiterals(zodType._def.innerType, state);
+  }
+  return void 0;
+};
 var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
   if (typeof discriminator !== "string") {
     return void 0;
@@ -302,21 +390,13 @@ var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
       return void 0;
     }
     const value = zodObject.shape[discriminator];
-    if (isZodType(value, "ZodEnum")) {
-      for (const enumValue of value._def.values) {
-        mapping[enumValue] = componentSchemaRef;
-      }
-      continue;
+    const literals = unwrapLiterals(value, state);
+    if (!literals) {
+      return void 0;
     }
-    const literalValue = (value?._def).value;
-    if (typeof literalValue !== "string") {
-      throw new Error(
-        `Discriminator ${discriminator} could not be found in on index ${index} of a discriminated union at ${state.path.join(
-          " > "
-        )}`
-      );
+    for (const enumValue of literals) {
+      mapping[enumValue] = componentSchemaRef;
     }
-    mapping[literalValue] = componentSchemaRef;
   }
   return {
     propertyName: discriminator,
@@ -356,16 +436,6 @@ var createLazySchema = (zodLazy, state) => {
   return createSchemaObject(innerSchema, state, ["lazy schema"]);
 };
 
-// src/openapi.ts
-var openApiVersions = [
-  "3.0.0",
-  "3.0.1",
-  "3.0.2",
-  "3.0.3",
-  "3.1.0"
-];
-var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
-
 // src/create/schema/parsers/null.ts
 var createNullSchema = () => ({
   type: "schema",
@@ -415,57 +485,6 @@ var createManualTypeSchema = (zodSchema, state) => {
   };
 };
 
-// src/create/schema/parsers/nativeEnum.ts
-var createNativeEnumSchema = (zodEnum, state) => {
-  const enumValues = getValidEnumValues(zodEnum._def.values);
-  const { numbers, strings } = sortStringsAndNumbers(enumValues);
-  if (strings.length && numbers.length) {
-    if (satisfiesVersion(state.components.openapi, "3.1.0"))
-      return {
-        type: "schema",
-        schema: {
-          type: ["string", "number"],
-          enum: [...strings, ...numbers]
-        }
-      };
-    return {
-      type: "schema",
-      schema: {
-        oneOf: [
-          { type: "string", enum: strings },
-          { type: "number", enum: numbers }
-        ]
-      }
-    };
-  }
-  if (strings.length) {
-    return {
-      type: "schema",
-      schema: {
-        type: "string",
-        enum: strings
-      }
-    };
-  }
-  return {
-    type: "schema",
-    schema: {
-      type: "number",
-      enum: numbers
-    }
-  };
-};
-var getValidEnumValues = (enumValues) => {
-  const keys = Object.keys(enumValues).filter(
-    (key) => typeof enumValues[enumValues[key]] !== "number"
-  );
-  return keys.map((key) => enumValues[key]);
-};
-var sortStringsAndNumbers = (values) => ({
-  strings: values.filter((value) => typeof value === "string"),
-  numbers: values.filter((value) => typeof value === "number")
-});
-
 // src/create/schema/parsers/nullable.ts
 var createNullableSchema = (zodNullable, state) => {
   const schemaObject = createSchemaObject(zodNullable.unwrap(), state, [
@@ -971,12 +990,13 @@ var createSetSchema = (zodSet, state) => {
 };
 
 // src/create/schema/parsers/string.ts
-var createStringSchema = (zodString) => {
+var createStringSchema = (zodString, state) => {
   const zodStringChecks = getZodStringChecks(zodString);
   const format = mapStringFormat(zodStringChecks);
   const patterns = mapPatterns(zodStringChecks);
   const minLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.min?.[0]?.value;
   const maxLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.max?.[0]?.value;
+  const contentEncoding = satisfiesVersion(state.components.openapi, "3.1.0") ? mapContentEncoding(zodStringChecks) : void 0;
   if (patterns.length <= 1) {
     return {
       type: "schema",
@@ -985,7 +1005,8 @@ var createStringSchema = (zodString) => {
         ...format && { format },
         ...patterns[0] && { pattern: patterns[0] },
         ...minLength !== void 0 && { minLength },
-        ...maxLength !== void 0 && { maxLength }
+        ...maxLength !== void 0 && { maxLength },
+        ...contentEncoding && { contentEncoding }
       }
     };
   }
@@ -998,7 +1019,8 @@ var createStringSchema = (zodString) => {
           ...format && { format },
           ...patterns[0] && { pattern: patterns[0] },
           ...minLength !== void 0 && { minLength },
-          ...maxLength !== void 0 && { maxLength }
+          ...maxLength !== void 0 && { maxLength },
+          ...contentEncoding && { contentEncoding }
         },
         ...patterns.slice(1).map(
           (pattern) => ({
@@ -1064,6 +1086,15 @@ var mapStringFormat = (zodStringChecks) => {
   if (zodStringChecks.datetime) {
     return "date-time";
   }
+  if (zodStringChecks.date) {
+    return "date";
+  }
+  if (zodStringChecks.time) {
+    return "time";
+  }
+  if (zodStringChecks.duration) {
+    return "duration";
+  }
   if (zodStringChecks.email) {
     return "email";
   }
@@ -1072,6 +1103,12 @@ var mapStringFormat = (zodStringChecks) => {
   }
   return void 0;
 };
+var mapContentEncoding = (zodStringChecks) => {
+  if (zodStringChecks.base64) {
+    return "base64";
+  }
+  return void 0;
+};
 
 // src/create/schema/parsers/tuple.ts
 var createTupleSchema = (zodTuple, state) => {
@@ -1191,7 +1228,7 @@ var createSchemaSwitch = (zodSchema, state) => {
     return createManualTypeSchema(zodSchema, state);
   }
   if (isZodType(zodSchema, "ZodString")) {
-    return createStringSchema(zodSchema);
+    return createStringSchema(zodSchema, state);
   }
   if (isZodType(zodSchema, "ZodNumber")) {
     return createNumberSchema(zodSchema, state);

package/lib-esm/index.mjs

@@ -84,6 +84,67 @@ var createDefaultSchema = (zodDefault, state) => {
   });
 };
 
+// src/openapi.ts
+var openApiVersions = [
+  "3.0.0",
+  "3.0.1",
+  "3.0.2",
+  "3.0.3",
+  "3.1.0"
+];
+var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
+
+// src/create/schema/parsers/nativeEnum.ts
+var createNativeEnumSchema = (zodEnum, state) => {
+  const enumValues = getValidEnumValues(zodEnum._def.values);
+  const { numbers, strings } = sortStringsAndNumbers(enumValues);
+  if (strings.length && numbers.length) {
+    if (satisfiesVersion(state.components.openapi, "3.1.0"))
+      return {
+        type: "schema",
+        schema: {
+          type: ["string", "number"],
+          enum: [...strings, ...numbers]
+        }
+      };
+    return {
+      type: "schema",
+      schema: {
+        oneOf: [
+          { type: "string", enum: strings },
+          { type: "number", enum: numbers }
+        ]
+      }
+    };
+  }
+  if (strings.length) {
+    return {
+      type: "schema",
+      schema: {
+        type: "string",
+        enum: strings
+      }
+    };
+  }
+  return {
+    type: "schema",
+    schema: {
+      type: "number",
+      enum: numbers
+    }
+  };
+};
+var getValidEnumValues = (enumValues) => {
+  const keys = Object.keys(enumValues).filter(
+    (key) => typeof enumValues[enumValues[key]] !== "number"
+  );
+  return keys.map((key) => enumValues[key]);
+};
+var sortStringsAndNumbers = (values) => ({
+  strings: values.filter((value) => typeof value === "string"),
+  numbers: values.filter((value) => typeof value === "number")
+});
+
 // src/create/schema/parsers/transform.ts
 var createTransformSchema = (zodTransform, state) => {
   if (zodTransform._def.openapi?.effectType === "output") {
@@ -266,6 +327,33 @@ var createDiscriminatedUnionSchema = (zodDiscriminatedUnion, state) => {
     effects: flattenEffects(schemas.map((schema) => schema.effects))
   };
 };
+var unwrapLiterals = (zodType, state) => {
+  if (isZodType(zodType, "ZodLiteral")) {
+    if (typeof zodType._def.value !== "string") {
+      return void 0;
+    }
+    return [zodType._def.value];
+  }
+  if (isZodType(zodType, "ZodNativeEnum")) {
+    const schema = createNativeEnumSchema(zodType, state);
+    if (schema.type === "schema" && schema.schema.type === "string") {
+      return schema.schema.enum;
+    }
+  }
+  if (isZodType(zodType, "ZodEnum")) {
+    return zodType._def.values;
+  }
+  if (isZodType(zodType, "ZodBranded")) {
+    return unwrapLiterals(zodType._def.type, state);
+  }
+  if (isZodType(zodType, "ZodReadonly")) {
+    return unwrapLiterals(zodType._def.innerType, state);
+  }
+  if (isZodType(zodType, "ZodCatch")) {
+    return unwrapLiterals(zodType._def.innerType, state);
+  }
+  return void 0;
+};
 var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
   if (typeof discriminator !== "string") {
     return void 0;
@@ -278,21 +366,13 @@ var mapDiscriminator = (schemas, zodObjects, discriminator, state) => {
       return void 0;
     }
     const value = zodObject.shape[discriminator];
-    if (isZodType(value, "ZodEnum")) {
-      for (const enumValue of value._def.values) {
-        mapping[enumValue] = componentSchemaRef;
-      }
-      continue;
+    const literals = unwrapLiterals(value, state);
+    if (!literals) {
+      return void 0;
     }
-    const literalValue = (value?._def).value;
-    if (typeof literalValue !== "string") {
-      throw new Error(
-        `Discriminator ${discriminator} could not be found in on index ${index} of a discriminated union at ${state.path.join(
-          " > "
-        )}`
-      );
+    for (const enumValue of literals) {
+      mapping[enumValue] = componentSchemaRef;
     }
-    mapping[literalValue] = componentSchemaRef;
   }
   return {
     propertyName: discriminator,
@@ -332,16 +412,6 @@ var createLazySchema = (zodLazy, state) => {
   return createSchemaObject(innerSchema, state, ["lazy schema"]);
 };
 
-// src/openapi.ts
-var openApiVersions = [
-  "3.0.0",
-  "3.0.1",
-  "3.0.2",
-  "3.0.3",
-  "3.1.0"
-];
-var satisfiesVersion = (test, against) => openApiVersions.indexOf(test) >= openApiVersions.indexOf(against);
-
 // src/create/schema/parsers/null.ts
 var createNullSchema = () => ({
   type: "schema",
@@ -391,57 +461,6 @@ var createManualTypeSchema = (zodSchema, state) => {
   };
 };
 
-// src/create/schema/parsers/nativeEnum.ts
-var createNativeEnumSchema = (zodEnum, state) => {
-  const enumValues = getValidEnumValues(zodEnum._def.values);
-  const { numbers, strings } = sortStringsAndNumbers(enumValues);
-  if (strings.length && numbers.length) {
-    if (satisfiesVersion(state.components.openapi, "3.1.0"))
-      return {
-        type: "schema",
-        schema: {
-          type: ["string", "number"],
-          enum: [...strings, ...numbers]
-        }
-      };
-    return {
-      type: "schema",
-      schema: {
-        oneOf: [
-          { type: "string", enum: strings },
-          { type: "number", enum: numbers }
-        ]
-      }
-    };
-  }
-  if (strings.length) {
-    return {
-      type: "schema",
-      schema: {
-        type: "string",
-        enum: strings
-      }
-    };
-  }
-  return {
-    type: "schema",
-    schema: {
-      type: "number",
-      enum: numbers
-    }
-  };
-};
-var getValidEnumValues = (enumValues) => {
-  const keys = Object.keys(enumValues).filter(
-    (key) => typeof enumValues[enumValues[key]] !== "number"
-  );
-  return keys.map((key) => enumValues[key]);
-};
-var sortStringsAndNumbers = (values) => ({
-  strings: values.filter((value) => typeof value === "string"),
-  numbers: values.filter((value) => typeof value === "number")
-});
-
 // src/create/schema/parsers/nullable.ts
 var createNullableSchema = (zodNullable, state) => {
   const schemaObject = createSchemaObject(zodNullable.unwrap(), state, [
@@ -947,12 +966,13 @@ var createSetSchema = (zodSet, state) => {
 };
 
 // src/create/schema/parsers/string.ts
-var createStringSchema = (zodString) => {
+var createStringSchema = (zodString, state) => {
   const zodStringChecks = getZodStringChecks(zodString);
   const format = mapStringFormat(zodStringChecks);
   const patterns = mapPatterns(zodStringChecks);
   const minLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.min?.[0]?.value;
   const maxLength = zodStringChecks.length?.[0]?.value ?? zodStringChecks.max?.[0]?.value;
+  const contentEncoding = satisfiesVersion(state.components.openapi, "3.1.0") ? mapContentEncoding(zodStringChecks) : void 0;
   if (patterns.length <= 1) {
     return {
       type: "schema",
@@ -961,7 +981,8 @@ var createStringSchema = (zodString) => {
         ...format && { format },
         ...patterns[0] && { pattern: patterns[0] },
         ...minLength !== void 0 && { minLength },
-        ...maxLength !== void 0 && { maxLength }
+        ...maxLength !== void 0 && { maxLength },
+        ...contentEncoding && { contentEncoding }
       }
     };
   }
@@ -974,7 +995,8 @@ var createStringSchema = (zodString) => {
           ...format && { format },
           ...patterns[0] && { pattern: patterns[0] },
           ...minLength !== void 0 && { minLength },
-          ...maxLength !== void 0 && { maxLength }
+          ...maxLength !== void 0 && { maxLength },
+          ...contentEncoding && { contentEncoding }
         },
         ...patterns.slice(1).map(
           (pattern) => ({
@@ -1040,6 +1062,15 @@ var mapStringFormat = (zodStringChecks) => {
   if (zodStringChecks.datetime) {
     return "date-time";
   }
+  if (zodStringChecks.date) {
+    return "date";
+  }
+  if (zodStringChecks.time) {
+    return "time";
+  }
+  if (zodStringChecks.duration) {
+    return "duration";
+  }
   if (zodStringChecks.email) {
     return "email";
   }
@@ -1048,6 +1079,12 @@ var mapStringFormat = (zodStringChecks) => {
   }
   return void 0;
 };
+var mapContentEncoding = (zodStringChecks) => {
+  if (zodStringChecks.base64) {
+    return "base64";
+  }
+  return void 0;
+};
 
 // src/create/schema/parsers/tuple.ts
 var createTupleSchema = (zodTuple, state) => {
@@ -1167,7 +1204,7 @@ var createSchemaSwitch = (zodSchema, state) => {
     return createManualTypeSchema(zodSchema, state);
   }
   if (isZodType(zodSchema, "ZodString")) {
-    return createStringSchema(zodSchema);
+    return createStringSchema(zodSchema, state);
   }
   if (isZodType(zodSchema, "ZodNumber")) {
     return createNumberSchema(zodSchema, state);

package/lib-types/create/schema/parsers/string.d.ts

@@ -1,3 +1,3 @@
 import type { ZodString } from 'zod';
-import type { Schema } from '..';
-export declare const createStringSchema: (zodString: ZodString) => Schema;
+import type { Schema, SchemaState } from '..';
+export declare const createStringSchema: (zodString: ZodString, state: SchemaState) => Schema;

package/lib-types/extendZod.d.ts

@@ -1,4 +1,4 @@
-import type { UnknownKeysParam, ZodDate, ZodObject, ZodRawShape, ZodTypeAny, z } from 'zod';
+import type { ZodDate, ZodObject, ZodTypeAny, z } from 'zod';
 import type { CreationType } from './create/components';
 import type { oas30, oas31 } from './openapi3-ts/dist';
 type SchemaObject = oas30.SchemaObject & oas31.SchemaObject;
@@ -56,7 +56,7 @@ interface ZodOpenApiExtendMetadata {
     extends: ZodObject<any, any, any, any, any>;
 }
 declare module 'zod' {
-    interface ZodType<Output, Def extends ZodTypeDef, Input = Output> {
+    interface ZodType {
         /**
          * Add OpenAPI metadata to a Zod Type
          */
@@ -68,7 +68,7 @@ declare module 'zod' {
          */
         openapi?: ZodOpenApiMetadata<ZodTypeAny>;
     }
-    interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    interface ZodObjectDef {
         extendMetadata?: ZodOpenApiExtendMetadata;
     }
 }

package/lib-types/zodType.d.ts

@@ -1,42 +1,42 @@
-import type { ArrayCardinality, EnumLike, UnknownKeysParam, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodCatch, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodDiscriminatedUnionOption, ZodEffects, ZodEnum, ZodFunction, ZodIntersection, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodPipeline, ZodPromise, ZodRawShape, ZodReadonly, ZodRecord, ZodSet, ZodString, ZodSymbol, ZodTuple, ZodType, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, objectInputType, objectOutputType } from 'zod';
-type ZodTypeMap<T extends ZodTypeAny, U extends ZodTypeAny, V, W extends ZodRawShape, B extends string | number | symbol, Discriminator extends string, Options extends Array<ZodDiscriminatedUnionOption<Discriminator>>, Enum extends [string, ...string[]], Returns extends ZodTypeAny, Args extends ZodTuple, ELike extends EnumLike, Union extends readonly [ZodTypeAny, ...ZodTypeAny[]], UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<W, Catchall, UnknownKeys>, Input = objectInputType<W, Catchall, UnknownKeys>, Cardinality extends ArrayCardinality = 'many'> = {
+import type { EnumLike, UnknownKeysParam, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodCatch, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodFunction, ZodIntersection, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodPipeline, ZodPromise, ZodRawShape, ZodReadonly, ZodRecord, ZodSet, ZodString, ZodSymbol, ZodTuple, ZodType, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUnion, ZodUnionOptions, ZodUnknown, ZodVoid } from 'zod';
+type ZodTypeMap = {
     ZodAny: ZodAny;
-    ZodArray: ZodArray<T, Cardinality>;
+    ZodArray: ZodArray<ZodTypeAny>;
     ZodBigInt: ZodBigInt;
     ZodBoolean: ZodBoolean;
-    ZodBranded: ZodBranded<T, B>;
-    ZodCatch: ZodCatch<T>;
+    ZodBranded: ZodBranded<ZodTypeAny, string | number | symbol>;
+    ZodCatch: ZodCatch<ZodTypeAny>;
     ZodDate: ZodDate;
-    ZodDefault: ZodDefault<T>;
-    ZodDiscriminatedUnion: ZodDiscriminatedUnion<Discriminator, Options>;
-    ZodEffects: ZodEffects<T>;
-    ZodEnum: ZodEnum<Enum>;
-    ZodFunction: ZodFunction<Args, Returns>;
-    ZodIntersection: ZodIntersection<T, U>;
-    ZodLazy: ZodLazy<T>;
-    ZodLiteral: ZodLiteral<V>;
+    ZodDefault: ZodDefault<ZodTypeAny>;
+    ZodDiscriminatedUnion: ZodDiscriminatedUnion<string, any>;
+    ZodEffects: ZodEffects<ZodTypeAny>;
+    ZodEnum: ZodEnum<[string, ...string[]]>;
+    ZodFunction: ZodFunction<ZodTuple<any, any>, ZodTypeAny>;
+    ZodIntersection: ZodIntersection<ZodTypeAny, ZodTypeAny>;
+    ZodLazy: ZodLazy<ZodTypeAny>;
+    ZodLiteral: ZodLiteral<ZodTypeAny>;
     ZodMap: ZodMap;
     ZodNaN: ZodNaN;
-    ZodNativeEnum: ZodNativeEnum<ELike>;
+    ZodNativeEnum: ZodNativeEnum<EnumLike>;
     ZodNever: ZodNever;
     ZodNull: ZodNull;
-    ZodNullable: ZodNullable<T>;
+    ZodNullable: ZodNullable<ZodTypeAny>;
     ZodNumber: ZodNumber;
-    ZodObject: ZodObject<W, UnknownKeys, Catchall, Output, Input>;
-    ZodOptional: ZodOptional<T>;
-    ZodPipeline: ZodPipeline<T, U>;
-    ZodPromise: ZodPromise<T>;
-    ZodReadonly: ZodReadonly<T>;
+    ZodObject: ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+    ZodOptional: ZodOptional<ZodTypeAny>;
+    ZodPipeline: ZodPipeline<ZodTypeAny, ZodTypeAny>;
+    ZodPromise: ZodPromise<ZodTypeAny>;
+    ZodReadonly: ZodReadonly<ZodTypeAny>;
     ZodRecord: ZodRecord;
     ZodSet: ZodSet;
     ZodString: ZodString;
     ZodSymbol: ZodSymbol;
     ZodTuple: ZodTuple;
     ZodUndefined: ZodUndefined;
-    ZodUnion: ZodUnion<Union>;
+    ZodUnion: ZodUnion<ZodUnionOptions>;
     ZodUnknown: ZodUnknown;
     ZodVoid: ZodVoid;
 };
-export declare const isZodType: <T extends ZodTypeAny, U extends ZodTypeAny, V, W extends ZodRawShape, B extends string | number | symbol, Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[], Enum extends [string, ...string[]], Returns extends ZodTypeAny, Args extends ZodTuple<[ZodTypeAny, ...ZodTypeAny[]], null>, ELike extends EnumLike, Union extends readonly [ZodTypeAny, ...ZodTypeAny[]], K extends keyof ZodTypeMap<T, U, V, W, B, Discriminator, Options, Enum, Returns, Args, ELike, Union, UnknownKeys, Catchall, Output, Input, Cardinality>, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<W, Catchall, UnknownKeys>, Input = objectInputType<W, Catchall, UnknownKeys>, Cardinality extends ArrayCardinality = "many">(zodType: unknown, typeName: K) => zodType is ZodTypeMap<T, U, V, W, B, Discriminator, Options, Enum, Returns, Args, ELike, Union, UnknownKeys, Catchall, Output, Input, Cardinality>[K];
-export declare const isAnyZodType: (zodType: unknown) => zodType is ZodType<any, ZodTypeDef, any>;
+export declare const isZodType: <K extends keyof ZodTypeMap>(zodType: unknown, typeName: K) => zodType is ZodTypeMap[K];
+export declare const isAnyZodType: (zodType: unknown) => zodType is ZodType<unknown, ZodTypeDef, unknown>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",
@@ -54,10 +54,10 @@
     "openapi3-ts": "4.3.1",
     "skuba": "8.0.0",
     "yaml": "2.4.1",
-    "zod": "3.22.4"
+    "zod": "3.23.0-beta.2"
   },
   "peerDependencies": {
-    "zod": "~3.21.4 || ~3.22.0"
+    "zod": "^3.21.4"
   },
   "engines": {
     "node": ">=16.11"