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

package/dist/extendZodTypes.d.ts

@@ -0,0 +1,91 @@
+import { ZodTypeAny, z, ZodObject } from 'zod';
+import { CreationType } from './create/components.js';
+import { currentSymbol, previousSymbol } from './extendZodSymbols.js';
+import { SchemaObject as SchemaObject$1, HeaderObject as HeaderObject$1 } from './openapi3-ts/dist/model/openapi30.js';
+import { SchemaObject as SchemaObject$2, ParameterObject, ExampleObject, ReferenceObject, HeaderObject } from './openapi3-ts/dist/model/openapi31.js';
+
+type SchemaObject = SchemaObject$1 & SchemaObject$2;
+type ReplaceDate<T> = T extends Date ? Date | string : T;
+/**
+ * zod-openapi metadata
+ */
+interface ZodOpenApiMetadata<T extends ZodTypeAny, TInferred = Exclude<ReplaceDate<z.input<T> | z.output<T>>, undefined>> extends SchemaObject {
+    example?: TInferred;
+    examples?: [TInferred, ...TInferred[]];
+    default?: TInferred;
+    /**
+     * Used to set the output of a ZodUnion to be `oneOf` instead of `allOf`
+     */
+    unionOneOf?: boolean;
+    /**
+     * Used to output this Zod Schema in the components schemas section. Any usage of this Zod Schema will then be transformed into a $ref.
+     */
+    ref?: string;
+    /**
+     * Used when you are manually adding a Zod Schema to the components section. This controls whether this should be rendered as a request (`input`) or response (`output`). Defaults to `output`
+     */
+    refType?: CreationType;
+    /**
+     * Used to set the created type of an effect.
+     * If this was previously set to `same` and this is throwing an error, your effect is no longer returning the same type.
+     */
+    effectType?: CreationType | (z.input<T> extends z.output<T> ? z.output<T> extends z.input<T> ? 'same' : never : never);
+    /**
+     * Used to set metadata for a parameter, request header or cookie
+     */
+    param?: Partial<ParameterObject> & {
+        example?: TInferred;
+        examples?: Record<string, (ExampleObject & {
+            value: TInferred;
+        }) | ReferenceObject>;
+        /**
+         * Used to output this Zod Schema in the components parameters section. Any usage of this Zod Schema will then be transformed into a $ref.
+         */
+        ref?: string;
+    };
+    /**
+     * Used to set data for a response header
+     */
+    header?: Partial<HeaderObject & HeaderObject$1> & {
+        /**
+         * Used to output this Zod Schema in the components headers section. Any usage of this Zod Schema will then be transformed into a $ref.
+         */
+        ref?: string;
+    };
+    /**
+     * Used to override the generated type. If this is provided no metadata will be generated.
+     */
+    type?: SchemaObject['type'];
+}
+interface ZodOpenApiMetadataDef {
+    /**
+     * Up to date OpenAPI metadata
+     */
+    openapi?: ZodOpenApiMetadata<ZodTypeAny>;
+    /**
+     * Used to keep track of the Zod Schema had `.openapi` called on it
+     */
+    [currentSymbol]?: ZodTypeAny;
+    /**
+     * Used to keep track of the previous Zod Schema that had `.openapi` called on it if another `.openapi` is called.
+     * This can also be present when .extend is called on an object.
+     */
+    [previousSymbol]?: ZodTypeAny;
+}
+interface ZodOpenApiExtendMetadata {
+    extends: ZodObject<any, any, any, any, any>;
+}
+declare module 'zod' {
+    interface ZodType {
+        /**
+         * Add OpenAPI metadata to a Zod Type
+         */
+        openapi<T extends ZodTypeAny>(this: T, metadata: ZodOpenApiMetadata<T>): T;
+    }
+    interface ZodTypeDef {
+        zodOpenApi?: ZodOpenApiMetadataDef;
+    }
+    interface ZodObjectDef {
+        extendMetadata?: ZodOpenApiExtendMetadata;
+    }
+}

package/dist/index.cjs

@@ -1,23 +1,60 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const components = require("./components.chunk.cjs");
-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 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 }
+  };
 };
