zod-openapi 2.19.0 → 3.0.0

package/dist/create/components.d.ts

@@ -0,0 +1,124 @@
+import { ZodType } from 'zod';
+import { SchemaObject as SchemaObject$1, ReferenceObject as ReferenceObject$1, ParameterObject as ParameterObject$1, HeaderObject as HeaderObject$1, ResponseObject as ResponseObject$1, RequestBodyObject as RequestBodyObject$1, CallbackObject as CallbackObject$1 } from '../openapi3-ts/dist/model/openapi30.js';
+import { ComponentsObject as ComponentsObject$1, SchemaObject, ReferenceObject, ParameterObject, ParameterLocation, HeaderObject, ResponseObject, RequestBodyObject, CallbackObject } from '../openapi3-ts/dist/model/openapi31.js';
+import { ZodOpenApiVersion, ZodOpenApiComponentsObject, ZodOpenApiResponseObject, ZodOpenApiRequestBodyObject, ZodOpenApiCallbackObject } 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) => ComponentsObject$1 | undefined;
+
+export { type BaseCallbackComponent, type CallbackComponent, type CallbackComponentMap, type CompleteCallbackComponent, type CompleteHeaderComponent, type CompleteParameterComponent, type CompleteRequestBodyComponent, type CompleteResponseComponent, type CompleteSchemaComponent, type ComponentEffect, type ComponentsObject, type CreationType, type Effect, type HeaderComponent, type HeaderComponentMap, type InProgressSchemaComponent, type ManualSchemaComponent, type ParameterComponent, type ParameterComponentMap, type PartialCallbackComponent, type PartialHeaderComponent, type PartialParameterComponent, type PartialRequestBodyComponent, type PartialResponseComponent, type RequestBodyComponent, type RequestBodyComponentMap, type ResolvedEffect, type ResponseComponent, type ResponseComponentMap, type SchemaComponent, type SchemaComponentMap, type SchemaEffect, createComponents, getDefaultComponents };

package/dist/create/content.d.ts

@@ -0,0 +1,7 @@
+import { ZodType } from 'zod';
+import { SchemaObject, ReferenceObject } from '../openapi3-ts/dist/model/openapi31.js';
+import { ComponentsObject, CreationType } from './components.js';
+
+declare const createMediaTypeSchema: (schemaObject: ZodType | SchemaObject | ReferenceObject | undefined, components: ComponentsObject, type: CreationType, subpath: string[]) => SchemaObject | ReferenceObject | undefined;
+
+export { createMediaTypeSchema };

package/dist/create/document.d.ts

@@ -0,0 +1,78 @@
+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, OperationObject as OperationObject$1, ParameterObject as ParameterObject$1, PathItemObject as PathItemObject$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, OperationObject, ParameterObject, PathItemObject, 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 = {
+    [type in 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>;
+declare const createDocument: (zodOpenApiObject: ZodOpenApiObject) => OpenAPIObject;
+
+export { type ZodObjectInputType, type ZodOpenApiCallbackObject, type ZodOpenApiCallbacksObject, type ZodOpenApiComponentsObject, type ZodOpenApiContentObject, type ZodOpenApiMediaTypeObject, type ZodOpenApiObject, type ZodOpenApiOperationObject, type ZodOpenApiParameters, type ZodOpenApiPathItemObject, type ZodOpenApiPathsObject, type ZodOpenApiRequestBodyObject, type ZodOpenApiResponseObject, type ZodOpenApiResponsesObject, type ZodOpenApiVersion, createDocument };

package/dist/create/parameters.d.ts

@@ -0,0 +1,8 @@
+import { ZodType } from 'zod';
+import { ParameterObject, ReferenceObject } from '../openapi3-ts/dist/model/openapi31.js';
+import { ComponentsObject } from './components.js';
+import { ZodOpenApiParameters } from './document.js';
+
+declare const createParamOrRef: (zodSchema: ZodType, components: ComponentsObject, subpath: string[], type?: keyof ZodOpenApiParameters, name?: string) => ParameterObject | ReferenceObject;
+
+export { createParamOrRef };

package/dist/extend.d.mts

@@ -1 +1 @@
-import './index.js';
+import './extendZodTypes.js';

package/dist/extend.d.ts

@@ -1 +1 @@
-import './index.js';
+import './extendZodTypes.js';

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/extendZodTypes.d.ts

@@ -0,0 +1,76 @@
+import { ZodTypeAny, z, ZodDate, ZodObject } from 'zod';
+import { CreationType } from './create/components.js';
+import { HeaderObject as HeaderObject$1, SchemaObject as SchemaObject$1 } from './openapi3-ts/dist/model/openapi30.js';
+import { ParameterObject, ExampleObject, ReferenceObject, HeaderObject, SchemaObject as SchemaObject$2 } from './openapi3-ts/dist/model/openapi31.js';
+
+type SchemaObject = SchemaObject$1 & SchemaObject$2;
+/**
+ * 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;
+    /**
+     * 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 request (`input`) or response (`output`). Defaults to `output`
+     */
+    refType?: CreationType;
+    /**
+     * 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
+     */
+    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 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 {
+        /**
+         * OpenAPI metadata
+         */
+        openapi?: ZodOpenApiMetadata<ZodTypeAny>;
+    }
+    interface ZodObjectDef {
+        extendMetadata?: ZodOpenApiExtendMetadata;
+    }
+}