zod-openapi 4.2.3 → 5.0.0-beta.0

package/dist/create/components.d.ts

@@ -1,124 +1,85 @@
-import { ZodType } from 'zod';
-import { SchemaObject as SchemaObject$1, ReferenceObject as ReferenceObject$1, ParameterObject as ParameterObject$1, HeaderObject as HeaderObject$1, ResponseObject as ResponseObject$1, RequestBodyObject as RequestBodyObject$1, CallbackObject as CallbackObject$1 } from '../openapi3-ts/dist/model/openapi30.js';
-import { ComponentsObject as ComponentsObject$1, SchemaObject, ReferenceObject, ParameterObject, ParameterLocation, HeaderObject, ResponseObject, RequestBodyObject, CallbackObject } from '../openapi3-ts/dist/model/openapi31.js';
-import { ZodOpenApiVersion, ZodOpenApiComponentsObject, CreateDocumentOptions, ZodOpenApiResponseObject, ZodOpenApiRequestBodyObject, ZodOpenApiCallbackObject } from './document.js';
+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';
 
-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 ComponentRegistry {
+    /**
+     * Contains a map of component name to their OpenAPI schema object or reference.
+     */
+    schemas: {
+        dynamicSchemaCount: number;
+        input: {
+            seen: WeakMap<$ZodType, {
+                type: 'manual';
+                id: string;
+                schemaObject: SchemaObject | ReferenceObject;
+            } | {
+                type: 'schema';
+                schemaObject: SchemaObject | ReferenceObject;
+            }>;
+            schemas: Map<string, {
+                zodType: $ZodType;
+                schemaObject: SchemaObject | ReferenceObject;
+            }>;
+        };
+        output: {
+            seen: WeakMap<$ZodType, {
+                type: 'manual';
+                id: string;
+                schemaObject: SchemaObject | ReferenceObject;
+            } | {
+                type: 'schema';
+                schemaObject: SchemaObject | ReferenceObject;
+            }>;
+            schemas: Map<string, {
+                zodType: $ZodType;
+                schemaObject: SchemaObject | ReferenceObject;
+            }>;
+        };
+        ids: Map<string, SchemaObject | ReferenceObject>;
+        manual: Map<string, {
+            key: string;
+            io: {
+                input: {
+                    used?: true;
+                    schemaObject: SchemaObject;
+                };
+                output: {
+                    used?: true;
+                    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>;
     };
-};
-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 getDefaultComponents: (componentsObject?: ZodOpenApiComponentsObject, openapi?: ZodOpenApiVersion) => ComponentsObject;
-declare const createComponents: (componentsObject: ZodOpenApiComponentsObject, components: ComponentsObject, documentOptions?: CreateDocumentOptions) => ComponentsObject$1 | undefined;
+declare const createRegistry: (components?: ZodOpenApiComponentsObject) => ComponentRegistry;
+declare const createComponents: (registry: ComponentRegistry, opts: CreateDocumentOptions) => ComponentsObject;
 
-export { type BaseCallbackComponent, type CallbackComponent, type CallbackComponentMap, type CompleteCallbackComponent, type CompleteHeaderComponent, type CompleteParameterComponent, type CompleteRequestBodyComponent, type CompleteResponseComponent, type CompleteSchemaComponent, type ComponentEffect, type ComponentsObject, type CreationType, type Effect, type HeaderComponent, type HeaderComponentMap, type InProgressSchemaComponent, type ManualSchemaComponent, type ParameterComponent, type ParameterComponentMap, type PartialCallbackComponent, type PartialHeaderComponent, type PartialParameterComponent, type PartialRequestBodyComponent, type PartialResponseComponent, type RequestBodyComponent, type RequestBodyComponentMap, type ResolvedEffect, type ResponseComponent, type ResponseComponentMap, type SchemaComponent, type SchemaComponentMap, type SchemaEffect, createComponents, getDefaultComponents };
+export { createComponents, createRegistry };
+export type { ComponentRegistry };

package/dist/create/content.d.ts

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

package/dist/create/document.d.ts

@@ -1,50 +1,50 @@
-import { ZodType, AnyZodObject, ZodTypeDef } from 'zod';
+import { ZodTypeDef, ZodType } from 'zod';
+import { $ZodType, $ZodTypes } from 'zod/v4/core';
 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, OperationObject as OperationObject$1, ParameterObject as ParameterObject$1, PathItemObject as PathItemObject$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 { MediaTypeObject, SchemaObject, ReferenceObject, RequestBodyObject, ResponseObject, HeadersObject as HeadersObject$1, ParameterLocation, OperationObject, ParameterObject, PathItemObject, ComponentsObject, HeaderObject, OpenAPIObject } from '../openapi3-ts/dist/model/openapi31.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';
 
-interface ZodOpenApiMediaTypeObject extends Omit<MediaTypeObject & MediaTypeObject$1, 'schema'> {
-    schema?: ZodType | SchemaObject | ReferenceObject;
+interface ZodOpenApiMediaTypeObject extends Omit<MediaTypeObject, 'schema'> {
+    schema?: $ZodType | SchemaObject | ReferenceObject;
 }
 interface ZodOpenApiContentObject {
     'application/json'?: ZodOpenApiMediaTypeObject;
     [mediatype: string]: ZodOpenApiMediaTypeObject | undefined;
 }
-interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject & RequestBodyObject$1, 'content'> {
+interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject, 'content'> {
     content: ZodOpenApiContentObject;
     /** Use this field to auto register this request body as a component */
-    ref?: string;
+    id?: string;
 }
-interface ZodOpenApiResponseObject extends Omit<ResponseObject & ResponseObject$1, 'content' | 'headers'> {
+type ZodOpenApiHeadersObject = ZodObjectInput | HeadersObject;
+interface ZodOpenApiResponseObject extends Omit<ResponseObject, 'content' | 'headers'> {
     content?: ZodOpenApiContentObject;
-    headers?: AnyZodObject | HeadersObject | HeadersObject$1;
+    headers?: ZodOpenApiHeadersObject;
     /** Use this field to auto register this response object as a component */
-    ref?: string;
+    id?: string;
 }
 interface ZodOpenApiResponsesObject extends ISpecificationExtension {
-    default?: ZodOpenApiResponseObject | ReferenceObject | ReferenceObject$1;
+    default?: ZodOpenApiResponseObject | ReferenceObject;
     [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | ReferenceObject;
 }
-type ZodOpenApiParameters = {
-    [type in ParameterLocation & ParameterLocation$1]?: ZodObjectInputType;
-};
+type ZodOpenApiParameters = Partial<Record<ParameterLocation, ZodObjectInput>>;
 interface ZodOpenApiCallbacksObject extends ISpecificationExtension {
     [name: string]: ZodOpenApiCallbackObject;
 }
 interface ZodOpenApiCallbackObject extends ISpecificationExtension {
     /** Use this field to auto register this callback object as a component */
-    ref?: string;
+    id?: string;
     [name: string]: ZodOpenApiPathItemObject | string | undefined;
 }
-interface ZodOpenApiOperationObject extends Omit<OperationObject & OperationObject$1, 'requestBody' | 'responses' | 'parameters' | 'callbacks'> {
-    parameters?: Array<ZodType | ParameterObject | ParameterObject$1 | ReferenceObject | ReferenceObject$1>;
+interface ZodOpenApiOperationObject extends Omit<OperationObject, 'requestBody' | 'responses' | 'parameters' | 'callbacks'> {
+    parameters?: Array<$ZodType | ParameterObject | ReferenceObject>;
     requestBody?: ZodOpenApiRequestBodyObject;
     requestParams?: ZodOpenApiParameters;
     responses: ZodOpenApiResponsesObject;
     callbacks?: ZodOpenApiCallbacksObject;
 }
-interface ZodOpenApiPathItemObject extends Omit<PathItemObject & PathItemObject$1, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
+interface ZodOpenApiPathItemObject extends Omit<PathItemObject, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
     get?: ZodOpenApiOperationObject;
     put?: ZodOpenApiOperationObject;
     post?: ZodOpenApiOperationObject;
@@ -53,17 +53,26 @@ interface ZodOpenApiPathItemObject extends Omit<PathItemObject & PathItemObject$
     head?: ZodOpenApiOperationObject;
     patch?: ZodOpenApiOperationObject;
     trace?: ZodOpenApiOperationObject;
+    /**
+     * Used to register this path item as a component.
+     */
+    id?: string;
 }
 interface ZodOpenApiPathsObject extends ISpecificationExtension {
     [path: string]: ZodOpenApiPathItemObject;
 }
-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>;
+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>;
     requestBodies?: Record<string, ZodOpenApiRequestBodyObject>;
-    headers?: Record<string, ZodType | HeaderObject | HeaderObject$1 | ReferenceObject | ReferenceObject$1>;
+    headers?: Record<string, ZodOpenApiHeaderObject>;
     responses?: Record<string, ZodOpenApiResponseObject>;
     callbacks?: Record<string, ZodOpenApiCallbackObject>;
+    pathItems?: Record<string, ZodOpenApiPathItemObject>;
 }
 type ZodOpenApiVersion = OpenApiVersion;
 interface ZodOpenApiObject extends Omit<OpenAPIObject, 'openapi' | 'paths' | 'webhooks' | 'components'> {
@@ -73,20 +82,16 @@ 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 {
     /**
-     * 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`
+     * Use to override the rendered schema
      */
-    unionOneOf?: boolean;
+    override?: Override;
+    allowEmptySchema?: Partial<Record<OverrideType, true>>;
 }
-declare const createDocument: (zodOpenApiObject: ZodOpenApiObject, documentOptions?: CreateDocumentOptions) => OpenAPIObject;
+declare const createDocument: (zodOpenApiObject: ZodOpenApiObject, opts?: CreateDocumentOptions) => OpenAPIObject;
 
-export { type CreateDocumentOptions, type ZodObjectInputType, type ZodOpenApiCallbackObject, type ZodOpenApiCallbacksObject, type ZodOpenApiComponentsObject, type ZodOpenApiContentObject, type ZodOpenApiMediaTypeObject, type ZodOpenApiObject, type ZodOpenApiOperationObject, type ZodOpenApiParameters, type ZodOpenApiPathItemObject, type ZodOpenApiPathsObject, type ZodOpenApiRequestBodyObject, type ZodOpenApiResponseObject, type ZodOpenApiResponsesObject, type ZodOpenApiVersion, createDocument };
+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 };

package/dist/create/object.d.ts

@@ -0,0 +1,5 @@
+import { $ZodTypes, $ZodObject } from 'zod/v4/core';
+
+declare const unwrapZodObject: (zodType: $ZodTypes, io: "input" | "output", path: string[]) => $ZodObject;
+
+export { unwrapZodObject };

package/dist/create/parameters.d.ts

@@ -1,9 +1,14 @@
-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';
+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';
 
-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;
+declare const createParameter: (parameter: $ZodType, location: {
+    in: ParameterLocation;
+    name: string;
+} | undefined, ctx: {
+    registry: ComponentRegistry;
+    io: "input" | "output";
+}, path: string[]) => ParameterObject | ReferenceObject;
 
-export { createParamOrRef, getZodObject };
+export { createParameter };

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

@@ -0,0 +1,21 @@
+import { core } from 'zod/v4';
+import { CreateDocumentOptions } from '../document.js';
+import { ComponentRegistry } from '../components.js';
+import '../../zod.js';
+import { SchemaObject, ReferenceObject } from '../../openapi3-ts/dist/model/openapi31.js';
+
+interface SchemaResult {
+    schema: SchemaObject | ReferenceObject;
+    components: Record<string, SchemaObject>;
+}
+declare const createSchema: (schema: core.$ZodType, ctx?: {
+    registry?: ComponentRegistry;
+    io?: "input" | "output";
+    opts?: CreateDocumentOptions;
+}) => {
+    schema: SchemaObject | ReferenceObject;
+    components: Record<string, SchemaObject>;
+};
+
+export { createSchema };
+export type { SchemaResult };

package/dist/index.cjs

@@ -1,60 +1,23 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const components = require("./components.chunk.cjs");
-const extendZod = require("./extendZod.chunk.cjs");
-const createDocument = (zodOpenApiObject, documentOptions) => {
-  const { paths, webhooks, components: components$1 = {}, ...rest } = zodOpenApiObject;
-  const defaultComponents = components.getDefaultComponents(
-    components$1,
-    zodOpenApiObject.openapi
-  );
-  const createdPaths = components.createPaths(paths, defaultComponents, documentOptions);
-  const createdWebhooks = components.createPaths(
-    webhooks,
-    defaultComponents,
-    documentOptions
-  );
-  const createdComponents = components.createComponents(
-    components$1,
-    defaultComponents,
-    documentOptions
-  );
-  return {
-    ...rest,
-    ...createdPaths && { paths: createdPaths },
-    ...createdWebhooks && { webhooks: createdWebhooks },
-    ...createdComponents && { components: createdComponents }
-  };
+const createDocument = (zodOpenApiObject, opts = {}) => {
+  const { paths, webhooks, components: components$1, ...rest } = zodOpenApiObject;
+  const document = rest;
+  const registry = components.createRegistry(components$1);
+  const createdPaths = components.createPaths(paths, registry, ["paths"]);
+  if (createdPaths) {
+    document.paths = createdPaths;
+  }
+  const createdWebhooks = components.createPaths(webhooks, registry, ["webhooks"]);
+  if (createdWebhooks) {
+    document.webhooks = createdWebhooks;
+  }
+  const createdComponents = components.createComponents(registry, opts);
+  if (Object.keys(createdComponents).length > 0) {
+    document.components = createdComponents;
+  }
+  return document;
 };
-const createSchema = (zodType, opts) => {
-  const components$1 = components.getDefaultComponents(
-    {
-      schemas: opts == null ? void 0 : opts.components
-    },
-    opts == null ? void 0 : opts.openapi
-  );
-  const state = {
-    components: components$1,
-    type: (opts == null ? void 0 : opts.schemaType) ?? "output",
-    path: [],
-    visited: /* @__PURE__ */ new Set(),
-    documentOptions: opts
-  };
-  const schema = components.createSchema(zodType, state, ["createSchema"]);
-  const schemaComponents = components.createSchemaComponents({}, components$1);
-  return {
-    schema,
-    components: schemaComponents
-  };
-};
-const oas30 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null
-}, Symbol.toStringTag, { value: "Module" }));
-const oas31 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null
-}, Symbol.toStringTag, { value: "Module" }));
-exports.extendZodWithOpenApi = extendZod.extendZodWithOpenApi;
+exports.createSchema = components.createSchema;
 exports.createDocument = createDocument;
-exports.createSchema = createSchema;
-exports.oas30 = oas30;
-exports.oas31 = oas31;

package/dist/index.d.mts

@@ -1,7 +1,5 @@
-export { CreateDocumentOptions, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiVersion, createDocument } from './create/document.js';
-export { CreateSchemaOptions, SchemaResult, createSchema } from './create/schema/single.js';
-export { extendZodWithOpenApi } from './extendZod.js';
-import * as oas30 from './openapi3-ts/dist/oas30.js';
-export { oas30 };
-import * as oas31 from './openapi3-ts/dist/oas31.js';
+export { CreateDocumentOptions, ZodObjectInput, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiHeaderObject, ZodOpenApiHeadersObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameterObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBody, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiSchemaObject, ZodOpenApiVersion, createDocument } from './create/document.js';
+export { SchemaResult, createSchema } from './create/schema/schema.js';
+export { Override, isAnyZodType } from './zod.js';
+import * as oas31 from './openapi3-ts/oas31.js';
 export { oas31 };

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-export { CreateDocumentOptions, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiVersion, createDocument } from './create/document.js';
-export { CreateSchemaOptions, SchemaResult, createSchema } from './create/schema/single.js';
-export { extendZodWithOpenApi } from './extendZod.js';
-import * as oas30 from './openapi3-ts/dist/oas30.js';
-export { oas30 };
-import * as oas31 from './openapi3-ts/dist/oas31.js';
+export { CreateDocumentOptions, ZodObjectInput, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiHeaderObject, ZodOpenApiHeadersObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameterObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBody, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiSchemaObject, ZodOpenApiVersion, createDocument } from './create/document.js';
+export { SchemaResult, createSchema } from './create/schema/schema.js';
+export { Override, isAnyZodType } from './zod.js';
+import * as oas31 from './openapi3-ts/oas31.js';
 export { oas31 };

package/dist/index.mjs

@@ -1,60 +1,24 @@
-import { getDefaultComponents, createPaths, createComponents, createSchema as createSchema$1, createSchemaComponents } from "./components.chunk.mjs";
-import { extendZodWithOpenApi } from "./extendZod.chunk.mjs";
-const createDocument = (zodOpenApiObject, documentOptions) => {
-  const { paths, webhooks, components = {}, ...rest } = zodOpenApiObject;
-  const defaultComponents = getDefaultComponents(
-    components,
-    zodOpenApiObject.openapi
-  );
-  const createdPaths = createPaths(paths, defaultComponents, documentOptions);
-  const createdWebhooks = createPaths(
-    webhooks,
-    defaultComponents,
-    documentOptions
-  );
-  const createdComponents = createComponents(
-    components,
-    defaultComponents,
-    documentOptions
-  );
-  return {
-    ...rest,
-    ...createdPaths && { paths: createdPaths },
-    ...createdWebhooks && { webhooks: createdWebhooks },
-    ...createdComponents && { components: createdComponents }
-  };
+import { createRegistry, createPaths, createComponents } from "./components.chunk.mjs";
+import { createSchema } from "./components.chunk.mjs";
+const createDocument = (zodOpenApiObject, opts = {}) => {
+  const { paths, webhooks, components, ...rest } = zodOpenApiObject;
+  const document = rest;
+  const registry = createRegistry(components);
+  const createdPaths = createPaths(paths, registry, ["paths"]);
+  if (createdPaths) {
+    document.paths = createdPaths;
+  }
+  const createdWebhooks = createPaths(webhooks, registry, ["webhooks"]);
+  if (createdWebhooks) {
+    document.webhooks = createdWebhooks;
+  }
+  const createdComponents = createComponents(registry, opts);
+  if (Object.keys(createdComponents).length > 0) {
+    document.components = createdComponents;
+  }
+  return document;
 };
-const createSchema = (zodType, opts) => {
-  const components = getDefaultComponents(
-    {
-      schemas: opts == null ? void 0 : opts.components
-    },
-    opts == null ? void 0 : opts.openapi
-  );
-  const state = {
-    components,
-    type: (opts == null ? void 0 : opts.schemaType) ?? "output",
-    path: [],
-    visited: /* @__PURE__ */ new Set(),
-    documentOptions: opts
-  };
-  const schema = createSchema$1(zodType, state, ["createSchema"]);
-  const schemaComponents = createSchemaComponents({}, components);
-  return {
-    schema,
-    components: schemaComponents
-  };
-};
-const oas30 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null
-}, Symbol.toStringTag, { value: "Module" }));
-const oas31 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null
-}, Symbol.toStringTag, { value: "Module" }));
 export {
   createDocument,
-  createSchema,
-  extendZodWithOpenApi,
-  oas30,
-  oas31
+  createSchema
 };

