zod-openapi 2.8.0 → 2.9.0

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

@@ -10,13 +10,13 @@ export interface SchemaState {
     visited: Set<ZodType>;
 }
 export declare const newSchemaState: (state: SchemaState) => SchemaState;
-export declare const createNewSchema: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, newState: SchemaState, subpath: string[]) => Schema;
-export declare const createNewRef: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(ref: string, zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => Schema;
-export declare const createExistingRef: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, component: SchemaComponent | undefined, state: SchemaState, subpath: string[]) => Schema | undefined;
+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 createSchemaOrRef: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => Schema;
-export declare const createSchemaObject: <Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output>(zodSchema: ZodType<Output, Def, Input>, state: SchemaState, subpath: string[]) => oas31.ReferenceObject | oas31.SchemaObject;
+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 {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<any>) => oas31.SchemaObject;
+export declare const createLiteralSchema: (zodLiteral: ZodLiteral<unknown>) => oas31.SchemaObject;

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

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

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

@@ -6,6 +6,6 @@ interface StringsAndNumbers {
     strings: string[];
     numbers: number[];
 }
-export declare const getValidEnumValues: (enumValues: EnumLike) => (string | number)[];
-export declare const sortStringsAndNumbers: (values: (string | number)[]) => StringsAndNumbers;
+export declare const getValidEnumValues: (enumValues: EnumLike) => number[];
+export declare const sortStringsAndNumbers: (values: Array<string | number>) => StringsAndNumbers;
 export {};

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

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

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

@@ -3,7 +3,6 @@ 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;
-export declare const mapNumberChecks: () => void;
 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,8 +1,8 @@
