zod-openapi 5.0.0-beta.3 → 5.0.0-beta.5

package/dist/create/components.d.ts

@@ -1,65 +1,125 @@
-import { $ZodType } from 'zod/v4/core';
-import { SchemaObject, ReferenceObject, HeaderObject, RequestBodyObject, ResponseObject, ParameterObject, PathItemObject, ComponentsObject } from '../openapi3-ts/dist/model/openapi31.js';
-import { ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiCallbackObject, ZodOpenApiPathItemObject, CreateDocumentOptions, ZodOpenApiComponentsObject } from './document.js';
+import { ZodType } from 'zod';
+import { SchemaObject as SchemaObject$1, ReferenceObject as ReferenceObject$1, ParameterObject as ParameterObject$1, HeaderObject as HeaderObject$1, RequestBodyObject as RequestBodyObject$1, ResponseObject as ResponseObject$1, CallbackObject as CallbackObject$1 } from '../openapi3-ts/dist/model/openapi30.js';
+import { SchemaObject, ReferenceObject, ParameterLocation, ParameterObject, HeaderObject, RequestBodyObject, ResponseObject, CallbackObject, ComponentsObject as ComponentsObject$1 } from '../openapi3-ts/dist/model/openapi31.js';
+import { ZodOpenApiComponentsObject, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiCallbackObject, ZodOpenApiVersion, CreateDocumentOptions } from './document.js';
 
