oapiex 0.1.2 → 0.2.1

package/dist/index.cjs

@@ -36,10 +36,11 @@ node_path = __toESM(node_path);
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
 let _h3ravel_musket = require("@h3ravel/musket");
-let url = require("url");
 let prettier = require("prettier");
 prettier = __toESM(prettier);
 let node_url = require("node:url");
+let node_fs = require("node:fs");
+let url = require("url");
 
 //#region src/Manager.ts
 const supportedBrowsers = [
@@ -166,6 +167,7 @@ const browser = async (source, config = globalConfig, initial = false) => {
 		}
 	} else if (config.browser === "puppeteer") {
 		const activeSession = getBrowserSession();
+		const browserTimeout = Math.max(config.requestTimeout, 3e4);
 		let browserInstance = activeSession?.browser === "puppeteer" ? activeSession.puppeteerBrowser : void 0;
 		let shouldClose = false;
 		let page;
@@ -193,14 +195,12 @@ const browser = async (source, config = globalConfig, initial = false) => {
 			try {
 				await page.goto(source, {
 					waitUntil: "domcontentloaded",
-					timeout: config.requestTimeout
+					timeout: browserTimeout
 				});
 			} catch (error) {
 				if (!page || !await hasExtractableReadmeContent(page)) throw error;
 			}
-			await waitForExtractableReadmeContent(page, config.requestTimeout, initial);
-			await waitForOperationHydration(page, config.requestTimeout);
-			let html = await page.content();
+			let html = await extractStablePageHtml(page, browserTimeout, initial);
 			if (!html) throw new Error(`Unable to extract HTML from remote source: ${source}`);
 			if (!html.includes("id=\"ssr-props\"")) {
 				const { data: rawHtml } = await axios.default.get(source, {
@@ -248,6 +248,37 @@ const waitForOperationHydration = async (page, timeout) => {
 		});
 	} catch {}
 };
+const extractStablePageHtml = async (page, timeout, initial = false, maxAttempts = 3) => {
+	let lastError;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+		await waitForExtractableReadmeContent(page, timeout, initial);
+		await waitForOperationHydration(page, timeout);
+		return await page.content();
+	} catch (error) {
+		lastError = error;
+		if (!isExecutionContextNavigationError(error) || attempt === maxAttempts) throw error;
+		await waitForNavigationSettle(page, timeout);
+	}
+	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error("Unable to extract stable HTML from remote source");
+};
+const waitForNavigationSettle = async (page, timeout) => {
+	try {
+		await page.waitForFunction(() => {
+			return document.readyState === "interactive" || document.readyState === "complete";
+		}, { timeout: Math.min(timeout, 5e3) });
+	} catch {}
+	try {
+		await page.waitForNetworkIdle?.({
+			idleTime: 500,
+			timeout: Math.min(timeout, 5e3)
+		});
+	} catch {}
+};
+const isExecutionContextNavigationError = (error) => {
+	if (!(error instanceof Error)) return false;
+	const message = error.message.toLowerCase();
+	return message.includes("execution context was destroyed") || message.includes("cannot find context with specified id") || message.includes("most likely because of a navigation");
+};
 const hasExtractableReadmeContent = async (page) => {
 	return Boolean(await page.$("[data-testid=\"http-method\"], article#content, script#ssr-props"));
 };
@@ -263,41 +294,94 @@ const extractSsrPropsScript = (html) => {
 	return html.match(/<script id="ssr-props"[^>]*>[\s\S]*?<\/script>/i)?.[0] ?? null;
 };
 
-//#endregion
-//#region src/Core.ts
-const isRecord = (value) => {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-};
-
 //#endregion
 //#region src/JsonRepair.ts
-const parsePossiblyTruncatedJson = (value) => {
-	const trimmed = value.trim();
-	if (!/^(?:\{|\[)/.test(trimmed)) return null;
-	try {
-		return JSON.parse(trimmed);
-	} catch {
-		const repaired = repairCommonJsonIssues(trimmed);
+var JsonRepair = class JsonRepair {
+	static parsePossiblyTruncated = (value) => {
+		const repairer = new JsonRepair();
+		const trimmed = value.trim();
+		if (!/^(?:\{|\[)/.test(trimmed)) return null;
 		try {
-			return JSON.parse(repaired);
+			return JSON.parse(trimmed);
 		} catch {
-			return null;
+			const repaired = repairer.repairCommonJsonIssues(trimmed);
+			try {
+				return JSON.parse(repaired);
+			} catch {
+				return null;
+			}
 		}
-	}
-};
-const repairCommonJsonIssues = (value) => {
-	const withMissingCommasInserted = insertMissingCommas(value);
-	return `${withMissingCommasInserted}${buildMissingJsonClosers(withMissingCommasInserted)}`;
-};
-const insertMissingCommas = (value) => {
-	let result = "";
-	let inString = false;
-	let isEscaped = false;
-	let previousSignificantCharacter = "";
-	for (let index = 0; index < value.length; index += 1) {
-		const character = value[index];
-		if (inString) {
+	};
+	repairCommonJsonIssues = (value) => {
+		const withUnexpectedTokensRemoved = this.removeUnexpectedObjectTokens(value);
+		const withMissingCommasInserted = this.insertMissingCommas(withUnexpectedTokensRemoved);
+		return `${withMissingCommasInserted}${this.buildMissingJsonClosers(withMissingCommasInserted)}`;
+	};
+	removeUnexpectedObjectTokens = (value) => {
+		return value.replace(/([[{,]\s*)([A-Za-z_$][\w$-]*)(?=\s*"(?:\\.|[^"\\])*"\s*:)/g, "$1");
+	};
+	insertMissingCommas = (value) => {
+		let result = "";
+		let inString = false;
+		let isEscaped = false;
+		let previousSignificantCharacter = "";
+		for (let index = 0; index < value.length; index += 1) {
+			const character = value[index];
+			if (inString) {
+				result += character;
+				if (isEscaped) {
+					isEscaped = false;
+					continue;
+				}
+				if (character === "\\") {
+					isEscaped = true;
+					continue;
+				}
+				if (character === "\"") {
+					inString = false;
+					previousSignificantCharacter = "\"";
+				}
+				continue;
+			}
+			if (character === "\"") {
+				const remainder = value.slice(index);
+				if (/^"(?:\\.|[^"\\])*"\s*:/.test(remainder) && this.shouldInsertCommaBeforeKey(previousSignificantCharacter, result)) result += ",";
+				result += character;
+				inString = true;
+				continue;
+			}
 			result += character;
+			if (!/\s/.test(character)) previousSignificantCharacter = character;
+		}
+		return result;
+	};
+	shouldInsertCommaBeforeKey = (previousSignificantCharacter, currentOutput) => {
+		if (!previousSignificantCharacter) return false;
+		if (![
+			"\"",
+			"}",
+			"]",
+			"e",
+			"l",
+			"0",
+			"1",
+			"2",
+			"3",
+			"4",
+			"5",
+			"6",
+			"7",
+			"8",
+			"9"
+		].includes(previousSignificantCharacter)) return false;
+		const trimmedOutput = currentOutput.trimEnd();
+		return !trimmedOutput.endsWith(",") && !trimmedOutput.endsWith("{");
+	};
+	buildMissingJsonClosers = (value) => {
+		const stack = [];
+		let inString = false;
+		let isEscaped = false;
+		for (const character of value) {
 			if (isEscaped) {
 				isEscaped = false;
 				continue;
@@ -307,74 +391,28 @@ const insertMissingCommas = (value) => {
 				continue;
 			}
 			if (character === "\"") {
-				inString = false;
-				previousSignificantCharacter = "\"";
+				inString = !inString;
+				continue;
 			}
-			continue;
-		}
-		if (character === "\"") {
-			const remainder = value.slice(index);
-			if (/^"(?:\\.|[^"\\])*"\s*:/.test(remainder) && shouldInsertCommaBeforeKey(previousSignificantCharacter, result)) result += ",";
-			result += character;
-			inString = true;
-			continue;
+			if (inString) continue;
+			if (character === "{") {
+				stack.push("}");
+				continue;
+			}
+			if (character === "[") {
+				stack.push("]");
+				continue;
+			}
+			if ((character === "}" || character === "]") && stack[stack.length - 1] === character) stack.pop();
 		}
-		result += character;
-		if (!/\s/.test(character)) previousSignificantCharacter = character;
-	}
-	return result;
+		return stack.reverse().join("");
+	};
 };
-const shouldInsertCommaBeforeKey = (previousSignificantCharacter, currentOutput) => {
-	if (!previousSignificantCharacter) return false;
-	if (![
-		"\"",
-		"}",
-		"]",
-		"e",
-		"l",
-		"0",
-		"1",
-		"2",
-		"3",
-		"4",
-		"5",
-		"6",
-		"7",
-		"8",
-		"9"
-	].includes(previousSignificantCharacter)) return false;
-	const trimmedOutput = currentOutput.trimEnd();
-	return !trimmedOutput.endsWith(",") && !trimmedOutput.endsWith("{");
-};
-const buildMissingJsonClosers = (value) => {
-	const stack = [];
-	let inString = false;
-	let isEscaped = false;
-	for (const character of value) {
-		if (isEscaped) {
-			isEscaped = false;
-			continue;
-		}
-		if (character === "\\") {
-			isEscaped = true;
-			continue;
-		}
-		if (character === "\"") {
-			inString = !inString;
-			continue;
-		}
-		if (inString) continue;
-		if (character === "{") {
-			stack.push("}");
-			continue;
-		}
-		if (character === "[") {
-			stack.push("]");
-			continue;
-		}
-		if ((character === "}" || character === "]") && stack[stack.length - 1] === character) stack.pop();
-	}
-	return stack.reverse().join("");
+
+//#endregion
+//#region src/Core.ts
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 };
 
 //#endregion
@@ -717,11 +755,16 @@ const extractParameterDescription = (param) => {
 const normalizeResponseBody = (body, contentType) => {
 	const trimmed = body.trim();
 	if (contentType?.toLowerCase().includes("json") || /^(?:\{|\[)/.test(trimmed)) {
-		const parsedBody = parsePossiblyTruncatedJson(trimmed);
+		const parsedBody = JsonRepair.parsePossiblyTruncated(trimmed);
 		if (parsedBody !== null) return {
 			format: "json",
 			body: parsedBody
 		};
+		const looseParsedBody = parseLooseStructuredValue(trimmed);
+		if (looseParsedBody !== null) return {
+			format: "json",
+			body: looseParsedBody
+		};
 		return {
 			format: "text",
 			body
@@ -869,15 +912,114 @@ const extractStringLiteralValue = (source, startIndex) => {
 	return null;
 };
 const parseLooseStructuredValue = (value) => {
-	const trimmed = value.trim();
+	const trimmed = preprocessLooseStructuredValue(value).trim();
 	if (!/^[[{]/.test(trimmed)) return null;
-	const normalized = trimmed.replace(/([{,]\s*)([A-Za-z_$][\w$-]*)(\s*:)/g, "$1\"$2\"$3").replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_match, inner) => JSON.stringify(inner.replace(/\\'/g, "'"))).replace(/,\s*([}\]])/g, "$1");
+	const normalized = replaceSingleQuotedStringsOutsideDoubleQuotes(trimmed.replace(/([{,]\s*)([A-Za-z_$][\w$-]*)(\s*:)/g, "$1\"$2\"$3").replace(/,\s*([}\]])/g, "$1"));
 	try {
 		return JSON.parse(normalized);
 	} catch {
 		return null;
 	}
 };
+const replaceSingleQuotedStringsOutsideDoubleQuotes = (value) => {
+	let result = "";
+	let inDoubleString = false;
+	let inSingleString = false;
+	let isEscaped = false;
+	let singleQuotedContent = "";
+	for (const character of value) {
+		if (inSingleString) {
+			if (isEscaped) {
+				singleQuotedContent += character;
+				isEscaped = false;
+				continue;
+			}
+			if (character === "\\") {
+				isEscaped = true;
+				continue;
+			}
+			if (character === "'") {
+				result += JSON.stringify(singleQuotedContent);
+				singleQuotedContent = "";
+				inSingleString = false;
+				continue;
+			}
+			singleQuotedContent += character;
+			continue;
+		}
+		if (inDoubleString) {
+			result += character;
+			if (isEscaped) {
+				isEscaped = false;
+				continue;
+			}
+			if (character === "\\") {
+				isEscaped = true;
+				continue;
+			}
+			if (character === "\"") inDoubleString = false;
+			continue;
+		}
+		if (character === "'") {
+			inSingleString = true;
+			singleQuotedContent = "";
+			continue;
+		}
+		if (character === "\"") inDoubleString = true;
+		result += character;
+	}
+	return result;
+};
+const preprocessLooseStructuredValue = (value) => {
+	let normalized = stripLineCommentsOutsideStrings(value);
+	normalized = removeLooseBareTokensBeforeKeys(normalized);
+	normalized = repairAnonymousDataEnvelope(normalized);
+	return normalized;
+};
+const stripLineCommentsOutsideStrings = (value) => {
+	let result = "";
+	let inString = false;
+	let isEscaped = false;
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		const nextCharacter = value[index + 1];
+		if (inString) {
+			result += character;
+			if (isEscaped) {
+				isEscaped = false;
+				continue;
+			}
+			if (character === "\\") {
+				isEscaped = true;
+				continue;
+			}
+			if (character === "\"") inString = false;
+			continue;
+		}
+		if (character === "\"") {
+			inString = true;
+			result += character;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "/") {
+			while (index < value.length && value[index] !== "\n") index += 1;
+			if (index < value.length) result += value[index];
+			continue;
+		}
+		result += character;
+	}
+	return result;
+};
+const removeLooseBareTokensBeforeKeys = (value) => {
+	return value.replace(/([[{]\s*)([A-Za-z_$][\w$-]*)(\s+)(?=")/g, "$1");
+};
+const repairAnonymousDataEnvelope = (value) => {
+	const trimmed = value.trimStart();
+	if (!trimmed.startsWith("{") || /"data"\s*:\s*\[/.test(trimmed)) return value;
+	if (!/^\{\s*"[^"]+"\s*:/.test(trimmed)) return value;
+	if (!/\]\s*,\s*"meta"\s*:/.test(trimmed)) return value;
+	return `${value.slice(0, value.indexOf("{"))}{"data": [{${trimmed.slice(1)}`;
+};
 const escapeSelector = (value) => {
 	return value.replace(/([#.:[\],=])/g, "\\$1");
 };
@@ -965,264 +1107,2306 @@ var Application = class {
 };
 
 //#endregion
-//#region src/Commands/InitCommand.ts
-const __filename$1 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
-var InitCommand = class extends _h3ravel_musket.Command {
-	signature = `init 
-        {--f|force : Overwrite existing config}
-    `;
-	description = "Generate a default oapiex.config.ts in the current directory";
-	async handle() {
-		const cwd = process.cwd();
-		const configPath = node_path.default.join(cwd, "oapiex.config.js");
-		const force = Boolean(this.option("force", false));
-		const configTemplate = this.buildConfigTemplate();
-		try {
-			await node_fs_promises.default.access(configPath);
-			if (!force) {
-				this.error(`Config file already exists at ${configPath}. Use --force to overwrite.`);
-				process.exit(1);
-			}
-		} catch {}
-		await node_fs_promises.default.writeFile(configPath, configTemplate, "utf8");
-		this.line(`Created ${configPath} `);
+//#region src/generator/TypeScriptModuleRenderer.ts
+var TypeScriptModuleRenderer = class {
+	/**
+	* Render a TypeScript declaration (interface, type alias, or shape alias) into its 
+	* string representation.
+	* 
+	* @param declaration 
+	* @returns 
+	*/
+	renderDeclaration(declaration) {
+		switch (declaration.kind) {
+			case "interface": return this.renderInterface(declaration);
+			case "interface-alias": return `export interface ${declaration.name} extends ${declaration.target} {}`;
+			case "type-alias": return `export type ${declaration.name} = ${declaration.target}`;
+			case "shape-alias": return `export type ${declaration.name} = ${this.renderShape(declaration.shape)}`;
+		}
 	}
-	buildConfigTemplate() {
-		const def = defaultConfig;
+	/**
+	* Render the TypeScript type definitions for an OpenAPI document, including the main 
+	* document structure and the individual operation definitions, using the provided type 
+	* references for each operation.
+	* 
+	* @param rootTypeName 
+	* @param document 
+	* @param operationTypeRefs 
+	* @returns 
+	*/
+	renderOpenApiDocumentDefinitions(rootTypeName, document, operationTypeRefs) {
 		return [
-			`import { defineConfig } from '${__filename$1.includes("node_modules") ? "oapiex" : "./src/Manager"}'`,
-			"",
-			"/**",
-			" * See https://oapi-extractor.toneflix.net/configuration for docs",
-			" */",
-			"export default defineConfig({",
-			`  outputFormat: '${def.outputFormat}',`,
-			`  outputShape: '${def.outputShape}',`,
-			`  browser: '${def.browser}',`,
-			`  requestTimeout: ${def.requestTimeout},`,
-			`  maxRedirects: ${def.maxRedirects},`,
-			`  userAgent: '${def.userAgent}',`,
-			`  retryCount: ${def.retryCount},`,
-			`  retryDelay: ${def.retryDelay},`,
-			"})"
+			"export interface OpenApiInfo {\n  title: string\n  version: string\n}",
+			"export interface OpenApiSchemaDefinition {\n  type?: string\n  description?: string\n  default?: unknown\n  properties?: Record<string, OpenApiSchemaDefinition>\n  items?: OpenApiSchemaDefinition\n  required?: string[]\n  example?: unknown\n}",
+			"export interface OpenApiParameterDefinition {\n  name: string\n  in: 'query' | 'header' | 'path' | 'cookie'\n  required?: boolean\n  description?: string\n  schema?: OpenApiSchemaDefinition\n  example?: unknown\n}",
+			"export interface OpenApiMediaTypeDefinition<TExample = unknown> {\n  schema?: OpenApiSchemaDefinition\n  example?: TExample\n}",
+			"export interface OpenApiResponseDefinition<_TResponse = unknown, TExample = unknown> {\n  description: string\n  content?: Record<string, OpenApiMediaTypeDefinition<TExample>>\n}",
+			"export interface OpenApiRequestBodyDefinition<TInput = unknown> {\n  description?: string\n  required: boolean\n  content: Record<string, OpenApiMediaTypeDefinition<TInput>>\n}",
+			"export interface OpenApiOperationDefinition<_TResponse = unknown, TResponseExample = unknown, TInput = Record<string, never>, _TQuery = Record<string, never>, _THeader = Record<string, never>, _TParams = Record<string, never>> {\n  summary?: string\n  description?: string\n  operationId?: string\n  parameters?: OpenApiParameterDefinition[]\n  requestBody?: OpenApiRequestBodyDefinition<TInput>\n  responses: Record<string, OpenApiResponseDefinition<_TResponse, TResponseExample>>\n}",
+			"export interface OpenApiSdkParameterManifest {\n  name: string\n  accessor: string\n  in: 'query' | 'header' | 'path'\n  required: boolean\n  description?: string\n}",
+			"export interface OpenApiSdkOperationManifest {\n  path: string\n  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'\n  methodName: string\n  summary?: string\n  description?: string\n  operationId?: string\n  requestBodyDescription?: string\n  responseDescription?: string\n  responseType: string\n  inputType: string\n  queryType: string\n  headerType: string\n  paramsType: string\n  hasBody: boolean\n  bodyRequired: boolean\n  pathParams: OpenApiSdkParameterManifest[]\n  queryParams: OpenApiSdkParameterManifest[]\n  headerParams: OpenApiSdkParameterManifest[]\n}",
+			"export interface OpenApiSdkGroupManifest {\n  className: string\n  propertyName: string\n  operations: OpenApiSdkOperationManifest[]\n}",
+			"export interface OpenApiSdkManifest {\n  groups: OpenApiSdkGroupManifest[]\n}",
+			"export interface OpenApiRuntimeBundle<TApi = unknown> {\n  document: unknown\n  manifest: OpenApiSdkManifest\n  __api?: TApi\n}",
+			Object.entries(document.paths).map(([path, operations]) => {
+				const pathTypeName = this.derivePathTypeName(path);
+				return [Object.keys(operations).map((method) => {
+					const operationTypeName = this.deriveOperationInterfaceName(path, method);
+					const refs = operationTypeRefs.get(`${path}::${method}`) ?? {
+						response: "Record<string, never>",
+						responseExample: "unknown",
+						input: "Record<string, never>",
+						query: "Record<string, never>",
+						header: "Record<string, never>",
+						params: "Record<string, never>"
+					};
+					return `export interface ${operationTypeName} extends OpenApiOperationDefinition<${refs.response}, ${refs.responseExample}, ${refs.input}, ${refs.query}, ${refs.header}, ${refs.params}> {}`;
+				}).join("\n\n"), `export interface ${pathTypeName} {\n${Object.keys(operations).map((method) => `  ${method}: ${this.deriveOperationInterfaceName(path, method)}`).join("\n")}\n}`].join("\n\n");
+			}).join("\n\n"),
+			`export interface Paths {\n${Object.keys(document.paths).map((path) => `  ${this.formatPropertyKey(path)}: ${this.derivePathTypeName(path)}`).join("\n")}\n}`,
+			`export interface ${rootTypeName} {\n  openapi: '3.1.0'\n  info: OpenApiInfo\n  paths: Paths\n}`
+		].join("\n\n");
+	}
+	renderSdkApiInterface(rootTypeName, manifest) {
+		return `export interface ${rootTypeName}Api {\n${manifest.groups.map((group) => {
+			const methods = group.operations.map((operation) => `    ${operation.methodName}${this.renderSdkMethodSignature(operation)}`).join("\n");
+			return `  ${group.propertyName}: {\n${methods}\n  }`;
+		}).join("\n")}\n}`;
+	}
+	renderSdkManifest(variableName, manifest) {
+		return `export const ${variableName}Manifest = ${this.renderValue(manifest)} as const satisfies OpenApiSdkManifest`;
+	}
+	renderSdkBundle(variableName, rootTypeName) {
+		return [
+			`export const ${variableName}Sdk: OpenApiRuntimeBundle<${rootTypeName}Api> = {`,
+			`  document: ${variableName},`,
+			`  manifest: ${variableName}Manifest,`,
+			"}"
 		].join("\n");
 	}
-};
-
-//#endregion
-//#region src/OpenApiTransform.ts
-const createOpenApiDocumentFromReadmeOperations = (operations, title = "Extracted API", version = "0.0.0") => {
-	const paths = {};
-	for (const operation of operations) {
-		const normalized = transformReadmeOperationToOpenApi(operation);
-		if (!normalized || shouldSkipNormalizedOperation(normalized)) continue;
-		paths[normalized.path] ??= {};
-		paths[normalized.path][normalized.method] = normalized.operation;
+	/**
+	* Render a value into a string representation suitable for inclusion in TypeScript 
+	* type definitions,
+	* 
+	* @param value 
+	* @returns 
+	*/
+	renderValue(value) {
+		return this.renderLiteral(value, 0);
 	}
-	return {
-		openapi: "3.1.0",
-		info: {
-			title,
-			version
-		},
-		paths
-	};
-};
-const shouldSkipNormalizedOperation = (normalized) => {
-	return normalized.path === "/" && normalized.method === "get" && normalized.operation.operationId === "get" && Object.keys(normalized.operation.responses).length === 0;
-};
-const transformReadmeOperationToOpenApi = (operation) => {
-	if (!operation.method || !operation.url) return null;
-	const url = new URL(operation.url);
-	if (shouldSkipPlaceholderOperation(url, operation)) return null;
-	const method = operation.method.toLowerCase();
-	const path = decodeOpenApiPathname(url.pathname);
-	return {
-		path,
-		method,
-		operation: {
-			summary: operation.sidebarLinks.find((link) => link.active)?.label,
-			description: operation.description ?? void 0,
-			operationId: buildOperationId(method, path),
-			parameters: createParameters(operation.requestParams),
-			requestBody: createRequestBody(operation.requestParams, operation.requestExampleNormalized?.body, hasExtractedBodyParams(operation.requestParams) ? null : resolveFallbackRequestBodyExample(operation)),
-			responses: createResponses(operation.responseSchemas, operation.responseBodies)
+	renderOpenApiDocumentValue(document) {
+		return this.renderLiteral(this.normalizeOpenApiDocument(document), 0);
+	}
+	/**
+	* Convert a string to camelCase, sanitizing it to create a valid TypeScript identifier.
+	* 
+	* @param value 
+	* @returns 
+	*/
+	toCamelCase(value) {
+		const typeName = this.sanitizeTypeName(value);
+		return typeName.charAt(0).toLowerCase() + typeName.slice(1);
+	}
+	renderInterface(declaration) {
+		const body = declaration.properties.map((property) => `  ${this.formatPropertyKey(property.key)}${property.optional ? "?" : ""}: ${this.renderShape(property.shape)}`).join("\n");
+		return `export interface ${declaration.name} {\n${body}\n}`;
+	}
+	renderShape(shape) {
+		switch (shape.kind) {
+			case "primitive": return shape.type;
+			case "array": return `${this.wrapUnion(this.renderShape(shape.item))}[]`;
+			case "union": return shape.types.map((entry) => this.renderShape(entry)).join(" | ");
+			case "object": return this.inlineObjectShape(shape);
 		}
-	};
-};
-const shouldSkipPlaceholderOperation = (url, operation) => {
-	if (url.hostname !== "example.com" || url.pathname !== "/") return false;
-	return operation.requestParams.length === 0 && operation.responseSchemas.length === 0 && operation.responseBodies.length === 0 && operation.requestExampleNormalized?.url === "https://example.com/";
-};
-const decodeOpenApiPathname = (pathname) => {
-	return pathname.split("/").map((segment) => {
-		if (!segment) return segment;
-		try {
-			return decodeURIComponent(segment);
-		} catch {
-			return segment;
+	}
+	inlineObjectShape(shape) {
+		if (shape.properties.length === 0) return "Record<string, never>";
+		return `{ ${shape.properties.map((property) => `${this.formatPropertyKey(property.key)}${property.optional ? "?" : ""}: ${this.renderShape(property.shape)}`).join("; ")} }`;
+	}
+	wrapUnion(value) {
+		return value.includes(" | ") ? `(${value})` : value;
+	}
+	derivePathTypeName(path) {
+		const segments = path.split("/").map((segment) => segment.trim()).filter(Boolean).filter((segment) => !/^v\d+$/i.test(segment)).map((segment) => this.isPathParam(segment) ? `by ${this.stripPathParam(segment)}` : segment);
+		return `${this.sanitizeTypeName(segments.join(" "))}Path`;
+	}
+	deriveOperationInterfaceName(path, method) {
+		return `${this.derivePathTypeName(path)}${this.sanitizeTypeName(method)}Operation`;
+	}
+	sanitizeTypeName(value) {
+		const normalized = value.replace(/[^A-Za-z0-9]+/g, " ").trim();
+		if (!normalized) return "GeneratedEntity";
+		const pascalCased = normalized.split(/\s+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+		return /^[A-Za-z_$]/.test(pascalCased) ? pascalCased : `Type${pascalCased}`;
+	}
+	formatPropertyKey(key) {
+		return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${this.escapeStringLiteral(key)}'`;
+	}
+	renderSdkMethodSignature(operation) {
+		const args = [];
+		if (operation.pathParams.length > 0) args.push(`(params: ${operation.paramsType}`);
+		if (operation.queryParams.length > 0) args.push(`${args.length === 0 ? "(" : ", "}query: ${operation.queryType}`);
+		if (operation.hasBody) args.push(`${args.length === 0 ? "(" : ", "}body${operation.bodyRequired ? "" : "?"}: ${operation.inputType}`);
+		if (operation.headerParams.length > 0) args.push(`${args.length === 0 ? "(" : ", "}headers?: ${operation.headerType}`);
+		if (args.length === 0) return `(): Promise<${operation.responseType}>`;
+		return `${args.join("")}): Promise<${operation.responseType}>`;
+	}
+	renderLiteral(value, indentLevel) {
+		if (value === null) return "null";
+		if (typeof value === "string") return `'${this.escapeStringLiteral(value)}'`;
+		if (typeof value === "number" || typeof value === "boolean") return String(value);
+		if (Array.isArray(value)) {
+			if (value.length === 0) return "[]";
+			const nextIndent = this.indent(indentLevel + 1);
+			const currentIndent = this.indent(indentLevel);
+			return `[\n${value.map((entry) => `${nextIndent}${this.renderLiteral(entry, indentLevel + 1)}`).join(",\n")}\n${currentIndent}]`;
 		}
-	}).join("/");
-};
-const hasExtractedBodyParams = (params) => {
-	return params.some((param) => param.in === "body" || param.in === null);
-};
-const createParameters = (params) => {
-	const parameters = params.filter((param) => isOpenApiParameterLocation(param.in)).map((param) => createParameter(param));
-	return parameters.length > 0 ? parameters : void 0;
-};
-const createRequestBody = (params, example, fallbackExample) => {
-	const bodyParams = params.filter((param) => param.in === "body" || param.in === null);
-	if (bodyParams.length === 0 && example == null) return;
-	const schema = buildRequestBodySchema(bodyParams, example, fallbackExample);
-	return {
-		required: bodyParams.length > 0 ? bodyParams.some((param) => param.required) : false,
-		content: { "application/json": {
-			schema,
-			...example != null ? { example } : {}
-		} }
-	};
-};
-const buildRequestBodySchema = (params, example, fallbackExample) => {
-	const schema = mergeOpenApiSchemas(createExampleSchema(example), createExampleSchema(fallbackExample)) ?? { type: "object" };
-	if (example != null) schema.example = example;
-	else if (fallbackExample != null) schema.example = fallbackExample;
-	for (const param of params) insertRequestBodyParam(schema, param);
-	return schema;
-};
-const inferSchemaFromExample = (value) => {
-	if (Array.isArray(value)) return {
-		type: "array",
-		items: inferSchemaFromExample(value[0]) ?? {},
-		example: value
-	};
-	if (isRecord(value)) return {
-		type: "object",
-		properties: Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, inferSchemaFromExample(entryValue) ?? {}])),
-		example: value
-	};
-	if (typeof value === "string") return {
-		type: "string",
-		example: value
-	};
-	if (typeof value === "number") return {
-		type: Number.isInteger(value) ? "integer" : "number",
-		example: value
-	};
-	if (typeof value === "boolean") return {
-		type: "boolean",
-		example: value
-	};
-	if (value === null) return {};
-};
-const insertRequestBodyParam = (rootSchema, param) => {
-	const path = param.path.length > 0 ? param.path : [param.name];
-	let currentSchema = rootSchema;
-	for (const [index, segment] of path.slice(0, -1).entries()) {
-		currentSchema.properties ??= {};
-		currentSchema.properties[segment] ??= { type: "object" };
-		if (param.required) currentSchema.required = Array.from(new Set([...currentSchema.required ?? [], segment]));
-		currentSchema = currentSchema.properties[segment];
-		currentSchema.type ??= "object";
-		if (index === path.length - 2 && param.required) currentSchema.required ??= [];
-	}
-	const leafKey = path[path.length - 1] ?? param.name;
-	currentSchema.properties ??= {};
-	currentSchema.properties[leafKey] = createParameterSchema(param);
-	if (param.required) currentSchema.required = Array.from(new Set([...currentSchema.required ?? [], leafKey]));
-};
-const createParameter = (param) => {
-	return {
-		name: param.name,
-		in: param.in,
-		required: param.in === "path" ? true : param.required,
-		description: param.description ?? void 0,
-		schema: createParameterSchema(param),
-		example: param.defaultValue ?? void 0
-	};
-};
-const createParameterSchema = (param) => {
-	return {
-		type: param.type ?? void 0,
-		description: param.description ?? void 0,
-		default: param.defaultValue ?? void 0
-	};
-};
-const createResponses = (schemas, responseBodies) => {
-	const responses = {};
-	for (const schema of schemas) {
-		if (!schema.statusCode) continue;
-		const content = createResponseContent(responseBodies.filter((body) => body.statusCode === schema.statusCode));
-		responses[schema.statusCode] = {
-			description: schema.description ?? schema.statusCode,
-			...content ? { content } : {}
-		};
+		if (typeof value === "object") {
+			const entries = Object.entries(value);
+			if (entries.length === 0) return "{}";
+			const nextIndent = this.indent(indentLevel + 1);
+			const currentIndent = this.indent(indentLevel);
+			return `{\n${entries.map(([key, entry]) => `${nextIndent}${this.formatPropertyKey(key)}: ${this.renderLiteral(entry, indentLevel + 1)}`).join(",\n")}\n${currentIndent}}`;
+		}
+		return "undefined";
 	}
-	for (const body of responseBodies) {
-		if (!body.statusCode || responses[body.statusCode]) continue;
-		const content = createResponseContent([body]);
-		responses[body.statusCode] = {
-			description: body.label ?? body.statusCode,
-			...content ? { content } : {}
-		};
+	normalizeOpenApiDocument(document) {
+		return this.normalizeObject(document, (key, value, parent) => {
+			if (key === "example" && parent && typeof parent === "object" && !Array.isArray(parent)) {
+				const owner = parent;
+				if (owner.schema && this.isPlainObject(owner.schema)) return this.normalizeExample(value, owner.schema);
+				if (this.isSchemaLike(owner)) return this.normalizeExample(value, owner);
+			}
+			return value;
+		});
 	}
-	return responses;
-};
-const createResponseContent = (bodies) => {
-	if (bodies.length === 0) return;
-	const content = {};
-	for (const body of bodies) {
-		const contentType = body.contentType ?? (body.format === "json" ? "application/json" : "text/plain");
-		content[contentType] = {
-			schema: inferSchemaFromBody(body.body, body.format),
-			example: body.body
-		};
+	normalizeObject(value, transform) {
+		if (Array.isArray(value)) return value.map((entry) => this.normalizeObject(entry, transform)).filter((entry) => entry !== void 0);
+		if (!this.isPlainObject(value)) return value;
+		const output = {};
+		for (const [key, entry] of Object.entries(value)) {
+			const transformed = transform(key, entry, value);
+			const normalized = this.normalizeObject(transformed, transform);
+			if (normalized !== void 0) output[key] = normalized;
+		}
+		return output;
 	}
-	return content;
-};
-const inferSchemaFromBody = (body, format) => {
-	if (format === "json") return inferSchemaFromExample(body);
-	if (format === "text") return {
-		type: "string",
-		example: body
-	};
-};
-const resolveFallbackRequestBodyExample = (operation) => {
-	const jsonResponseBody = operation.responseBodies.find((body) => body.format === "json")?.body;
-	if (jsonResponseBody != null) return jsonResponseBody;
-	if (typeof operation.responseExample === "object" && operation.responseExample !== null) return operation.responseExample;
-	if (typeof operation.responseExampleRaw === "string") return parsePossiblyTruncatedJson(operation.responseExampleRaw);
-	if (typeof operation.responseExample === "string") return parsePossiblyTruncatedJson(operation.responseExample);
-	return null;
-};
-const createExampleSchema = (value) => {
-	if (value == null) return null;
-	return inferSchemaFromExample(value) ?? null;
-};
-const mergeOpenApiSchemas = (left, right) => {
-	if (!left) return right;
-	if (!right) return left;
-	const merged = {
-		...right,
-		...left,
-		...left.type || right.type ? { type: left.type ?? right.type } : {},
-		...left.description || right.description ? { description: left.description ?? right.description } : {},
-		...left.default !== void 0 || right.default !== void 0 ? { default: left.default ?? right.default } : {},
-		...left.example !== void 0 || right.example !== void 0 ? { example: left.example ?? right.example } : {}
-	};
-	if (left.properties || right.properties) {
-		const propertyKeys = new Set([...Object.keys(left.properties ?? {}), ...Object.keys(right.properties ?? {})]);
-		merged.properties = Object.fromEntries(Array.from(propertyKeys).map((key) => [key, mergeOpenApiSchemas(left.properties?.[key] ?? null, right.properties?.[key] ?? null) ?? {}]));
+	normalizeExample(example, schema) {
+		if (example === void 0) return;
+		const type = typeof schema.type === "string" ? schema.type : void 0;
+		if (type === "string") {
+			if (typeof example === "string") return example;
+			if (typeof example === "number" || typeof example === "boolean") return String(example);
+			return;
+		}
+		if (type === "number" || type === "integer") {
+			if (typeof example === "number") return example;
+			if (typeof example === "string" && example.trim() !== "" && Number.isFinite(Number(example))) return Number(example);
+			return;
+		}
+		if (type === "boolean") {
+			if (typeof example === "boolean") return example;
+			if (example === "true") return true;
+			if (example === "false") return false;
+			return;
+		}
+		if (type === "array") {
+			if (!Array.isArray(example)) return;
+			const itemSchema = this.isPlainObject(schema.items) ? schema.items : void 0;
+			if (!itemSchema) return example;
+			return example.map((entry) => this.normalizeExample(entry, itemSchema)).filter((entry) => entry !== void 0);
+		}
+		if (type === "object") {
+			if (!this.isPlainObject(example)) return;
+			const properties = this.isPlainObject(schema.properties) ? schema.properties : {};
+			const required = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+			const normalized = {};
+			for (const [key, entry] of Object.entries(example)) {
+				const propertySchema = properties[key];
+				const normalizedEntry = propertySchema ? this.normalizeExample(entry, propertySchema) : entry;
+				if (normalizedEntry !== void 0) normalized[key] = normalizedEntry;
+			}
+			for (const requiredKey of required) {
+				if (requiredKey in normalized) continue;
+				const propertySchema = properties[requiredKey];
+				if (!propertySchema) return;
+				const fallback = propertySchema.default !== void 0 ? this.normalizeExample(propertySchema.default, propertySchema) : propertySchema.example !== void 0 ? this.normalizeExample(propertySchema.example, propertySchema) : void 0;
+				if (fallback === void 0) return;
+				normalized[requiredKey] = fallback;
+			}
+			return normalized;
+		}
+		return example;
+	}
+	isPlainObject(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	}
+	isSchemaLike(value) {
+		return "type" in value || "properties" in value || "items" in value || "required" in value || "default" in value;
+	}
+	indent(level) {
+		return "  ".repeat(level);
+	}
+	escapeStringLiteral(value) {
+		return value.replace(/\\/g, String.raw`\\`).replace(/'/g, String.raw`\'`).replace(/\r/g, String.raw`\r`).replace(/\n/g, String.raw`\n`).replace(/\t/g, String.raw`\t`).replace(/\f/g, String.raw`\f`).replace(/\x08/g, String.raw`\b`).replace(/\u2028/g, String.raw`\u2028`).replace(/\u2029/g, String.raw`\u2029`);
+	}
+	isPathParam(segment) {
+		return segment.startsWith("{") && segment.endsWith("}") || /^:[A-Za-z0-9_]+$/.test(segment);
+	}
+	stripPathParam(segment) {
+		return segment.replace(/^\{/, "").replace(/\}$/, "").replace(/^:/, "");
 	}
-	if (left.items || right.items) merged.items = mergeOpenApiSchemas(left.items ?? null, right.items ?? null) ?? {};
-	if (left.required || right.required) merged.required = Array.from(new Set([...right.required ?? [], ...left.required ?? []]));
-	return merged;
-};
-const buildOperationId = (method, path) => {
-	return `${method}${path.replace(/\{([^}]+)\}/g, "$1").split("/").filter(Boolean).map((segment) => segment.replace(/[^a-zA-Z0-9]+/g, " ")).map((segment) => segment.trim()).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).replace(/\s+(.)/g, (_match, char) => char.toUpperCase())).join("")}`;
 };
-const isOpenApiParameterLocation = (value) => {
-	return value === "query" || value === "header" || value === "path" || value === "cookie";
+
+//#endregion
+//#region src/generator/TypeScriptNamingSupport.ts
+var TypeScriptNamingSupport = class TypeScriptNamingSupport {
+	static contextualTailSegments = new Set([
+		"history",
+		"status",
+		"detail",
+		"details"
+	]);
+	static nestedContextSegments = new Set([
+		"account",
+		"accounts",
+		"transaction",
+		"transactions",
+		"wallet",
+		"wallets",
+		"virtual-account",
+		"virtual-accounts",
+		"history"
+	]);
+	static roleSuffixes = [
+		"Input",
+		"Query",
+		"Header",
+		"Params"
+	];
+	sanitizeTypeName(value) {
+		const normalized = value.replace(/[^A-Za-z0-9]+/g, " ").trim();
+		if (!normalized) return "GeneratedEntity";
+		const pascalCased = normalized.split(/\s+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+		return /^[A-Za-z_$]/.test(pascalCased) ? pascalCased : `Type${pascalCased}`;
+	}
+	isPathParam(segment) {
+		return segment.startsWith("{") && segment.endsWith("}") || /^:[A-Za-z0-9_]+$/.test(segment);
+	}
+	stripPathParam(segment) {
+		return segment.replace(/^\{/, "").replace(/\}$/, "").replace(/^:/, "");
+	}
+	singularize(value) {
+		if (/ies$/i.test(value)) return `${value.slice(0, -3)}y`;
+		if (/(sses|shes|ches|xes|zes)$/i.test(value)) return value.slice(0, -2);
+		if (value.endsWith("s") && !value.endsWith("ss") && value.length > 1) return value.slice(0, -1);
+		return value;
+	}
+	pluralize(value) {
+		if (/y$/i.test(value)) return `${value.slice(0, -1)}ies`;
+		if (/s$/i.test(value)) return value;
+		return `${value}s`;
+	}
+	toCamelCase(value) {
+		const typeName = this.sanitizeTypeName(value);
+		return typeName.charAt(0).toLowerCase() + typeName.slice(1);
+	}
+	deriveOperationNaming(path) {
+		const pathSegments = this.getNormalizedPathSegments(path);
+		const staticSegments = pathSegments.filter((segment) => !this.isPathParam(segment)).map((segment) => this.singularize(segment));
+		const paramSegments = pathSegments.filter((segment) => this.isPathParam(segment)).map((segment) => this.singularize(this.stripPathParam(segment)));
+		const tailSegment = staticSegments[staticSegments.length - 1] ?? "resource";
+		const parentSegment = staticSegments[staticSegments.length - 2] ?? null;
+		const hasPathParamBeforeTail = pathSegments.slice(0, -1).some((segment) => this.isPathParam(segment));
+		const shouldPrefixParent = Boolean(parentSegment && (TypeScriptNamingSupport.contextualTailSegments.has(tailSegment.toLowerCase()) || hasPathParamBeforeTail && TypeScriptNamingSupport.nestedContextSegments.has(tailSegment.toLowerCase())));
+		return {
+			baseName: this.sanitizeTypeName(shouldPrefixParent ? `${parentSegment} ${tailSegment}` : tailSegment),
+			collisionSuffix: paramSegments.length > 0 ? `By ${paramSegments.map((segment) => this.sanitizeTypeName(segment)).join(" And ")}` : parentSegment && !shouldPrefixParent ? this.sanitizeTypeName(parentSegment) : ""
+		};
+	}
+	fallbackCollisionSuffix(method, path, baseName) {
+		const pathSegments = this.getNormalizedPathSegments(path);
+		const staticSegments = pathSegments.filter((segment) => !this.isPathParam(segment));
+		const tailSegment = staticSegments[staticSegments.length - 1] ?? "";
+		const hasParams = pathSegments.some((segment) => this.isPathParam(segment));
+		if (method === "get" && !hasParams && /s$/i.test(tailSegment)) return "List";
+		if (method === "post" && !hasParams) return "Create";
+		if ((method === "put" || method === "patch") && hasParams) return "Update";
+		if (method === "delete") return "Delete";
+		return `${this.sanitizeTypeName(method)}${baseName}`;
+	}
+	insertCollisionSuffix(baseName, collisionName) {
+		if (!collisionName) return baseName;
+		for (const roleSuffix of TypeScriptNamingSupport.roleSuffixes) if (baseName.endsWith(roleSuffix) && baseName.length > roleSuffix.length) return `${baseName.slice(0, -roleSuffix.length)}${collisionName}${roleSuffix}`;
+		return `${baseName}${collisionName}`;
+	}
+	deriveSdkGroupNamesBySignature(document, namespaceStrategy) {
+		const pathBySignature = /* @__PURE__ */ new Map();
+		for (const path of Object.keys(document.paths)) {
+			const signature = this.getStaticPathSignature(path);
+			if (!pathBySignature.has(signature)) pathBySignature.set(signature, path);
+		}
+		const entries = Array.from(pathBySignature.entries()).map(([signature, path]) => ({
+			signature,
+			staticSegments: signature.split("/").filter(Boolean),
+			candidates: this.buildSdkGroupNameCandidates(path, namespaceStrategy)
+		})).sort((left, right) => {
+			return left.staticSegments.length - right.staticSegments.length || left.signature.localeCompare(right.signature);
+		});
+		const groupNamesBySignature = /* @__PURE__ */ new Map();
+		const usedNames = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			const className = entry.candidates.find((candidate) => !usedNames.has(candidate)) ?? this.createUniqueSdkGroupName(entry.candidates[entry.candidates.length - 1] ?? "Resource", usedNames);
+			usedNames.add(className);
+			groupNamesBySignature.set(entry.signature, className);
+		}
+		return groupNamesBySignature;
+	}
+	getStaticPathSegments(path) {
+		return this.getNormalizedPathSegments(path).filter((segment) => !this.isPathParam(segment)).map((segment) => this.singularize(segment));
+	}
+	getStaticPathSignature(path) {
+		return this.getStaticPathSegments(path).join("/");
+	}
+	getNormalizedPathSegments(path) {
+		return path.split("/").map((segment) => segment.trim()).filter(Boolean).filter((segment) => !/^v\d+$/i.test(segment));
+	}
+	deriveSdkMethodName(method, path, operation, methodStrategy) {
+		if (methodStrategy === "operation-id" && operation.operationId) return this.toCamelCase(this.sanitizeTypeName(operation.operationId));
+		const hasPathParams = this.getNormalizedPathSegments(path).some((segment) => this.isPathParam(segment));
+		if (method === "get") return this.endsWithPluralStaticSegment(path) ? "list" : hasPathParams ? "get" : "list";
+		if (method === "post") return "create";
+		if (method === "patch" || method === "put") return "update";
+		if (method === "delete") return "delete";
+		return this.toCamelCase(this.sanitizeTypeName(method));
+	}
+	ensureUniqueSdkMethodNames(operations) {
+		const counts = /* @__PURE__ */ new Map();
+		return operations.map((operation) => {
+			const count = counts.get(operation.methodName) ?? 0;
+			counts.set(operation.methodName, count + 1);
+			if (count === 0) return operation;
+			const suffix = this.sanitizeTypeName(this.fallbackCollisionSuffix(operation.method.toLowerCase(), operation.path, "Operation"));
+			return {
+				...operation,
+				methodName: `${operation.methodName}${suffix}`
+			};
+		});
+	}
+	createSdkParameterManifest(parameters, location, path) {
+		return [...(parameters ?? []).filter((parameter) => parameter.in === location).sort((left, right) => left.name.localeCompare(right.name)), ...this.getInferredPathParameters(path, location, (parameters ?? []).filter((parameter) => parameter.in === location))].sort((left, right) => left.name.localeCompare(right.name)).map((parameter) => ({
+			name: parameter.name,
+			accessor: this.toParameterAccessor(parameter.name),
+			in: location,
+			required: parameter.required ?? false,
+			description: parameter.description
+		}));
+	}
+	getInferredPathParameters(path, location, existingParameters) {
+		if (location !== "path" || !path) return [];
+		const existingNames = new Set(existingParameters.map((parameter) => parameter.name));
+		return this.getNormalizedPathSegments(path).filter((segment) => this.isPathParam(segment)).map((segment) => this.stripPathParam(segment)).filter((name) => !existingNames.has(name)).map((name) => ({
+			name,
+			in: "path",
+			required: true,
+			schema: { type: "string" }
+		}));
+	}
+	buildSdkGroupNameCandidates(path, namespaceStrategy) {
+		const normalizedSegments = this.getNormalizedPathSegments(path);
+		const rawStaticSegments = normalizedSegments.filter((segment) => !this.isPathParam(segment));
+		const staticSegments = rawStaticSegments.map((segment) => this.singularize(segment));
+		const defaultName = this.deriveOperationNaming(path).baseName;
+		const preferredName = this.getPreferredSdkGroupName(normalizedSegments, rawStaticSegments, staticSegments);
+		const contextualNames = staticSegments.map((_, index, segments) => this.sanitizeTypeName(segments.slice(index).join(" "))).reverse();
+		if (namespaceStrategy === "scoped") return Array.from(new Set([
+			preferredName ?? "",
+			this.sanitizeTypeName(staticSegments.join(" ")),
+			...contextualNames,
+			defaultName
+		].filter(Boolean)));
+		return Array.from(new Set([
+			preferredName ?? "",
+			defaultName,
+			...contextualNames
+		].filter(Boolean)));
+	}
+	getPreferredSdkGroupName(normalizedSegments, rawStaticSegments, staticSegments) {
+		const tailSegment = rawStaticSegments[rawStaticSegments.length - 1];
+		const tailBaseSegment = staticSegments[staticSegments.length - 1];
+		const parentSegment = staticSegments[staticSegments.length - 2];
+		const hasPathParams = normalizedSegments.some((segment) => this.isPathParam(segment));
+		const hasPathParamBeforeTail = normalizedSegments.slice(0, -1).some((segment) => this.isPathParam(segment));
+		if (!tailSegment || !tailBaseSegment || !parentSegment) return null;
+		if (rawStaticSegments.length === 2 && !hasPathParams) return this.sanitizeTypeName(`${tailBaseSegment} ${parentSegment}`);
+		if (!hasPathParamBeforeTail) return null;
+		if (this.singularize(tailSegment) !== tailSegment) return this.sanitizeTypeName(`${parentSegment} ${tailBaseSegment}`);
+		return this.sanitizeTypeName(`${tailBaseSegment} ${parentSegment}`);
+	}
+	createUniqueSdkGroupName(baseName, usedNames) {
+		let suffix = 2;
+		let candidate = baseName;
+		while (usedNames.has(candidate)) {
+			candidate = `${baseName}${suffix}`;
+			suffix += 1;
+		}
+		return candidate;
+	}
+	endsWithPluralStaticSegment(path) {
+		const tailSegment = this.getNormalizedPathSegments(path).at(-1);
+		if (!tailSegment || this.isPathParam(tailSegment)) return false;
+		return this.singularize(tailSegment) !== tailSegment;
+	}
+	toParameterAccessor(value) {
+		const normalized = value.replace(/[^A-Za-z0-9]+/g, " ").trim();
+		if (!normalized) return "value";
+		const [first, ...rest] = normalized.split(/\s+/).filter(Boolean);
+		const camelValue = [first.toLowerCase(), ...rest.map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase())].join("");
+		return /^[A-Za-z_$]/.test(camelValue) ? camelValue : `value${camelValue}`;
+	}
+};
+
+//#endregion
+//#region src/generator/TypeScriptShapeBuilder.ts
+var TypeScriptShapeBuilder = class {
+	constructor(naming) {
+		this.naming = naming;
+	}
+	createContext() {
+		return {
+			declarations: [],
+			declarationByName: /* @__PURE__ */ new Map(),
+			nameBySignature: /* @__PURE__ */ new Map(),
+			usedNames: /* @__PURE__ */ new Set()
+		};
+	}
+	namespaceTopLevelShape(shape, role) {
+		if (shape.kind !== "object") return shape;
+		return {
+			...shape,
+			signature: `${role}:${shape.signature}`
+		};
+	}
+	inferShapeFromExample(value, nameHint) {
+		if (value === null) return {
+			kind: "primitive",
+			type: "null"
+		};
+		if (Array.isArray(value)) {
+			if (value.length === 0) return {
+				kind: "array",
+				item: {
+					kind: "primitive",
+					type: "unknown"
+				}
+			};
+			const itemShapes = this.dedupeShapes(value.map((entry) => this.inferShapeFromExample(entry, this.naming.singularize(nameHint))));
+			return {
+				kind: "array",
+				item: itemShapes.length === 1 ? itemShapes[0] : {
+					kind: "union",
+					types: itemShapes
+				}
+			};
+		}
+		if (this.isRecord(value)) return this.createObjectShape(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => ({
+			key,
+			optional: false,
+			shape: this.inferShapeFromExample(entry, key)
+		})));
+		switch (typeof value) {
+			case "string": return {
+				kind: "primitive",
+				type: "string"
+			};
+			case "number": return {
+				kind: "primitive",
+				type: "number"
+			};
+			case "boolean": return {
+				kind: "primitive",
+				type: "boolean"
+			};
+			default: return {
+				kind: "primitive",
+				type: "unknown"
+			};
+		}
+	}
+	registerNamedShape(shape, preferredName, context, collisionSuffix) {
+		if (shape.kind === "object") return this.registerObjectShape(shape, preferredName, context, collisionSuffix, true);
+		const name = this.createUniqueTypeName(preferredName, context, collisionSuffix);
+		const declaration = {
+			kind: "shape-alias",
+			name,
+			shape: this.prepareNestedShape(shape, preferredName, context)
+		};
+		context.declarations.push(declaration);
+		context.declarationByName.set(name, declaration);
+		return name;
+	}
+	registerObjectShape(shape, preferredName, context, collisionSuffix, emitAlias = false) {
+		const existingName = context.nameBySignature.get(shape.signature);
+		const compatibleDeclaration = this.findCompatibleObjectDeclaration(shape, preferredName, context);
+		if (existingName) {
+			if (emitAlias && existingName !== preferredName && !context.declarationByName.has(preferredName)) {
+				const aliasName = this.createUniqueTypeName(preferredName, context, collisionSuffix);
+				if (aliasName !== existingName) {
+					const aliasDeclaration = {
+						kind: "interface-alias",
+						name: aliasName,
+						target: existingName
+					};
+					context.declarations.push(aliasDeclaration);
+					context.declarationByName.set(aliasName, aliasDeclaration);
+				}
+			}
+			return existingName;
+		}
+		if (compatibleDeclaration) {
+			if (this.isObjectShapeAssignableTo(shape, compatibleDeclaration.rawShape)) {
+				context.nameBySignature.set(shape.signature, compatibleDeclaration.name);
+				return compatibleDeclaration.name;
+			}
+			const mergedShape = this.mergeObjectShapes(compatibleDeclaration.rawShape, shape);
+			compatibleDeclaration.rawShape = mergedShape;
+			compatibleDeclaration.properties = mergedShape.properties.map((property) => ({
+				...property,
+				shape: this.prepareNestedShape(property.shape, property.key, context)
+			}));
+			context.nameBySignature.set(shape.signature, compatibleDeclaration.name);
+			context.nameBySignature.set(mergedShape.signature, compatibleDeclaration.name);
+			return compatibleDeclaration.name;
+		}
+		const declarationName = this.createUniqueTypeName(preferredName, context, collisionSuffix);
+		const declaration = {
+			kind: "interface",
+			name: declarationName,
+			baseName: this.naming.sanitizeTypeName(preferredName),
+			rawShape: shape,
+			properties: []
+		};
+		context.nameBySignature.set(shape.signature, declarationName);
+		context.declarations.push(declaration);
+		context.declarationByName.set(declarationName, declaration);
+		declaration.properties = shape.properties.map((property) => ({
+			...property,
+			shape: this.prepareNestedShape(property.shape, property.key, context)
+		}));
+		return declarationName;
+	}
+	resolveSdkResponseType(responses, fallbackType) {
+		const successResponse = Object.entries(responses).filter(([statusCode]) => /^2\d\d$/.test(statusCode)).sort(([left], [right]) => left.localeCompare(right))[0]?.[1];
+		if (!successResponse) return fallbackType;
+		const mediaType = this.getPreferredMediaType(successResponse.content);
+		if (!mediaType) return fallbackType;
+		const responseSchema = this.resolveResponsePayloadSchema(mediaType.schema, mediaType.example).schema ?? mediaType.schema;
+		return responseSchema && this.resolveSchemaType(responseSchema) === "array" ? `${fallbackType}[]` : fallbackType;
+	}
+	getSuccessResponseShape(responses) {
+		const successResponse = Object.entries(responses).filter(([statusCode]) => /^2\d\d$/.test(statusCode)).sort(([left], [right]) => left.localeCompare(right))[0]?.[1];
+		if (!successResponse) return this.emptyObjectShape;
+		const mediaType = this.getPreferredMediaType(successResponse.content);
+		if (!mediaType) return this.emptyObjectShape;
+		const payload = this.resolveResponsePayloadSchema(mediaType.schema, mediaType.example);
+		if (!payload.schema) return this.schemaToShape(mediaType.schema, "Response", mediaType.example);
+		if (this.resolveSchemaType(payload.schema) === "array") return this.schemaToShape(payload.schema.items, "Item", this.extractExampleArrayItem(payload.example));
+		return this.schemaToShape(payload.schema, "Response", payload.example);
+	}
+	getRequestInputShape(requestBody) {
+		if (!requestBody) return this.emptyObjectShape;
+		const mediaType = this.getPreferredMediaType(requestBody.content);
+		if (!mediaType) return this.emptyObjectShape;
+		return this.schemaToShape(mediaType.schema, "Input", mediaType.example);
+	}
+	getResponseExampleShape(responses) {
+		const shapes = Object.entries(responses).sort(([left], [right]) => left.localeCompare(right)).flatMap(([, response]) => {
+			const mediaType = this.getPreferredMediaType(response.content);
+			if (!mediaType) return [];
+			const fullExample = mediaType.example ?? mediaType.schema?.example;
+			if (mediaType.schema) return [this.schemaToShape(mediaType.schema, "ResponseExample", fullExample)];
+			if (fullExample !== void 0) return [this.inferShapeFromExample(fullExample, "ResponseExample")];
+			return [];
+		});
+		const uniqueShapes = this.dedupeShapes(shapes);
+		if (uniqueShapes.length === 0) return {
+			kind: "primitive",
+			type: "unknown"
+		};
+		return uniqueShapes.length === 1 ? uniqueShapes[0] : {
+			kind: "union",
+			types: uniqueShapes
+		};
+	}
+	createParameterGroupShape(parameters, location, path) {
+		const relevantParameters = (parameters ?? []).filter((parameter) => parameter.in === location).sort((left, right) => left.name.localeCompare(right.name));
+		const mergedParameters = [...relevantParameters, ...this.naming.getInferredPathParameters(path, location, relevantParameters)].sort((left, right) => left.name.localeCompare(right.name));
+		if (mergedParameters.length === 0) return this.emptyObjectShape;
+		return this.createObjectShape(mergedParameters.map((parameter) => ({
+			key: parameter.name,
+			optional: !(parameter.required ?? false),
+			shape: this.schemaToShape(parameter.schema, parameter.name, parameter.example)
+		})));
+	}
+	get emptyObjectShape() {
+		return this.createObjectShape([]);
+	}
+	findCompatibleObjectDeclaration(shape, preferredName, context) {
+		const baseName = this.naming.sanitizeTypeName(preferredName);
+		return context.declarations.find((declaration) => {
+			if (declaration.kind !== "interface" || declaration.baseName !== baseName) return false;
+			return this.isObjectShapeAssignableTo(shape, declaration.rawShape) || this.isObjectShapeAssignableTo(declaration.rawShape, shape) || this.canMergeObjectShapes(declaration.rawShape, shape);
+		});
+	}
+	canMergeObjectShapes(left, right) {
+		const keys = new Set([...left.properties.map((property) => property.key), ...right.properties.map((property) => property.key)]);
+		for (const key of keys) {
+			const leftProperty = left.properties.find((property) => property.key === key);
+			const rightProperty = right.properties.find((property) => property.key === key);
+			if (!leftProperty || !rightProperty) {
+				if (!(leftProperty ?? rightProperty)?.optional) return false;
+				continue;
+			}
+			if (!this.canMergeShapes(leftProperty.shape, rightProperty.shape)) return false;
+		}
+		return true;
+	}
+	isObjectShapeAssignableTo(source, target) {
+		const targetProperties = new Map(target.properties.map((property) => [property.key, property]));
+		for (const sourceProperty of source.properties) {
+			const targetProperty = targetProperties.get(sourceProperty.key);
+			if (!targetProperty) return false;
+			if (sourceProperty.optional && !targetProperty.optional) return false;
+			if (!this.isShapeAssignableTo(sourceProperty.shape, targetProperty.shape)) return false;
+		}
+		return target.properties.every((targetProperty) => {
+			return source.properties.some((sourceProperty) => sourceProperty.key === targetProperty.key) || targetProperty.optional;
+		});
+	}
+	isShapeAssignableTo(source, target) {
+		if (target.kind === "union") return target.types.some((targetType) => this.isShapeAssignableTo(source, targetType));
+		switch (source.kind) {
+			case "primitive":
+				if (target.kind !== "primitive") return false;
+				return source.type === target.type;
+			case "array":
+				if (target.kind !== "array") return false;
+				return this.isShapeAssignableTo(source.item, target.item);
+			case "union": return source.types.every((sourceType) => this.isShapeAssignableTo(sourceType, target));
+			case "object":
+				if (target.kind !== "object") return false;
+				return this.isObjectShapeAssignableTo(source, target);
+		}
+	}
+	canMergeShapes(left, right) {
+		if (left.kind === "union") return left.types.every((leftType) => this.canMergeShapes(leftType, right));
+		if (right.kind === "union") return right.types.every((rightType) => this.canMergeShapes(left, rightType));
+		if (left.kind === "primitive" && right.kind === "primitive") return true;
+		if (left.kind === "array" && right.kind === "array") return this.canMergeShapes(left.item, right.item);
+		if (left.kind === "object" && right.kind === "object") return this.canMergeObjectShapes(left, right);
+		return false;
+	}
+	mergeObjectShapes(left, right) {
+		const keys = new Set([...left.properties.map((property) => property.key), ...right.properties.map((property) => property.key)]);
+		return this.createObjectShape(Array.from(keys).map((key) => {
+			const leftProperty = left.properties.find((property) => property.key === key);
+			const rightProperty = right.properties.find((property) => property.key === key);
+			if (leftProperty && rightProperty) return {
+				key,
+				optional: leftProperty.optional || rightProperty.optional,
+				shape: this.mergeShapes(leftProperty.shape, rightProperty.shape)
+			};
+			return {
+				key,
+				optional: true,
+				shape: (leftProperty ?? rightProperty).shape
+			};
+		}));
+	}
+	mergeShapes(left, right) {
+		if (left.kind === "union" || right.kind === "union") return this.createUnionShape(left, right);
+		if (left.kind !== right.kind) return this.createUnionShape(left, right);
+		switch (left.kind) {
+			case "primitive": return right.kind === "primitive" && left.type === right.type ? left : this.createUnionShape(left, right);
+			case "array":
+				if (right.kind !== "array") return left;
+				return {
+					kind: "array",
+					item: this.mergeShapes(left.item, right.item)
+				};
+			case "object":
+				if (right.kind !== "object") return left;
+				return this.mergeObjectShapes(left, right);
+		}
+	}
+	createUnionShape(...shapes) {
+		const flattened = shapes.flatMap((shape) => shape.kind === "union" ? shape.types : [shape]);
+		const deduped = this.dedupeShapes(flattened);
+		return deduped.length === 1 ? deduped[0] : {
+			kind: "union",
+			types: deduped
+		};
+	}
+	prepareNestedShape(shape, keyHint, context) {
+		if (shape.kind === "object") return {
+			kind: "primitive",
+			type: this.registerObjectShape(shape, this.naming.sanitizeTypeName(this.naming.singularize(keyHint)), context, this.naming.sanitizeTypeName(keyHint))
+		};
+		if (shape.kind === "array") return {
+			kind: "array",
+			item: this.prepareNestedShape(shape.item, this.naming.singularize(keyHint), context)
+		};
+		if (shape.kind === "union") {
+			const preparedTypes = this.dedupeShapes(shape.types.map((entry, index) => {
+				return this.prepareNestedShape(entry, this.getUnionMemberKeyHint(keyHint, index, entry), context);
+			}));
+			if (preparedTypes.length === 1) return preparedTypes[0];
+			return {
+				kind: "union",
+				types: preparedTypes
+			};
+		}
+		return shape;
+	}
+	getUnionMemberKeyHint(keyHint, index, shape) {
+		if (shape.kind !== "object" && shape.kind !== "array") return keyHint;
+		const sanitizedKeyHint = this.naming.sanitizeTypeName(keyHint);
+		if (sanitizedKeyHint.endsWith("ResponseExample")) return `${sanitizedKeyHint}Variant${index + 1}`;
+		return keyHint;
+	}
+	schemaToShape(schema, nameHint, fallbackExample) {
+		if (!schema) return this.inferShapeFromExample(fallbackExample, nameHint);
+		const schemaType = this.resolveSchemaType(schema);
+		if (schemaType === "array") return {
+			kind: "array",
+			item: this.schemaToShape(schema.items, this.naming.singularize(nameHint), this.extractExampleArrayItem(schema.example) ?? this.extractExampleArrayItem(fallbackExample))
+		};
+		if (schemaType === "object") {
+			const propertyExamples = this.isRecord(schema.example) ? schema.example : this.isRecord(fallbackExample) ? fallbackExample : void 0;
+			const properties = Object.entries(schema.properties ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => ({
+				key,
+				optional: !(schema.required ?? []).includes(key),
+				shape: this.schemaToShape(entry, key, propertyExamples?.[key])
+			}));
+			if (properties.length > 0) return this.createObjectShape(properties);
+			return this.inferShapeFromExample(schema.example ?? fallbackExample, nameHint);
+		}
+		if (schemaType === "integer" || schemaType === "number") return {
+			kind: "primitive",
+			type: "number"
+		};
+		if (schemaType === "string") return {
+			kind: "primitive",
+			type: "string"
+		};
+		if (schemaType === "boolean") return {
+			kind: "primitive",
+			type: "boolean"
+		};
+		if (schema.example === null || fallbackExample === null) return {
+			kind: "primitive",
+			type: "null"
+		};
+		if (schema.example !== void 0 || fallbackExample !== void 0) return this.inferShapeFromExample(schema.example ?? fallbackExample, nameHint);
+		return {
+			kind: "primitive",
+			type: "unknown"
+		};
+	}
+	dedupeShapes(shapes) {
+		const seen = /* @__PURE__ */ new Set();
+		return shapes.filter((shape) => {
+			const signature = this.getShapeSignature(shape);
+			if (seen.has(signature)) return false;
+			seen.add(signature);
+			return true;
+		});
+	}
+	createObjectShape(properties) {
+		const normalizedProperties = properties.map((property) => ({ ...property })).sort((left, right) => left.key.localeCompare(right.key));
+		return {
+			kind: "object",
+			signature: JSON.stringify(normalizedProperties.map((property) => ({
+				key: property.key,
+				optional: property.optional,
+				shape: this.getShapeSignature(property.shape)
+			}))),
+			properties: normalizedProperties
+		};
+	}
+	getShapeSignature(shape) {
+		switch (shape.kind) {
+			case "primitive": return `primitive:${shape.type}`;
+			case "array": return `array:${this.getShapeSignature(shape.item)}`;
+			case "union": return `union:${shape.types.map((entry) => this.getShapeSignature(entry)).join("|")}`;
+			case "object": return `object:${shape.signature}`;
+		}
+	}
+	getPreferredMediaType(content) {
+		if (!content) return;
+		return content["application/json"] ?? content["application/*+json"] ?? Object.values(content)[0];
+	}
+	resolveResponsePayloadSchema(schema, example) {
+		for (const path of [["data"], ["meta", "data"]]) {
+			const candidate = this.getSchemaCandidateAtPath(schema, example, path);
+			if (candidate) return candidate;
+		}
+		return {};
+	}
+	getSchemaCandidateAtPath(schema, example, path) {
+		const schemaAtPath = this.getSchemaAtPath(schema, path);
+		const exampleAtPath = this.getExampleAtPath(example, path);
+		if (!schemaAtPath && exampleAtPath === void 0) return;
+		if (schemaAtPath) return {
+			schema: schemaAtPath.example === void 0 && exampleAtPath !== void 0 ? {
+				...schemaAtPath,
+				example: exampleAtPath
+			} : schemaAtPath,
+			example: exampleAtPath ?? schemaAtPath.example
+		};
+		return {
+			schema: {
+				...this.inferSchemaTypeFromExample(exampleAtPath),
+				example: exampleAtPath
+			},
+			example: exampleAtPath
+		};
+	}
+	getSchemaAtPath(schema, path) {
+		let currentSchema = schema;
+		for (const segment of path) {
+			if (!currentSchema?.properties?.[segment]) return;
+			currentSchema = currentSchema.properties[segment];
+		}
+		return currentSchema;
+	}
+	getExampleAtPath(example, path) {
+		let currentValue = example;
+		for (const segment of path) {
+			if (!this.isRecord(currentValue) || !(segment in currentValue)) return;
+			currentValue = currentValue[segment];
+		}
+		return currentValue;
+	}
+	inferSchemaTypeFromExample(value) {
+		if (Array.isArray(value)) return {
+			type: "array",
+			items: value.map((entry) => this.inferSchemaTypeFromExample(entry)).find((entry) => this.hasSchemaDetails(entry)) ?? {}
+		};
+		if (this.isRecord(value)) return {
+			type: "object",
+			properties: Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, this.inferSchemaTypeFromExample(entry)]))
+		};
+		if (typeof value === "string") return { type: "string" };
+		if (typeof value === "number") return { type: "number" };
+		if (typeof value === "boolean") return { type: "boolean" };
+		return {};
+	}
+	hasSchemaDetails(schema) {
+		return Boolean(schema?.type || schema?.properties || schema?.items || schema?.example !== void 0);
+	}
+	resolveSchemaType(schema) {
+		return schema.type ?? (schema.properties ? "object" : void 0);
+	}
+	extractExampleArrayItem(value) {
+		return Array.isArray(value) ? value[0] : void 0;
+	}
+	createUniqueTypeName(preferredName, context, collisionSuffix) {
+		const baseName = this.naming.sanitizeTypeName(preferredName) || "GeneratedEntity";
+		const collisionName = this.naming.sanitizeTypeName(collisionSuffix);
+		let candidate = baseName;
+		let suffix = 2;
+		if (!context.usedNames.has(candidate)) {
+			context.usedNames.add(candidate);
+			return candidate;
+		}
+		candidate = this.naming.insertCollisionSuffix(baseName, collisionName);
+		if (!context.usedNames.has(candidate)) {
+			context.usedNames.add(candidate);
+			return candidate;
+		}
+		while (context.usedNames.has(candidate)) {
+			candidate = `${baseName}${suffix}`;
+			suffix += 1;
+		}
+		context.usedNames.add(candidate);
+		return candidate;
+	}
+	isRecord(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	}
+};
+
+//#endregion
+//#region src/generator/TypeScriptTypeBuilder.ts
+var TypeScriptTypeBuilder = class {
+	naming = new TypeScriptNamingSupport();
+	shapes = new TypeScriptShapeBuilder(this.naming);
+	createContext() {
+		return this.shapes.createContext();
+	}
+	collectSemanticModels(document) {
+		const models = [];
+		for (const [path, operations] of Object.entries(document.paths)) {
+			const naming = this.naming.deriveOperationNaming(path);
+			const baseName = naming.baseName;
+			const sortedOperations = Object.entries(operations).sort(([, leftOperation], [, rightOperation]) => {
+				return this.getOperationPriority(rightOperation) - this.getOperationPriority(leftOperation);
+			});
+			for (const [method, operation] of sortedOperations) {
+				const collisionSuffix = naming.collisionSuffix || this.naming.fallbackCollisionSuffix(method, path, baseName);
+				models.push({
+					path,
+					method,
+					name: baseName,
+					role: "response",
+					shape: this.shapes.getSuccessResponseShape(operation.responses),
+					collisionSuffix
+				});
+				models.push({
+					path,
+					method,
+					name: `${baseName}ResponseExample`,
+					role: "responseExample",
+					shape: this.shapes.getResponseExampleShape(operation.responses),
+					collisionSuffix
+				});
+				models.push({
+					path,
+					method,
+					name: `${baseName}Input`,
+					role: "input",
+					shape: this.shapes.getRequestInputShape(operation.requestBody),
+					collisionSuffix
+				});
+				models.push({
+					path,
+					method,
+					name: `${baseName}Query`,
+					role: "query",
+					shape: this.shapes.createParameterGroupShape(operation.parameters, "query", path),
+					collisionSuffix
+				});
+				models.push({
+					path,
+					method,
+					name: `${baseName}Header`,
+					role: "header",
+					shape: this.shapes.createParameterGroupShape(operation.parameters, "header", path),
+					collisionSuffix
+				});
+				models.push({
+					path,
+					method,
+					name: `${baseName}Params`,
+					role: "params",
+					shape: this.shapes.createParameterGroupShape(operation.parameters, "path", path),
+					collisionSuffix
+				});
+			}
+		}
+		return models;
+	}
+	buildSdkManifest(document, operationTypeRefs, options = {}) {
+		const sdkGroupNamesBySignature = this.naming.deriveSdkGroupNamesBySignature(document, options.namespaceStrategy ?? "smart");
+		const groups = /* @__PURE__ */ new Map();
+		for (const [path, operations] of Object.entries(document.paths)) {
+			const staticSignature = this.naming.getStaticPathSegments(path).join("/");
+			const className = sdkGroupNamesBySignature.get(staticSignature) ?? "Resource";
+			const propertyName = this.naming.toCamelCase(this.naming.pluralize(className));
+			const group = groups.get(propertyName) ?? {
+				className,
+				propertyName,
+				operations: []
+			};
+			for (const [method, operation] of Object.entries(operations)) {
+				const refs = operationTypeRefs.get(`${path}::${method}`) ?? {
+					response: "Record<string, never>",
+					responseExample: "unknown",
+					input: "Record<string, never>",
+					query: "Record<string, never>",
+					header: "Record<string, never>",
+					params: "Record<string, never>"
+				};
+				group.operations.push({
+					path,
+					method: method.toUpperCase(),
+					methodName: this.naming.deriveSdkMethodName(method, path, operation, options.methodStrategy ?? "smart"),
+					summary: operation.summary,
+					description: operation.description,
+					operationId: operation.operationId,
+					requestBodyDescription: operation.requestBody?.description,
+					responseDescription: this.resolveSuccessResponseDescription(operation.responses),
+					responseType: this.shapes.resolveSdkResponseType(operation.responses, refs.response),
+					inputType: refs.input,
+					queryType: refs.query,
+					headerType: refs.header,
+					paramsType: refs.params,
+					hasBody: Boolean(operation.requestBody),
+					bodyRequired: operation.requestBody?.required ?? false,
+					pathParams: this.naming.createSdkParameterManifest(operation.parameters, "path", path),
+					queryParams: this.naming.createSdkParameterManifest(operation.parameters, "query", path),
+					headerParams: this.naming.createSdkParameterManifest(operation.parameters, "header", path)
+				});
+			}
+			groups.set(propertyName, group);
+		}
+		return { groups: Array.from(groups.values()).map((group) => ({
+			...group,
+			operations: this.naming.ensureUniqueSdkMethodNames(group.operations)
+		})).sort((left, right) => left.propertyName.localeCompare(right.propertyName)) };
+	}
+	inferShapeFromExample(value, nameHint) {
+		return this.shapes.inferShapeFromExample(value, nameHint);
+	}
+	sanitizeTypeName(value) {
+		return this.naming.sanitizeTypeName(value);
+	}
+	registerNamedShape(shape, preferredName, context, collisionSuffix) {
+		return this.shapes.registerNamedShape(shape, preferredName, context, collisionSuffix);
+	}
+	namespaceTopLevelShape(shape, role) {
+		return this.shapes.namespaceTopLevelShape(shape, role);
+	}
+	registerObjectShape(shape, preferredName, context, collisionSuffix, emitAlias = false) {
+		return this.shapes.registerObjectShape(shape, preferredName, context, collisionSuffix, emitAlias);
+	}
+	getOperationPriority(operation) {
+		return Number(Boolean(operation.requestBody)) * 10;
+	}
+	resolveSuccessResponseDescription(responses) {
+		for (const statusCode of [
+			"200",
+			"201",
+			"202",
+			"204"
+		]) {
+			const description = responses[statusCode]?.description?.trim();
+			if (description) return description;
+		}
+		for (const response of Object.values(responses)) {
+			const description = response.description?.trim();
+			if (description) return description;
+		}
+	}
+};
+
+//#endregion
+//#region src/generator/TypeScriptGenerator.ts
+var TypeScriptGenerator = class TypeScriptGenerator {
+	typeBuilder = new TypeScriptTypeBuilder();
+	moduleRenderer = new TypeScriptModuleRenderer();
+	/**
+	* Static helper method to generate a TypeScript module string from a generic JSON-like 
+	* value, inferring types and creating type definitions as needed, using the provided root 
+	* type name.
+	* 
+	* @param value 
+	* @param rootTypeName 
+	* @returns 
+	*/
+	static generateModule = (value, rootTypeName = "GeneratedOutput", options = {}) => {
+		return new TypeScriptGenerator().generate(value, rootTypeName, options);
+	};
+	/**
+	* Generate a TypeScript module string from a generic JSON-like value, inferring types 
+	* and creating type definitions as needed.
+	* 
+	* @param value 
+	* @param rootTypeName 
+	* @returns 
+	*/
+	generate(value, rootTypeName = "GeneratedOutput", options = {}) {
+		if (this.isOpenApiDocumentLike(value)) return this.generateModule(value, rootTypeName, options);
+		return this.generateGenericModule(value, rootTypeName);
+	}
+	/**
+	* Generate a TypeScript module string from an OpenAPI document, including type definitions
+	* 
+	* @param document 
+	* @param rootTypeName 
+	* @returns 
+	*/
+	generateModule(document, rootTypeName, options = {}) {
+		const context = this.typeBuilder.createContext();
+		const operationTypeRefs = /* @__PURE__ */ new Map();
+		for (const model of this.typeBuilder.collectSemanticModels(document)) {
+			const operationKey = `${model.path}::${model.method}`;
+			const resolvedName = this.typeBuilder.registerNamedShape(this.typeBuilder.namespaceTopLevelShape(model.shape, model.role), model.name, context, model.collisionSuffix);
+			const existingRefs = operationTypeRefs.get(operationKey) ?? {
+				response: "Record<string, never>",
+				responseExample: "unknown",
+				input: "Record<string, never>",
+				query: "Record<string, never>",
+				header: "Record<string, never>",
+				params: "Record<string, never>"
+			};
+			existingRefs[model.role] = resolvedName;
+			operationTypeRefs.set(operationKey, existingRefs);
+		}
+		const declarations = context.declarations.map((declaration) => this.moduleRenderer.renderDeclaration(declaration)).join("\n\n");
+		const variableName = this.moduleRenderer.toCamelCase(rootTypeName);
+		const sdkManifest = this.typeBuilder.buildSdkManifest(document, operationTypeRefs, options);
+		return [
+			declarations,
+			this.moduleRenderer.renderOpenApiDocumentDefinitions(rootTypeName, document, operationTypeRefs),
+			this.moduleRenderer.renderSdkApiInterface(rootTypeName, sdkManifest),
+			this.moduleRenderer.renderSdkManifest(variableName, sdkManifest),
+			`export const ${variableName}: ${rootTypeName} = ${this.moduleRenderer.renderOpenApiDocumentValue(document)}`,
+			this.moduleRenderer.renderSdkBundle(variableName, rootTypeName),
+			"",
+			`export default ${variableName}`
+		].filter(Boolean).join("\n\n");
+	}
+	generateGenericModule(value, rootTypeName) {
+		const context = this.typeBuilder.createContext();
+		const rootShape = this.typeBuilder.inferShapeFromExample(value, rootTypeName);
+		const rootSanitizedName = this.typeBuilder.sanitizeTypeName(rootTypeName);
+		let rootType = rootSanitizedName;
+		if (rootShape.kind === "object") rootType = this.typeBuilder.registerObjectShape(rootShape, rootSanitizedName, context, rootSanitizedName);
+		else {
+			const declaration = {
+				kind: "shape-alias",
+				name: rootSanitizedName,
+				shape: rootShape
+			};
+			context.declarations.push(declaration);
+			context.declarationByName.set(rootSanitizedName, declaration);
+		}
+		const rootAlias = rootType === rootTypeName ? "" : `export type ${rootTypeName} = ${rootType}`;
+		const variableName = this.moduleRenderer.toCamelCase(rootTypeName);
+		return [
+			context.declarations.map((declaration) => this.moduleRenderer.renderDeclaration(declaration)).join("\n\n"),
+			rootAlias,
+			`export const ${variableName}: ${rootTypeName} = ${this.moduleRenderer.renderValue(value)}`,
+			"",
+			`export default ${variableName}`
+		].filter(Boolean).join("\n\n");
+	}
+	isOpenApiDocumentLike(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+		const candidate = value;
+		if (typeof candidate.info !== "object" || candidate.info === null || Array.isArray(candidate.info)) return false;
+		const info = candidate.info;
+		return candidate.openapi === "3.1.0" && typeof info.title === "string" && typeof info.version === "string" && typeof candidate.paths === "object" && candidate.paths !== null && !Array.isArray(candidate.paths);
+	}
+};
+
+//#endregion
+//#region src/generator/OutputGenerator.ts
+var OutputGenerator = class {
+	/**
+	* Serialize the extracted payload into the desired output format, optionally 
+	* generating TypeScript types when requested.
+	* 
+	* @param payload The extracted payload to serialize.
+	* @param outputFormat The desired output format ('json', 'js', 'ts', 'pretty').
+	* @param rootTypeName The root type name to use when generating TypeScript types.
+	* @returns A promise that resolves to the serialized output string.
+	
+	*/
+	static serializeOutput = async (payload, outputFormat, rootTypeName = "ExtractedApiDocument", typeScriptOptions = {}) => {
+		if (outputFormat === "js") return prettier.default.format(`export default ${JSON.stringify(payload, null, 2)}`, {
+			parser: "babel",
+			semi: false,
+			singleQuote: true
+		});
+		if (outputFormat === "ts") return prettier.default.format(TypeScriptGenerator.generateModule(payload, rootTypeName, typeScriptOptions), {
+			parser: "typescript",
+			semi: false,
+			singleQuote: true
+		});
+		return JSON.stringify(payload, null, outputFormat === "json" ? 0 : 2);
+	};
+	/**
+	* Build a safe file path for the output based on the workspace root, source 
+	* identifier, desired shape, and output format.
+	* 
+	* @param workspaceRoot     The root directory of the workspace.
+	* @param source            The original source identifier
+	* @param shape             The desired output shape ('raw' or 'openapi').  
+	* @param outputFormat      The desired output format ('json', 'js', 'ts', 'pretty').
+	* @returns                 The constructed file path for the output.
+	*/
+	static buildFilePath = (workspaceRoot, source, shape, outputFormat) => {
+		const ext = {
+			pretty: "txt",
+			json: "json",
+			js: "js",
+			ts: "ts"
+		}[outputFormat];
+		const safeSource = this.toSafeSourceName(source);
+		const shapeSuffix = shape === "openapi" ? ".openapi" : "";
+		return node_path.default.join(workspaceRoot, "output", `${safeSource || "output"}${shapeSuffix}.${ext}`);
+	};
+	static buildArtifactDirectory = (workspaceRoot, source, artifact) => {
+		const safeSource = this.toSafeSourceName(source);
+		return node_path.default.join(workspaceRoot, "output", `${safeSource || artifact}.${artifact}`);
+	};
+	static toSafeSourceName(source) {
+		return source.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+	}
+	/**
+	* Determine the appropriate root type name for TypeScript generation based on the desired 
+	* output shape. This helps ensure that generated types are meaningful and contextually relevant.
+	* 
+	* @param shape     The desired output shape ('raw' or 'openapi').
+	* @returns         The root type name to use for TypeScript generation.
+	*/
+	static getRootTypeName = (shape) => {
+		return shape === "openapi" ? "ExtractedApiDocument" : "ExtractedPayload";
+	};
+};
+
+//#endregion
+//#region src/generator/SdkPackageGenerator.ts
+var SdkPackageGenerator = class {
+	typeBuilder = new TypeScriptTypeBuilder();
+	typeScriptGenerator = new TypeScriptGenerator();
+	generate(document, options = {}) {
+		const outputMode = options.outputMode ?? "both";
+		const signatureStyle = options.signatureStyle ?? "grouped";
+		const rootTypeName = options.rootTypeName ?? "ExtractedApiDocument";
+		const schemaModule = options.schemaModule ?? this.typeScriptGenerator.generateModule(document, rootTypeName, options);
+		const operationTypeRefs = this.createOperationTypeRefs(document);
+		const manifest = this.typeBuilder.buildSdkManifest(document, operationTypeRefs, options);
+		const classNames = manifest.groups.map((group) => group.className);
+		const files = {
+			"package.json": this.renderPackageJson(options),
+			"README.md": this.renderReadme(manifest, options, outputMode, signatureStyle),
+			"src/Schema.ts": schemaModule,
+			"src/index.ts": this.renderIndexFile(classNames, outputMode, rootTypeName),
+			"tsconfig.json": this.renderTsconfig(),
+			"tsdown.config.ts": this.renderTsdownConfig(),
+			"vitest.config.ts": this.renderVitestConfig(),
+			"tests/exports.test.ts": this.renderExportsTest(rootTypeName, outputMode)
+		};
+		if (outputMode !== "runtime") {
+			files["src/BaseApi.ts"] = this.renderBaseApi();
+			files["src/ApiBinder.ts"] = this.renderApiBinder(manifest);
+			for (const group of manifest.groups) files[`src/Apis/${group.className}.ts`] = this.renderApiClass(group, signatureStyle);
+			files["src/Core.ts"] = this.renderCoreFile();
+		}
+		return files;
+	}
+	createOperationTypeRefs(document) {
+		const context = this.typeBuilder.createContext();
+		const operationTypeRefs = /* @__PURE__ */ new Map();
+		for (const model of this.typeBuilder.collectSemanticModels(document)) {
+			const operationKey = `${model.path}::${model.method}`;
+			const resolvedName = this.typeBuilder.registerNamedShape(this.typeBuilder.namespaceTopLevelShape(model.shape, model.role), model.name, context, model.collisionSuffix);
+			const existingRefs = operationTypeRefs.get(operationKey) ?? {
+				response: "Record<string, never>",
+				responseExample: "unknown",
+				input: "Record<string, never>",
+				query: "Record<string, never>",
+				header: "Record<string, never>",
+				params: "Record<string, never>"
+			};
+			existingRefs[model.role] = resolvedName;
+			operationTypeRefs.set(operationKey, existingRefs);
+		}
+		return operationTypeRefs;
+	}
+	renderBaseApi() {
+		return [
+			"import { BaseApi as KitBaseApi } from '@oapiex/sdk-kit'",
+			"",
+			"export class BaseApi extends KitBaseApi {}"
+		].join("\n");
+	}
+	renderApiBinder(manifest) {
+		return [
+			"import { BaseApi } from './BaseApi'",
+			"",
+			...manifest.groups.map((group) => `import { ${group.className} } from './Apis/${group.className}'`),
+			"",
+			"export class ApiBinder extends BaseApi {",
+			...manifest.groups.map((group) => `    ${group.propertyName}!: ${group.className}`),
+			"",
+			"    protected override boot () {",
+			...manifest.groups.map((group) => `        this.${group.propertyName} = new ${group.className}(this.core)`),
+			"    }",
+			"}"
+		].join("\n");
+	}
+	renderApiClass(group, signatureStyle) {
+		const typeImportContext = this.createTypeImportContext(group, signatureStyle);
+		const imports = ["import { BaseApi } from '../BaseApi'", "import { Http } from '@oapiex/sdk-kit'"];
+		if (typeImportContext.specifiers.length > 0) imports.splice(1, 0, `import type { ${typeImportContext.specifiers.join(", ")} } from '../Schema'`);
+		return [
+			...imports,
+			"",
+			`export class ${group.className} extends BaseApi {`,
+			"",
+			...group.operations.flatMap((operation) => [this.renderApiMethod(operation, signatureStyle, typeImportContext.aliasMap), ""]).slice(0, -1),
+			"}"
+		].join("\n");
+	}
+	renderApiMethod(operation, signatureStyle, aliasMap) {
+		const signature = signatureStyle === "flat" ? this.renderFlatSignature(operation, aliasMap) : this.renderGroupedSignature(operation, aliasMap);
+		const urlPathArgs = signatureStyle === "flat" ? this.renderFlatObjectLiteral(operation.paramsType, operation.pathParams) : operation.pathParams.length > 0 ? "params" : "{}";
+		const urlQueryArgs = signatureStyle === "flat" ? this.renderFlatObjectLiteral(operation.queryType, operation.queryParams) : operation.queryParams.length > 0 ? "query" : "{}";
+		const headerArgs = signatureStyle === "flat" ? this.renderFlatHeaders(operation) : operation.headerParams.length > 0 ? "((headers ? { ...headers } : {}) as Record<string, string | undefined>)" : "{}";
+		const bodyArg = signatureStyle === "flat" ? operation.hasBody ? "body" : "{}" : operation.hasBody ? "body ?? {}" : "{}";
+		const docComment = this.renderMethodDocComment(operation, signatureStyle, aliasMap);
+		return [
+			...docComment ? [docComment] : [],
+			`    async ${operation.methodName} ${signature}: Promise<${this.rewriteTypeReference(operation.responseType, aliasMap)}> {`,
+			"        await this.core.validateAccess()",
+			"",
+			`        const { data } = await Http.send<${this.rewriteTypeReference(operation.responseType, aliasMap)}>(`,
+			`            this.core.builder.buildTargetUrl('${operation.path}', ${urlPathArgs}, ${urlQueryArgs}),`,
+			`            '${operation.method}',`,
+			`            ${bodyArg},`,
+			`            ${headerArgs}`,
+			"        )",
+			"",
+			"        return data",
+			"    }"
+		].join("\n");
+	}
+	renderMethodDocComment(operation, signatureStyle, aliasMap) {
+		const lines = [];
+		const summary = operation.summary?.trim();
+		const description = operation.description?.trim();
+		const operationId = operation.operationId?.trim();
+		const responseType = this.rewriteTypeReference(operation.responseType, aliasMap);
+		const responseDescription = operation.responseDescription?.trim();
+		if (summary) lines.push(summary);
+		if (description && description !== summary) {
+			if (lines.length > 0) lines.push("");
+			lines.push(...this.wrapDocText(description));
+		}
+		const metadataLines = [`HTTP ${operation.method} ${operation.path}`, ...operationId ? [`Operation ID: ${operationId}`] : []];
+		if (metadataLines.length > 0) {
+			if (lines.length > 0) lines.push("");
+			lines.push(...metadataLines);
+		}
+		const parameterDocs = signatureStyle === "flat" ? this.renderFlatParameterDocs(operation, aliasMap) : this.renderGroupedParameterDocs(operation, aliasMap);
+		if (parameterDocs.length > 0) {
+			if (lines.length > 0) lines.push("");
+			lines.push(...parameterDocs);
+		}
+		lines.push(`@returns ${responseDescription ? `${responseDescription} ` : ""}${responseType}`.trim());
+		return [
+			"    /**",
+			...lines.map((line) => line ? `     * ${line}` : "     *"),
+			"     */"
+		].join("\n");
+	}
+	renderGroupedParameterDocs(operation, aliasMap) {
+		const docs = [];
+		if (operation.pathParams.length > 0) docs.push(this.renderParamDoc("params", operation.paramsType, aliasMap, this.describeParameterGroup(operation.pathParams, "path parameters")));
+		if (operation.queryParams.length > 0) docs.push(this.renderParamDoc("query", operation.queryType, aliasMap, this.describeParameterGroup(operation.queryParams, "query parameters")));
+		if (operation.hasBody) docs.push(this.renderParamDoc("body", operation.inputType, aliasMap, operation.requestBodyDescription?.trim() || "Request body"));
+		if (operation.headerParams.length > 0) docs.push(this.renderParamDoc("headers", operation.headerType, aliasMap, this.describeParameterGroup(operation.headerParams, "request headers")));
+		return docs;
+	}
+	renderFlatParameterDocs(operation, aliasMap) {
+		return [
+			...operation.pathParams.map((parameter) => this.renderParamDoc(parameter.accessor, `${operation.paramsType}[${JSON.stringify(parameter.name)}]`, aliasMap, parameter.description?.trim() || `Path parameter ${parameter.name}`)),
+			...operation.queryParams.map((parameter) => this.renderParamDoc(parameter.accessor, `${operation.queryType}[${JSON.stringify(parameter.name)}]`, aliasMap, parameter.description?.trim() || `Query parameter ${parameter.name}`)),
+			...operation.hasBody ? [this.renderParamDoc("body", operation.inputType, aliasMap, operation.requestBodyDescription?.trim() || "Request body")] : [],
+			...operation.headerParams.map((parameter) => this.renderParamDoc(parameter.accessor, `${operation.headerType}[${JSON.stringify(parameter.name)}]`, aliasMap, parameter.description?.trim() || `Header ${parameter.name}`))
+		];
+	}
+	renderParamDoc(name, typeRef, aliasMap, description) {
+		return `@param ${name} ${description} Type: ${this.rewriteTypeReference(typeRef, aliasMap)}`;
+	}
+	describeParameterGroup(parameters, fallback) {
+		const described = parameters.map((parameter) => parameter.description?.trim() ? `${parameter.name}: ${parameter.description.trim()}` : parameter.name).filter(Boolean);
+		if (described.length === 0) return fallback;
+		return described.join("; ");
+	}
+	wrapDocText(text) {
+		return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	}
+	renderGroupedSignature(operation, aliasMap) {
+		const args = [];
+		if (operation.pathParams.length > 0) args.push(`params: ${this.rewriteTypeReference(operation.paramsType, aliasMap)}`);
+		if (operation.queryParams.length > 0) args.push(`query: ${this.rewriteTypeReference(operation.queryType, aliasMap)}`);
+		if (operation.hasBody) args.push(`body${operation.bodyRequired ? "" : "?"}: ${this.rewriteTypeReference(operation.inputType, aliasMap)}`);
+		if (operation.headerParams.length > 0) args.push(`headers?: ${this.rewriteTypeReference(operation.headerType, aliasMap)}`);
+		return `(${args.join(", ")})`;
+	}
+	renderFlatSignature(operation, aliasMap) {
+		return `(${[
+			...operation.pathParams.map((parameter) => `${parameter.accessor}${parameter.required ? "" : "?"}: ${this.rewriteTypeReference(operation.paramsType, aliasMap)}[${JSON.stringify(parameter.name)}]`),
+			...operation.queryParams.map((parameter) => `${parameter.accessor}${parameter.required ? "" : "?"}: ${this.rewriteTypeReference(operation.queryType, aliasMap)}[${JSON.stringify(parameter.name)}]`),
+			...operation.hasBody ? [`body${operation.bodyRequired ? "" : "?"}: ${this.rewriteTypeReference(operation.inputType, aliasMap)}`] : [],
+			...operation.headerParams.map((parameter) => `${parameter.accessor}${parameter.required ? "" : "?"}: ${this.rewriteTypeReference(operation.headerType, aliasMap)}[${JSON.stringify(parameter.name)}]`)
+		].join(", ")})`;
+	}
+	createTypeImportContext(group, signatureStyle) {
+		const requiredTypeRefs = /* @__PURE__ */ new Set();
+		for (const operation of group.operations) {
+			requiredTypeRefs.add(operation.responseType);
+			if (operation.hasBody) requiredTypeRefs.add(operation.inputType);
+			if (operation.queryParams.length > 0) requiredTypeRefs.add(operation.queryType);
+			if (operation.headerParams.length > 0) requiredTypeRefs.add(operation.headerType);
+			if (operation.pathParams.length > 0) requiredTypeRefs.add(operation.paramsType);
+			if (signatureStyle === "flat") continue;
+		}
+		const identifiers = Array.from(new Set(Array.from(requiredTypeRefs).flatMap((typeRef) => this.collectTypeIdentifiers(typeRef)))).sort();
+		const aliasMap = /* @__PURE__ */ new Map();
+		return {
+			specifiers: identifiers.map((identifier) => {
+				if (identifier === group.className) {
+					const aliasedName = `${identifier}Model`;
+					aliasMap.set(identifier, aliasedName);
+					return `${identifier} as ${aliasedName}`;
+				}
+				return identifier;
+			}),
+			aliasMap
+		};
+	}
+	rewriteTypeReference(typeRef, aliasMap) {
+		let rewritten = typeRef;
+		for (const [identifier, alias] of aliasMap.entries()) rewritten = rewritten.replace(new RegExp(`\\b${identifier}\\b`, "g"), alias);
+		return rewritten;
+	}
+	renderFlatObjectLiteral(_typeName, parameters) {
+		if (parameters.length === 0) return "{}";
+		return `{ ${parameters.map((parameter) => `${JSON.stringify(parameter.name)}: ${parameter.accessor}`).join(", ")} }`;
+	}
+	renderFlatHeaders(operation) {
+		if (operation.headerParams.length === 0) return "{}";
+		return `({ ${operation.headerParams.map((parameter) => `${JSON.stringify(parameter.name)}: ${parameter.accessor}`).join(", ")} } as Record<string, string | undefined>)`;
+	}
+	renderCoreFile() {
+		return [
+			"import { Core as KitCore } from '@oapiex/sdk-kit'",
+			"",
+			"import { ApiBinder } from './ApiBinder'",
+			"",
+			"export class Core extends KitCore {",
+			"    static override apiClass = ApiBinder",
+			"",
+			"    declare api: ApiBinder",
+			"}"
+		].join("\n");
+	}
+	renderPackageJson(options) {
+		return JSON.stringify({
+			name: options.packageName ?? "generated-sdk",
+			type: "module",
+			version: options.packageVersion ?? "0.1.0",
+			private: true,
+			description: options.packageDescription ?? "Generated SDK scaffold emitted by oapiex.",
+			main: "./dist/index.cjs",
+			module: "./dist/index.js",
+			types: "./dist/index.d.ts",
+			exports: {
+				".": {
+					import: "./dist/index.js",
+					require: "./dist/index.cjs"
+				},
+				"./package.json": "./package.json"
+			},
+			files: ["dist"],
+			scripts: {
+				test: "pnpm vitest --run",
+				"test:watch": "pnpm vitest",
+				build: "tsdown"
+			},
+			dependencies: { [options.sdkKitPackageName ?? "@oapiex/sdk-kit"]: "^0.1.1" },
+			devDependencies: {
+				"@types/node": "^20.14.5",
+				tsdown: "^0.20.1",
+				typescript: "^5.4.5",
+				vitest: "^3.2.4"
+			}
+		}, null, 2);
+	}
+	renderReadme(manifest, options, outputMode, signatureStyle) {
+		const packageName = options.packageName ?? "generated-sdk";
+		const title = `# ${packageName}`;
+		const description = this.renderReadmeDescription(outputMode);
+		const usage = this.renderReadmeUsage(manifest, packageName, outputMode, signatureStyle);
+		const exports = this.renderReadmeExports(outputMode);
+		return [
+			title,
+			"",
+			description,
+			"",
+			"## Install",
+			"",
+			"```bash",
+			`pnpm add ${packageName}`,
+			"```",
+			"",
+			"## Quick Start",
+			"",
+			"```ts",
+			usage,
+			"```",
+			"",
+			"## Main Exports",
+			"",
+			...exports.map((line) => `- ${line}`),
+			"",
+			"## Commands",
+			"",
+			"```bash",
+			"pnpm test",
+			"pnpm build",
+			"```"
+		].join("\n");
+	}
+	renderReadmeDescription(outputMode) {
+		if (outputMode === "runtime") return "Generated runtime-first TypeScript SDK emitted by oapiex.";
+		if (outputMode === "classes") return "Generated class-based TypeScript SDK emitted by oapiex.";
+		return "Generated TypeScript SDK emitted by oapiex with both class-based and runtime-first entrypoints.";
+	}
+	renderReadmeUsage(manifest, packageName, outputMode, signatureStyle) {
+		const exampleOperation = this.pickExampleOperation(manifest);
+		const runtimeSnippet = this.renderReadmeClientSnippet(packageName, "runtime", signatureStyle, exampleOperation);
+		if (outputMode === "runtime") return runtimeSnippet;
+		const classSnippet = this.renderReadmeClientSnippet(packageName, "classes", signatureStyle, exampleOperation);
+		if (outputMode === "classes") return classSnippet;
+		const typeImports = exampleOperation ? this.collectReadmeTypeImports(exampleOperation.operation) : [];
+		return [
+			typeImports.length > 0 ? `import { Core, createClient, type ${typeImports.join(", type ")} } from '${packageName}'` : `import { Core, createClient } from '${packageName}'`,
+			"",
+			...this.renderReadmeClientBody("sdk", "classes", signatureStyle, exampleOperation),
+			"",
+			"// --- OR ---",
+			"",
+			...this.renderReadmeClientBody("runtimeSdk", "runtime", signatureStyle, exampleOperation)
+		].join("\n");
+	}
+	renderReadmeClientSnippet(packageName, mode, signatureStyle, exampleOperation) {
+		const importNames = mode === "runtime" ? ["createClient"] : ["Core"];
+		const typeImports = exampleOperation ? this.collectReadmeTypeImports(exampleOperation.operation) : [];
+		const importLine = typeImports.length > 0 ? `import { ${importNames.join(", ")}, type ${typeImports.join(", type ")} } from '${packageName}'` : `import { ${importNames.join(", ")} } from '${packageName}'`;
+		const sdkVariable = mode === "runtime" ? "runtimeSdk" : "sdk";
+		return [
+			importLine,
+			"",
+			...this.renderReadmeClientBody(sdkVariable, mode, signatureStyle, exampleOperation)
+		].join("\n");
+	}
+	renderReadmeClientBody(sdkVariable, mode, signatureStyle, exampleOperation) {
+		const initLine = mode === "runtime" ? `const ${sdkVariable} = createClient({` : `const ${sdkVariable} = new Core({`;
+		const callLines = exampleOperation ? this.renderReadmeOperationCall(sdkVariable, exampleOperation, mode === "runtime" ? "grouped" : signatureStyle) : [];
+		return [
+			initLine,
+			"  clientId: process.env.CLIENT_ID!,",
+			"  clientSecret: process.env.CLIENT_SECRET!,",
+			"  environment: 'sandbox',",
+			"})",
+			...callLines.length > 0 ? ["", ...callLines] : []
+		];
+	}
+	renderReadmeExports(outputMode) {
+		if (outputMode === "runtime") return ["`createClient()` for a typed runtime SDK instance", "`Schema` exports for request, response, params, query, and header types"];
+		if (outputMode === "classes") return ["`Core` as the class-based SDK entrypoint", "generated API classes plus `Schema` type exports"];
+		return [
+			"`Core` for class-based usage",
+			"`createClient()` for runtime-first usage",
+			"`Schema` exports for generated request, response, params, query, and header types"
+		];
+	}
+	pickExampleOperation(manifest) {
+		const group = manifest.groups[0];
+		const operation = group?.operations[0];
+		if (!group || !operation) return null;
+		return {
+			group,
+			operation
+		};
+	}
+	collectReadmeTypeImports(operation) {
+		const types = /* @__PURE__ */ new Set();
+		if (operation.pathParams.length > 0) types.add(operation.paramsType);
+		if (operation.queryParams.length > 0) types.add(operation.queryType);
+		if (operation.hasBody) types.add(operation.inputType);
+		if (operation.headerParams.length > 0) types.add(operation.headerType);
+		return Array.from(types).sort();
+	}
+	renderReadmeOperationCall(sdkVariable, exampleOperation, signatureStyle) {
+		const { group, operation } = exampleOperation;
+		const args = signatureStyle === "flat" ? this.renderReadmeFlatArgs(operation) : this.renderReadmeGroupedArgs(operation);
+		return [
+			`await ${sdkVariable}.api.${group.propertyName}.${operation.methodName}(`,
+			...args.map((arg) => `  ${arg},`),
+			")"
+		];
+	}
+	renderReadmeGroupedArgs(operation) {
+		const args = [];
+		if (operation.pathParams.length > 0) args.push(`{} as ${operation.paramsType}`);
+		if (operation.queryParams.length > 0) args.push(`{} as ${operation.queryType}`);
+		if (operation.hasBody) args.push(`{} as ${operation.inputType}`);
+		if (operation.headerParams.length > 0) args.push(`{} as ${operation.headerType}`);
+		return args;
+	}
+	renderReadmeFlatArgs(operation) {
+		return [
+			...operation.pathParams.map((parameter) => `{} as ${operation.paramsType}[${JSON.stringify(parameter.name)}]`),
+			...operation.queryParams.map((parameter) => `{} as ${operation.queryType}[${JSON.stringify(parameter.name)}]`),
+			...operation.hasBody ? [`{} as ${operation.inputType}`] : [],
+			...operation.headerParams.map((parameter) => `{} as ${operation.headerType}[${JSON.stringify(parameter.name)}]`)
+		];
+	}
+	renderTsconfig() {
+		return JSON.stringify({
+			compilerOptions: {
+				rootDir: ".",
+				outDir: "./dist",
+				target: "esnext",
+				module: "es2022",
+				moduleResolution: "bundler",
+				esModuleInterop: true,
+				strict: true,
+				allowJs: true,
+				skipLibCheck: true,
+				resolveJsonModule: true
+			},
+			include: ["./src/**/*", "./tests/**/*"],
+			exclude: ["./dist", "./node_modules"]
+		}, null, 2);
+	}
+	renderTsdownConfig() {
+		return [
+			"import { defineConfig } from 'tsdown'",
+			"",
+			"export default defineConfig({",
+			"    entry: {",
+			"        index: 'src/index.ts',",
+			"    },",
+			"    exports: true,",
+			"    format: ['esm', 'cjs'],",
+			"    outDir: 'dist',",
+			"    dts: true,",
+			"    sourcemap: false,",
+			"    external: ['@oapiex/sdk-kit'],",
+			"    clean: true,",
+			"})"
+		].join("\n");
+	}
+	renderVitestConfig() {
+		return [
+			"import { defineConfig } from 'vitest/config'",
+			"",
+			"export default defineConfig({",
+			"    test: {",
+			"        name: 'generated-sdk',",
+			"        environment: 'node',",
+			"        include: ['tests/*.{test,spec}.?(c|m)[jt]s?(x)'],",
+			"    },",
+			"})"
+		].join("\n");
+	}
+	renderExportsTest(rootTypeName, outputMode) {
+		const rootExportName = `${rootTypeName.charAt(0).toLowerCase()}${rootTypeName.slice(1)}`;
+		const assertions = [
+			"        expect(sdk.createClient).toBeTypeOf('function')",
+			"        expect(sdk.createSdk).toBeTypeOf('function')",
+			`        expect(sdk.${rootExportName}Sdk).toBeDefined()`,
+			`        expect(sdk.${rootExportName}Manifest).toBeDefined()`
+		];
+		if (outputMode !== "runtime") {
+			assertions.unshift("        expect(sdk.Core).toBeTypeOf('function')");
+			assertions.unshift("        expect(sdk.BaseApi).toBeTypeOf('function')");
+		}
+		return [
+			"import { describe, expect, it } from 'vitest'",
+			"",
+			"import * as sdk from '../src/index'",
+			"",
+			"describe('generated sdk exports', () => {",
+			"    it('exposes the generated schema and runtime helpers', () => {",
+			...assertions,
+			"    })",
+			"})"
+		].join("\n");
+	}
+	renderIndexFile(classNames, outputMode, rootTypeName) {
+		const rootExportName = `${rootTypeName.charAt(0).toLowerCase()}${rootTypeName.slice(1)}`;
+		const lines = [
+			`import type { ${rootTypeName}Api } from './Schema'`,
+			`import { ${rootExportName}Sdk } from './Schema'`,
+			"import { createSdk as createBoundSdk } from '@oapiex/sdk-kit'",
+			"import type { BaseApi as KitBaseApi, Core as KitCore, InitOptions } from '@oapiex/sdk-kit'",
+			"",
+			"export * from './Schema'"
+		];
+		if (outputMode !== "runtime") {
+			lines.push("export { ApiBinder } from './ApiBinder'");
+			lines.push("export { BaseApi } from './BaseApi'");
+			lines.push(...classNames.map((className) => `export { ${className} as ${className}Api } from './Apis/${className}'`));
+			lines.push("export { Core } from './Core'");
+		}
+		lines.push("");
+		lines.push("export const createClient = (");
+		lines.push("    options: InitOptions");
+		lines.push(`): KitCore & { api: KitBaseApi & ${rootTypeName}Api } =>`);
+		lines.push(`    createBoundSdk(${rootExportName}Sdk, options) as KitCore & { api: KitBaseApi & ${rootTypeName}Api }`);
+		lines.push("");
+		lines.push("export {");
+		lines.push("    BadRequestException,");
+		lines.push("    Builder,");
+		lines.push("    ForbiddenRequestException,");
+		lines.push("    Http,");
+		lines.push("    HttpException,");
+		lines.push("    UnauthorizedRequestException,");
+		lines.push("    WebhookValidator,");
+		lines.push("    createSdk,");
+		lines.push("} from '@oapiex/sdk-kit'");
+		lines.push("");
+		lines.push("export type {");
+		lines.push("    InitOptions,");
+		lines.push("    UnifiedResponse,");
+		lines.push("    XGenericObject,");
+		lines.push("} from '@oapiex/sdk-kit'");
+		return lines.join("\n");
+	}
+	collectTypeIdentifiers(typeRef) {
+		return Array.from(new Set((typeRef.match(/\b[A-Z][A-Za-z0-9_]*/g) ?? []).filter((identifier) => {
+			return !["Record", "Promise"].includes(identifier);
+		})));
+	}
+};
+
+//#endregion
+//#region src/OpenApiTransform.ts
+var OpenApiTransformer = class {
+	createDocument(operations, title = "Extracted API", version = "0.0.0") {
+		const paths = {};
+		for (const operation of operations) {
+			const normalized = this.transformOperation(operation);
+			if (!normalized || this.shouldSkipNormalizedOperation(normalized)) continue;
+			paths[normalized.path] ??= {};
+			paths[normalized.path][normalized.method] = normalized.operation;
+		}
+		return {
+			openapi: "3.1.0",
+			info: {
+				title,
+				version
+			},
+			paths
+		};
+	}
+	transformOperation(operation) {
+		if (!operation.method || !operation.url) return null;
+		const url = new URL(operation.url);
+		if (this.shouldSkipPlaceholderOperation(url, operation)) return null;
+		const method = operation.method.toLowerCase();
+		const path = this.decodeOpenApiPathname(url.pathname);
+		return {
+			path,
+			method,
+			operation: {
+				summary: operation.sidebarLinks.find((link) => link.active)?.label,
+				description: operation.description ?? void 0,
+				operationId: this.buildOperationId(method, path),
+				parameters: this.createParameters(operation.requestParams),
+				requestBody: this.createRequestBody(operation.requestParams, operation.requestExampleNormalized?.body, this.hasExtractedBodyParams(operation.requestParams) ? null : this.resolveFallbackRequestBodyExample(operation)),
+				responses: this.createResponses(operation.responseSchemas, operation.responseBodies)
+			}
+		};
+	}
+	shouldSkipNormalizedOperation(normalized) {
+		return normalized.path === "/" && normalized.method === "get" && normalized.operation.operationId === "get" && Object.keys(normalized.operation.responses).length === 0;
+	}
+	shouldSkipPlaceholderOperation(url, operation) {
+		if (url.hostname !== "example.com" || url.pathname !== "/") return false;
+		return operation.requestParams.length === 0 && operation.responseSchemas.length === 0 && operation.responseBodies.length === 0 && operation.requestExampleNormalized?.url === "https://example.com/";
+	}
+	decodeOpenApiPathname(pathname) {
+		return pathname.split("/").map((segment) => {
+			if (!segment) return segment;
+			try {
+				return decodeURIComponent(segment);
+			} catch {
+				return segment;
+			}
+		}).join("/");
+	}
+	hasExtractedBodyParams(params) {
+		return params.some((param) => param.in === "body" || param.in === null);
+	}
+	createParameters(params) {
+		const parameters = params.filter((param) => this.isOpenApiParameterLocation(param.in)).map((param) => this.createParameter(param));
+		return parameters.length > 0 ? parameters : void 0;
+	}
+	createRequestBody(params, example, fallbackExample) {
+		const bodyParams = params.filter((param) => param.in === "body" || param.in === null);
+		if (bodyParams.length === 0 && example == null) return;
+		const schema = this.buildRequestBodySchema(bodyParams, example, fallbackExample);
+		return {
+			required: bodyParams.length > 0 ? bodyParams.some((param) => param.required) : false,
+			content: { "application/json": {
+				schema,
+				...example != null ? { example } : {}
+			} }
+		};
+	}
+	buildRequestBodySchema(params, example, fallbackExample) {
+		const schema = this.mergeOpenApiSchemas(this.createExampleSchema(example), this.createExampleSchema(fallbackExample)) ?? { type: "object" };
+		if (example != null) schema.example = example;
+		else if (fallbackExample != null) schema.example = fallbackExample;
+		for (const param of params) this.insertRequestBodyParam(schema, param);
+		return schema;
+	}
+	inferSchemaFromExample(value) {
+		if (Array.isArray(value)) return {
+			type: "array",
+			items: this.inferSchemaFromExample(value[0]) ?? {},
+			example: value
+		};
+		if (isRecord(value)) return {
+			type: "object",
+			properties: Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, this.inferSchemaFromExample(entryValue) ?? {}])),
+			example: value
+		};
+		if (typeof value === "string") return {
+			type: "string",
+			example: value
+		};
+		if (typeof value === "number") return {
+			type: Number.isInteger(value) ? "integer" : "number",
+			example: value
+		};
+		if (typeof value === "boolean") return {
+			type: "boolean",
+			example: value
+		};
+		if (value === null) return {};
+	}
+	insertRequestBodyParam(rootSchema, param) {
+		const path = param.path.length > 0 ? param.path : [param.name];
+		let currentSchema = rootSchema;
+		for (const [index, segment] of path.slice(0, -1).entries()) {
+			currentSchema.properties ??= {};
+			currentSchema.properties[segment] ??= { type: "object" };
+			if (param.required) currentSchema.required = Array.from(new Set([...currentSchema.required ?? [], segment]));
+			currentSchema = currentSchema.properties[segment];
+			currentSchema.type ??= "object";
+			if (index === path.length - 2 && param.required) currentSchema.required ??= [];
+		}
+		const leafKey = path[path.length - 1] ?? param.name;
+		currentSchema.properties ??= {};
+		currentSchema.properties[leafKey] = this.createParameterSchema(param);
+		if (param.required) currentSchema.required = Array.from(new Set([...currentSchema.required ?? [], leafKey]));
+	}
+	createParameter(param) {
+		return {
+			name: param.name,
+			in: param.in,
+			required: param.in === "path" ? true : param.required,
+			description: param.description ?? void 0,
+			schema: this.createParameterSchema(param),
+			example: param.defaultValue ?? void 0
+		};
+	}
+	createParameterSchema(param) {
+		return {
+			type: param.type ?? void 0,
+			description: param.description ?? void 0,
+			default: param.defaultValue ?? void 0
+		};
+	}
+	createResponses(schemas, responseBodies) {
+		const responses = {};
+		for (const schema of schemas) {
+			if (!schema.statusCode) continue;
+			const matchingBodies = responseBodies.filter((body) => body.statusCode === schema.statusCode);
+			const content = this.createResponseContent(matchingBodies);
+			responses[schema.statusCode] = {
+				description: schema.description ?? schema.statusCode,
+				...content ? { content } : {}
+			};
+		}
+		for (const body of responseBodies) {
+			if (!body.statusCode || responses[body.statusCode]) continue;
+			const content = this.createResponseContent([body]);
+			responses[body.statusCode] = {
+				description: body.label ?? body.statusCode,
+				...content ? { content } : {}
+			};
+		}
+		return responses;
+	}
+	createResponseContent(bodies) {
+		if (bodies.length === 0) return;
+		const content = {};
+		for (const body of bodies) {
+			const contentType = body.contentType ?? (body.format === "json" ? "application/json" : "text/plain");
+			const normalizedExample = this.normalizeResponseExampleValue(body.body, body.format);
+			content[contentType] = {
+				schema: this.inferSchemaFromBody(normalizedExample, body.format),
+				example: normalizedExample
+			};
+		}
+		return content;
+	}
+	inferSchemaFromBody(body, format) {
+		if (format === "json") return this.inferSchemaFromExample(body);
+		if (format === "text") return {
+			type: "string",
+			example: body
+		};
+	}
+	normalizeResponseExampleValue(body, format) {
+		if (format !== "json" || typeof body !== "string") return body;
+		return JsonRepair.parsePossiblyTruncated(body) ?? parseLooseStructuredValue(body) ?? body;
+	}
+	resolveFallbackRequestBodyExample(operation) {
+		const jsonResponseBody = operation.responseBodies.find((body) => body.format === "json")?.body;
+		if (jsonResponseBody != null) return jsonResponseBody;
+		if (typeof operation.responseExample === "object" && operation.responseExample !== null) return operation.responseExample;
+		if (typeof operation.responseExampleRaw === "string") return JsonRepair.parsePossiblyTruncated(operation.responseExampleRaw);
+		if (typeof operation.responseExample === "string") return JsonRepair.parsePossiblyTruncated(operation.responseExample);
+		return null;
+	}
+	createExampleSchema(value) {
+		if (value == null) return null;
+		return this.inferSchemaFromExample(value) ?? null;
+	}
+	mergeOpenApiSchemas(left, right) {
+		if (!left) return right;
+		if (!right) return left;
+		const merged = {
+			...right,
+			...left,
+			...left.type || right.type ? { type: left.type ?? right.type } : {},
+			...left.description || right.description ? { description: left.description ?? right.description } : {},
+			...left.default !== void 0 || right.default !== void 0 ? { default: left.default ?? right.default } : {},
+			...left.example !== void 0 || right.example !== void 0 ? { example: left.example ?? right.example } : {}
+		};
+		if (left.properties || right.properties) {
+			const propertyKeys = new Set([...Object.keys(left.properties ?? {}), ...Object.keys(right.properties ?? {})]);
+			merged.properties = Object.fromEntries(Array.from(propertyKeys).map((key) => [key, this.mergeOpenApiSchemas(left.properties?.[key] ?? null, right.properties?.[key] ?? null) ?? {}]));
+		}
+		if (left.items || right.items) merged.items = this.mergeOpenApiSchemas(left.items ?? null, right.items ?? null) ?? {};
+		if (left.required || right.required) merged.required = Array.from(new Set([...right.required ?? [], ...left.required ?? []]));
+		return merged;
+	}
+	buildOperationId(method, path) {
+		return `${method}${path.replace(/\{([^}]+)\}/g, "$1").split("/").filter(Boolean).map((segment) => segment.replace(/[^a-zA-Z0-9]+/g, " ")).map((segment) => segment.trim()).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).replace(/\s+(.)/g, (_match, char) => char.toUpperCase())).join("")}`;
+	}
+	isOpenApiParameterLocation(value) {
+		return value === "query" || value === "header" || value === "path" || value === "cookie";
+	}
+};
+const transformer = new OpenApiTransformer();
+
+//#endregion
+//#region src/Commands/GenerateCommand.ts
+var GenerateCommand = class extends _h3ravel_musket.Command {
+	signature = `generate
+        {artifact : Artifact to generate [sdk]}
+        {source? : Documentation URL/local source or parsed TypeScript output file}
+        {--d|dir? : Output directory for the generated artifact}
+        {--n|name? : Package name for generated SDK packages}
+        {--O|output-mode=both : SDK output mode [runtime,classes,both]}
+        {--S|signature-style=grouped : SDK method signature style [flat,grouped]}
+        {--N|namespace-strategy=smart : Namespace naming strategy [smart,scoped]}
+        {--M|method-strategy=smart : Method naming strategy [smart,operation-id]}
+        {--r|root-type-name=ExtractedApiDocument : Root type name for the generated Schema.ts module}
+        {--B|browser? : Remote loader [axios,happy-dom,jsdom,puppeteer]}
+        {--t|timeout? : Request/browser timeout in milliseconds}
+        {--c|crawl : Crawl sidebar links and parse every discovered operation}
+        {--b|base-url? : Base URL used to resolve sidebar links when crawling from a local file}
+    `;
+	description = "Generate artifacts such as SDK packages from documentation sources or parsed TypeScript outputs";
+	async handle() {
+		const conf = this.app.getConfig();
+		const artifact = String(this.argument("artifact", "")).trim().toLowerCase();
+		const source = String(this.argument("source", "")).trim();
+		const browser = String(this.option("browser", conf.browser)).trim().toLowerCase();
+		const timeoutOption = String(this.option("timeout", "")).trim();
+		const crawl = this.option("crawl");
+		const baseUrl = String(this.option("baseUrl", "")).trim() || null;
+		const packageDir = await this.resolveOutputDirectory(source);
+		const spinner = this.spinner(`Generating ${artifact} artifact...`).start();
+		let startedBrowserSession = false;
+		try {
+			const start = Date.now();
+			if (!isSupportedBrowser(browser)) throw new Error(`Unsupported browser: ${browser}`);
+			if (artifact !== "sdk") throw new Error(`Unsupported artifact: ${artifact}`);
+			if (!source) throw new Error("The sdk artifact requires a source argument");
+			if (!this.isTypeScriptArtifactSource(source) && !isSupportedBrowser(browser)) throw new Error(`Unsupported browser: ${browser}`);
+			const requestTimeout = this.resolveTimeoutOverride(timeoutOption, conf.requestTimeout);
+			const namespaceStrategy = this.parseNamespaceStrategy(this.option("namespaceStrategy", "smart"));
+			const methodStrategy = this.parseMethodStrategy(this.option("methodStrategy", "smart"));
+			const outputMode = this.parseOutputMode(this.option("outputMode", "both"));
+			const signatureStyle = this.parseSignatureStyle(this.option("signatureStyle", "grouped"));
+			const rootTypeName = String(this.option("rootTypeName", "ExtractedApiDocument")).trim() || "ExtractedApiDocument";
+			this.app.configure({
+				browser,
+				requestTimeout
+			});
+			if (!this.isTypeScriptArtifactSource(source) && crawl) {
+				await startBrowserSession(this.app.getConfig());
+				startedBrowserSession = true;
+			}
+			const sdkSource = await this.resolveSdkSource({
+				source,
+				crawl,
+				baseUrl,
+				rootTypeName,
+				namespaceStrategy,
+				methodStrategy
+			});
+			const packageName = this.resolvePackageName(packageDir);
+			const files = new SdkPackageGenerator().generate(sdkSource.document, {
+				outputMode,
+				signatureStyle,
+				rootTypeName,
+				namespaceStrategy,
+				methodStrategy,
+				schemaModule: sdkSource.schemaModule,
+				packageName: String(this.option("name", "")).trim() || packageName
+			});
+			await this.writePackageFiles(packageDir, files);
+			const duration = Date.now() - start;
+			_h3ravel_shared.Logger.twoColumnDetail(_h3ravel_shared.Logger.log([["Generated", "green"], [`${duration / 1e3}s`, "gray"]], " ", false), packageDir.replace(process.cwd(), "."));
+			spinner.succeed("Artifact generation completed");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			spinner.fail(`Failed to generate artifact: ${message}`);
+			process.exitCode = 1;
+		} finally {
+			if (startedBrowserSession) await endBrowserSession();
+		}
+	}
+	/**
+	* Resolves the SDK source by either loading a pre-generated TypeScript artifact or 
+	* crawling/parsing HTML documentation based on the provided options and source string.
+	* 
+	* @param options The options for resolving the SDK source.
+	* @returns An object containing the OpenAPI document and the generated schema module as a string.
+	*/
+	async resolveSdkSource(options) {
+		if (this.isTypeScriptArtifactSource(options.source)) return this.loadSdkSourceFromTypeScriptArtifact(options.source);
+		const operation = extractReadmeOperationFromHtml(await this.app.loadHtmlSource(options.source, true));
+		const payload = options.crawl ? await this.app.crawlReadmeOperations(options.source, operation, options.baseUrl) : operation;
+		const document = this.buildOpenApiPayload(payload);
+		return {
+			document,
+			schemaModule: await prettier.default.format(TypeScriptGenerator.generateModule(document, options.rootTypeName, {
+				namespaceStrategy: options.namespaceStrategy,
+				methodStrategy: options.methodStrategy
+			}), {
+				parser: "typescript",
+				semi: false,
+				singleQuote: true
+			})
+		};
+	}
+	/**
+	* Loads the SDK source from a pre-generated TypeScript artifact.
+	* 
+	* @param source 
+	* @returns 
+	*/
+	async loadSdkSourceFromTypeScriptArtifact(source) {
+		const filePath = node_path.default.resolve(process.cwd(), source);
+		const schemaModule = await node_fs_promises.default.readFile(filePath, "utf8");
+		const importedModule = await import(`${(0, node_url.pathToFileURL)(filePath).href}?t=${Date.now()}`);
+		const documentCandidate = importedModule.default ?? Object.values(importedModule).find((value) => this.isOpenApiDocumentLike(value));
+		if (!this.isOpenApiDocumentLike(documentCandidate)) throw new Error("The provided TypeScript source does not export an OpenAPI document");
+		return {
+			document: documentCandidate,
+			schemaModule
+		};
+	}
+	/**
+	* Builds an OpenAPI document from the extracted operations.
+	* 
+	* @param payload 
+	* @returns 
+	*/
+	buildOpenApiPayload(payload) {
+		if ("operations" in payload) return transformer.createDocument(payload.operations, "Extracted API", "0.0.0");
+		return transformer.createDocument([payload], "Extracted API", "0.0.0");
+	}
+	resolveTimeoutOverride(value, fallback) {
+		if (!value) return fallback;
+		const parsed = Number(value);
+		if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`Invalid timeout override: ${value}`);
+		return parsed;
+	}
+	/**
+	* Resolves the output directory for the generated SDK package.
+	* 
+	* @param source The source string used to determine the output directory.
+	* @returns The resolved output directory path.
+	*/
+	async resolveOutputDirectory(source, explicitDir) {
+		explicitDir ??= String(this.option("dir", "")).trim();
+		const dir = explicitDir ? node_path.default.resolve(process.cwd(), explicitDir) : OutputGenerator.buildArtifactDirectory(process.cwd(), source, "sdk");
+		if ((0, node_fs.existsSync)(dir)) {
+			if ((0, node_fs.readdirSync)(dir).length > 0) switch (await this.choice(`Output directory (${explicitDir}) already exists and is not empty, what would you like to do?`, [
+				{
+					name: "Overwrite",
+					value: "overwrite"
+				},
+				{
+					name: "Try to merge",
+					value: "merge"
+				},
+				{
+					name: "Choose a different directory",
+					value: "choose"
+				},
+				{
+					name: "Cancel",
+					value: "cancel"
+				}
+			])) {
+				case "overwrite":
+					await node_fs_promises.default.rm(dir, {
+						recursive: true,
+						force: true
+					});
+					break;
+				case "choose": {
+					const newDir = await this.ask("Please enter a new output directory (relative to current directory):", explicitDir);
+					return this.resolveOutputDirectory(source, newDir);
+				}
+				case "cancel":
+					this.info("Operation cancelled by user");
+					return process.exit(0);
+				default: break;
+			}
+		}
+		return dir;
+	}
+	resolvePackageName(packageDir) {
+		const explicitName = String(this.option("name", "")).trim();
+		if (explicitName) return explicitName;
+		return node_path.default.basename(packageDir).replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "generated-sdk";
+	}
+	parseOutputMode(value) {
+		const normalized = String(value ?? "both").trim().toLowerCase();
+		if (normalized === "runtime" || normalized === "classes" || normalized === "both") return normalized;
+		throw new Error(`Unsupported sdk output mode: ${normalized}`);
+	}
+	parseSignatureStyle(value) {
+		const normalized = String(value ?? "grouped").trim().toLowerCase();
+		if (normalized === "flat" || normalized === "grouped") return normalized;
+		throw new Error(`Unsupported signature style: ${normalized}`);
+	}
+	parseNamespaceStrategy(value) {
+		const normalized = String(value ?? "smart").trim().toLowerCase();
+		if (normalized === "smart" || normalized === "scoped") return normalized;
+		throw new Error(`Unsupported namespace strategy: ${normalized}`);
+	}
+	parseMethodStrategy(value) {
+		const normalized = String(value ?? "smart").trim().toLowerCase();
+		if (normalized === "smart" || normalized === "operation-id") return normalized;
+		throw new Error(`Unsupported method strategy: ${normalized}`);
+	}
+	/**
+	* Checks if the provided source string points to a TypeScript or JavaScript file, which is 
+	* used to determine if the source should be loaded as a pre-generated artifact instead 
+	* of crawling/parsing HTML documentation.
+	* 
+	* @param source The source string to check.
+	* @returns True if the source is a TypeScript or JavaScript file, false otherwise.
+	*/
+	isTypeScriptArtifactSource(source) {
+		return /\.(?:[cm]?ts|[cm]?js)$/i.test(source);
+	}
+	/**
+	* Type guard to check if a value conforms to the OpenApiDocumentLike interface. 
+	* 
+	* @param value 
+	* @returns 
+	*/
+	isOpenApiDocumentLike(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+		const candidate = value;
+		const info = candidate.info;
+		return candidate.openapi === "3.1.0" && typeof info === "object" && info !== null && !Array.isArray(info) && typeof info.title === "string" && typeof info.version === "string" && typeof candidate.paths === "object" && candidate.paths !== null && !Array.isArray(candidate.paths);
+	}
+	/**
+	* Writes the generated files to the output directory, creating any necessary subdirectories. 
+	* 
+	* @param packageDir 
+	* @param files 
+	*/
+	async writePackageFiles(packageDir, files) {
+		await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
+			const filePath = node_path.default.join(packageDir, relativePath);
+			await node_fs_promises.default.mkdir(node_path.default.dirname(filePath), { recursive: true });
+			await node_fs_promises.default.writeFile(filePath, content, "utf8");
+		}));
+	}
+};
+
+//#endregion
+//#region src/Commands/InitCommand.ts
+const __filename$1 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+var InitCommand = class extends _h3ravel_musket.Command {
+	signature = `init 
+        {--f|force : Overwrite existing config}
+        {--p|pkg? : Generate config for another package (e.g. sdk-kit) instead of oapiex [sdk]}
+    `;
+	description = "Generate a default oapiex.config.ts in the current directory";
+	async handle() {
+		const cwd = process.cwd();
+		const configPath = node_path.default.join(cwd, "oapiex.config.js");
+		const force = this.option("force", false);
+		const pkg = this.option("pkg", "base").trim().toLowerCase();
+		const configTemplate = {
+			base: this.buildConfigTemplate(),
+			sdk: this.buildSdkConfigTemplate()
+		};
+		if (!["base", "sdk"].includes(pkg)) return void this.error(`Invalid package option: ${pkg}`);
+		try {
+			await node_fs_promises.default.access(configPath);
+			if (!force) {
+				this.error(`Config file already exists at ${configPath}. Use --force to overwrite.`);
+				process.exit(1);
+			}
+		} catch {}
+		await node_fs_promises.default.writeFile(configPath, configTemplate[pkg], "utf8");
+		this.line(`Created ${configPath} `);
+	}
+	buildConfigTemplate() {
+		const def = defaultConfig;
+		return [
+			`import { defineConfig } from '${__filename$1.includes("node_modules") ? "oapiex" : "./src/Manager"}'`,
+			"",
+			"/**",
+			" * See https://toneflix.github.io/oapiex/configuration for docs",
+			" */",
+			"export default defineConfig({",
+			`  outputFormat: '${def.outputFormat}',`,
+			`  outputShape: '${def.outputShape}',`,
+			`  browser: '${def.browser}',`,
+			`  requestTimeout: ${def.requestTimeout},`,
+			`  maxRedirects: ${def.maxRedirects},`,
+			`  userAgent: '${def.userAgent}',`,
+			`  retryCount: ${def.retryCount},`,
+			`  retryDelay: ${def.retryDelay},`,
+			"})"
+		].join("\n");
+	}
+	buildSdkConfigTemplate() {
+		return [
+			"import { defineConfig } from '@oapiex/sdk-kit'",
+			"",
+			"/**",
+			" * See https://toneflix.github.io/oapiex/configuration for docs",
+			" */",
+			"export default defineConfig({",
+			"  environment: 'sandbox',",
+			"  urls: {",
+			"    live: 'https://live.oapiex.com',",
+			"    sandbox: 'https://sandbox.oapiex.com',",
+			"  },",
+			"})"
+		].join("\n");
+	}
 };
 
 //#endregion
@@ -1230,9 +3414,10 @@ const isOpenApiParameterLocation = (value) => {
 var ParseCommand = class extends _h3ravel_musket.Command {
 	signature = `parse
         {source : Local HTML file path or remote URL}
-        {--O|output=pretty : Output format [pretty,json,js]}
+        {--O|output=pretty : Output format [pretty,json,js,ts]}
         {--S|shape=raw : Result shape [raw,openapi]}
         {--B|browser? : Remote loader [axios,happy-dom,jsdom,puppeteer]}
+        {--t|timeout? : Request/browser timeout in milliseconds}
         {--c|crawl : Crawl sidebar links and parse every discovered operation}
         {--b|base-url? : Base URL used to resolve sidebar links when crawling from a local file}
     `;
@@ -1243,6 +3428,7 @@ var ParseCommand = class extends _h3ravel_musket.Command {
 		const output = String(this.option("output", conf.outputFormat)).trim().toLowerCase();
 		const shape = String(this.option("shape", conf.outputShape)).trim().toLowerCase();
 		const browser = String(this.option("browser", conf.browser)).trim().toLowerCase();
+		const timeoutOption = String(this.option("timeout", "")).trim();
 		const crawl = this.option("crawl");
 		const baseUrl = String(this.option("baseUrl", "")).trim() || null;
 		const spinner = this.spinner(`${crawl ? "Crawling and p" : "P"}arsing source...`).start();
@@ -1250,7 +3436,11 @@ var ParseCommand = class extends _h3ravel_musket.Command {
 		try {
 			const start = Date.now();
 			if (!isSupportedBrowser(browser)) throw new Error(`Unsupported browser: ${browser}`);
-			this.app.configure({ browser });
+			const requestTimeout = this.resolveTimeoutOverride(timeoutOption, conf.requestTimeout);
+			this.app.configure({
+				browser,
+				requestTimeout
+			});
 			if (crawl) {
 				await startBrowserSession(this.app.getConfig());
 				startedBrowserSession = true;
@@ -1258,7 +3448,7 @@ var ParseCommand = class extends _h3ravel_musket.Command {
 			const operation = extractReadmeOperationFromHtml(await this.app.loadHtmlSource(source, true));
 			const payload = crawl ? await this.app.crawlReadmeOperations(source, operation, baseUrl) : operation;
 			const normalizedPayload = shape === "openapi" ? this.buildOpenApiPayload(payload) : payload;
-			const serialized = output === "js" ? `export default ${JSON.stringify(normalizedPayload, null, 2)}` : JSON.stringify(normalizedPayload, null, output === "json" ? 0 : 2);
+			const serialized = await OutputGenerator.serializeOutput(normalizedPayload, output, OutputGenerator.getRootTypeName(shape));
 			const filePath = await this.saveOutputToFile(serialized, source, shape, output);
 			const duration = Date.now() - start;
 			_h3ravel_shared.Logger.twoColumnDetail(_h3ravel_shared.Logger.log([["Output", "green"], [`${duration / 1e3}s`, "gray"]], " ", false), filePath.replace(process.cwd(), "."));
@@ -1271,27 +3461,22 @@ var ParseCommand = class extends _h3ravel_musket.Command {
 			if (startedBrowserSession) await endBrowserSession();
 		}
 	}
+	resolveTimeoutOverride = (value, fallback) => {
+		if (!value) return fallback;
+		const parsed = Number(value);
+		if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`Invalid timeout override: ${value}`);
+		return parsed;
+	};
 	buildOpenApiPayload = (payload) => {
-		if ("operations" in payload) return createOpenApiDocumentFromReadmeOperations(payload.operations, "Extracted API", "0.0.0");
-		return createOpenApiDocumentFromReadmeOperations([payload], "Extracted API", "0.0.0");
+		if ("operations" in payload) return transformer.createDocument(payload.operations, "Extracted API", "0.0.0");
+		return transformer.createDocument([payload], "Extracted API", "0.0.0");
 	};
 	saveOutputToFile = async (content, source, shape, outputFormat) => {
-		const ext = {
-			pretty: "txt",
-			json: "json",
-			js: "js"
-		}[outputFormat];
-		const outputDir = node_path.default.resolve(process.cwd(), "output");
-		await node_fs_promises.default.mkdir(outputDir, { recursive: true });
-		const filename = `${source.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "output"}${shape === "openapi" ? ".openapi" : ""}.${ext}`;
-		const filePath = node_path.default.join(outputDir, filename);
-		if (outputFormat === "js") content = await prettier.default.format(content, {
-			parser: "babel",
-			semi: false,
-			singleQuote: true
-		});
-		await node_fs_promises.default.writeFile(filePath, content, "utf8");
-		return filePath;
+		const outputDir = OutputGenerator.buildFilePath(process.cwd(), source, shape, outputFormat);
+		const outputDirname = node_path.default.dirname(outputDir);
+		await node_fs_promises.default.mkdir(outputDirname, { recursive: true });
+		await node_fs_promises.default.writeFile(outputDir, content, "utf8");
+		return outputDir;
 	};
 };
 
@@ -1332,21 +3517,16 @@ async function resolveConfig(cliOverrides = {}) {
 
 //#endregion
 exports.Application = Application;
+exports.GenerateCommand = GenerateCommand;
 exports.InitCommand = InitCommand;
+exports.JsonRepair = JsonRepair;
+exports.OpenApiTransformer = OpenApiTransformer;
+exports.OutputGenerator = OutputGenerator;
 exports.ParseCommand = ParseCommand;
+exports.SdkPackageGenerator = SdkPackageGenerator;
+exports.TypeScriptGenerator = TypeScriptGenerator;
 exports.browser = browser;
-exports.buildOperationId = buildOperationId;
 exports.buildOperationUrl = buildOperationUrl;
-exports.buildRequestBodySchema = buildRequestBodySchema;
-exports.createExampleSchema = createExampleSchema;
-exports.createOpenApiDocumentFromReadmeOperations = createOpenApiDocumentFromReadmeOperations;
-exports.createParameter = createParameter;
-exports.createParameterSchema = createParameterSchema;
-exports.createParameters = createParameters;
-exports.createRequestBody = createRequestBody;
-exports.createResponseContent = createResponseContent;
-exports.createResponses = createResponses;
-exports.decodeOpenApiPathname = decodeOpenApiPathname;
 exports.defaultConfig = defaultConfig;
 exports.defineConfig = defineConfig;
 exports.endBrowserSession = endBrowserSession;
@@ -1375,6 +3555,7 @@ exports.extractResponseSchemas = extractResponseSchemas;
 exports.extractResponseSchemasFromOpenApi = extractResponseSchemasFromOpenApi;
 exports.extractSidebarLinkLabel = extractSidebarLinkLabel;
 exports.extractSidebarLinks = extractSidebarLinks;
+exports.extractStablePageHtml = extractStablePageHtml;
 exports.extractStringLiteralValue = extractStringLiteralValue;
 exports.findParameterRoot = findParameterRoot;
 exports.flattenOpenApiSchemaProperties = flattenOpenApiSchemaProperties;
@@ -1385,20 +3566,14 @@ Object.defineProperty(exports, 'globalConfig', {
     return globalConfig;
   }
 });
-exports.hasExtractedBodyParams = hasExtractedBodyParams;
 exports.inferParameterLocation = inferParameterLocation;
 exports.inferParameterLocationFromText = inferParameterLocationFromText;
 exports.inferParameterPath = inferParameterPath;
 exports.inferParameterType = inferParameterType;
-exports.inferSchemaFromBody = inferSchemaFromBody;
-exports.inferSchemaFromExample = inferSchemaFromExample;
-exports.insertRequestBodyParam = insertRequestBodyParam;
-exports.isOpenApiParameterLocation = isOpenApiParameterLocation;
 exports.isRecord = isRecord;
 exports.isRequiredParameter = isRequiredParameter;
 exports.isSupportedBrowser = isSupportedBrowser;
 exports.loadUserConfig = loadUserConfig;
-exports.mergeOpenApiSchemas = mergeOpenApiSchemas;
 exports.mergeReadmeOperations = mergeReadmeOperations;
 exports.mergeSsrPropsIntoRenderedHtml = mergeSsrPropsIntoRenderedHtml;
 exports.normalizeCurlSnippet = normalizeCurlSnippet;
@@ -1407,18 +3582,14 @@ exports.normalizeRequestCodeSnippet = normalizeRequestCodeSnippet;
 exports.normalizeResponseBody = normalizeResponseBody;
 exports.normalizeStructuredRequestBody = normalizeStructuredRequestBody;
 exports.parseLooseStructuredValue = parseLooseStructuredValue;
-exports.parsePossiblyTruncatedJson = parsePossiblyTruncatedJson;
 exports.readInputValue = readInputValue;
 exports.readText = readText;
 exports.readTexts = readTexts;
 exports.resolveConfig = resolveConfig;
-exports.resolveFallbackRequestBodyExample = resolveFallbackRequestBodyExample;
 exports.resolveOpenApiMediaExample = resolveOpenApiMediaExample;
 exports.resolveParameterInput = resolveParameterInput;
 exports.resolveReadmeSidebarUrls = resolveReadmeSidebarUrls;
 exports.resolveSsrOperation = resolveSsrOperation;
-exports.shouldSkipNormalizedOperation = shouldSkipNormalizedOperation;
-exports.shouldSkipPlaceholderOperation = shouldSkipPlaceholderOperation;
 exports.startBrowserSession = startBrowserSession;
 exports.supportedBrowsers = supportedBrowsers;
-exports.transformReadmeOperationToOpenApi = transformReadmeOperationToOpenApi;
+exports.transformer = transformer;