zod-openapi 2.18.0 → 2.19.0-beta.0

package/extend/index.d.ts

@@ -0,0 +1 @@
+export * from "../dist/extend";

package/extend/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../dist/extend.cjs",
+  "module": "../dist/extend.mjs",
+  "types": "./index.d.ts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-openapi",
-  "version": "2.18.0",
+  "version": "2.19.0-beta.0",
   "description": "Convert Zod Schemas to OpenAPI v3.x documentation",
   "keywords": [
     "typescript",
@@ -21,42 +21,38 @@
   },
   "license": "MIT",
   "sideEffects": [
-    "./src/extend.ts",
-    "./lib-esm/extend.mjs",
-    "./lib-commonjs/extend.js"
+    "dist/extend.*",
+    "dist/side-effects/**",
+    "src/entries/extend.ts"
   ],
   "exports": {
     ".": {
-      "import": "./lib-esm/index.mjs",
-      "require": "./lib-commonjs/index.js",
-      "types": "./lib-types/index.d.ts"
+      "types": {
+        "import": "./dist/index.d.mts",
+        "require": "./dist/index.d.ts"
+      },
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     },
     "./extend": {
-      "import": "./lib-esm/extend.mjs",
-      "require": "./lib-commonjs/extend.js",
-      "types": "./lib-types/extend.d.ts"
-    }
-  },
-  "main": "./lib-commonjs/index.js",
-  "module": "./lib-esm/index.mjs",
-  "types": "./lib-types/index.d.ts",
-  "typesVersions": {
-    "*": {
-      ".": [
-        "lib-types/index.d.ts"
-      ],
-      "extend": [
-        "lib-types/extend.d.ts"
-      ]
-    }
+      "types": {
+        "import": "./dist/extend.d.mts",
+        "require": "./dist/extend.d.ts"
+      },
+      "import": "./dist/extend.mjs",
+      "require": "./dist/extend.cjs"
+    },
+    "./package.json": "./package.json"
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
-    "lib*/**/*.d.ts",
-    "lib*/**/*.{js,mjs}{,.map}",
-    "lib*/**/*.json"
+    "dist",
+    "extend"
   ],
   "scripts": {
-    "build": "pnpm 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 && crackle package",
     "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",
@@ -67,12 +63,14 @@
     "test:watch": "skuba test --watch"
   },
   "devDependencies": {
-    "@redocly/cli": "1.14.0",
+    "@arethetypeswrong/cli": "0.15.3",
+    "@crackle/cli": "0.15.4",
+    "@redocly/cli": "1.15.0",
     "@types/node": "^20.3.0",
-    "eslint-plugin-zod-openapi": "^0.1.0",
-    "openapi3-ts": "4.3.2",
+    "eslint-plugin-zod-openapi": "^0.2.0",
+    "openapi3-ts": "4.3.3",
     "skuba": "8.0.1",
-    "yaml": "2.4.2",
+    "yaml": "2.4.5",
     "zod": "3.23.8"
   },
   "peerDependencies": {

package/lib-types/api.d.ts

@@ -1,3 +0,0 @@
-export { createComponents, getDefaultComponents, type ComponentsObject, } from './create/components';
-export { createMediaTypeSchema } from './create/content';
-export { createParamOrRef } from './create/parameters';

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

@@ -1,5 +0,0 @@
-import type { oas31 } from '../openapi3-ts/dist';
-import { type ComponentsObject } from './components';
-import type { ZodOpenApiCallbackObject } from './document';
-export declare const createCallback: (callbackObject: ZodOpenApiCallbackObject, components: ComponentsObject, subpath: string[]) => oas31.CallbackObject;
-export declare const createCallbacks: (callbacksObject: oas31.CallbackObject | undefined, components: ComponentsObject, subpath: string[]) => oas31.CallbackObject | undefined;

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

@@ -1,125 +0,0 @@
-import type { ZodType } from 'zod';
-import type { oas30, oas31 } from '../openapi3-ts/dist';
-import type { ZodOpenApiCallbackObject, 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 effect */
-    effects?: Effect[];
-    resolvedEffect?: ResolvedEffect;
-}
-/**
- *
- */
-export interface ManualSchemaComponent extends BaseSchemaComponent {
-    type: 'manual';
-}
-export interface InProgressSchemaComponent extends BaseSchemaComponent {
-    type: 'in-progress';
-}
-interface BaseSchemaComponent {
-    ref: string;
-}
-export type SchemaComponent = CompleteSchemaComponent | ManualSchemaComponent | InProgressSchemaComponent;
-export type SchemaComponentMap = Map<ZodType, SchemaComponent>;
-export interface CompleteParameterComponent extends BaseParameterComponent {
-    type: 'complete';
-    paramObject: oas31.ParameterObject | oas31.ReferenceObject | oas30.ParameterObject | oas30.ReferenceObject;
-}
-export interface PartialParameterComponent extends BaseParameterComponent {
-    type: 'manual';
-}
-interface BaseParameterComponent {
-    ref: string;
-    in: oas31.ParameterLocation;
-    name: string;
-}
-export type ParameterComponent = CompleteParameterComponent | PartialParameterComponent;
-export type ParameterComponentMap = Map<ZodType, ParameterComponent>;
-export interface CompleteHeaderComponent extends BaseHeaderComponent {
-    type: 'complete';
-    headerObject: oas31.HeaderObject | oas31.ReferenceObject | oas30.HeaderObject | oas30.ReferenceObject;
-}
-export interface PartialHeaderComponent extends BaseHeaderComponent {
-    type: 'manual';
-}
-interface BaseHeaderComponent {
-    ref: string;
-}
-export type HeaderComponent = CompleteHeaderComponent | PartialHeaderComponent;
-export type HeaderComponentMap = Map<ZodType, HeaderComponent>;
-interface BaseResponseComponent {
-    ref: string;
-}
-export interface CompleteResponseComponent extends BaseResponseComponent {
-    type: 'complete';
-    responseObject: oas31.ResponseObject | oas31.ReferenceObject | oas30.ResponseObject | oas30.ReferenceObject;
-}
-export interface PartialResponseComponent extends BaseResponseComponent {
-    type: 'manual';
-}
-export type ResponseComponent = CompleteResponseComponent | PartialResponseComponent;
-export type ResponseComponentMap = Map<ZodOpenApiResponseObject, ResponseComponent>;
-interface BaseRequestBodyComponent {
-    ref: string;
-}
-export interface CompleteRequestBodyComponent extends BaseRequestBodyComponent {
-    type: 'complete';
-    requestBodyObject: oas31.RequestBodyObject | oas31.ReferenceObject | oas30.RequestBodyObject | oas30.ReferenceObject;
-}
-export interface PartialRequestBodyComponent extends BaseRequestBodyComponent {
-    type: 'manual';
-}
-export type RequestBodyComponent = CompleteRequestBodyComponent | PartialRequestBodyComponent;
-export type RequestBodyComponentMap = Map<ZodOpenApiRequestBodyObject, RequestBodyComponent>;
-export interface BaseCallbackComponent {
-    ref: string;
-}
-export interface CompleteCallbackComponent extends BaseCallbackComponent {
-    type: 'complete';
-    callbackObject: ZodOpenApiCallbackObject | oas31.CallbackObject | oas30.CallbackObject;
-}
-export interface PartialCallbackComponent extends BaseCallbackComponent {
-    type: 'manual';
-}
-export type CallbackComponent = CompleteCallbackComponent | PartialCallbackComponent;
-export type CallbackComponentMap = Map<ZodOpenApiCallbackObject, CallbackComponent>;
-export interface ComponentsObject {
-    schemas: SchemaComponentMap;
-    parameters: ParameterComponentMap;
-    headers: HeaderComponentMap;
-    requestBodies: RequestBodyComponentMap;
-    responses: ResponseComponentMap;
-    callbacks: CallbackComponentMap;
-    openapi: ZodOpenApiVersion;
-}
-export declare const getDefaultComponents: (componentsObject?: ZodOpenApiComponentsObject, openapi?: ZodOpenApiVersion) => ComponentsObject;
-export declare const createComponentSchemaRef: (schemaRef: string) => string;
-export declare const createComponentResponseRef: (responseRef: string) => string;
-export declare const createComponentRequestBodyRef: (requestBodyRef: string) => string;
-export declare const createComponentCallbackRef: (callbackRef: string) => string;
-export declare const createComponents: (componentsObject: ZodOpenApiComponentsObject, components: ComponentsObject) => oas31.ComponentsObject | undefined;
-export {};

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

@@ -1,6 +0,0 @@
-import type { ZodType } from 'zod';
-import type { oas31 } from '../openapi3-ts/dist';
-import type { ComponentsObject, CreationType } from './components';
-import type { ZodOpenApiContentObject } from './document';
-export declare const createMediaTypeSchema: (schemaObject: ZodType | oas31.SchemaObject | oas31.ReferenceObject | undefined, components: ComponentsObject, type: CreationType, subpath: string[]) => oas31.SchemaObject | oas31.ReferenceObject | undefined;
-export declare const createContent: (contentObject: ZodOpenApiContentObject, components: ComponentsObject, type: CreationType, subpath: string[]) => oas31.ContentObject;

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

@@ -1,73 +0,0 @@
-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'> {
-    schema?: ZodType | oas31.SchemaObject | oas31.ReferenceObject;
-}
-export interface ZodOpenApiContentObject {
-    'application/json'?: ZodOpenApiMediaTypeObject;
-    [mediatype: string]: ZodOpenApiMediaTypeObject | undefined;
-}
-export interface ZodOpenApiRequestBodyObject extends Omit<oas31.RequestBodyObject & oas30.RequestBodyObject, 'content'> {
-    content: ZodOpenApiContentObject;
-    /** Use this field to auto register this request body as a component */
-    ref?: string;
-}
-export interface ZodOpenApiResponseObject extends Omit<oas31.ResponseObject & oas30.ResponseObject, 'content' | 'headers'> {
-    content?: ZodOpenApiContentObject;
-    headers?: AnyZodObject | oas30.HeadersObject | oas31.HeadersObject;
-    /** Use this field to auto register this response object as a component */
-    ref?: string;
-}
-export interface ZodOpenApiResponsesObject extends oas31.ISpecificationExtension {
-    default?: ZodOpenApiResponseObject | oas31.ReferenceObject | oas30.ReferenceObject;
-    [statuscode: `${1 | 2 | 3 | 4 | 5}${string}`]: ZodOpenApiResponseObject | oas31.ReferenceObject;
-}
-export type ZodOpenApiParameters = {
-    [type in oas31.ParameterLocation & oas30.ParameterLocation]?: ZodObjectInputType;
-};
-export interface ZodOpenApiCallbacksObject extends oas31.ISpecificationExtension {
-    [name: string]: ZodOpenApiCallbackObject;
-}
-export interface ZodOpenApiCallbackObject extends oas31.ISpecificationExtension {
-    /** Use this field to auto register this callback object as a component */
-    ref?: string;
-    [name: string]: ZodOpenApiPathItemObject | string | undefined;
-}
-export interface ZodOpenApiOperationObject extends Omit<oas31.OperationObject & oas30.OperationObject, 'requestBody' | 'responses' | 'parameters' | 'callbacks'> {
-    parameters?: Array<ZodType | oas31.ParameterObject | oas30.ParameterObject | oas31.ReferenceObject | oas30.ReferenceObject>;
-    requestBody?: ZodOpenApiRequestBodyObject;
-    requestParams?: ZodOpenApiParameters;
-    responses: ZodOpenApiResponsesObject;
-    callbacks?: ZodOpenApiCallbacksObject;
-}
-export interface ZodOpenApiPathItemObject extends Omit<oas31.PathItemObject & oas30.PathItemObject, 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'> {
-    get?: ZodOpenApiOperationObject;
-    put?: ZodOpenApiOperationObject;
-    post?: ZodOpenApiOperationObject;
-    delete?: ZodOpenApiOperationObject;
-    options?: ZodOpenApiOperationObject;
-    head?: ZodOpenApiOperationObject;
-    patch?: ZodOpenApiOperationObject;
-    trace?: ZodOpenApiOperationObject;
-}
-export interface ZodOpenApiPathsObject extends oas31.ISpecificationExtension {
-    [path: string]: ZodOpenApiPathItemObject;
-}
-export interface ZodOpenApiComponentsObject extends Omit<oas31.ComponentsObject & oas30.ComponentsObject, 'schemas' | 'responses' | 'requestBodies' | 'headers' | 'parameters'> {
-    parameters?: Record<string, ZodType | oas31.ParameterObject | oas30.ParameterObject | oas31.ReferenceObject | oas30.ReferenceObject>;
-    schemas?: Record<string, ZodType | oas31.SchemaObject | oas31.ReferenceObject | oas30.SchemaObject | oas30.ReferenceObject>;
-    requestBodies?: Record<string, ZodOpenApiRequestBodyObject>;
-    headers?: Record<string, ZodType | oas31.HeaderObject | oas30.HeaderObject | oas31.ReferenceObject | oas30.ReferenceObject>;
-    responses?: Record<string, ZodOpenApiResponseObject>;
-    callbacks?: Record<string, ZodOpenApiCallbackObject>;
-}
-export type ZodOpenApiVersion = OpenApiVersion;
-export interface ZodOpenApiObject extends Omit<oas31.OpenAPIObject, 'openapi' | 'paths' | 'webhooks' | 'components'> {
-    openapi: ZodOpenApiVersion;
-    paths?: ZodOpenApiPathsObject;
-    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,10 +0,0 @@
-import type { AnyZodObject, ZodType } from 'zod';
-import type { oas30, oas31 } from '../openapi3-ts/dist';
-import type { ComponentsObject } from './components';
-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/paths.d.ts

@@ -1,6 +0,0 @@
-import type { oas31 } from '../openapi3-ts/dist';
-import { type ComponentsObject } from './components';
-import type { ZodOpenApiPathItemObject, ZodOpenApiPathsObject, ZodOpenApiRequestBodyObject } from './document';
-export declare const createRequestBody: (requestBodyObject: ZodOpenApiRequestBodyObject | undefined, components: ComponentsObject, subpath: string[]) => oas31.ReferenceObject | oas31.RequestBodyObject | undefined;
-export declare const createPathItem: (pathObject: ZodOpenApiPathItemObject, components: ComponentsObject, path: string[]) => oas31.PathItemObject;
-export declare const createPaths: (pathsObject: ZodOpenApiPathsObject | undefined, components: ComponentsObject) => oas31.PathsObject | undefined;

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

@@ -1,10 +0,0 @@
-import type { AnyZodObject, ZodType } from 'zod';
-import type { oas30, oas31 } from '../openapi3-ts/dist';
-import { type ComponentsObject } from './components';
-import type { ZodOpenApiResponseObject, ZodOpenApiResponsesObject } from './document';
-export declare const createResponseHeaders: (responseHeaders: oas31.HeadersObject | oas30.HeadersObject | AnyZodObject | undefined, components: ComponentsObject) => oas31.ResponseObject['headers'];
-export declare const createHeaderOrRef: (schema: ZodType, components: ComponentsObject) => oas31.BaseParameterObject | oas31.ReferenceObject;
-export declare const createBaseHeader: (schema: ZodType, components: ComponentsObject) => oas31.BaseParameterObject;
-export declare const createComponentHeaderRef: (ref: string) => string;
-export declare const createResponse: (responseObject: ZodOpenApiResponseObject | oas31.ReferenceObject, components: ComponentsObject, subpath: string[]) => oas31.ResponseObject | oas31.ReferenceObject;
-export declare const createResponses: (responsesObject: ZodOpenApiResponsesObject, components: ComponentsObject, subpath: string[]) => oas31.ResponsesObject;

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

@@ -1,29 +0,0 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-import type { oas31 } from '../../openapi3-ts/dist';
-import { type ComponentsObject, type CreationType, type Effect, type SchemaComponent } from '../components';
-export type LazyMap = Map<ZodType, true>;
-export interface SchemaState {
-    components: ComponentsObject;
-    type: CreationType;
-    path: string[];
-    visited: Set<ZodType>;
-}
-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 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,3 +0,0 @@
-import type { oas31 } from '../../openapi3-ts/dist';
-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,3 +0,0 @@
-import type { ArrayCardinality, ZodArray, ZodTypeAny } from 'zod';
-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 +0,0 @@
-import type { ZodBoolean } from 'zod';
-import type { Schema } from '..';
-export declare const createBooleanSchema: (_zodBoolean: ZodBoolean) => Schema;

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

@@ -1,3 +0,0 @@
-import type { ZodBranded, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { ZodCatch, ZodTypeAny } from 'zod';
-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 +0,0 @@
-import type { ZodDate } from 'zod';
-import type { Schema } from '..';
-export declare const createDateSchema: (_zodDate: ZodDate) => Schema;

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

@@ -1,3 +0,0 @@
-import type { ZodDefault, ZodTypeAny } from 'zod';
-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 +0,0 @@
-import type { AnyZodObject, ZodDiscriminatedUnion, ZodDiscriminatedUnionOption } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-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 +0,0 @@
-import type { ZodEnum } from 'zod';
-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,3 +0,0 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-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,3 +0,0 @@
-import type { ZodIntersection, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { ZodLazy, ZodTypeAny } from 'zod';
-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 +0,0 @@
-import type { ZodLiteral } from 'zod';
-import type { Schema, SchemaState } from '..';
-export declare const createLiteralSchema: (zodLiteral: ZodLiteral<unknown>, state: SchemaState) => Schema;

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

@@ -1,3 +0,0 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-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,10 +0,0 @@
-import type { EnumLike, ZodNativeEnum } from 'zod';
-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[];
-}
-export declare const getValidEnumValues: (enumValues: EnumLike) => number[];
-export declare const sortStringsAndNumbers: (values: Array<string | number>) => StringsAndNumbers;
-export {};

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

@@ -1,2 +0,0 @@
-import type { Schema } from '..';
-export declare const createNullSchema: () => Schema;

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

@@ -1,3 +0,0 @@
-import type { ZodNullable, ZodTypeAny } from 'zod';
-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,13 +0,0 @@
-import type { ZodNumber, ZodNumberCheck } from 'zod';
-import type { oas30, oas31 } from '../../../openapi3-ts/dist';
-import type { ZodOpenApiVersion } from '../../document';
-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 = {
-    [kind in ZodNumberCheck['kind']]?: Extract<ZodNumberCheck, {
-        kind: kind;
-    }>;
-};
-export {};

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

@@ -1,21 +0,0 @@
-import type { UnknownKeysParam, ZodObject, ZodRawShape, ZodType, ZodTypeAny, objectInputType, objectOutputType } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-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) => Schema;
-export declare const mapRequired: (shape: ZodRawShape, state: SchemaState) => {
-    required: string[];
-    effects?: Effect[];
-} | 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,10 +0,0 @@
-import type { ZodOptional, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { ZodPipeline, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { ZodEffects, ZodTypeAny, input, output } from 'zod';
-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,3 +0,0 @@
-import type { ZodReadonly, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { KeySchema, ZodRecord, ZodString, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { ZodEffects, ZodTypeAny, input, output } from 'zod';
-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,3 +0,0 @@
-import type { ZodSet, ZodTypeAny } from 'zod';
-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 +0,0 @@
-import type { ZodString } from 'zod';
-import type { Schema, SchemaState } from '..';
-export declare const createStringSchema: (zodString: ZodString, state: SchemaState) => Schema;

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

@@ -1,10 +0,0 @@
-import type { ZodEffects, ZodTypeAny, input, output } from 'zod';
-import type { oas31 } from '../../../openapi3-ts/dist';
-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: (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,3 +0,0 @@
-import type { ZodTuple, ZodTypeAny } from 'zod';
-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,3 +0,0 @@
-import type { ZodTypeAny, ZodUnion } from 'zod';
-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 +0,0 @@
-import type { ZodAny, ZodUnknown } from 'zod';
-import type { Schema } from '..';
-export declare const createUnknownSchema: (_zodUnknown: ZodUnknown | ZodAny) => Schema;

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

@@ -1 +0,0 @@
-export declare const isISpecificationExtension: (key: string) => key is `x-${string}`;

package/lib-types/extend.d.ts

@@ -1 +0,0 @@
-export * from './extendZodTypes';

package/lib-types/extendZod.d.ts

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