package/dist/openapi.d.ts

@@ -1,4 +1,5 @@
-declare const openApiVersions: readonly ["3.0.0", "3.0.1", "3.0.2", "3.0.3", "3.1.0"];
+declare const openApiVersions: readonly ["3.1.0", "3.1.1"];
 type OpenApiVersion = (typeof openApiVersions)[number];
 
-export { type OpenApiVersion, openApiVersions };
+export { openApiVersions };
+export type { OpenApiVersion };

package/dist/openapi3-ts/dist/model/openapi31.d.ts

@@ -59,6 +59,9 @@ interface ComponentsObject extends ISpecificationExtension {
     callbacks?: {
         [callback: string]: CallbackObject | ReferenceObject;
     };
+    pathItems?: {
+        [pathItem: string]: PathItemObject | ReferenceObject;
+    };
 }
 interface PathsObject extends ISpecificationExtension {
     [path: string]: PathItemObject;
@@ -205,6 +208,7 @@ interface ReferenceObject {
 }
 type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
 interface SchemaObject extends ISpecificationExtension {
+    $ref?: string;
     discriminator?: DiscriminatorObject;
     readOnly?: boolean;
     writeOnly?: boolean;
@@ -294,4 +298,5 @@ interface SecurityRequirementObject {
     [name: string]: string[];
 }
 
-export { type BaseParameterObject, type CallbackObject, type CallbacksObject, type ComponentsObject, type ContactObject, type ContentObject, type DiscriminatorObject, type EncodingObject, type EncodingPropertyObject, type ExampleObject, type ExamplesObject, type ExternalDocumentationObject, type HeaderObject, type HeadersObject, ISpecificationExtension, type InfoObject, type LicenseObject, type LinkObject, type LinkParametersObject, type LinksObject, type MediaTypeObject, type OAuthFlowObject, type OAuthFlowsObject, type OpenAPIObject, type OperationObject, type ParameterLocation, type ParameterObject, type ParameterStyle, type PathItemObject, type PathObject, type PathsObject, type ReferenceObject, type RequestBodyObject, type ResponseObject, type ResponsesObject, type SchemaObject, type SchemaObjectType, type SchemasObject, type ScopesObject, type SecurityRequirementObject, type SecuritySchemeObject, type SecuritySchemeType, ServerObject, type TagObject, type XmlObject };
+export { ISpecificationExtension, ServerObject };
+export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, TagObject, XmlObject };