zod-openapi 2.15.2 → 2.17.0-beta.1

package/README.md

@@ -29,12 +29,25 @@ pnpm install zod zod-openapi
 
 ## Usage
 
-### `extendZodWithOpenApi`
+### Extend Zod
 
 This mutates Zod to add an extra `.openapi()` method. Call this at the top of your entry point(s).
 
-```typescript
+#### Automatic
+
+```ts
+import 'zod-openapi/extend';
 import { z } from 'zod';
+
+z.string().openapi({ description: 'hello world!', example: 'hello world' });
+```
+
+#### Manual
+
+This is useful if you have a different instance of Zod that you would like to extend.
+
+```typescript
+import { z } from 'another-lib';
 import { extendZodWithOpenApi } from 'zod-openapi';
 
 extendZodWithOpenApi(z);
@@ -65,11 +78,10 @@ Creates an OpenAPI documentation object
 import { z } from 'zod';
 import { createDocument, extendZodWithOpenApi } from 'zod-openapi';
 
-extendZodWithOpenApi(z);
-
 const jobId = z.string().openapi({
-  description: 'Job ID',
+  description: 'A unique identifier for a job',
   example: '12345',
+  ref: 'jobId',
 });
 
 const title = z.string().openapi({
@@ -122,10 +134,9 @@ Generates the following object:
           {
             "in": "path",
             "name": "jobId",
+            "description": "A unique identifier for a job",
             "schema": {
-              "type": "string",
-              "description": "Job ID",
-              "example": "12345"
+              "$ref": "#/components/schemas/jobId"
             }
           }
         ],
@@ -155,9 +166,7 @@ Generates the following object:
                   "type": "object",
                   "properties": {
                     "jobId": {
-                      "type": "string",
-                      "description": "Job ID",
-                      "example": "12345"
+                      "$ref": "#/components/schemas/jobId"
                     },
                     "title": {
                       "type": "string",
@@ -173,6 +182,15 @@ Generates the following object:
         }
       }
     }
+  },
+  "components": {
+    "schemas": {
+      "jobId": {
+        "type": "string",
+        "description": "A unique identifier for a job",
+        "example": "12345"
+      }
+    }
   }
 }
 ```
@@ -512,7 +530,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 +559,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/extend.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/extend.ts
+var extend_exports = {};
+module.exports = __toCommonJS(extend_exports);
+var import_zod = require("zod");
+
+// src/extendZod.ts
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(openapi) {
+    const result = new this.constructor({
+      ...this._def,
+      openapi
+    });
+    return result;
+  };
+  const zodObjectExtend = zod.ZodObject.prototype.extend;
+  zod.ZodObject.prototype.extend = function(...args) {
+    const extendResult = zodObjectExtend.apply(this, args);
+    extendResult._def.extendMetadata = {
+      extends: this
+    };
+    delete extendResult._def.openapi;
+    return extendResult;
+  };
+  const zodObjectOmit = zod.ZodObject.prototype.omit;
+  zod.ZodObject.prototype.omit = function(...args) {
+    const omitResult = zodObjectOmit.apply(this, args);
+    delete omitResult._def.extendMetadata;
+    delete omitResult._def.openapi;
+    return omitResult;
+  };
+  const zodObjectPick = zod.ZodObject.prototype.pick;
+  zod.ZodObject.prototype.pick = function(...args) {
+    const pickResult = zodObjectPick.apply(this, args);
+    delete pickResult._def.extendMetadata;
+    delete pickResult._def.openapi;
+    return pickResult;
+  };
+}
+
+// src/extend.ts
+extendZodWithOpenApi(import_zod.z);

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/extend.mjs

@@ -0,0 +1,42 @@
+// src/extend.ts
+import { z } from "zod";
+
+// src/extendZod.ts
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(openapi) {
+    const result = new this.constructor({
+      ...this._def,
+      openapi
+    });
+    return result;
+  };
+  const zodObjectExtend = zod.ZodObject.prototype.extend;
+  zod.ZodObject.prototype.extend = function(...args) {
+    const extendResult = zodObjectExtend.apply(this, args);
+    extendResult._def.extendMetadata = {
+      extends: this
+    };
+    delete extendResult._def.openapi;
+    return extendResult;
+  };
+  const zodObjectOmit = zod.ZodObject.prototype.omit;
+  zod.ZodObject.prototype.omit = function(...args) {
+    const omitResult = zodObjectOmit.apply(this, args);
+    delete omitResult._def.extendMetadata;
+    delete omitResult._def.openapi;
+    return omitResult;
+  };
+  const zodObjectPick = zod.ZodObject.prototype.pick;
+  zod.ZodObject.prototype.pick = function(...args) {
+    const pickResult = zodObjectPick.apply(this, args);
+    delete pickResult._def.extendMetadata;
+    delete pickResult._def.openapi;
+    return pickResult;
+  };
+}
+
+// src/extend.ts
+extendZodWithOpenApi(z);

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/extend.d.ts

@@ -0,0 +1 @@
+export type * from './extendZod';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "2.15.2",
+  "version": "2.17.0-beta.1",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",
@@ -20,12 +20,21 @@
     "url": "git+ssh://git@github.com/samchungy/zod-openapi.git"
   },
   "license": "MIT",
-  "sideEffects": false,
+  "sideEffects": [
+    "./src/extend.ts",
+    "./lib-esm/extend.mjs",
+    "./lib-commonjs/extend.js"
+  ],
   "exports": {
     ".": {
       "import": "./lib-esm/index.mjs",
       "require": "./lib-commonjs/index.js",
       "types": "./lib-types/index.d.ts"
+    },
+    "./extend": {
+      "import": "./lib-esm/extend.mjs",
+      "require": "./lib-commonjs/extend.js",
+      "types": "./lib-types/extend.d.ts"
     }
   },
   "main": "./lib-commonjs/index.js",
@@ -52,9 +61,9 @@
     "@types/node": "^20.3.0",
     "eslint-plugin-zod-openapi": "^0.1.0",
     "openapi3-ts": "4.3.1",
-    "skuba": "8.0.0",
+    "skuba": "8.0.1",
     "yaml": "2.4.1",
-    "zod": "3.22.4"
+    "zod": "3.23.3"
   },
   "peerDependencies": {
     "zod": "^3.21.4"