-interface ComponentRegistry {
-    /**
-     * Contains a map of component name to their OpenAPI schema object or reference.
-     */
-    schemas: {
-        dynamicSchemaCount: number;
-        input: Map<string, {
-            zodType: $ZodType;
-            schemaObject: SchemaObject | ReferenceObject;
-        }>;
-        output: Map<string, {
-            zodType: $ZodType;
-            schemaObject: SchemaObject | ReferenceObject;
-        }>;
-        ids: Map<string, SchemaObject | ReferenceObject>;
-        manual: Map<string, {
-            identifier: string;
-            io: {
-                input: {
-                    used: number;
-                    schemaObject: SchemaObject;
-                };
-                output: {
-                    used: number;
-                    schemaObject: SchemaObject;
-                };
-            };
-            zodType: $ZodType;
-        }>;
-        setSchema: (key: string, schema: $ZodType, io: 'input' | 'output') => SchemaObject | ReferenceObject;
-    };
-    headers: {
-        ids: Map<string, HeaderObject | ReferenceObject>;
-        seen: WeakMap<$ZodType, HeaderObject | ReferenceObject>;
-    };
-    requestBodies: {
-        ids: Map<string, RequestBodyObject | ReferenceObject>;
-        seen: WeakMap<ZodOpenApiRequestBodyObject, RequestBodyObject | ReferenceObject>;
-    };
-    responses: {
-        ids: Map<string, ResponseObject | ReferenceObject>;
-        seen: WeakMap<ZodOpenApiResponseObject, ResponseObject | ReferenceObject>;
-    };
-    parameters: {
-        ids: Map<string, ParameterObject | ReferenceObject>;
-        seen: WeakMap<$ZodType, ParameterObject | ReferenceObject>;
-    };
-    callbacks: {
-        ids: Map<string, ZodOpenApiCallbackObject | ReferenceObject>;
-        seen: WeakMap<ZodOpenApiCallbackObject, ZodOpenApiCallbackObject | ReferenceObject>;
-    };
-    pathItems: {
-        ids: Map<string, PathItemObject | ReferenceObject>;
-        seen: WeakMap<ZodOpenApiPathItemObject, PathItemObject | ReferenceObject>;
+type CreationType = 'input' | 'output';
+type BaseEffect = {
+    zodType: ZodType;
+    path: string[];
+};
+type ComponentEffect = BaseEffect & {
+    type: 'component';
+};
+type SchemaEffect = BaseEffect & {
+    type: 'schema';
+    creationType: CreationType;
+};
+type Effect = ComponentEffect | SchemaEffect;
+type ResolvedEffect = {
+    creationType: CreationType;
+    path: string[];
+    zodType: ZodType;
+    component?: {
+        ref: string;
+        zodType: ZodType;
+        path: string[];
     };
+};
+interface CompleteSchemaComponent extends BaseSchemaComponent {
+    type: 'complete';
+    schemaObject: SchemaObject | ReferenceObject | SchemaObject$1 | ReferenceObject$1;
+    /** Set when the created schemaObject is specific to a particular effect */
+    effects?: Effect[];
+    resolvedEffect?: ResolvedEffect;
+}
+/**
+ *
+ */
+interface ManualSchemaComponent extends BaseSchemaComponent {
+    type: 'manual';
+}
+interface InProgressSchemaComponent extends BaseSchemaComponent {
+    type: 'in-progress';
+}
+interface BaseSchemaComponent {
+    ref: string;
+}
+type SchemaComponent = CompleteSchemaComponent | ManualSchemaComponent | InProgressSchemaComponent;
+type SchemaComponentMap = Map<ZodType, SchemaComponent>;
+interface CompleteParameterComponent extends BaseParameterComponent {
+    type: 'complete';
+    paramObject: ParameterObject | ReferenceObject | ParameterObject$1 | ReferenceObject$1;
+}
+interface PartialParameterComponent extends BaseParameterComponent {
+    type: 'manual';
+}
+interface BaseParameterComponent {
+    ref: string;
+    in: ParameterLocation;
+    name: string;
+}
+type ParameterComponent = CompleteParameterComponent | PartialParameterComponent;
+type ParameterComponentMap = Map<ZodType, ParameterComponent>;
+interface CompleteHeaderComponent extends BaseHeaderComponent {
+    type: 'complete';
+    headerObject: HeaderObject | ReferenceObject | HeaderObject$1 | ReferenceObject$1;
+}
+interface PartialHeaderComponent extends BaseHeaderComponent {
+    type: 'manual';
+}
+interface BaseHeaderComponent {
+    ref: string;
+}
+type HeaderComponent = CompleteHeaderComponent | PartialHeaderComponent;
+type HeaderComponentMap = Map<ZodType, HeaderComponent>;
+interface BaseResponseComponent {
+    ref: string;
+}
+interface CompleteResponseComponent extends BaseResponseComponent {
+    type: 'complete';
+    responseObject: ResponseObject | ReferenceObject | ResponseObject$1 | ReferenceObject$1;
+}
+interface PartialResponseComponent extends BaseResponseComponent {
+    type: 'manual';
+}
+type ResponseComponent = CompleteResponseComponent | PartialResponseComponent;
+type ResponseComponentMap = Map<ZodOpenApiResponseObject, ResponseComponent>;
+interface BaseRequestBodyComponent {
+    ref: string;
+}
+interface CompleteRequestBodyComponent extends BaseRequestBodyComponent {
+    type: 'complete';
+    requestBodyObject: RequestBodyObject | ReferenceObject | RequestBodyObject$1 | ReferenceObject$1;
+}
+interface PartialRequestBodyComponent extends BaseRequestBodyComponent {
+    type: 'manual';
+}
+type RequestBodyComponent = CompleteRequestBodyComponent | PartialRequestBodyComponent;
+type RequestBodyComponentMap = Map<ZodOpenApiRequestBodyObject, RequestBodyComponent>;
+interface BaseCallbackComponent {
+    ref: string;
+}
+interface CompleteCallbackComponent extends BaseCallbackComponent {
+    type: 'complete';
+    callbackObject: ZodOpenApiCallbackObject | CallbackObject | CallbackObject$1;
+}
+interface PartialCallbackComponent extends BaseCallbackComponent {
+    type: 'manual';
+}
+type CallbackComponent = CompleteCallbackComponent | PartialCallbackComponent;
+type CallbackComponentMap = Map<ZodOpenApiCallbackObject, CallbackComponent>;
+interface ComponentsObject {
+    schemas: SchemaComponentMap;
+    parameters: ParameterComponentMap;
+    headers: HeaderComponentMap;
+    requestBodies: RequestBodyComponentMap;
+    responses: ResponseComponentMap;
+    callbacks: CallbackComponentMap;
+    openapi: ZodOpenApiVersion;
 }
-declare const createRegistry: (components?: ZodOpenApiComponentsObject) => ComponentRegistry;
-declare const createComponents: (registry: ComponentRegistry, opts: CreateDocumentOptions) => ComponentsObject;
+declare const getDefaultComponents: (componentsObject?: ZodOpenApiComponentsObject, openapi?: ZodOpenApiVersion) => ComponentsObject;
+declare const createComponents: (componentsObject: ZodOpenApiComponentsObject, components: ComponentsObject, documentOptions?: CreateDocumentOptions) => ComponentsObject$1 | undefined;
 
-export { createComponents, createRegistry };
-export type { ComponentRegistry };
+export { createComponents, getDefaultComponents };
+export type { BaseCallbackComponent, CallbackComponent, CallbackComponentMap, CompleteCallbackComponent, CompleteHeaderComponent, CompleteParameterComponent, CompleteRequestBodyComponent, CompleteResponseComponent, CompleteSchemaComponent, ComponentEffect, ComponentsObject, CreationType, Effect, HeaderComponent, HeaderComponentMap, InProgressSchemaComponent, ManualSchemaComponent, ParameterComponent, ParameterComponentMap, PartialCallbackComponent, PartialHeaderComponent, PartialParameterComponent, PartialRequestBodyComponent, PartialResponseComponent, RequestBodyComponent, RequestBodyComponentMap, ResolvedEffect, ResponseComponent, ResponseComponentMap, SchemaComponent, SchemaComponentMap, SchemaEffect };

package/dist/create/content.d.ts

@@ -1,10 +1,8 @@
-import { MediaTypeObject } from '../openapi3-ts/dist/model/openapi31.js';
-import { ComponentRegistry } from './components.js';
-import { ZodOpenApiMediaTypeObject } from './document.js';
+import { ZodType } from 'zod';
+import { SchemaObject, ReferenceObject } from '../openapi3-ts/dist/model/openapi31.js';
+import { ComponentsObject, CreationType } from './components.js';
+import { CreateDocumentOptions } from './document.js';
 
-declare const createMediaTypeObject: (mediaTypeObject: ZodOpenApiMediaTypeObject, ctx: {
-    registry: ComponentRegistry;
-    io: "input" | "output";
-}, path: string[]) => MediaTypeObject;
+declare const createMediaTypeSchema: (schemaObject: ZodType | SchemaObject | ReferenceObject | undefined, components: ComponentsObject, type: CreationType, subpath: string[], documentOptions?: CreateDocumentOptions) => SchemaObject | ReferenceObject | undefined;
 
-export { createMediaTypeObject };
+export { createMediaTypeSchema };

package/dist/create/document.d.ts

@@ -1,50 +1,48 @@
-import { ZodTypeDef, ZodType } from 'zod';
-import { $ZodType, $ZodTypes } from 'zod/v4/core';
+import { ZodType, AnyZodObject, ZodTypeDef } from 'zod';
 import { OpenApiVersion } from '../openapi.js';
+import { MediaTypeObject as MediaTypeObject$1, RequestBodyObject as RequestBodyObject$1, ResponseObject as ResponseObject$1, HeadersObject, ReferenceObject as ReferenceObject$1, ParameterLocation as ParameterLocation$1, PathItemObject as PathItemObject$1, OperationObject as OperationObject$1, ParameterObject as ParameterObject$1, ComponentsObject as ComponentsObject$1, SchemaObject as SchemaObject$1, HeaderObject as HeaderObject$1 } from '../openapi3-ts/dist/model/openapi30.js';
 import { ISpecificationExtension } from '../openapi3-ts/dist/model/specification-extension.js';
-import { RequestBodyObject, MediaTypeObject, SchemaObject, ReferenceObject, ResponseObject, HeadersObject, PathItemObject, OperationObject, ParameterObject, ParameterLocation, HeaderObject, ComponentsObject, OpenAPIObject } from '../openapi3-ts/dist/model/openapi31.js';
-import { Override } from '../zod.js';
+import { MediaTypeObject, SchemaObject, ReferenceObject, RequestBodyObject, ResponseObject, HeadersObject as HeadersObject$1, ParameterLocation, PathItemObject, OperationObject, ParameterObject, ComponentsObject, HeaderObject, OpenAPIObject } from '../openapi3-ts/dist/model/openapi31.js';
 
-interface ZodOpenApiMediaTypeObject extends Omit<MediaTypeObject, 'schema'> {
-    schema?: $ZodType | SchemaObject | ReferenceObject;
+interface ZodOpenApiMediaTypeObject extends Omit<MediaTypeObject & MediaTypeObject$1, 'schema'> {
+    schema?: ZodType | SchemaObject | ReferenceObject;
 }
 interface ZodOpenApiContentObject {
     'application/json'?: ZodOpenApiMediaTypeObject;
     [mediatype: string]: ZodOpenApiMediaTypeObject | undefined;
 }
-interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject, 'content'> {
+interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject & RequestBodyObject$1, 'content'> {
     content: ZodOpenApiContentObject;
     /** Use this field to auto register this request body as a component */
-    id?: string;
+    ref?: string;
 }
-type ZodOpenApiHeadersObject = ZodObjectInput | HeadersObject;
-interface ZodOpenApiResponseObject extends Omit<ResponseObject, 'content' | 'headers'> {
+interface ZodOpenApiResponseObject extends Omit<ResponseObject & ResponseObject$1, 'content' | 'headers'> {
     content?: ZodOpenApiContentObject;
-    headers?: ZodOpenApiHeadersObject;
+    headers?: AnyZodObject | HeadersObject | HeadersObject$1;
     /** Use this field to auto register this response object as a component */
-    id?: string;
+    ref?: string;
 }
 interface ZodOpenApiResponsesObject extends ISpecificationExtension {
-    default?: ZodOpenApiResponseObject | ReferenceObject;
+    default?: ZodOpenApiResponseObject | ReferenceObject | ReferenceObject$1;
     [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | ReferenceObject;
 }
-type ZodOpenApiParameters = Partial<Record<ParameterLocation, ZodObjectInput>>;
+type ZodOpenApiParameters = Partial<Record<ParameterLocation & ParameterLocation$1, ZodObjectInputType>>;
 interface ZodOpenApiCallbacksObject extends ISpecificationExtension {
     [name: string]: ZodOpenApiCallbackObject;
 }
 interface ZodOpenApiCallbackObject extends ISpecificationExtension {
     /** Use this field to auto register this callback object as a component */
-    id?: string;
+    ref?: string;
     [name: string]: ZodOpenApiPathItemObject | string | undefined;
 }
-interface ZodOpenApiOperationObject extends Omit<OperationObject, 'requestBody' | 'responses' | 'parameters' | 'callbacks'> {
-    parameters?: Array<$ZodType | ParameterObject | ReferenceObject>;
+interface ZodOpenApiOperationObject extends Omit<OperationObject & OperationObject$1, 'requestBody' | 'responses' | 'parameters' | 'callbacks'> {
+    parameters?: Array<ZodType | ParameterObject | ParameterObject$1 | ReferenceObject | ReferenceObject$1>;
     requestBody?: ZodOpenApiRequestBodyObject;
     requestParams?: ZodOpenApiParameters;
     responses: ZodOpenApiResponsesObject;
     callbacks?: ZodOpenApiCallbacksObject;
 }
-interface ZodOpenApiPathItemObject extends Omit<PathItemObject, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
+interface ZodOpenApiPathItemObject extends Omit<PathItemObject & PathItemObject$1, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
     get?: ZodOpenApiOperationObject;
     put?: ZodOpenApiOperationObject;
     post?: ZodOpenApiOperationObject;
@@ -53,26 +51,17 @@ interface ZodOpenApiPathItemObject extends Omit<PathItemObject, 'get' | 'put' |
     head?: ZodOpenApiOperationObject;
     patch?: ZodOpenApiOperationObject;
     trace?: ZodOpenApiOperationObject;
-    /**
-     * Used to register this path item as a component.
-     */
-    id?: string;
 }
 interface ZodOpenApiPathsObject extends ISpecificationExtension {
     [path: string]: ZodOpenApiPathItemObject;
 }
-type ZodOpenApiParameterObject = $ZodType | ParameterObject | ReferenceObject;
-type ZodOpenApiHeaderObject = $ZodType | HeaderObject | ReferenceObject;
-type ZodOpenApiSchemaObject = $ZodType | SchemaObject | ReferenceObject;
-type ZodOpenApiRequestBody = $ZodType | RequestBodyObject | ReferenceObject;
-interface ZodOpenApiComponentsObject extends Omit<ComponentsObject, 'schemas' | 'responses' | 'requestBodies' | 'headers' | 'parameters' | 'pathItems' | 'callbacks'> {
-    parameters?: Record<string, ZodOpenApiParameterObject>;
-    schemas?: Record<string, ZodOpenApiSchemaObject>;
+interface ZodOpenApiComponentsObject extends Omit<ComponentsObject & ComponentsObject$1, 'schemas' | 'responses' | 'requestBodies' | 'headers' | 'parameters'> {
+    parameters?: Record<string, ZodType | ParameterObject | ParameterObject$1 | ReferenceObject | ReferenceObject$1>;
+    schemas?: Record<string, ZodType | SchemaObject | ReferenceObject | SchemaObject$1 | ReferenceObject$1>;
     requestBodies?: Record<string, ZodOpenApiRequestBodyObject>;
-    headers?: Record<string, ZodOpenApiHeaderObject>;
+    headers?: Record<string, ZodType | HeaderObject | HeaderObject$1 | ReferenceObject | ReferenceObject$1>;
     responses?: Record<string, ZodOpenApiResponseObject>;
     callbacks?: Record<string, ZodOpenApiCallbackObject>;
-    pathItems?: Record<string, ZodOpenApiPathItemObject>;
 }
 type ZodOpenApiVersion = OpenApiVersion;
 interface ZodOpenApiObject extends Omit<OpenAPIObject, 'openapi' | 'paths' | 'webhooks' | 'components'> {
@@ -82,16 +71,21 @@ interface ZodOpenApiObject extends Omit<OpenAPIObject, 'openapi' | 'paths' | 'we
     components?: ZodOpenApiComponentsObject;
 }
 type ZodObjectInputType<Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Record<string, unknown>> = ZodType<Output, Def, Input>;
-type ZodObjectInput = $ZodType<unknown, Record<string, unknown>>;
-type OverrideType = $ZodTypes['_zod']['def']['type'];
 interface CreateDocumentOptions {
     /**
-     * Use to override the rendered schema
+     * Used to throw an error if a Discriminated Union member is not registered as a component
+     */
+    enforceDiscriminatedUnionComponents?: boolean;
+    /**
+     * Used to change the default Zod Date schema
+     */
+    defaultDateSchema?: Pick<SchemaObject, 'type' | 'format'>;
+    /**
+     * Used to set the output of a ZodUnion to be `oneOf` instead of `anyOf`
      */
-    override?: Override;
-    allowEmptySchema?: Partial<Record<OverrideType, true>>;
+    unionOneOf?: boolean;
 }
-declare const createDocument: (zodOpenApiObject: ZodOpenApiObject, opts?: CreateDocumentOptions) => OpenAPIObject;
+declare const createDocument: (zodOpenApiObject: ZodOpenApiObject, documentOptions?: CreateDocumentOptions) => OpenAPIObject;
 
 export { createDocument };
-export type { CreateDocumentOptions, ZodObjectInput, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiHeaderObject, ZodOpenApiHeadersObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameterObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBody, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiSchemaObject, ZodOpenApiVersion };
+export type { CreateDocumentOptions, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiVersion };

package/dist/create/parameters.d.ts

@@ -1,14 +1,9 @@
-import { $ZodType } from 'zod/v4/core';
-import { ParameterLocation, ParameterObject, ReferenceObject } from '../openapi3-ts/dist/model/openapi31.js';
-import { ComponentRegistry } from './components.js';
-import '../zod.js';
+import { ZodType, AnyZodObject } from 'zod';
+import { ParameterObject, ReferenceObject } from '../openapi3-ts/dist/model/openapi31.js';
+import { ComponentsObject } from './components.js';
+import { ZodOpenApiParameters, CreateDocumentOptions, ZodObjectInputType } from './document.js';
 
-declare const createParameter: (parameter: $ZodType, location: {
-    in: ParameterLocation;
-    name: string;
-} | undefined, ctx: {
-    registry: ComponentRegistry;
-    io: "input" | "output";
-}, path: string[]) => ParameterObject | ReferenceObject;
+declare const createParamOrRef: (zodSchema: ZodType, components: ComponentsObject, subpath: string[], type?: keyof ZodOpenApiParameters, name?: string, documentOptions?: CreateDocumentOptions) => ParameterObject | ReferenceObject;
+declare const getZodObject: (schema: ZodObjectInputType, type: "input" | "output") => AnyZodObject;
 
-export { createParameter };
+export { createParamOrRef, getZodObject };

package/dist/create/schema/single.d.ts

@@ -0,0 +1,33 @@
+import { ZodType } from 'zod';
+import { OpenApiVersion } from '../../openapi.js';
+import { SchemaObject } from '../../openapi3-ts/dist/model/openapi30.js';
+import { SchemaObject as SchemaObject$1, ReferenceObject } from '../../openapi3-ts/dist/model/openapi31.js';
+import { CreationType } from '../components.js';
+import { CreateDocumentOptions } from '../document.js';
+
+interface SchemaResult {
+    schema: SchemaObject | SchemaObject$1 | ReferenceObject;
+    components?: Record<string, SchemaObject | SchemaObject$1 | ReferenceObject> | undefined;
+}
+interface CreateSchemaOptions extends CreateDocumentOptions {
+    /**
+     * This controls whether this should be rendered as a request (`input`) or response (`output`). Defaults to `output`
+     */
+    schemaType?: CreationType;
+    /**
+     * OpenAPI version to use, defaults to `'3.1.0'`
+     */
+    openapi?: OpenApiVersion;
+    /**
+     * Additional components to use and create while rendering the schema
+     */
+    components?: Record<string, ZodType>;
+    /**
+     * The $ref path to use for the component. Defaults to `#/components/schemas/`
+     */
+    componentRefPath?: string;
+}
+declare const createSchema: (zodType: ZodType, opts?: CreateSchemaOptions) => SchemaResult;
+
+export { createSchema };
+export type { CreateSchemaOptions, SchemaResult };

package/dist/extend.cjs

@@ -0,0 +1,4 @@
+"use strict";
+const zod = require("zod");
+const extendZod = require("./extendZod.chunk.cjs");
+extendZod.extendZodWithOpenApi(zod.z);

package/dist/extend.d.mts

@@ -0,0 +1 @@
+import './extendZodTypes.js';

package/dist/extend.d.ts

@@ -0,0 +1 @@
+import './extendZodTypes.js';

package/dist/extend.mjs

@@ -0,0 +1,3 @@
+import { z } from "zod";
+import { extendZodWithOpenApi } from "./extendZod.chunk.mjs";
+extendZodWithOpenApi(z);

package/dist/extendZod.chunk.cjs

@@ -0,0 +1,95 @@
+"use strict";
+const extendZodSymbols = require("./extendZodSymbols.chunk.cjs");
+const mergeOpenApi = (openapi, {
+  ref: _ref,
+  refType: _refType,
+  param: _param,
+  header: _header,
+  ...rest
+} = {}) => ({
+  ...rest,
+  ...openapi
+});
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(openapi) {
+    const { zodOpenApi, ...rest } = this._def;
+    const result = new this.constructor({
+      ...rest,
+      zodOpenApi: {
+        openapi: mergeOpenApi(
+          openapi,
+          zodOpenApi == null ? void 0 : zodOpenApi.openapi
+        )
+      }
+    });
+    result._def.zodOpenApi[extendZodSymbols.currentSymbol] = result;
+    if (zodOpenApi) {
+      result._def.zodOpenApi[extendZodSymbols.previousSymbol] = this;
+    }
+    return result;
+  };
+  const zodDescribe = zod.ZodType.prototype.describe;
+  zod.ZodType.prototype.describe = function(...args) {
+    const result = zodDescribe.apply(this, args);
+    const def = result._def;
+    if (def.zodOpenApi) {
+      const cloned = { ...def.zodOpenApi };
+      cloned.openapi = mergeOpenApi({ description: args[0] }, cloned.openapi);
+      cloned[extendZodSymbols.previousSymbol] = this;
+      cloned[extendZodSymbols.currentSymbol] = result;
+      def.zodOpenApi = cloned;
+    } else {
+      def.zodOpenApi = {
+        openapi: { description: args[0] },
+        [extendZodSymbols.currentSymbol]: result
+      };
+    }
+    return result;
+  };
+  const zodObjectExtend = zod.ZodObject.prototype.extend;
+  zod.ZodObject.prototype.extend = function(...args) {
+    const extendResult = zodObjectExtend.apply(this, args);
+    const zodOpenApi = extendResult._def.zodOpenApi;
+    if (zodOpenApi) {
+      const cloned = { ...zodOpenApi };
+      cloned.openapi = mergeOpenApi({}, cloned.openapi);
+      cloned[extendZodSymbols.previousSymbol] = this;
+      extendResult._def.zodOpenApi = cloned;
+    } else {
+      extendResult._def.zodOpenApi = {
+        [extendZodSymbols.previousSymbol]: this
+      };
+    }
+    return extendResult;
+  };
+  const zodObjectOmit = zod.ZodObject.prototype.omit;
+  zod.ZodObject.prototype.omit = function(...args) {
+    const omitResult = zodObjectOmit.apply(this, args);
+    const zodOpenApi = omitResult._def.zodOpenApi;
+    if (zodOpenApi) {
+      const cloned = { ...zodOpenApi };
+      cloned.openapi = mergeOpenApi({}, cloned.openapi);
+      delete cloned[extendZodSymbols.previousSymbol];
+      delete cloned[extendZodSymbols.currentSymbol];
+      omitResult._def.zodOpenApi = cloned;
+    }
+    return omitResult;
+  };
+  const zodObjectPick = zod.ZodObject.prototype.pick;
+  zod.ZodObject.prototype.pick = function(...args) {
+    const pickResult = zodObjectPick.apply(this, args);
+    const zodOpenApi = pickResult._def.zodOpenApi;
+    if (zodOpenApi) {
+      const cloned = { ...zodOpenApi };
+      cloned.openapi = mergeOpenApi({}, cloned.openapi);
+      delete cloned[extendZodSymbols.previousSymbol];
+      delete cloned[extendZodSymbols.currentSymbol];
+      pickResult._def.zodOpenApi = cloned;
+    }
+    return pickResult;
+  };
+}
+exports.extendZodWithOpenApi = extendZodWithOpenApi;

package/dist/extendZod.chunk.mjs

@@ -0,0 +1,96 @@
+import { currentSymbol, previousSymbol } from "./extendZodSymbols.chunk.mjs";
+const mergeOpenApi = (openapi, {
+  ref: _ref,
+  refType: _refType,
+  param: _param,
+  header: _header,
+  ...rest
+} = {}) => ({
+  ...rest,
+  ...openapi
+});
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(openapi) {
+    const { zodOpenApi, ...rest } = this._def;
+    const result = new this.constructor({
+      ...rest,
+      zodOpenApi: {
+        openapi: mergeOpenApi(
+          openapi,
+          zodOpenApi == null ? void 0 : zodOpenApi.openapi
+        )
+      }
+    });
+    result._def.zodOpenApi[currentSymbol] = result;
+    if (zodOpenApi) {
+      result._def.zodOpenApi[previousSymbol] = this;
+    }
+    return result;
+  };
+  const zodDescribe = zod.ZodType.prototype.describe;
+  zod.ZodType.prototype.describe = function(...args) {
+    const result = zodDescribe.apply(this, args);
+    const def = result._def;
+    if (def.zodOpenApi) {
+      const cloned = { ...def.zodOpenApi };
+      cloned.openapi = mergeOpenApi({ description: args[0] }, cloned.openapi);
+      cloned[previousSymbol] = this;
+      cloned[currentSymbol] = result;
+      def.zodOpenApi = cloned;
+    } else {
+      def.zodOpenApi = {
+        openapi: { description: args[0] },
+        [currentSymbol]: result
+      };
+    }
+    return result;
+  };
+  const zodObjectExtend = zod.ZodObject.prototype.extend;
+  zod.ZodObject.prototype.extend = function(...args) {
+    const extendResult = zodObjectExtend.apply(this, args);
+    const zodOpenApi = extendResult._def.zodOpenApi;
+    if (zodOpenApi) {
+      const cloned = { ...zodOpenApi };
+      cloned.openapi = mergeOpenApi({}, cloned.openapi);
+      cloned[previousSymbol] = this;
+      extendResult._def.zodOpenApi = cloned;
+    } else {
+      extendResult._def.zodOpenApi = {
+        [previousSymbol]: this
+      };
+    }
+    return extendResult;
+  };
+  const zodObjectOmit = zod.ZodObject.prototype.omit;
+  zod.ZodObject.prototype.omit = function(...args) {
+    const omitResult = zodObjectOmit.apply(this, args);
+    const zodOpenApi = omitResult._def.zodOpenApi;
+    if (zodOpenApi) {
+      const cloned = { ...zodOpenApi };
+      cloned.openapi = mergeOpenApi({}, cloned.openapi);
+      delete cloned[previousSymbol];
+      delete cloned[currentSymbol];
+      omitResult._def.zodOpenApi = cloned;
+    }
+    return omitResult;
+  };
+  const zodObjectPick = zod.ZodObject.prototype.pick;
+  zod.ZodObject.prototype.pick = function(...args) {
+    const pickResult = zodObjectPick.apply(this, args);
+    const zodOpenApi = pickResult._def.zodOpenApi;
+    if (zodOpenApi) {
+      const cloned = { ...zodOpenApi };
+      cloned.openapi = mergeOpenApi({}, cloned.openapi);
+      delete cloned[previousSymbol];
+      delete cloned[currentSymbol];
+      pickResult._def.zodOpenApi = cloned;
+    }
+    return pickResult;
+  };
+}
+export {
+  extendZodWithOpenApi
+};

package/dist/extendZod.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import './extendZodTypes.js';
+
+declare function extendZodWithOpenApi(zod: typeof z): void;
+
+export { extendZodWithOpenApi };

package/dist/extendZodSymbols.chunk.cjs

@@ -0,0 +1,5 @@
+"use strict";
+const currentSymbol = Symbol("current");
+const previousSymbol = Symbol("previous");
+exports.currentSymbol = currentSymbol;
+exports.previousSymbol = previousSymbol;

package/dist/extendZodSymbols.chunk.mjs

@@ -0,0 +1,6 @@
+const currentSymbol = Symbol("current");
+const previousSymbol = Symbol("previous");
+export {
+  currentSymbol,
+  previousSymbol
+};

package/dist/extendZodSymbols.d.ts

@@ -0,0 +1,4 @@
+declare const currentSymbol: unique symbol;
+declare const previousSymbol: unique symbol;
+
+export { currentSymbol, previousSymbol };