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

package/dist/create/components.d.ts

@@ -1,125 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

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

@@ -1,33 +0,0 @@
-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

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

package/dist/extend.d.mts

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

package/dist/extend.d.ts

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

package/dist/extend.mjs

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

package/dist/extendZod.chunk.cjs

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

@@ -1,96 +0,0 @@
-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

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

package/dist/extendZodSymbols.chunk.cjs

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

package/dist/extendZodSymbols.chunk.mjs

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

package/dist/extendZodSymbols.d.ts

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

package/dist/extendZodTypes.d.ts

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

package/dist/openapi.d.ts

@@ -1,5 +0,0 @@
-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 };
-export type { OpenApiVersion };