zod-openapi 2.12.0 → 2.14.0

package/lib-types/create/components.d.ts

@@ -2,11 +2,34 @@ import type { ZodType } from 'zod';
 import type { oas30, oas31 } from '../openapi3-ts/dist';
 import type { ZodOpenApiComponentsObject, ZodOpenApiRequestBodyObject, ZodOpenApiResponseObject, ZodOpenApiVersion } from './document';
 export type CreationType = 'input' | 'output';
+type BaseEffect = {
+    zodType: ZodType;
+    path: string[];
+};
+export type ComponentEffect = BaseEffect & {
+    type: 'component';
+};
+export type SchemaEffect = BaseEffect & {
+    type: 'schema';
+    creationType: CreationType;
+};
+export type Effect = ComponentEffect | SchemaEffect;
+export type ResolvedEffect = {
+    creationType: CreationType;
+    path: string[];
+    zodType: ZodType;
+    component?: {
+        ref: string;
+        zodType: ZodType;
+        path: string[];
+    };
+};
 export interface CompleteSchemaComponent extends BaseSchemaComponent {
     type: 'complete';
     schemaObject: oas31.SchemaObject | oas31.ReferenceObject | oas30.SchemaObject | oas30.ReferenceObject;
-    /** Set when the created schemaObject is specific to a particular CreationType */
-    creationType?: CreationType;
+    /** Set when the created schemaObject is specific to a particular effect */
+    effects?: Effect[];
+    resolvedEffect?: ResolvedEffect;
 }
 /**
  *

package/lib-types/create/document.d.ts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, ZodType } from 'zod';
+import type { AnyZodObject, ZodType, ZodTypeDef } from 'zod';
 import type { OpenApiVersion } from '../openapi';
 import type { oas30, oas31 } from '../openapi3-ts/dist';
 export interface ZodOpenApiMediaTypeObject extends Omit<oas31.MediaTypeObject & oas30.MediaTypeObject, 'schema'> {
@@ -24,7 +24,7 @@ export interface ZodOpenApiResponsesObject extends oas31.ISpecificationExtension
     [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | oas31.ReferenceObject;
 }
 export type ZodOpenApiParameters = {
-    [type in oas31.ParameterLocation & oas30.ParameterLocation]?: AnyZodObject;
+    [type in oas31.ParameterLocation & oas30.ParameterLocation]?: ZodObjectInputType;
 };
 export interface ZodOpenApiOperationObject extends Omit<oas31.OperationObject & oas30.OperationObject, 'requestBody' | 'responses' | 'parameters'> {
     parameters?: Array<ZodType | oas31.ParameterObject | oas30.ParameterObject | oas31.ReferenceObject | oas30.ReferenceObject>;
@@ -59,4 +59,5 @@ export interface ZodOpenApiObject extends Omit<oas31.OpenAPIObject, 'openapi' |
     webhooks?: ZodOpenApiPathsObject;
     components?: ZodOpenApiComponentsObject;
 }
+export type ZodObjectInputType<Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Record<string, unknown>> = ZodType<Output, Def, Input>;
 export declare const createDocument: (zodOpenApiObject: ZodOpenApiObject) => oas31.OpenAPIObject;

package/lib-types/create/parameters.d.ts

@@ -1,9 +1,10 @@
-import type { ZodType } from 'zod';
+import type { AnyZodObject, ZodType } from 'zod';
 import type { oas30, oas31 } from '../openapi3-ts/dist';
 import type { ComponentsObject } from './components';
-import type { ZodOpenApiParameters } from './document';
+import type { ZodObjectInputType, ZodOpenApiParameters } from './document';
 export declare const createComponentParamRef: (ref: string) => string;
 export declare const createBaseParameter: (schema: ZodType, components: ComponentsObject, subpath: string[]) => oas31.BaseParameterObject;
 export declare const createParamOrRef: (zodSchema: ZodType, components: ComponentsObject, subpath: string[], type?: keyof ZodOpenApiParameters, name?: string) => oas31.ParameterObject | oas31.ReferenceObject;
 export declare const createManualParameters: (parameters: Array<oas31.ParameterObject | oas31.ReferenceObject | oas30.ParameterObject | oas30.ReferenceObject | ZodType> | undefined, components: ComponentsObject, subpath: string[]) => Array<oas31.ParameterObject | oas31.ReferenceObject>;
 export declare const createParametersObject: (parameters: Array<oas31.ParameterObject | oas31.ReferenceObject | oas30.ParameterObject | oas30.ReferenceObject | ZodType> | undefined, requestParams: ZodOpenApiParameters | undefined, components: ComponentsObject, subpath: string[]) => Array<oas31.ParameterObject | oas31.ReferenceObject> | undefined;
+export declare const getZodObject: (schema: ZodObjectInputType, type: 'input' | 'output') => AnyZodObject;

package/lib-types/create/schema/index.d.ts

@@ -1,22 +1,29 @@
 import type { ZodType, ZodTypeDef } from 'zod';
 import type { oas31 } from '../../openapi3-ts/dist';
-import { type ComponentsObject, type CreationType, type SchemaComponent } from '../components';
+import { type ComponentsObject, type CreationType, type Effect, type SchemaComponent } from '../components';
 export type LazyMap = Map<ZodType, true>;
 export interface SchemaState {
     components: ComponentsObject;
     type: CreationType;
-    effectType?: CreationType;
     path: string[];
     visited: Set<ZodType>;
 }
-export declare const newSchemaState: (state: SchemaState) => SchemaState;
-export declare const createNewSchema: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, newState: SchemaState, subpath: string[]) => Schema;
-export declare const createNewRef: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(ref: string, zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => Schema;
-export declare const createExistingRef: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, component: SchemaComponent | undefined, state: SchemaState, subpath: string[]) => Schema | undefined;
-type Schema = {
-    schema: oas31.ReferenceObject | oas31.SchemaObject;
-    newState: SchemaState;
+export declare const createNewSchema: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => Schema;
+export declare const createNewRef: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(ref: string, zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => Schema;
+export declare const createExistingRef: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, component: SchemaComponent | undefined, state: SchemaState) => Schema | undefined;
+export type BaseObject = {
+    effects?: Effect[];
 };
-export declare const createSchemaOrRef: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => Schema;
-export declare const createSchemaObject: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => oas31.ReferenceObject | oas31.SchemaObject;
-export {};
+export type RefObject = BaseObject & {
+    type: 'ref';
+    schema: oas31.ReferenceObject;
+    zodType: ZodType;
+};
+export type SchemaObject = BaseObject & {
+    type: 'schema';
+    schema: oas31.SchemaObject;
+};
+export type Schema = SchemaObject | RefObject;
+export declare const createSchemaOrRef: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => Schema;
+export declare const createSchemaObject: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => Schema;
+export declare const createSchema: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => oas31.SchemaObject | oas31.ReferenceObject;

package/lib-types/create/schema/metadata.d.ts

@@ -1,2 +1,3 @@
 import type { oas31 } from '../../openapi3-ts/dist';
-export declare const enhanceWithMetadata: (schemaObject: oas31.SchemaObject | oas31.ReferenceObject, metadata: oas31.SchemaObject | oas31.ReferenceObject) => oas31.SchemaObject | oas31.ReferenceObject;
+import type { Schema } from '.';
+export declare const enhanceWithMetadata: (schema: Schema, metadata: oas31.SchemaObject | oas31.ReferenceObject) => Schema;

package/lib-types/create/schema/parsers/array.d.ts

@@ -1,4 +1,3 @@
 import type { ArrayCardinality, ZodArray, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createArraySchema: <T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many">(zodArray: ZodArray<T, Cardinality>, state: SchemaState) => oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createArraySchema: <T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many">(zodArray: ZodArray<T, Cardinality>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/boolean.d.ts

@@ -1,3 +1,3 @@
 import type { ZodBoolean } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createBooleanSchema: (_zodBoolean: ZodBoolean) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createBooleanSchema: (_zodBoolean: ZodBoolean) => Schema;

package/lib-types/create/schema/parsers/brand.d.ts

@@ -1,4 +1,3 @@
 import type { ZodBranded, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createBrandedSchema: <T extends ZodTypeAny, B extends string | number | symbol>(zodBranded: ZodBranded<T, B>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createBrandedSchema: <T extends ZodTypeAny, B extends string | number | symbol>(zodBranded: ZodBranded<T, B>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/catch.d.ts

@@ -1,4 +1,3 @@
 import type { ZodCatch, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createCatchSchema: <T extends ZodTypeAny>(zodCatch: ZodCatch<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createCatchSchema: <T extends ZodTypeAny>(zodCatch: ZodCatch<T>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/date.d.ts

@@ -1,3 +1,3 @@
 import type { ZodDate } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createDateSchema: (_zodDate: ZodDate) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createDateSchema: (_zodDate: ZodDate) => Schema;

package/lib-types/create/schema/parsers/default.d.ts

@@ -1,4 +1,3 @@
 import type { ZodDefault, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createDefaultSchema: <T extends ZodTypeAny>(zodDefault: ZodDefault<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createDefaultSchema: <T extends ZodTypeAny>(zodDefault: ZodDefault<T>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/discriminatedUnion.d.ts

@@ -1,5 +1,5 @@
 import type { AnyZodObject, ZodDiscriminatedUnion, ZodDiscriminatedUnionOption } from 'zod';
 import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createDiscriminatedUnionSchema: <Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[]>(zodDiscriminatedUnion: ZodDiscriminatedUnion<Discriminator, Options>, state: SchemaState) => oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createDiscriminatedUnionSchema: <Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[]>(zodDiscriminatedUnion: ZodDiscriminatedUnion<Discriminator, Options>, state: SchemaState) => Schema;
 export declare const mapDiscriminator: (schemas: Array<oas31.SchemaObject | oas31.ReferenceObject>, zodObjects: AnyZodObject[], discriminator: unknown, state: SchemaState) => oas31.SchemaObject['discriminator'];

package/lib-types/create/schema/parsers/enum.d.ts

@@ -1,3 +1,3 @@
 import type { ZodEnum } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createEnumSchema: <T extends [string, ...string[]]>(zodEnum: ZodEnum<T>) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createEnumSchema: <T extends [string, ...string[]]>(zodEnum: ZodEnum<T>) => Schema;

package/lib-types/create/schema/parsers/index.d.ts

@@ -1,4 +1,3 @@
 import type { ZodType, ZodTypeDef } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import type { SchemaState } from '../../schema';
-export declare const createSchemaSwitch: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import type { Schema, SchemaState } from '../../schema';
+export declare const createSchemaSwitch: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/intersection.d.ts

@@ -1,4 +1,3 @@
 import type { ZodIntersection, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createIntersectionSchema: <T extends ZodTypeAny, U extends ZodTypeAny>(zodIntersection: ZodIntersection<T, U>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createIntersectionSchema: <T extends ZodTypeAny, U extends ZodTypeAny>(zodIntersection: ZodIntersection<T, U>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/lazy.d.ts

@@ -1,4 +1,3 @@
 import type { ZodLazy, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createLazySchema: <T extends ZodTypeAny>(zodLazy: ZodLazy<T>, state: SchemaState) => oas31.ReferenceObject | oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createLazySchema: <T extends ZodTypeAny>(zodLazy: ZodLazy<T>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/literal.d.ts

@@ -1,3 +1,3 @@
 import type { ZodLiteral } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createLiteralSchema: (zodLiteral: ZodLiteral<unknown>) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createLiteralSchema: (zodLiteral: ZodLiteral<unknown>) => Schema;

package/lib-types/create/schema/parsers/manual.d.ts

@@ -1,4 +1,3 @@
 import type { ZodType, ZodTypeDef } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import type { SchemaState } from '../../schema';
-export declare const createManualTypeSchema: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => oas31.SchemaObject;
+import type { Schema, SchemaState } from '../../schema';
+export declare const createManualTypeSchema: <Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/nativeEnum.d.ts

@@ -1,7 +1,6 @@
 import type { EnumLike, ZodNativeEnum } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import type { SchemaState } from '../../schema';
-export declare const createNativeEnumSchema: <T extends EnumLike>(zodEnum: ZodNativeEnum<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import type { Schema, SchemaState } from '../../schema';
+export declare const createNativeEnumSchema: <T extends EnumLike>(zodEnum: ZodNativeEnum<T>, state: SchemaState) => Schema;
 interface StringsAndNumbers {
     strings: string[];
     numbers: number[];

package/lib-types/create/schema/parsers/null.d.ts

@@ -1,3 +1,3 @@
 import type { ZodNull } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createNullSchema: (_zodNull: ZodNull) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createNullSchema: (_zodNull: ZodNull) => Schema;

package/lib-types/create/schema/parsers/nullable.d.ts

@@ -1,4 +1,3 @@
 import type { ZodNullable, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createNullableSchema: <T extends ZodTypeAny>(zodNullable: ZodNullable<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createNullableSchema: <T extends ZodTypeAny>(zodNullable: ZodNullable<T>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/number.d.ts

@@ -1,8 +1,8 @@
 import type { ZodNumber, ZodNumberCheck } from 'zod';
 import type { oas30, oas31 } from '../../../openapi3-ts/dist';
 import type { ZodOpenApiVersion } from '../../document';
-import type { SchemaState } from '../../schema';
-export declare const createNumberSchema: (zodNumber: ZodNumber, state: SchemaState) => oas31.SchemaObject;
+import type { Schema, SchemaState } from '../../schema';
+export declare const createNumberSchema: (zodNumber: ZodNumber, state: SchemaState) => Schema;
 export declare const mapMaximum: (zodNumberCheck: ZodNumberCheckMap, openapi: ZodOpenApiVersion) => Pick<oas31.SchemaObject | oas30.SchemaObject, 'maximum' | 'exclusiveMaximum'> | undefined;
 export declare const mapMinimum: (zodNumberCheck: ZodNumberCheckMap, openapi: ZodOpenApiVersion) => Pick<oas31.SchemaObject | oas30.SchemaObject, 'minimum' | 'exclusiveMinimum'> | undefined;
 type ZodNumberCheckMap = {

package/lib-types/create/schema/parsers/object.d.ts

@@ -1,13 +1,21 @@
 import type { UnknownKeysParam, ZodObject, ZodRawShape, ZodType, ZodTypeAny, objectInputType, objectOutputType } from 'zod';
 import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createObjectSchema: <T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>>(zodObject: ZodObject<T, UnknownKeys, Catchall, Output, Input>, state: SchemaState) => oas31.SchemaObject;
-export declare const createExtendedSchema: <T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>>(zodObject: ZodObject<T, UnknownKeys, Catchall, Output, Input>, baseZodObject: ZodObject<T, UnknownKeys, Catchall, Output, Input> | undefined, state: SchemaState) => oas31.SchemaObject | undefined;
+import { type Effect } from '../../components';
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createObjectSchema: <T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>>(zodObject: ZodObject<T, UnknownKeys, Catchall, Output, Input>, state: SchemaState) => Schema;
+export declare const createExtendedSchema: <T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>>(zodObject: ZodObject<T, UnknownKeys, Catchall, Output, Input>, baseZodObject: ZodObject<T, UnknownKeys, Catchall, Output, Input> | undefined, state: SchemaState) => Schema | undefined;
 interface AdditionalPropertyOptions {
     unknownKeys?: UnknownKeysParam;
     catchAll: ZodType;
 }
-export declare const createObjectSchemaFromShape: (shape: ZodRawShape, { unknownKeys, catchAll }: AdditionalPropertyOptions, state: SchemaState) => oas31.SchemaObject;
-export declare const mapRequired: (shape: ZodRawShape, state: SchemaState) => oas31.SchemaObject['required'];
-export declare const mapProperties: (shape: ZodRawShape, state: SchemaState) => oas31.SchemaObject['properties'];
+export declare const createObjectSchemaFromShape: (shape: ZodRawShape, { unknownKeys, catchAll }: AdditionalPropertyOptions, state: SchemaState) => Schema;
+export declare const mapRequired: (shape: ZodRawShape, state: SchemaState) => {
+    required: string[];
+    effects?: Effect[] | undefined;
+} | undefined;
+interface PropertyMap {
+    properties: NonNullable<oas31.SchemaObject['properties']>;
+    effects: Array<Effect[] | undefined>;
+}
+export declare const mapProperties: (shape: ZodRawShape, state: SchemaState) => PropertyMap | undefined;
 export {};

package/lib-types/create/schema/parsers/optional.d.ts

@@ -1,5 +1,10 @@
 import type { ZodOptional, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createOptionalSchema: <T extends ZodTypeAny>(zodOptional: ZodOptional<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
-export declare const isOptionalSchema: (zodSchema: ZodTypeAny, state: SchemaState) => boolean;
+import type { Effect } from '../../components';
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createOptionalSchema: <T extends ZodTypeAny>(zodOptional: ZodOptional<T>, state: SchemaState) => Schema;
+type OptionalResult = {
+    optional: boolean;
+    effects?: Effect[];
+};
+export declare const isOptionalSchema: (zodSchema: ZodTypeAny, state: SchemaState) => OptionalResult;
+export {};

package/lib-types/create/schema/parsers/pipeline.d.ts

@@ -1,4 +1,3 @@
 import type { ZodPipeline, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createPipelineSchema: <A extends ZodTypeAny, B extends ZodTypeAny>(zodPipeline: ZodPipeline<A, B>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createPipelineSchema: <A extends ZodTypeAny, B extends ZodTypeAny>(zodPipeline: ZodPipeline<A, B>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/preprocess.d.ts

@@ -1,4 +1,3 @@
 import type { ZodEffects, ZodTypeAny, input, output } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createPreprocessSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodPreprocess: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createPreprocessSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodPreprocess: ZodEffects<T, Output, Input>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/readonly.d.ts

@@ -1,4 +1,3 @@
 import type { ZodReadonly, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createReadonlySchema: <T extends ZodTypeAny>(zodReadonly: ZodReadonly<T>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createReadonlySchema: <T extends ZodTypeAny>(zodReadonly: ZodReadonly<T>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/record.d.ts

@@ -1,4 +1,3 @@
 import type { KeySchema, ZodRecord, ZodString, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createRecordSchema: <Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny>(zodRecord: ZodRecord<Key, Value>, state: SchemaState) => oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createRecordSchema: <Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny>(zodRecord: ZodRecord<Key, Value>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/refine.d.ts

@@ -1,4 +1,3 @@
 import type { ZodEffects, ZodTypeAny, input, output } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createRefineSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodRefine: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createRefineSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodRefine: ZodEffects<T, Output, Input>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/set.d.ts

@@ -1,4 +1,3 @@
 import type { ZodSet, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createSetSchema: <Value extends ZodTypeAny = ZodTypeAny>(zodSet: ZodSet<Value>, state: SchemaState) => oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createSetSchema: <Value extends ZodTypeAny = ZodTypeAny>(zodSet: ZodSet<Value>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/string.d.ts

@@ -1,3 +1,3 @@
 import type { ZodString } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createStringSchema: (zodString: ZodString) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createStringSchema: (zodString: ZodString) => Schema;

package/lib-types/create/schema/parsers/transform.d.ts

@@ -1,6 +1,10 @@
-import type { ZodEffects, ZodType, ZodTypeAny, input, output } from 'zod';
+import type { ZodEffects, ZodTypeAny, input, output } from 'zod';
 import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createTransformSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodTransform: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+import type { Effect, ResolvedEffect } from '../../components';
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createTransformSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodTransform: ZodEffects<T, Output, Input>, state: SchemaState) => Schema;
 export declare const createManualOutputTransformSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodTransform: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject;
-export declare const throwTransformError: (zodType: ZodType, state: SchemaState) => never;
+export declare const throwTransformError: (effect: ResolvedEffect) => never;
+export declare const resolveEffect: (effects: Effect[], state: SchemaState) => ResolvedEffect | undefined;
+export declare const verifyEffects: (effects: Effect[], state: SchemaState) => void;
+export declare const flattenEffects: (effects: Array<Effect[] | undefined>) => Effect[] | undefined;

package/lib-types/create/schema/parsers/tuple.d.ts

@@ -1,4 +1,3 @@
 import type { ZodTuple, ZodTypeAny } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createTupleSchema: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null>(zodTuple: ZodTuple<T, Rest>, state: SchemaState) => oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createTupleSchema: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null>(zodTuple: ZodTuple<T, Rest>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/union.d.ts

@@ -1,4 +1,3 @@
 import type { ZodTypeAny, ZodUnion } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-import { type SchemaState } from '../../schema';
-export declare const createUnionSchema: <T extends readonly [ZodTypeAny, ...ZodTypeAny[]]>(zodUnion: ZodUnion<T>, state: SchemaState) => oas31.SchemaObject;
+import { type Schema, type SchemaState } from '../../schema';
+export declare const createUnionSchema: <T extends readonly [ZodTypeAny, ...ZodTypeAny[]]>(zodUnion: ZodUnion<T>, state: SchemaState) => Schema;

package/lib-types/create/schema/parsers/unknown.d.ts

@@ -1,3 +1,3 @@
 import type { ZodAny, ZodUnknown } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-export declare const createUnknownSchema: (_zodUnknown: ZodUnknown | ZodAny) => oas31.SchemaObject;
+import type { Schema } from '..';
+export declare const createUnknownSchema: (_zodUnknown: ZodUnknown | ZodAny) => Schema;

package/lib-types/extendZod.d.ts

@@ -2,51 +2,70 @@ import type { UnknownKeysParam, ZodDate, ZodObject, ZodRawShape, ZodTypeAny, z }
 import type { CreationType } from './create/components';
 import type { oas30, oas31 } from './openapi3-ts/dist';
 type SchemaObject = oas30.SchemaObject & oas31.SchemaObject;
+/**
+ * zod-openapi metadata
+ */
 interface ZodOpenApiMetadata<T extends ZodTypeAny, TInferred = z.input<T> | z.output<T>> extends SchemaObject {
     example?: TInferred;
     examples?: [TInferred, ...TInferred[]];
     default?: T extends ZodDate ? string : TInferred;
     /**
-     * Use this field to set the output of a ZodUnion to be `oneOf` instead of `allOf`
+     * Used to set the output of a ZodUnion to be `oneOf` instead of `allOf`
      */
     unionOneOf?: boolean;
     /**
-     * Use this field to output this Zod Schema in the components schemas section. Any usage of this Zod Schema will then be transformed into a $ref.
+     * 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;
     /**
-     * Use this field when you are manually adding a Zod Schema to the components section. This controls whether this should be rendered as request (`input`) or response (`output`). Defaults to `output`
+     * Used when you are manually adding a Zod Schema to the components section. This controls whether this should be rendered as request (`input`) or response (`output`). Defaults to `output`
      */
     refType?: CreationType;
     /**
-     * Use this field to set the created type of an effect.
+     * Used to set the created type of an effect.
+     */
+    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
      */
-    effectType?: CreationType;
     param?: Partial<oas31.ParameterObject> & {
         example?: TInferred;
         examples?: Record<string, (oas31.ExampleObject & {
             value: TInferred;
         }) | oas31.ReferenceObject>;
         /**
-         * Use this field to output this Zod Schema in the components parameters section. Any usage of this Zod Schema will then be transformed into a $ref.
+         * 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<oas31.HeaderObject & oas30.HeaderObject> & {
         /**
-         * Use this field to output this Zod Schema in the components headers section. Any usage of this Zod Schema will then be transformed into a $ref.
+         * 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 ZodOpenApiExtendMetadata {
     extends: ZodObject<any, any, any, any, any>;
 }
 declare module 'zod' {
     interface ZodType<Output, Def extends ZodTypeDef, Input = Output> {
+        /**
+         * Add OpenAPI metadata to a Zod Type
+         */
         openapi<T extends ZodTypeAny>(this: T, metadata: ZodOpenApiMetadata<T>): T;
     }
     interface ZodTypeDef {
+        /**
+         * OpenAPI metadata
+         */
         openapi?: ZodOpenApiMetadata<ZodTypeAny>;
     }
     interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {

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

@@ -88,7 +88,7 @@ export interface OperationObject extends ISpecificationExtension {
     operationId?: string;
     parameters?: (ParameterObject | ReferenceObject)[];
     requestBody?: RequestBodyObject | ReferenceObject;
-    responses: ResponsesObject;
+    responses?: ResponsesObject;
     callbacks?: CallbacksObject;
     deprecated?: boolean;
     security?: SecurityRequirementObject[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",
@@ -21,34 +21,40 @@
   },
   "license": "MIT",
   "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./lib-esm/index.mjs",
+      "require": "./lib-commonjs/index.js",
+      "types": "./lib-types/index.d.ts"
+    }
+  },
   "main": "./lib-commonjs/index.js",
-  "module": "./lib-esm/index.js",
+  "module": "./lib-esm/index.mjs",
   "types": "./lib-types/index.d.ts",
   "files": [
     "lib*/**/*.d.ts",
-    "lib*/**/*.js",
-    "lib*/**/*.js.map",
+    "lib*/**/*.{js,mjs}{,.map}",
     "lib*/**/*.json"
   ],
   "scripts": {
-    "build": "yarn copy:types && node esbuild.mjs && node esbuild.esm.mjs && tsc --allowJS false --declaration --emitDeclarationOnly --outDir lib-types --project tsconfig.build.json",
+    "build": "pnpm copy:types && node esbuild.mjs && node esbuild.esm.mjs && tsc --allowJS false --declaration --emitDeclarationOnly --outDir lib-types --project tsconfig.build.json",
     "copy:types": "skuba node scripts/copyTypes.ts",
     "create:docs": " skuba node examples/simple/createSchema.ts && redocly build-docs examples/simple/openapi.yml --output=examples/simple/redoc-static.html",
     "format": "skuba format",
     "lint": "skuba lint",
-    "prepare": "yarn build",
+    "prepare": "pnpm build",
     "test": "skuba test",
     "test:ci": "skuba test --coverage",
     "test:watch": "skuba test --watch"
   },
   "dependencies": {},
   "devDependencies": {
-    "@redocly/cli": "1.6.0",
+    "@redocly/cli": "1.9.1",
     "@types/node": "^20.3.0",
     "eslint-plugin-zod-openapi": "^0.1.0",
-    "openapi3-ts": "4.2.1",
-    "skuba": "7.3.1",
-    "yaml": "2.3.4",
+    "openapi3-ts": "4.2.2",
+    "skuba": "7.5.0",
+    "yaml": "2.4.0",
     "zod": "3.22.4"
   },
   "peerDependencies": {
@@ -65,6 +71,6 @@
     "entryPoint": "src/index.ts",
     "template": "oss-npm-package",
     "type": "package",
-    "version": "6.0.0"
+    "version": "7.4.1"
   }
 }