-import type { UnknownKeysParam, ZodObject, ZodRawShape, ZodType } from 'zod';
+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>(zodObject: ZodObject<T, UnknownKeys, any, any, any>, state: SchemaState) => oas31.SchemaObject;
-export declare const createExtendedSchema: (zodObject: ZodObject<any, any, any, any, any>, baseZodObject: ZodObject<any, any, any, any, any> | undefined, state: SchemaState) => oas31.SchemaObject | undefined;
+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;
 interface AdditionalPropertyOptions {
     unknownKeys?: UnknownKeysParam;
     catchAll: ZodType;

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

@@ -1,5 +1,5 @@
 import type { ZodOptional, ZodTypeAny } from 'zod';
 import type { oas31 } from '../../../openapi3-ts/dist';
 import { type SchemaState } from '../../schema';
-export declare const createOptionalSchema: (zodOptional: ZodOptional<any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+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;

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

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

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

@@ -1,4 +1,4 @@
-import type { ZodEffects } 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 createPreprocessSchema: (zodPreprocess: ZodEffects<any, any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+export declare const createPreprocessSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodPreprocess: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { ZodEffects } 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 createRefineSchema: (zodRefine: ZodEffects<any, any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+export declare const createRefineSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodRefine: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;

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

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

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

@@ -1,5 +1,5 @@
-import type { ZodEffects, ZodType } from 'zod';
+import type { ZodEffects, ZodType, ZodTypeAny, input, output } from 'zod';
 import type { oas31 } from '../../../openapi3-ts/dist';
 import { type SchemaState } from '../../schema';
-export declare const createTransformSchema: (zodTransform: ZodEffects<any, any, any>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
+export declare const createTransformSchema: <T extends ZodTypeAny, Output = output<T>, Input = input<T>>(zodTransform: ZodEffects<T, Output, Input>, state: SchemaState) => oas31.SchemaObject | oas31.ReferenceObject;
 export declare const throwTransformError: (zodType: ZodType, state: SchemaState) => never;

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

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

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

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

package/lib-types/extendZod.d.ts

@@ -20,11 +20,9 @@ interface ZodOpenApiMetadata<T extends ZodTypeAny, TInferred = z.input<T> | z.ou
     effectType?: CreationType;
     param?: Partial<oas31.ParameterObject> & {
         example?: TInferred;
-        examples?: {
-            [param: string]: (oas31.ExampleObject & {
-                value: TInferred;
-            }) | oas31.ReferenceObject;
-        };
+        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.
          */

package/lib-types/zodType.d.ts

@@ -1,42 +1,42 @@
-import type { ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodCatch, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodFunction, ZodIntersection, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodPipeline, ZodPromise, ZodReadonly, ZodRecord, ZodSet, ZodString, ZodSymbol, ZodTuple, ZodType, ZodTypeDef, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid } from 'zod';
-type ZodTypeMap = {
+import type { ArrayCardinality, EnumLike, UnknownKeysParam, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodCatch, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodDiscriminatedUnionOption, ZodEffects, ZodEnum, ZodFunction, ZodIntersection, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodPipeline, ZodPromise, ZodRawShape, ZodReadonly, ZodRecord, ZodSet, ZodString, ZodSymbol, ZodTuple, ZodType, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, objectInputType, objectOutputType } from 'zod';
+type ZodTypeMap<T extends ZodTypeAny, U extends ZodTypeAny, V, W extends ZodRawShape, B extends string | number | symbol, Discriminator extends string, Options extends Array<ZodDiscriminatedUnionOption<Discriminator>>, Enum extends [string, ...string[]], Returns extends ZodTypeAny, Args extends ZodTuple, ELike extends EnumLike, Union extends readonly [ZodTypeAny, ...ZodTypeAny[]], UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<W, Catchall, UnknownKeys>, Input = objectInputType<W, Catchall, UnknownKeys>, Cardinality extends ArrayCardinality = 'many'> = {
     ZodAny: ZodAny;
-    ZodArray: ZodArray<any>;
+    ZodArray: ZodArray<T, Cardinality>;
     ZodBigInt: ZodBigInt;
     ZodBoolean: ZodBoolean;
-    ZodBranded: ZodBranded<any, any>;
-    ZodCatch: ZodCatch<any>;
+    ZodBranded: ZodBranded<T, B>;
+    ZodCatch: ZodCatch<T>;
     ZodDate: ZodDate;
-    ZodDefault: ZodDefault<any>;
-    ZodDiscriminatedUnion: ZodDiscriminatedUnion<any, any>;
-    ZodEffects: ZodEffects<any>;
-    ZodEnum: ZodEnum<any>;
-    ZodFunction: ZodFunction<any, any>;
-    ZodIntersection: ZodIntersection<any, any>;
-    ZodLazy: ZodLazy<any>;
-    ZodLiteral: ZodLiteral<any>;
+    ZodDefault: ZodDefault<T>;
+    ZodDiscriminatedUnion: ZodDiscriminatedUnion<Discriminator, Options>;
+    ZodEffects: ZodEffects<T>;
+    ZodEnum: ZodEnum<Enum>;
+    ZodFunction: ZodFunction<Args, Returns>;
+    ZodIntersection: ZodIntersection<T, U>;
+    ZodLazy: ZodLazy<T>;
+    ZodLiteral: ZodLiteral<V>;
     ZodMap: ZodMap;
     ZodNaN: ZodNaN;
-    ZodNativeEnum: ZodNativeEnum<any>;
+    ZodNativeEnum: ZodNativeEnum<ELike>;
     ZodNever: ZodNever;
     ZodNull: ZodNull;
-    ZodNullable: ZodNullable<any>;
+    ZodNullable: ZodNullable<T>;
     ZodNumber: ZodNumber;
-    ZodObject: ZodObject<any>;
-    ZodOptional: ZodOptional<any>;
-    ZodPipeline: ZodPipeline<any, any>;
-    ZodPromise: ZodPromise<any>;
-    ZodReadonly: ZodReadonly<any>;
+    ZodObject: ZodObject<W, UnknownKeys, Catchall, Output, Input>;
+    ZodOptional: ZodOptional<T>;
+    ZodPipeline: ZodPipeline<T, U>;
+    ZodPromise: ZodPromise<T>;
+    ZodReadonly: ZodReadonly<T>;
     ZodRecord: ZodRecord;
     ZodSet: ZodSet;
     ZodString: ZodString;
     ZodSymbol: ZodSymbol;
     ZodTuple: ZodTuple;
     ZodUndefined: ZodUndefined;
-    ZodUnion: ZodUnion<any>;
+    ZodUnion: ZodUnion<Union>;
     ZodUnknown: ZodUnknown;
     ZodVoid: ZodVoid;
 };
-export declare const isZodType: <U extends keyof ZodTypeMap>(zodType: unknown, typeName: U) => zodType is ZodTypeMap[U];
+export declare const isZodType: <T extends ZodTypeAny, U extends ZodTypeAny, V, W extends ZodRawShape, B extends string | number | symbol, Discriminator extends string, Options extends ZodDiscriminatedUnionOption<Discriminator>[], Enum extends [string, ...string[]], Returns extends ZodTypeAny, Args extends ZodTuple<[ZodTypeAny, ...ZodTypeAny[]], null>, ELike extends EnumLike, Union extends readonly [ZodTypeAny, ...ZodTypeAny[]], K extends keyof ZodTypeMap<T, U, V, W, B, Discriminator, Options, Enum, Returns, Args, ELike, Union, UnknownKeys, Catchall, Output, Input, Cardinality>, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<W, Catchall, UnknownKeys>, Input = objectInputType<W, Catchall, UnknownKeys>, Cardinality extends ArrayCardinality = "many">(zodType: unknown, typeName: K) => zodType is ZodTypeMap<T, U, V, W, B, Discriminator, Options, Enum, Returns, Args, ELike, Union, UnknownKeys, Catchall, Output, Input, Cardinality>[K];
 export declare const isAnyZodType: (zodType: unknown) => zodType is ZodType<any, ZodTypeDef, any>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",
@@ -47,9 +47,9 @@
     "@types/node": "^20.3.0",
     "eslint-plugin-zod-openapi": "^0.1.0",
     "openapi3-ts": "4.1.2",
-    "skuba": "7.0.1",
+    "skuba": "7.1.1",
     "yaml": "2.3.1",
-    "zod": "3.22.0"
+    "zod": "3.22.2"
   },
   "peerDependencies": {
     "zod": "^3.21.4"