-exports.createSchema = components.createSchema;
+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.createDocument = createDocument;
+exports.createSchema = createSchema;
+exports.oas30 = oas30;
+exports.oas31 = oas31;

package/dist/index.d.mts

@@ -1,5 +1,7 @@
-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 { 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 { oas31 };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-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 { 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 { oas31 };

package/dist/index.mjs

@@ -1,24 +1,60 @@
-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;
+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 }
+  };
 };
+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
+  createSchema,
+  extendZodWithOpenApi,
+  oas30,
+  oas31
 };

package/dist/openapi.d.ts

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

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

@@ -0,0 +1,291 @@
+import { ServerObject } from './oas-common.js';
+export { ServerVariableObject } from './oas-common.js';
+import { ISpecificationExtension } from './specification-extension.js';
+
+interface OpenAPIObject extends ISpecificationExtension {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+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;
+    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;
+    };
+}
+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;
+}
+type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
+type SchemaObjectFormat = 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
+interface SchemaObject extends ISpecificationExtension {
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    examples?: any[];
+    deprecated?: boolean;
+    type?: SchemaObjectType | SchemaObjectType[];
+    format?: SchemaObjectFormat;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: {
+        [propertyName: string]: SchemaObject | ReferenceObject;
+    };
+    additionalProperties?: SchemaObject | ReferenceObject | boolean;
+    description?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+}
+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[];
+}
+
+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, SchemaObjectFormat, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, TagObject, XmlObject };

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

@@ -59,9 +59,6 @@ interface ComponentsObject extends ISpecificationExtension {
     callbacks?: {
         [callback: string]: CallbackObject | ReferenceObject;
     };
-    pathItems?: {
-        [pathItem: string]: PathItemObject | ReferenceObject;
-    };
 }
 interface PathsObject extends ISpecificationExtension {
     [path: string]: PathItemObject;
@@ -208,7 +205,6 @@ interface ReferenceObject {
 }
 type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array';
 interface SchemaObject extends ISpecificationExtension {
-    $ref?: string;
     discriminator?: DiscriminatorObject;
     readOnly?: boolean;
     writeOnly?: boolean;

package/dist/openapi3-ts/dist/oas30.d.ts

@@ -0,0 +1,3 @@
+export { 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, SchemaObjectFormat, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, TagObject, XmlObject } from './model/openapi30.js';
+export { IExtensionName, IExtensionType, ISpecificationExtension } from './model/specification-extension.js';
+export { ServerObject, ServerVariableObject } from './model/oas-common.js';

package/dist/openapi3-ts/{oas31.d.ts → dist/oas31.d.ts}

@@ -1,3 +1,3 @@
-export { 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 } from './dist/model/openapi31.js';
-export { IExtensionName, IExtensionType, ISpecificationExtension } from './dist/model/specification-extension.js';
-export { ServerObject, ServerVariableObject } from './dist/model/oas-common.js';
+export { 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 } from './model/openapi31.js';
+export { IExtensionName, IExtensionType, ISpecificationExtension } from './model/specification-extension.js';
+export { ServerObject, ServerVariableObject } from './model/oas-common.js';

package/extend/index.d.ts

@@ -0,0 +1 @@
+export * from "../dist/extend";

package/extend/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../dist/extend.cjs",
+  "module": "../dist/extend.mjs",
+  "types": "./index.d.ts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.5",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",
@@ -77,13 +77,13 @@
     "@redocly/cli": "1.34.3",
     "@types/node": "22.15.21",
     "eslint-plugin-zod-openapi": "1.0.0",
-    "openapi3-ts": "4.5.0",
-    "skuba": "11.0.1",
+    "openapi3-ts": "4.4.0",
+    "skuba": "11.0.1-fix-node16-compatibility-20250523051131",
     "yaml": "2.8.0",
-    "zod": "3.25.67"
+    "zod": "3.25.23"
   },
   "peerDependencies": {
-    "zod": "^3.25.67"
+    "zod": "^3.21.4"
   },
   "packageManager": "pnpm@10.11.0",
   "engines": {

package/dist/create/object.d.ts

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