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

package/README.md

@@ -8,7 +8,7 @@ A TypeScript library which uses <a href="https://github.com/colinhacks/zod">Zod<
 <div align="center">
 <a href="https://www.npmjs.com/package/zod-openapi"><img src="https://img.shields.io/npm/v/zod-openapi"/></a>
 <a href="https://www.npmjs.com/package/zod-openapi"><img src="https://img.shields.io/npm/dm/zod-openapi"/></a>
-<a href="https://nodejs.org/en/"><img src="https://img.shields.io/badge/node-%3E%3D%2018-brightgreen"/></a>
+<a href="https://nodejs.org/en/"><img src="https://img.shields.io/node/v/zod-openapi"/></a>
 <a href="https://github.com/samchungy/zod-openapi/actions/workflows/test.yml"><img src="https://github.com/samchungy/zod-openapi/actions/workflows/test.yml/badge.svg"/></a>
 <a href="https://github.com/samchungy/zod-openapi/actions/workflows/release.yml"><img src="https://github.com/samchungy/zod-openapi/actions/workflows/release.yml/badge.svg"/></a>
 <a href="https://github.com/seek-oss/skuba"><img src="https://img.shields.io/badge/🤿%20skuba-powered-009DC4"/></a>

package/dist/api.d.mts

@@ -1,5 +1,22 @@
-export { createComponents, createRegistry } from './create/components.js';
-export { createMediaTypeObject } from './create/content.js';
-export { createParameter } from './create/parameters.js';
-export { unwrapZodObject } from './create/object.js';
-export { Override, isAnyZodType } from './zod.js';
+import { ComponentRegistry, MediaTypeObject, Override, ParameterLocation, ParameterObject, ReferenceObject, ZodOpenApiMediaTypeObject, createComponents, createRegistry, isAnyZodType } from "./components-DAYTA1Um.mjs";
+import { $ZodObject, $ZodType, $ZodTypes } from "zod/v4/core";
+
+//#region src/create/content.d.ts
+declare const createMediaTypeObject: (mediaTypeObject: ZodOpenApiMediaTypeObject, ctx: {
+  registry: ComponentRegistry;
+  io: "input" | "output";
+}, path: string[]) => MediaTypeObject;
+//#endregion
+//#region src/create/parameters.d.ts
+declare const createParameter: (parameter: $ZodType, location: {
+  in: ParameterLocation;
+  name: string;
+} | undefined, ctx: {
+  registry: ComponentRegistry;
+  io: "input" | "output";
+}, path: string[]) => ParameterObject | ReferenceObject;
+//#endregion
+//#region src/create/object.d.ts
+declare const unwrapZodObject: (zodType: $ZodTypes, io: "input" | "output", path: string[]) => $ZodObject;
+//#endregion
+export { Override, createComponents, createMediaTypeObject, createParameter, createRegistry, isAnyZodType, unwrapZodObject };

package/dist/api.d.ts

@@ -1,5 +1,22 @@
-export { createComponents, createRegistry } from './create/components.js';
-export { createMediaTypeObject } from './create/content.js';
-export { createParameter } from './create/parameters.js';
-export { unwrapZodObject } from './create/object.js';
-export { Override, isAnyZodType } from './zod.js';
+import { ComponentRegistry, MediaTypeObject, Override, ParameterLocation, ParameterObject, ReferenceObject, ZodOpenApiMediaTypeObject, createComponents, createRegistry, isAnyZodType } from "./components-5_CJdR73.js";
+import { $ZodObject, $ZodType, $ZodTypes } from "zod/v4/core";
+
+//#region src/create/content.d.ts
+declare const createMediaTypeObject: (mediaTypeObject: ZodOpenApiMediaTypeObject, ctx: {
+  registry: ComponentRegistry;
+  io: "input" | "output";
+}, path: string[]) => MediaTypeObject;
+//#endregion
+//#region src/create/parameters.d.ts
+declare const createParameter: (parameter: $ZodType, location: {
+  in: ParameterLocation;
+  name: string;
+} | undefined, ctx: {
+  registry: ComponentRegistry;
+  io: "input" | "output";
+}, path: string[]) => ParameterObject | ReferenceObject;
+//#endregion
+//#region src/create/object.d.ts
+declare const unwrapZodObject: (zodType: $ZodTypes, io: "input" | "output", path: string[]) => $ZodObject;
+//#endregion
+export { Override, createComponents, createMediaTypeObject, createParameter, createRegistry, isAnyZodType, unwrapZodObject };

