orval 8.0.0-rc.2 → 8.0.0-rc.4

package/dist/{config-BH1mpZT1.mjs → config-DQWtHEeF.mjs}

@@ -1,9 +1,8 @@
 import path from "node:path";
-import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMode, PropertySortOrder, RefComponentSuffix, asyncReduce, createLogger, createSuccessMessage, dynamicImport, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, ibmOpenapiValidator, isBoolean, isFunction, isObject, isReference, isRootKey, isSchema, isString, isUndefined, isUrl, jsDoc, log, logError, mergeDeep, openApiConverter, pascal, removeFilesAndEmptyFolders, resolveRef, upath, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
-import SwaggerParser from "@apidevtools/swagger-parser";
-import chalk from "chalk";
-import fs from "fs-extra";
-import yaml from "js-yaml";
+import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMode, PropertySortOrder, RefComponentSuffix, asyncReduce, conventionName, createLogger, createSuccessMessage, dynamicImport, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, isBoolean, isFunction, isObject, isReference, isString, isUndefined, isUrl, jsDoc, log, logError, pascal, removeFilesAndEmptyFolders, resolveRef, upath, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, parseJson, parseYaml, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import { upgrade, validate } from "@scalar/openapi-parser";
 import * as mock from "@orval/mock";
 import { DEFAULT_MOCK_OPTIONS, generateMockImports } from "@orval/mock";
 import angular from "@orval/angular";
@@ -13,13 +12,14 @@ import hono from "@orval/hono";
 import mcp from "@orval/mcp";
 import query from "@orval/query";
 import swr from "@orval/swr";
-import zod from "@orval/zod";
+import zod, { dereference, generateZodValidationSchemaDefinition, isZodVersionV4, parseZodValidationSchemaDefinition } from "@orval/zod";
+import chalk from "chalk";
 import { ExecaError, execa } from "execa";
+import fs from "fs-extra";
 import { unique } from "remeda";
 import { parseArgsStringToArgv } from "string-argv";
-import https from "node:https";
-import enquirer from "enquirer";
 import { findUp } from "find-up";
+import yaml from "js-yaml";
 import { parse } from "tsconfck";
 import fs$1 from "node:fs";
 import { createJiti } from "jiti";
@@ -27,7 +27,7 @@ import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
 var description = "A swagger client generator for typescript";
-var version = "8.0.0-rc.2";
+var version = "8.0.0-rc.4";
 
 //#endregion
 //#region src/client.ts
@@ -59,9 +59,9 @@ const getGeneratorClient = (outputClient, output) => {
 	if (!generator) throw new Error(`Oups... 🍻. Client not found: ${outputClient}`);
 	return generator;
 };
