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

package/dist/create/components.d.ts

@@ -0,0 +1,125 @@
+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';
+
+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 getDefaultComponents: (componentsObject?: ZodOpenApiComponentsObject, openapi?: ZodOpenApiVersion) => ComponentsObject;
+declare const createComponents: (componentsObject: ZodOpenApiComponentsObject, components: ComponentsObject, documentOptions?: CreateDocumentOptions) => ComponentsObject$1 | undefined;
+
+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

@@ -0,0 +1,8 @@
+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 createMediaTypeSchema: (schemaObject: ZodType | SchemaObject | ReferenceObject | undefined, components: ComponentsObject, type: CreationType, subpath: string[], documentOptions?: CreateDocumentOptions) => SchemaObject | ReferenceObject | undefined;
+
+export { createMediaTypeSchema };

package/dist/create/document.d.ts

@@ -0,0 +1,91 @@
+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 { 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 & MediaTypeObject$1, 'schema'> {
+    schema?: ZodType | SchemaObject | ReferenceObject;
+}
+interface ZodOpenApiContentObject {
+    'application/json'?: ZodOpenApiMediaTypeObject;
+    [mediatype: string]: ZodOpenApiMediaTypeObject | undefined;
+}
+interface ZodOpenApiRequestBodyObject extends Omit<RequestBodyObject & RequestBodyObject$1, 'content'> {
+    content: ZodOpenApiContentObject;
+    /** Use this field to auto register this request body as a component */
+    ref?: string;
+}
+interface ZodOpenApiResponseObject extends Omit<ResponseObject & ResponseObject$1, 'content' | 'headers'> {
+    content?: ZodOpenApiContentObject;
+    headers?: AnyZodObject | HeadersObject | HeadersObject$1;
+    /** Use this field to auto register this response object as a component */
+    ref?: string;
+}
+interface ZodOpenApiResponsesObject extends ISpecificationExtension {
+    default?: ZodOpenApiResponseObject | ReferenceObject | ReferenceObject$1;
+    [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | ReferenceObject;
+}
+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 */
+    ref?: 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>;
+    requestBody?: ZodOpenApiRequestBodyObject;
+    requestParams?: ZodOpenApiParameters;
+    responses: ZodOpenApiResponsesObject;
+    callbacks?: ZodOpenApiCallbacksObject;
+}
+interface ZodOpenApiPathItemObject extends Omit<PathItemObject & PathItemObject$1, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
+    get?: ZodOpenApiOperationObject;
+    put?: ZodOpenApiOperationObject;
+    post?: ZodOpenApiOperationObject;
+    delete?: ZodOpenApiOperationObject;
+    options?: ZodOpenApiOperationObject;
+    head?: ZodOpenApiOperationObject;
+    patch?: ZodOpenApiOperationObject;
+    trace?: ZodOpenApiOperationObject;
+}
+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>;
+    requestBodies?: Record<string, ZodOpenApiRequestBodyObject>;
+    headers?: Record<string, ZodType | HeaderObject | HeaderObject$1 | ReferenceObject | ReferenceObject$1>;
+    responses?: Record<string, ZodOpenApiResponseObject>;
+    callbacks?: Record<string, ZodOpenApiCallbackObject>;
+}
+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>;
+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`
+     */
+    unionOneOf?: boolean;
+}
+declare const createDocument: (zodOpenApiObject: ZodOpenApiObject, documentOptions?: CreateDocumentOptions) => OpenAPIObject;
+
+export { createDocument };
+export type { CreateDocumentOptions, ZodObjectInputType, ZodOpenApiCallbackObject, ZodOpenApiCallbacksObject, ZodOpenApiComponentsObject, ZodOpenApiContentObject, ZodOpenApiMediaTypeObject, ZodOpenApiObject, ZodOpenApiOperationObject, ZodOpenApiParameters, ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiResponsesObject, ZodOpenApiVersion };

package/dist/create/parameters.d.ts

@@ -0,0 +1,9 @@
+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 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 { 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 };

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

@@ -0,0 +1,60 @@
+"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 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;