package/dist/api.js

@@ -0,0 +1,8 @@
+require('./zod-i2t01GF0.js');
+const require_components = require('./components-CXjVnBr-.js');
+
+exports.createComponents = require_components.createComponents;
+exports.createMediaTypeObject = require_components.createMediaTypeObject;
+exports.createParameter = require_components.createParameter;
+exports.createRegistry = require_components.createRegistry;
+exports.unwrapZodObject = require_components.unwrapZodObject;

package/dist/api.mjs

@@ -1,8 +1,4 @@
-import { createComponents, createMediaTypeObject, createParameter, createRegistry, unwrapZodObject } from "./components.chunk.mjs";
-export {
-  createComponents,
-  createMediaTypeObject,
-  createParameter,
-  createRegistry,
-  unwrapZodObject
-};
+import "./zod-BvA30wad.mjs";
+import { createComponents, createMediaTypeObject, createParameter, createRegistry, unwrapZodObject } from "./components-CvutxtFV.mjs";
+
+export { createComponents, createMediaTypeObject, createParameter, createRegistry, unwrapZodObject };

package/dist/components-5_CJdR73.d.ts

@@ -0,0 +1,543 @@
+import { $ZodType, $ZodTypes } from "zod/v4/core";
+import { ZodType, ZodTypeDef } from "zod";
+import { core } from "zod/v4";
+
+//#region src/openapi3-ts/dist/model/specification-extension.d.ts
+type IExtensionName = `x-${string}`;
+type IExtensionType = any;
+type ISpecificationExtension = {
+  [extensionName: IExtensionName]: IExtensionType;
+};
+//#endregion
+//#region src/openapi3-ts/dist/model/oas-common.d.ts
+interface ServerObject extends ISpecificationExtension {
+  url: string;
+  description?: string;
+  variables?: {
+    [v: string]: ServerVariableObject;
+  };
+}
+interface ServerVariableObject extends ISpecificationExtension {
+  enum?: string[] | boolean[] | number[];
+  default: string | boolean | number;
+  description?: string;
+}
+//#endregion
+//#region src/openapi3-ts/dist/model/openapi31.d.ts
+interface OpenAPIObject extends ISpecificationExtension {
+  openapi: string;
+  info: InfoObject;
+  servers?: ServerObject[];
+  paths?: PathsObject;
+  components?: ComponentsObject;
+  security?: SecurityRequirementObject[];
+  tags?: TagObject[];
+  externalDocs?: ExternalDocumentationObject;
+  webhooks?: PathsObject;
+}
+interface InfoObject extends ISpecificationExtension {
+  title: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: ContactObject;
+  license?: LicenseObject;
+  version: string;
+}
+interface ContactObject extends ISpecificationExtension {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+interface LicenseObject extends ISpecificationExtension {
+  name: string;
+  identifier?: string;
+  url?: string;
+}
+interface ComponentsObject extends ISpecificationExtension {
+  schemas?: {
+    [schema: string]: SchemaObject | ReferenceObject;
+  };
+  responses?: {
+    [response: string]: ResponseObject | ReferenceObject;
+  };
+  parameters?: {
+    [parameter: string]: ParameterObject | ReferenceObject;
+  };
+  examples?: {
+    [example: string]: ExampleObject | ReferenceObject;
+  };
+  requestBodies?: {
+    [request: string]: RequestBodyObject | ReferenceObject;
+  };
+  headers?: {
+    [header: string]: HeaderObject | ReferenceObject;
+  };
+  securitySchemes?: {
+    [securityScheme: string]: SecuritySchemeObject | ReferenceObject;
+  };
+  links?: {
+    [link: string]: LinkObject | ReferenceObject;
+  };
+  callbacks?: {
+    [callback: string]: CallbackObject | ReferenceObject;
+  };
+  pathItems?: {
+    [pathItem: string]: PathItemObject | ReferenceObject;
+  };
+}
+interface PathsObject extends ISpecificationExtension {
+  [path: string]: PathItemObject;
+}
+type PathObject = PathsObject;
+interface PathItemObject extends ISpecificationExtension {
+  $ref?: string;
+  summary?: string;
+  description?: string;
+  get?: OperationObject;
+  put?: OperationObject;
+  post?: OperationObject;
+  delete?: OperationObject;
+  options?: OperationObject;
+  head?: OperationObject;
+  patch?: OperationObject;
+  trace?: OperationObject;
+  servers?: ServerObject[];
+  parameters?: (ParameterObject | ReferenceObject)[];
+}
+interface OperationObject extends ISpecificationExtension {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+  operationId?: string;
+  parameters?: (ParameterObject | ReferenceObject)[];
+  requestBody?: RequestBodyObject | ReferenceObject;
+  responses?: ResponsesObject;
+  callbacks?: CallbacksObject;
+  deprecated?: boolean;
+  security?: SecurityRequirementObject[];
+  servers?: ServerObject[];
+}
+interface ExternalDocumentationObject extends ISpecificationExtension {
+  description?: string;
+  url: string;
+}
+type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+interface BaseParameterObject extends ISpecificationExtension {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: ParameterStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: SchemaObject | ReferenceObject;
+  examples?: {
+    [param: string]: ExampleObject | ReferenceObject;
+  };
+  example?: any;
+  content?: ContentObject;
+}
+interface ParameterObject extends BaseParameterObject {
+  name: string;
+  in: ParameterLocation;
+}
+interface RequestBodyObject extends ISpecificationExtension {
+  description?: string;
+  content: ContentObject;
+  required?: boolean;
+}
+interface ContentObject {
+  [mediatype: string]: MediaTypeObject;
+}
+interface MediaTypeObject extends ISpecificationExtension {
+  schema?: SchemaObject | ReferenceObject;
+  examples?: ExamplesObject;
+  example?: any;
+  encoding?: EncodingObject;
+}
+interface EncodingObject extends ISpecificationExtension {
+  [property: string]: EncodingPropertyObject | any;
+}
+interface EncodingPropertyObject {
+  contentType?: string;
+  headers?: {
+    [key: string]: HeaderObject | ReferenceObject;
+  };
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+  [key: string]: any;
+}
+interface ResponsesObject extends ISpecificationExtension {
+  default?: ResponseObject | ReferenceObject;
+  [statuscode: string]: ResponseObject | ReferenceObject | any;
+}
+interface ResponseObject extends ISpecificationExtension {
+  description: string;
+  headers?: HeadersObject;
+  content?: ContentObject;
+  links?: LinksObject;
+}
+interface CallbacksObject extends ISpecificationExtension {
+  [name: string]: CallbackObject | ReferenceObject | any;
+}
+interface CallbackObject extends ISpecificationExtension {
+  [name: string]: PathItemObject | any;
+}
+interface HeadersObject {
+  [name: string]: HeaderObject | ReferenceObject;
+}
+interface ExampleObject {
+  summary?: string;
+  description?: string;
+  value?: any;
+  externalValue?: string;
+  [property: string]: any;
+}
+interface LinksObject {
+  [name: string]: LinkObject | ReferenceObject;
+}
+interface LinkObject extends ISpecificationExtension {
+  operationRef?: string;
+  operationId?: string;
+  parameters?: LinkParametersObject;
+  requestBody?: any | string;
+  description?: string;
+  server?: ServerObject;
+  [property: string]: any;
+}
+interface LinkParametersObject {
+  [name: string]: any | string;
+}
+interface HeaderObject extends BaseParameterObject {
+  $ref?: string;
+}
+interface TagObject extends ISpecificationExtension {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+  [extension: string]: any;
+}
+interface ExamplesObject {
+  [name: string]: ExampleObject | ReferenceObject;
+}
+interface ReferenceObject {
+  $ref: string;
+  summary?: string;
+  description?: string;
+}
+type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
+interface SchemaObject extends ISpecificationExtension {
+  $ref?: string;
+  discriminator?: DiscriminatorObject;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  xml?: XmlObject;
+  externalDocs?: ExternalDocumentationObject;
+  example?: any;
+  examples?: any[];
+  deprecated?: boolean;
+  type?: SchemaObjectType | SchemaObjectType[];
+  format?: 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
+  allOf?: (SchemaObject | ReferenceObject)[];
+  oneOf?: (SchemaObject | ReferenceObject)[];
+  anyOf?: (SchemaObject | ReferenceObject)[];
+  not?: SchemaObject | ReferenceObject;
+  items?: SchemaObject | ReferenceObject;
+  properties?: {
+    [propertyName: string]: SchemaObject | ReferenceObject;
+  };
+  additionalProperties?: SchemaObject | ReferenceObject | boolean;
+  propertyNames?: SchemaObject | ReferenceObject;
+  description?: string;
+  default?: any;
+  title?: string;
+  multipleOf?: number;
+  maximum?: number;
+  const?: any;
+  exclusiveMaximum?: number;
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  enum?: any[];
+  prefixItems?: (SchemaObject | ReferenceObject)[];
+  contentMediaType?: string;
+  contentEncoding?: string;
+}
+interface SchemasObject {
+  [schema: string]: SchemaObject;
+}
+interface DiscriminatorObject {
+  propertyName: string;
+  mapping?: {
+    [key: string]: string;
+  };
+}
+interface XmlObject extends ISpecificationExtension {
+  name?: string;
+  namespace?: string;
+  prefix?: string;
+  attribute?: boolean;
+  wrapped?: boolean;
+}
+type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+interface SecuritySchemeObject extends ISpecificationExtension {
+  type: SecuritySchemeType;
+  description?: string;
+  name?: string;
+  in?: string;
+  scheme?: string;
+  bearerFormat?: string;
+  flows?: OAuthFlowsObject;
+  openIdConnectUrl?: string;
+}
+interface OAuthFlowsObject extends ISpecificationExtension {
+  implicit?: OAuthFlowObject;
+  password?: OAuthFlowObject;
+  clientCredentials?: OAuthFlowObject;
+  authorizationCode?: OAuthFlowObject;
+}
+interface OAuthFlowObject extends ISpecificationExtension {
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  refreshUrl?: string;
+  scopes: ScopesObject;
+}
+interface ScopesObject extends ISpecificationExtension {
+  [scope: string]: any;
+}
+interface SecurityRequirementObject {
+  [name: string]: string[];
+}
+//#endregion
+//#region src/openapi.d.ts
+declare const openApiVersions: readonly ["3.1.0", "3.1.1"];
+type OpenApiVersion = (typeof openApiVersions)[number];
+//#endregion
+//#region src/zod.d.ts
+type Override = (ctx: {
+  zodSchema: core.$ZodTypes;
+  jsonSchema: core.JSONSchema.BaseSchema;
+  io: 'input' | 'output';
+}) => void;
+declare const isAnyZodType: (schema: unknown) => schema is core.$ZodTypes;
+declare module 'zod/v4' {
+  interface GlobalMeta {
+    /**
+     * Used to set metadata for a parameter
+     */
+    param?: Partial<ParameterObject> & {
+      /**
+       * Used to output this Zod Schema in the components parameters section. Any usage of this Zod Schema will then be transformed into a $ref.
+       */
+      id?: string;
+    };
+    /**
+     * Used to set metadata for a response header
+     */
+    header?: Partial<HeaderObject> & {
+      /**
+       * Used to output this Zod Schema in the components headers section. Any usage of this Zod Schema will then be transformed into a $ref.
+       */
+      id?: string;
+    };
+    /**
+     * Use to override the rendered schema
+     */
+    override?: SchemaObject | Override;
+    /**
+     * For use only if this Zod Schema is manually registered in the `components` section
+     * and is not used anywhere else in the document.
+     * Defaults to `output` if not specified.
+     */
+    unusedIO?: 'input' | 'output';
+    /**
+     * An alternate id to use for this schema in the event the schema is used in both input and output contexts.
+     * If not specified, the id will be simply derived as the id of the schema plus an `Output` suffix. Please note that `id` must be set.
+     */
+    outputId?: string;
+  }
+}
+//#endregion
+//#region src/create/document.d.ts
+interface ZodOpenApiMediaTypeObject extends Omit<MediaTypeObject, 'schema'> {
+  schema?: $ZodType | SchemaObject | ReferenceObject;
+}
+interface ZodOpenApiContentObject {
+  'application/json'?: ZodOpenApiMediaTypeObject;
+  [mediatype: string]: ZodOpenApiMediaTypeObject | undefined;
+}
+interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject, 'content'> {
+  content: ZodOpenApiContentObject;
+  /** Use this field to auto register this request body as a component */
+  id?: string;
+}
+type ZodOpenApiHeadersObject = ZodObjectInput | HeadersObject;
+interface ZodOpenApiResponseObject extends Omit<ResponseObject, 'content' | 'headers'> {
+  content?: ZodOpenApiContentObject;
+  headers?: ZodOpenApiHeadersObject;
+  /** Use this field to auto register this response object as a component */
+  id?: string;
+}
+interface ZodOpenApiResponsesObject extends ISpecificationExtension {
+  default?: ZodOpenApiResponseObject | ReferenceObject;
+  [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | ReferenceObject;
+}
+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 */
+  id?: string;
+  [name: string]: ZodOpenApiPathItemObject | string | undefined;
+}
+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, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
+  get?: ZodOpenApiOperationObject;
+  put?: ZodOpenApiOperationObject;
+  post?: ZodOpenApiOperationObject;
+  delete?: ZodOpenApiOperationObject;
+  options?: ZodOpenApiOperationObject;
+  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>;
+  requestBodies?: Record<string, ZodOpenApiRequestBodyObject>;
+  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'> {
+  openapi: ZodOpenApiVersion;
+  paths?: ZodOpenApiPathsObject;
+  webhooks?: ZodOpenApiPathsObject;
+  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 this to allowlist empty schemas to be created for given types
+   * - `true` — Allow empty schemas for input and output
+   * - `{ input: true, output: true }` — Allow empty schemas for input and output
+   * - `{ input: true }` — Allow empty schemas for input only
+   * - `{ output: true }` — Allow empty schemas for output only
+   */
+  allowEmptySchema?: Partial<Record<OverrideType, true | Partial<{
+    input: true;
+    output: true;
+  }>>>;
+  /**
+   * Use to override the rendered schema
+   * - `{ type: 'string' }` — Override the schema type to be a string using an object
+   * - `(ctx) => { ctx.jsonSchema.type = 'string'; }` — Override the schema type to be a string using a function
+   */
+  override?: Override;
+  /**
+   * How to handle reused schemas.
+   * - `"ref"` — Reused schemas will be rendered as references
+   * - `"inline"` — Default. Reused schemas will be inlined into the document
+   */
+  reused?: 'ref' | 'inline';
+  /** How to handle cycles.
+   * - `"ref"` — Default. Cycles will be broken using $defs
+   * - `"throw"` — Cycles will throw an error if encountered */
+  cycles?: 'ref' | 'throw';
+}
+declare const createDocument: (zodOpenApiObject: ZodOpenApiObject, opts?: CreateDocumentOptions) => OpenAPIObject;
+//#endregion
+//#region src/create/components.d.ts
+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>;
+  };
+}
+declare const createRegistry: (components?: ZodOpenApiComponentsObject) => ComponentRegistry;
+declare const createComponents: (registry: ComponentRegistry, opts: CreateDocumentOptions) => ComponentsObject;
+//#endregion
+export { BaseParameterObject, CallbackObject, CallbacksObject, ComponentRegistry, ComponentsObject, ContactObject, ContentObject, CreateDocumentOptions, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, IExtensionName, IExtensionType, ISpecificationExtension, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, Override, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TagObject, XmlObject, ZodObjectInput, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiHeaderObject, ZodOpenApiHeadersObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameterObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBody, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiSchemaObject, ZodOpenApiVersion, createComponents, createDocument, createRegistry, isAnyZodType };