-const generateClientImports = ({ client = DEFAULT_CLIENT, implementation, imports, specsName, hasSchemaDir, isAllowSyntheticDefaultImports, hasGlobalMutator, hasTagsMutator, hasParamsSerializerOptions, packageJson, output }) => {
+const generateClientImports = ({ client = DEFAULT_CLIENT, implementation, imports, projectName, hasSchemaDir, isAllowSyntheticDefaultImports, hasGlobalMutator, hasTagsMutator, hasParamsSerializerOptions, packageJson, output }) => {
 	const { dependencies } = getGeneratorClient(client, output);
-	return generateDependencyImports(implementation, dependencies ? [...dependencies(hasGlobalMutator, hasParamsSerializerOptions, packageJson, output.httpClient, hasTagsMutator, output.override), ...imports] : imports, specsName, hasSchemaDir, isAllowSyntheticDefaultImports);
+	return generateDependencyImports(implementation, dependencies ? [...dependencies(hasGlobalMutator, hasParamsSerializerOptions, packageJson, output.httpClient, hasTagsMutator, output.override), ...imports] : imports, projectName, hasSchemaDir, isAllowSyntheticDefaultImports);
 };
 const generateClientHeader = ({ outputClient = DEFAULT_CLIENT, isRequestOptions, isGlobalMutator, isMutator, provideIn, hasAwaitedType, titles, output, verbOptions, tag, clientImplementation }) => {
 	const { header } = getGeneratorClient(outputClient, output);
@@ -172,18 +172,13 @@ const generateExtraFiles = (outputClient = DEFAULT_CLIENT, verbsOptions, output,
 
 //#endregion
 //#region src/api.ts
-const getApiBuilder = async ({ input, output, context }) => {
-	const api = await asyncReduce(Object.entries(context.specs[context.specKey].paths ?? {}), async (acc, [pathRoute, verbs]) => {
+async function getApiBuilder({ input, output, context }) {
+	const api = await asyncReduce(Object.entries(context.spec.paths ?? {}), async (acc, [pathRoute, verbs]) => {
 		const route = getRoute(pathRoute);
 		let resolvedVerbs = verbs;
-		let resolvedContext = context;
 		if (isReference(verbs)) {
 			const { schema, imports } = resolveRef(verbs, context);
 			resolvedVerbs = schema;
-			resolvedContext = {
-				...context,
-				...imports.length > 0 ? { specKey: imports[0].specKey } : {}
-			};
 		}
 		let verbsOptions = await generateVerbsOptions({
 			verbs: resolvedVerbs,
@@ -191,7 +186,7 @@ const getApiBuilder = async ({ input, output, context }) => {
 			output,
 			route,
 			pathRoute,
-			context: resolvedContext
+			context
 		});
 		if (output.override.useDeprecatedOperations === false) verbsOptions = verbsOptions.filter((verb) => {
 			return !verb.deprecated;
@@ -203,13 +198,13 @@ const getApiBuilder = async ({ input, output, context }) => {
 			acc$1.push(...body.schemas, ...response.schemas);
 			return acc$1;
 		}, []);
-		const fullRoute = getFullRoute(route, verbs.servers ?? context.specs[context.specKey].servers, output.baseUrl);
+		const fullRoute = getFullRoute(route, verbs.servers ?? context.spec.servers, output.baseUrl);
 		if (!output.target) throw new Error("Output does not have a target");
 		const pathOperations = await generateOperations(output.client, verbsOptions, {
 			route: fullRoute,
 			pathRoute,
 			override: output.override,
-			context: resolvedContext,
+			context,
 			mock: output.mock,
 			output: output.target
 		}, output);
@@ -237,155 +232,146 @@ const getApiBuilder = async ({ input, output, context }) => {
 		importsMock: generateMockImports,
 		extraFiles
 	};
-};
+}
 
 //#endregion
 //#region src/import-open-api.ts
-const importOpenApi = async ({ data, input, output, target, workspace }) => {
-	const specs = await generateInputSpecs({
-		specs: data,
-		input,
-		workspace
-	});
+async function importOpenApi({ spec, input, output, target, workspace, projectName }) {
+	const transformedOpenApi = await applyTransformer(spec, input.override.transformer, workspace);
 	const schemas = getApiSchemas({
 		input,
 		output,
 		target,
 		workspace,
-		specs
+		spec: transformedOpenApi
 	});
 	const api = await getApiBuilder({
 		input,
 		output,
 		context: {
-			specKey: target,
+			projectName,
 			target,
 			workspace,
-			specs,
+			spec: transformedOpenApi,
 			output
 		}
 	});
 	return {
 		...api,
-		schemas: {
-			...schemas,
-			[target]: [...schemas[target] ?? [], ...api.schemas]
-		},
+		schemas: [...schemas, ...api.schemas],
 		target,
-		info: specs[target].info
+		info: transformedOpenApi.info,
+		spec: transformedOpenApi
 	};
-};
-const generateInputSpecs = async ({ specs, input, workspace }) => {
-	const transformerFn = input.override?.transformer ? await dynamicImport(input.override.transformer, workspace) : void 0;
-	return asyncReduce(Object.entries(specs), async (acc, [specKey, value]) => {
-		const schema = await openApiConverter(value, input.converterOptions, specKey);
-		const transfomedSchema = transformerFn ? transformerFn(schema) : schema;
-		if (input.validation) await ibmOpenapiValidator(transfomedSchema, input.validation);
-		acc[specKey] = transfomedSchema;
-		return acc;
-	}, {});
-};
-const getApiSchemas = ({ input, output, target, workspace, specs }) => {
-	return Object.entries(specs).reduce((acc, [specKey, spec]) => {
-		const context = {
-			specKey,
-			target,
-			workspace,
-			specs,
-			output
-		};
-		const schemaDefinition = generateSchemasDefinition(spec.openapi ? spec.components?.schemas : getAllSchemas(spec, specKey), context, output.override.components.schemas.suffix, input.filters);
-		const responseDefinition = generateComponentDefinition(spec.components?.responses, context, output.override.components.responses.suffix);
-		const bodyDefinition = generateComponentDefinition(spec.components?.requestBodies, context, output.override.components.requestBodies.suffix);
-		const parameters = generateParameterDefinition(spec.components?.parameters, context, output.override.components.parameters.suffix);
-		const schemas = [
-			...schemaDefinition,
-			...responseDefinition,
-			...bodyDefinition,
-			...parameters
-		];
-		if (schemas.length === 0) return acc;
-		acc[specKey] = schemas;
-		return acc;
-	}, {});
-};
-const getAllSchemas = (spec, specKey) => {
-	const keysToOmit = new Set([
-		"openapi",
-		"info",
-		"servers",
-		"paths",
-		"components",
-		"security",
-		"tags",
-		"externalDocs"
-	]);
-	const cleanedSpec = Object.fromEntries(Object.entries(spec).filter(([key]) => !keysToOmit.has(key)));
-	if (specKey && isSchema(cleanedSpec)) {
-		const name$1 = upath.getSchemaFileName(specKey);
-		const additionalKeysToOmit = new Set([
-			"type",
-			"properties",
-			"allOf",
-			"oneOf",
-			"anyOf",
-			"items"
-		]);
-		return {
-			[name$1]: cleanedSpec,
-			...getAllSchemas(Object.fromEntries(Object.entries(cleanedSpec).filter(([key]) => !additionalKeysToOmit.has(key))))
-		};
-	}
-	return {
-		...Object.entries(cleanedSpec).reduce((acc, [key, value]) => {
-			if (!isObject(value)) return acc;
-			if (!isSchema(value) && !isReference(value)) return {
-				...acc,
-				...getAllSchemas(value)
-			};
-			acc[key] = value;
-			return acc;
-		}, {}),
-		...spec?.components?.schemas
+}
+async function applyTransformer(openApi, transformer, workspace) {
+	const transformerFn = transformer ? await dynamicImport(transformer, workspace) : void 0;
+	if (!transformerFn) return openApi;
+	const transformedOpenApi = transformerFn(openApi);
+	const { valid, errors } = await validate(transformedOpenApi);
+	if (!valid) throw new Error(`Validation failed`, { cause: errors });
+	return transformedOpenApi;
+}
+function getApiSchemas({ input, output, target, workspace, spec }) {
+	const context = {
+		target,
+		workspace,
+		spec,
+		output
 	};
-};
+	const schemaDefinition = generateSchemasDefinition(spec.components?.schemas, context, output.override.components.schemas.suffix, input.filters);
+	const responseDefinition = generateComponentDefinition(spec.components?.responses, context, output.override.components.responses.suffix);
+	const bodyDefinition = generateComponentDefinition(spec.components?.requestBodies, context, output.override.components.requestBodies.suffix);
+	const parameters = generateParameterDefinition(spec.components?.parameters, context, output.override.components.parameters.suffix);
+	return [
+		...schemaDefinition,
+		...responseDefinition,
+		...bodyDefinition,
+		...parameters
+	];
+}
 
 //#endregion
 //#region src/import-specs.ts
-const resolveSpecs = async (path$1, { validate, ...options }, _isUrl, isOnlySchema) => {
-	try {
-		if (validate) try {
-			await SwaggerParser.validate(path$1, options);
-		} catch (error) {
-			if (error instanceof Error && error.name === "ParserError") throw error;
-			if (!isOnlySchema) log(`⚠️  ${chalk.yellow(error)}`);
-		}
-		const data = (await SwaggerParser.resolve(path$1, options)).values();
-		if (_isUrl) return data;
-		return Object.fromEntries(Object.entries(data).sort().map(([key, value]) => [isUrl(key) ? key : upath.resolve(key), value]));
-	} catch {
-		const file = await fs.readFile(path$1, "utf8");
-		return { [path$1]: yaml.load(file) };
-	}
-};
-const importSpecs = async (workspace, options) => {
+async function resolveSpec(input, parserOptions) {
+	const dereferencedData = dereferenceExternalRef(await bundle(input, {
+		plugins: [
+			readFiles(),
+			fetchUrls({ headers: parserOptions?.headers }),
+			parseJson(),
+			parseYaml()
+		],
+		treeShake: true
+	}));
+	const { valid, errors } = await validate(dereferencedData);
+	if (!valid) throw new Error("Validation failed", { cause: errors });
+	const { specification } = upgrade(dereferencedData);
+	return specification;
+}
+async function importSpecs(workspace, options, projectName) {
 	const { input, output } = options;
-	if (!isString(input.target)) return importOpenApi({
-		data: { [workspace]: input.target },
-		input,
-		output,
-		target: workspace,
-		workspace
-	});
-	const isPathUrl = isUrl(input.target);
 	return importOpenApi({
-		data: await resolveSpecs(input.target, input.parserOptions, isPathUrl, !output.target),
+		spec: await resolveSpec(input.target, input.parserOptions),
 		input,
 		output,
 		target: input.target,
-		workspace
+		workspace,
+		projectName
 	});
-};
+}
+/**
+* The plugins from `@scalar/json-magic` does not dereference $ref.
+* Instead if fetches them and puts them under x-ext, and changes the $ref to point to #x-ext/<name>.
+* This function dereferences those x-ext $ref's.
+*/
+function dereferenceExternalRef(data) {
+	const extensions = data["x-ext"] ?? {};
+	const UNWANTED_KEYS = new Set(["$schema", "$id"]);
+	function scrub(obj) {
+		if (obj === null || obj === void 0) return obj;
+		if (Array.isArray(obj)) return obj.map((x) => scrub(x));
+		if (typeof obj === "object") {
+			const rec = obj;
+			const out = {};
+			for (const [k, v] of Object.entries(rec)) {
+				if (UNWANTED_KEYS.has(k)) continue;
+				out[k] = scrub(v);
+			}
+			return out;
+		}
+		return obj;
+	}
+	function replaceRefs(obj) {
+		if (obj === null || obj === void 0) return obj;
+		if (typeof obj === "object") {
+			if (Array.isArray(obj)) return obj.map((element) => replaceRefs(element));
+			const record = obj;
+			if ("$ref" in record && typeof record.$ref === "string") {
+				const refValue = record.$ref;
+				if (refValue.startsWith("#/x-ext/")) {
+					const parts = refValue.replace("#/x-ext/", "").split("/");
+					const extKey = parts.shift();
+					if (extKey) {
+						let refObj = extensions[extKey];
+						for (const p of parts) if (refObj && typeof refObj === "object" && p in refObj) refObj = refObj[p];
+						else {
+							refObj = void 0;
+							break;
+						}
+						if (refObj) return replaceRefs(scrub(refObj));
+					}
+				}
+			}
+			const result$1 = {};
+			for (const [key, value] of Object.entries(record)) result$1[key] = replaceRefs(value);
+			return result$1;
+		}
+		return obj;
+	}
+	const result = {};
+	for (const [key, value] of Object.entries(data)) if (key !== "x-ext") result[key] = replaceRefs(value);
+	return result;
+}
 
 //#endregion
 //#region src/utils/execute-hook.ts
@@ -409,123 +395,6 @@ async function executeObjectCommand(command, args) {
 	else if (isFunction(command.command)) await command.command();
 }
 
-//#endregion
-//#region src/utils/request.ts
-const request = (urlOptions, data) => {
-	return new Promise((resolve, reject) => {
-		const req = https.request(urlOptions, (res) => {
-			let body = "";
-			res.on("data", (chunk) => body += chunk.toString());
-			res.on("error", reject);
-			res.on("end", () => {
-				const response = {
-					status: res.statusCode,
-					headers: res.headers,
-					body: JSON.parse(body)
-				};
-				if (res.statusCode && res.statusCode >= 200 && res.statusCode <= 299) resolve(response);
-				else reject(response);
-			});
-		});
-		req.on("error", reject);
-		if (data) req.write(data, "binary");
-		req.end();
-	});
-};
-
-//#endregion
-//#region src/utils/github.ts
-const getGithubSpecReq = ({ accessToken, repo, owner, branch, path: path$1 }) => {
-	const payload = JSON.stringify({ query: `query {
-      repository(name: "${repo}", owner: "${owner}") {
-        object(expression: "${branch}:${path$1}") {
-          ... on Blob {
-            text
-          }
-        }
-      }
-    }` });
-	return [{
-		method: "POST",
-		hostname: "api.github.com",
-		path: "/graphql",
-		headers: {
-			"content-type": "application/json",
-			"user-agent": "orval-importer",
-			authorization: `bearer ${accessToken}`,
-			"Content-Length": payload.length
-		}
-	}, payload];
-};
-let githubToken = null;
-const getGithubAcessToken = async (githubTokenPath) => {
-	if (githubToken) return githubToken;
-	if (await fs.pathExists(githubTokenPath)) return fs.readFile(githubTokenPath, "utf8");
-	else {
-		const answers = await enquirer.prompt([{
-			type: "input",
-			name: "githubToken",
-			message: "Please provide a GitHub token with `repo` rules checked (https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)"
-		}, {
-			type: "confirm",
-			name: "saveToken",
-			message: "Would you like to store your token for the next time? (stored in your node_modules)"
-		}]);
-		githubToken = answers.githubToken;
-		if (answers.saveToken) await fs.outputFile(githubTokenPath, answers.githubToken);
-		return answers.githubToken;
-	}
-};
-const getGithubOpenApi = async (url) => {
-	const githubTokenPath = upath.join(import.meta.dirname, ".githubToken");
-	const accessToken = await getGithubAcessToken(githubTokenPath);
-	const [info] = url.split("github.com/").slice(-1);
-	const [owner, repo, , branch, ...paths] = info.split("/");
-	const path$1 = paths.join("/");
-	try {
-		const { body } = await request(...getGithubSpecReq({
-			accessToken,
-			repo,
-			owner,
-			branch,
-			path: path$1
-		}));
-		if (body.errors?.length) {
-			if (body.errors?.some((error) => error?.type === "NOT_FOUND")) {
-				if ((await enquirer.prompt([{
-					type: "confirm",
-					name: "removeToken",
-					message: "Your token doesn't have the correct permissions, should we remove it?"
-				}])).removeToken) await fs.unlink(githubTokenPath);
-			}
-		}
-		return body.data?.repository?.object.text;
-	} catch (error) {
-		if (!error.body) throw new Error(`Oups... 🍻. ${error}`);
-		if (error.body.message === "Bad credentials") {
-			if ((await enquirer.prompt([{
-				type: "confirm",
-				name: "removeToken",
-				message: "Your token doesn't have the correct permissions, should we remove it?"
-			}])).removeToken) await fs.unlink(githubTokenPath);
-		}
-		throw new Error(error.body.message || `Oups... 🍻. ${error}`);
-	}
-};
-const githubResolver = {
-	order: 199,
-	canRead(file) {
-		return file.url.includes("github.com");
-	},
-	read(file) {
-		return getGithubOpenApi(file.url);
-	}
-};
-
-//#endregion
-//#region src/utils/http-resolver.ts
-const httpResolver = { safeUrlResolver: false };
-
 //#endregion
 //#region src/utils/package-json.ts
 const loadPackageJson = async (packageJson, workspace = process.cwd()) => {
@@ -621,7 +490,7 @@ const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
 function defineConfig(options) {
 	return options;
 }
-const createFormData = (workspace, formData) => {
+function createFormData(workspace, formData) {
 	const defaultArrayHandling = FormDataArrayHandling.SERIALIZE;
 	if (formData === void 0) return {
 		disabled: false,
@@ -646,8 +515,17 @@ const createFormData = (workspace, formData) => {
 		mutator: normalizeMutator(workspace, formData),
 		arrayHandling: defaultArrayHandling
 	};
-};
-const normalizeOptions = async (optionsExport, workspace = process.cwd(), globalOptions = {}) => {
+}
+function normalizeSchemasOption(schemas, workspace) {
+	if (!schemas) return;
+	if (isString(schemas)) return normalizePath(schemas, workspace);
+	const types = Array.isArray(schemas.type) ? schemas.type : [schemas.type];
+	return {
+		path: normalizePath(schemas.path, workspace),
+		type: types
+	};
+}
+async function normalizeOptions(optionsExport, workspace = process.cwd(), globalOptions = {}) {
 	const options = await (isFunction(optionsExport) ? optionsExport() : optionsExport);
 	if (!options.input) throw new Error(chalk.red(`Config require an input`));
 	if (!options.output) throw new Error(chalk.red(`Config require an output`));
@@ -680,15 +558,13 @@ const normalizeOptions = async (optionsExport, workspace = process.cwd(), global
 	const normalizedOptions = {
 		input: {
 			target: globalOptions.input ? normalizePathOrUrl(globalOptions.input, process.cwd()) : normalizePathOrUrl(inputOptions.target, workspace),
-			validation: inputOptions.validation || false,
 			override: { transformer: normalizePath(inputOptions.override?.transformer, workspace) },
-			converterOptions: inputOptions.converterOptions ?? {},
-			parserOptions: mergeDeep(parserDefaultOptions, inputOptions.parserOptions ?? {}),
-			filters: inputOptions.filters
+			filters: inputOptions.filters,
+			parserOptions: inputOptions.parserOptions
 		},
 		output: {
 			target: globalOptions.output ? normalizePath(globalOptions.output, process.cwd()) : normalizePath(outputOptions.target, outputWorkspace),
-			schemas: normalizePath(outputOptions.schemas, outputWorkspace),
+			schemas: normalizeSchemasOption(outputOptions.schemas, outputWorkspace),
 			namingConvention: outputOptions.namingConvention || NamingConvention.CAMEL_CASE,
 			fileExtension: outputOptions.fileExtension || defaultFileExtension,
 			workspace: outputOptions.workspace ? outputWorkspace : void 0,
@@ -785,12 +661,15 @@ const normalizeOptions = async (optionsExport, workspace = process.cwd(), global
 				fetch: {
 					includeHttpResponseReturnType: outputOptions.override?.fetch?.includeHttpResponseReturnType ?? true,
 					forceSuccessResponse: outputOptions.override?.fetch?.forceSuccessResponse ?? false,
+					useZodSchemaResponse: outputOptions.override?.fetch?.useZodSchemaResponse ?? false,
+					runtimeValidation: outputOptions.override?.fetch?.runtimeValidation ?? false,
 					...outputOptions.override?.fetch
 				},
 				useDates: outputOptions.override?.useDates || false,
 				useDeprecatedOperations: outputOptions.override?.useDeprecatedOperations ?? true,
 				enumGenerationType: outputOptions.override?.enumGenerationType ?? "const",
-				suppressReadonlyModifier: outputOptions.override?.suppressReadonlyModifier || false
+				suppressReadonlyModifier: outputOptions.override?.suppressReadonlyModifier || false,
+				aliasCombinedTypes: outputOptions.override?.aliasCombinedTypes ?? false
 			},
 			allParamsOptional: outputOptions.allParamsOptional ?? false,
 			urlEncodeParameters: outputOptions.urlEncodeParameters ?? false,
@@ -802,15 +681,8 @@ const normalizeOptions = async (optionsExport, workspace = process.cwd(), global
 	if (!normalizedOptions.input.target) throw new Error(chalk.red(`Config require an input target`));
 	if (!normalizedOptions.output.target && !normalizedOptions.output.schemas) throw new Error(chalk.red(`Config require an output target or schemas`));
 	return normalizedOptions;
-};
-const parserDefaultOptions = {
-	validate: true,
-	resolve: {
-		github: githubResolver,
-		http: httpResolver
-	}
-};
-const normalizeMutator = (workspace, mutator) => {
+}
+function normalizeMutator(workspace, mutator) {
 	if (isObject(mutator)) {
 		if (!mutator.path) throw new Error(chalk.red(`Mutator need a path`));
 		return {
@@ -824,16 +696,16 @@ const normalizeMutator = (workspace, mutator) => {
 		default: true
 	};
 	return mutator;
-};
-const normalizePathOrUrl = (path$1, workspace) => {
+}
+function normalizePathOrUrl(path$1, workspace) {
 	if (isString(path$1) && !isUrl(path$1)) return normalizePath(path$1, workspace);
 	return path$1;
-};
-const normalizePath = (path$1, workspace) => {
+}
+function normalizePath(path$1, workspace) {
 	if (!isString(path$1)) return path$1;
 	return upath.resolve(workspace, path$1);
-};
-const normalizeOperationsAndTags = (operationsOrTags, workspace, global) => {
+}
+function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, query: query$1, zod: zod$1, ...rest }]) => {
 		return [key, {
 			...rest,
@@ -878,16 +750,16 @@ const normalizeOperationsAndTags = (operationsOrTags, workspace, global) => {
 			...paramsSerializer ? { paramsSerializer: normalizeMutator(workspace, paramsSerializer) } : {}
 		}];
 	}));
-};
-const normalizeOutputMode = (mode) => {
+}
+function normalizeOutputMode(mode) {
 	if (!mode) return OutputMode.SINGLE;
 	if (!Object.values(OutputMode).includes(mode)) {
 		createLogger().warn(chalk.yellow(`Unknown the provided mode => ${mode}`));
 		return OutputMode.SINGLE;
 	}
 	return mode;
-};
-const normalizeHooks = (hooks) => {
+}
+function normalizeHooks(hooks) {
 	return Object.keys(hooks).reduce((acc, key) => {
 		if (isString(hooks[key])) return {
 			...acc,
@@ -907,19 +779,19 @@ const normalizeHooks = (hooks) => {
 		};
 		return acc;
 	}, {});
-};
-const normalizeHonoOptions = (hono$1 = {}, workspace) => {
+}
+function normalizeHonoOptions(hono$1 = {}, workspace) {
 	return {
 		...hono$1.handlers ? { handlers: upath.resolve(workspace, hono$1.handlers) } : {},
 		compositeRoute: hono$1.compositeRoute ?? "",
 		validator: hono$1.validator ?? true,
 		validatorOutputPath: hono$1.validatorOutputPath ? upath.resolve(workspace, hono$1.validatorOutputPath) : ""
 	};
-};
-const normalizeJSDocOptions = (jsdoc = {}) => {
+}
+function normalizeJSDocOptions(jsdoc = {}) {
 	return { ...jsdoc };
-};
-const normalizeQueryOptions = (queryOptions = {}, outputWorkspace, globalOptions = {}) => {
+}
+function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions = {}) {
 	if (queryOptions.options) console.warn("[WARN] Using query options is deprecated and will be removed in a future major release. Please use queryOptions or mutationOptions instead.");
 	return {
 		...isUndefined(queryOptions.usePrefetch) ? {} : { usePrefetch: queryOptions.usePrefetch },
@@ -953,14 +825,16 @@ const normalizeQueryOptions = (queryOptions = {}, outputWorkspace, globalOptions
 		...isUndefined(globalOptions.version) ? {} : { version: globalOptions.version },
 		...isUndefined(queryOptions.version) ? {} : { version: queryOptions.version }
 	};
-};
-const getDefaultFilesHeader = ({ title, description: description$1, version: version$1 } = {}) => [
-	`Generated by ${name} v${version} 🍺`,
-	`Do not edit manually.`,
-	...title ? [title] : [],
-	...description$1 ? [description$1] : [],
-	...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
-];
+}
+function getDefaultFilesHeader({ title, description: description$1, version: version$1 } = {}) {
+	return [
+		`Generated by ${name} v${version} 🍺`,
+		`Do not edit manually.`,
+		...title ? [title] : [],
+		...description$1 ? [description$1] : [],
+		...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
+	];
+}
 
 //#endregion
 //#region src/utils/watcher.ts
@@ -997,60 +871,169 @@ async function startWatcher(watchOptions, watchFn, defaultTarget = ".") {
 	});
 }
 
+//#endregion
+//#region src/write-zod-specs.ts
+function generateZodSchemaFileContent(header, schemaName, zodContent) {
+	return `${header}import { z as zod } from 'zod';
+
+export const ${schemaName} = ${zodContent}
+
+export type ${schemaName} = zod.infer<typeof ${schemaName}>;
+`;
+}
+async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNames, namingConvention, shouldMergeExisting = false) {
+	const importFileExtension = fileExtension.replace(/\.ts$/, "");
+	const indexPath = upath.join(schemasPath, `index${fileExtension}`);
+	let existingExports = "";
+	if (shouldMergeExisting && await fs.pathExists(indexPath)) {
+		const existingContent = await fs.readFile(indexPath, "utf-8");
+		const headerMatch = existingContent.match(/^(\/\*\*[\s\S]*?\*\/\n)?/);
+		const headerPart = headerMatch ? headerMatch[0] : "";
+		existingExports = existingContent.substring(headerPart.length).trim();
+	}
+	const newExports = schemaNames.map((schemaName) => {
+		return `export * from './${conventionName(schemaName, namingConvention)}${importFileExtension}';`;
+	}).sort().join("\n");
+	const allExports = existingExports ? `${existingExports}\n${newExports}` : newExports;
+	const uniqueExports = [...new Set(allExports.split("\n"))].filter((line) => line.trim()).sort().join("\n");
+	await fs.outputFile(indexPath, `${header}\n${uniqueExports}\n`);
+}
+async function writeZodSchemas(builder, schemasPath, fileExtension, header, output) {
+	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
+	await Promise.all(schemasWithOpenApiDef.map(async (generatorSchema) => {
+		const { name: name$1, schema: schemaObject } = generatorSchema;
+		if (!schemaObject) return;
+		const fileName = conventionName(name$1, output.namingConvention);
+		const filePath = upath.join(schemasPath, `${fileName}${fileExtension}`);
+		const context = {
+			spec: builder.spec,
+			target: builder.target,
+			workspace: "",
+			output
+		};
+		const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+		const strict = typeof output.override?.zod?.strict === "object" ? output.override.zod.strict.body ?? false : output.override?.zod?.strict ?? false;
+		const coerce = typeof output.override?.zod?.coerce === "object" ? output.override.zod.coerce.body ?? false : output.override?.zod?.coerce ?? false;
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name$1, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
+		const fileContent = generateZodSchemaFileContent(header, name$1, parsedZodDefinition.consts ? `${parsedZodDefinition.consts}\n${parsedZodDefinition.zod}` : parsedZodDefinition.zod);
+		await fs.outputFile(filePath, fileContent);
+	}));
+	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, schemasWithOpenApiDef.map((schema) => schema.name), output.namingConvention, false);
+}
+async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension, header, output, context) {
+	const verbOptionsArray = Object.values(verbOptions);
+	if (verbOptionsArray.length === 0) return;
+	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const strict = typeof output.override?.zod?.strict === "object" ? output.override.zod.strict.body ?? false : output.override?.zod?.strict ?? false;
+	const coerce = typeof output.override?.zod?.coerce === "object" ? output.override.zod.coerce.body ?? false : output.override?.zod?.coerce ?? false;
+	const generateVerbsSchemas = verbOptionsArray.flatMap((verbOption) => {
+		const operation = verbOption.originalOperation;
+		const bodySchema = operation.requestBody && "content" in operation.requestBody ? operation.requestBody.content["application/json"]?.schema : void 0;
+		const bodySchemas = bodySchema ? [{
+			name: `${pascal(verbOption.operationName)}Body`,
+			schema: dereference(bodySchema, context)
+		}] : [];
+		const queryParams = operation.parameters?.filter((p) => "in" in p && p.in === "query");
+		const queryParamsSchemas = queryParams && queryParams.length > 0 ? [{
+			name: `${pascal(verbOption.operationName)}Params`,
+			schema: {
+				type: "object",
+				properties: Object.fromEntries(queryParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, context)])),
+				required: queryParams.filter((p) => p.required).map((p) => p.name)
+			}
+		}] : [];
+		const headerParams = operation.parameters?.filter((p) => "in" in p && p.in === "header");
+		const headerParamsSchemas = headerParams && headerParams.length > 0 ? [{
+			name: `${pascal(verbOption.operationName)}Headers`,
+			schema: {
+				type: "object",
+				properties: Object.fromEntries(headerParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, context)])),
+				required: headerParams.filter((p) => p.required).map((p) => p.name)
+			}
+		}] : [];
+		return [
+			...bodySchemas,
+			...queryParamsSchemas,
+			...headerParamsSchemas
+		];
+	});
+	await Promise.all(generateVerbsSchemas.map(async ({ name: name$1, schema }) => {
+		const fileName = conventionName(name$1, output.namingConvention);
+		const filePath = upath.join(schemasPath, `${fileName}${fileExtension}`);
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, context, name$1, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
+		const fileContent = generateZodSchemaFileContent(header, name$1, parsedZodDefinition.consts ? `${parsedZodDefinition.consts}\n${parsedZodDefinition.zod}` : parsedZodDefinition.zod);
+		await fs.outputFile(filePath, fileContent);
+	}));
+	if (output.indexFiles && generateVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, generateVerbsSchemas.map((s) => s.name), output.namingConvention, true);
+}
+
 //#endregion
 //#region src/write-specs.ts
-const getHeader = (option, info) => {
+function getHeader(option, info) {
 	if (!option) return "";
 	const header = option(info);
 	return Array.isArray(header) ? jsDoc({ description: header }) : header;
-};
-const writeSpecs = async (builder, workspace, options, projectName) => {
+}
+async function writeSpecs(builder, workspace, options, projectName) {
 	const { info = {
 		title: "",
 		version: 0
 	}, schemas, target } = builder;
 	const { output } = options;
 	const projectTitle = projectName ?? info.title;
-	const specsName = Object.keys(schemas).reduce((acc, specKey) => {
-		acc[specKey] = upath.getSpecName(specKey, target).slice(1).split("/").join("-");
-		return acc;
-	}, {});
 	const header = getHeader(output.override.header, info);
-	if (output.schemas) {
-		const rootSchemaPath = output.schemas;
-		const fileExtension = [
-			"tags",
-			"tags-split",
-			"split"
-		].includes(output.mode) ? ".ts" : output.fileExtension ?? ".ts";
-		await Promise.all(Object.entries(schemas).map(([specKey, schemas$1]) => {
-			return writeSchemas({
-				schemaPath: isRootKey(specKey, target) ? rootSchemaPath : upath.join(rootSchemaPath, specsName[specKey]),
-				schemas: schemas$1,
+	if (output.schemas) if (isString(output.schemas)) {
+		const fileExtension = output.fileExtension || ".ts";
+		const schemaPath = output.schemas;
+		await writeSchemas({
+			schemaPath,
+			schemas,
+			target,
+			namingConvention: output.namingConvention,
+			fileExtension,
+			header,
+			indexFiles: output.indexFiles
+		});
+	} else {
+		const types = Array.isArray(output.schemas.type) ? output.schemas.type : [output.schemas.type];
+		for (const schemaType of types) if (schemaType === "typescript") {
+			const fileExtension = output.fileExtension || ".ts";
+			await writeSchemas({
+				schemaPath: output.schemas.path,
+				schemas,
 				target,
 				namingConvention: output.namingConvention,
 				fileExtension,
-				specsName,
-				specKey,
-				isRootKey: isRootKey(specKey, target),
 				header,
 				indexFiles: output.indexFiles
 			});
-		}));
+		} else if (schemaType === "zod") {
+			const fileExtension = ".zod.ts";
+			await writeZodSchemas(builder, output.schemas.path, fileExtension, header, output);
+			if (builder.verbOptions) await writeZodSchemasFromVerbs(builder.verbOptions, output.schemas.path, fileExtension, header, output, {
+				spec: builder.spec,
+				target: builder.target,
+				workspace,
+				output
+			});
+		}
 	}
 	let implementationPaths = [];
 	if (output.target) implementationPaths = await getWriteMode(output.mode)({
 		builder,
 		workspace,
 		output,
-		specsName,
+		projectName,
 		header,
 		needSchema: !output.schemas && output.client !== "zod"
 	});
 	if (output.workspace) {
 		const workspacePath = output.workspace;
 		const imports = implementationPaths.filter((path$1) => !output.mock || !path$1.endsWith(`.${getMockFileExtensionByTypeName(output.mock)}.ts`)).map((path$1) => upath.relativeSafe(workspacePath, getFileInfo(path$1).pathWithoutExtension));
-		if (output.schemas) imports.push(upath.relativeSafe(workspacePath, getFileInfo(output.schemas).dirname));
+		if (output.schemas) {
+			const schemasPath = typeof output.schemas === "string" ? output.schemas : output.schemas.path;
+			imports.push(upath.relativeSafe(workspacePath, getFileInfo(schemasPath).dirname));
+		}
 		if (output.indexFiles) {
 			const indexFile = upath.join(workspacePath, "/index.ts");
 			if (await fs.pathExists(indexFile)) {
@@ -1065,7 +1048,7 @@ const writeSpecs = async (builder, workspace, options, projectName) => {
 		await Promise.all(builder.extraFiles.map(async (file) => fs.outputFile(file.path, file.content)));
 		implementationPaths = [...implementationPaths, ...builder.extraFiles.map((file) => file.path)];
 	}
-	const paths = [...output.schemas ? [getFileInfo(output.schemas).dirname] : [], ...implementationPaths];
+	const paths = [...output.schemas ? [getFileInfo(typeof output.schemas === "string" ? output.schemas : output.schemas.path).dirname] : [], ...implementationPaths];
 	if (options.hooks.afterAllFilesWrite) await executeHook("afterAllFilesWrite", options.hooks.afterAllFilesWrite, paths);
 	if (output.prettier) try {
 		await execa("prettier", ["--write", ...paths]);
@@ -1110,8 +1093,8 @@ const writeSpecs = async (builder, workspace, options, projectName) => {
 		log(chalk.yellow(message));
 	}
 	createSuccessMessage(projectTitle);
-};
-const getWriteMode = (mode) => {
+}
+function getWriteMode(mode) {
 	switch (mode) {
 		case OutputMode.SPLIT: return writeSplitMode;
 		case OutputMode.TAGS: return writeTagsMode;
@@ -1119,7 +1102,7 @@ const getWriteMode = (mode) => {
 		case OutputMode.SINGLE:
 		default: return writeSingleMode;
 	}
-};
+}
 
 //#endregion
 //#region src/generate-spec.ts
@@ -1149,7 +1132,7 @@ async function generateSpec(workspace, options, projectName) {
 		], getFileInfo(options.output.schemas).dirname);
 		log(`${projectName} Cleaning output folder`);
 	}
-	await writeSpecs(await importSpecs(workspace, options), workspace, options, projectName);
+	await writeSpecs(await importSpecs(workspace, options, projectName), workspace, options, projectName);
 }
 
 //#endregion
@@ -1205,4 +1188,4 @@ async function loadConfigFile(configFilePath) {
 
 //#endregion
 export { defineConfig as a, name as c, startWatcher as i, version as l, loadConfigFile as n, normalizeOptions as o, generateSpec as r, description as s, findConfigFile as t };
-//# sourceMappingURL=config-BH1mpZT1.mjs.map
+//# sourceMappingURL=config-DQWtHEeF.mjs.map