@workos/oagen 0.1.1 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,1553 @@
+import { A as walkTypeRef, C as assertNever, D as collectModelRefs, E as collectFieldDependencies, O as collectRequestBodyModels, S as SpecParseError, T as collectEnumRefs, _ as ConfigVersionMismatchError, a as singularize, b as OagenError, c as stripListItemMarkers, d as toPascalCase, f as toSnakeCase, g as ConfigLoadError, h as ConfigError, k as mapTypeRef, l as toCamelCase, m as CommandError, n as ACRONYM_SET, p as toUpperSnakeCase, r as cleanSchemaName, s as stripBackendPrefixes, u as toKebabCase, v as ExtractorError, w as assignModelsToServices, x as RegistryError, y as InternalError } from "./tree-sitter-DFRXfWg9.mjs";
+import { a as integrateGeneratedFiles, c as applyFileHeaders, d as generateAllFiles, f as generateFiles, i as generate, l as buildEmitterContext, n as getEmitter, o as mapFilesForTargetIntegration, r as registerEmitter, s as treeShakeFiles, t as diffSpecs, u as collectReferencedNames } from "./diff-Cn6S74vV.mjs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { BaseResolver, bundleDocument, createConfig, makeDocumentFromString } from "@redocly/openapi-core";
+//#region src/parser/refs.ts
+async function loadAndBundleSpec(specPath) {
+	const absolutePath = resolve(specPath);
+	const document = makeDocumentFromString(await readFile(absolutePath, "utf-8"), pathToFileURL(absolutePath).href);
+	const config = await createConfig({});
+	const resolver = new BaseResolver();
+	const result = await bundleDocument({
+		document,
+		config: config.styleguide,
+		externalRefResolver: resolver,
+		dereference: false
+	});
+	if (result.problems.some((p) => p.severity === "error")) throw new SpecParseError(`Failed to parse spec: ${result.problems.filter((p) => p.severity === "error").map((p) => p.message).join("\n")}`, `Check the OpenAPI spec at "${absolutePath}" for syntax errors. Run a linter such as \`npx @redocly/cli lint ${specPath}\` to identify issues.`);
+	return {
+		parsed: result.bundle.parsed,
+		specPath: absolutePath
+	};
+}
+//#endregion
+//#region src/parser/inline-models.ts
+/**
+* Qualify an inline model name with the parent schema name.
+* If `parentName` is provided and the field name doesn't already start with
+* the parent, the result is `${parentName}${PascalField}` with the trailing
+* word singularized (e.g., Connection + Domains → ConnectionDomain).
+*/
+function qualifyInlineModelName(baseName, parentName) {
+	if (!parentName) return baseName;
+	const cleanParent = stripListItemMarkers(parentName);
+	if (baseName.startsWith(cleanParent)) return baseName;
+	const trailingMatch = baseName.match(/^(.*?)([A-Z][a-z]*)$/);
+	if (trailingMatch) {
+		const [, prefix, trailingWord] = trailingMatch;
+		return `${cleanParent}${prefix}${singularize(trailingWord)}`;
+	}
+	return `${cleanParent}${baseName}`;
+}
+/**
+* Walk all component schemas and extract inline Model definitions for fields
+* that are objects with properties (or arrays of such objects).
+* These correspond to the ModelRef entries created by schemaToTypeRef.
+*/
+function extractInlineModelsFromSchemas(schemas) {
+	if (!schemas) return [];
+	const inlineModels = [];
+	for (const [schemaName, schema] of Object.entries(schemas)) extractInlineModelsFromProperties(schema, inlineModels, cleanSchemaName(toPascalCase(schemaName)));
+	return inlineModels;
+}
+function extractInlineModelsFromProperties(schema, results, parentName) {
+	const properties = schema.properties ?? {};
+	const allOfSchemas = schema.allOf ?? [];
+	for (const sub of allOfSchemas) if (sub.properties) extractInlineModelsFromProperties(sub, results, parentName);
+	for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+		if (!fieldSchema) continue;
+		if (fieldSchema.properties && (fieldSchema.type === "object" || !fieldSchema.type)) {
+			const modelName = qualifyInlineModelName(toPascalCase(fieldName), parentName);
+			results.push(buildInlineModel(modelName, fieldSchema));
+			extractInlineModelsFromProperties(fieldSchema, results, modelName);
+		}
+		if (fieldSchema.type === "array" && fieldSchema.items) {
+			const items = fieldSchema.items;
+			if (items.properties && (items.type === "object" || !items.type)) {
+				const modelName = qualifyInlineModelName(toPascalCase(fieldName), parentName);
+				results.push(buildInlineModel(modelName, items));
+				extractInlineModelsFromProperties(items, results, modelName);
+			}
+		}
+		if (fieldSchema.oneOf) {
+			const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
+			if (objectVariant) {
+				const modelName = qualifyInlineModelName(toPascalCase(fieldName), parentName);
+				if (!new Set(results.map((r) => r.name)).has(modelName)) {
+					results.push(buildInlineModel(modelName, objectVariant));
+					extractInlineModelsFromProperties(objectVariant, results, modelName);
+				}
+			}
+		}
+	}
+}
+function buildInlineModel(name, schema) {
+	const requiredSet = new Set(schema.required ?? []);
+	const fields = [];
+	for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
+		if (!fieldSchema) continue;
+		fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
+	}
+	return {
+		name,
+		description: schema.description,
+		fields
+	};
+}
+//#endregion
+//#region src/parser/schemas.ts
+function extractSchemas(schemas) {
+	const enums = [];
+	if (!schemas) return {
+		models: [],
+		enums
+	};
+	const modelsByCleanName = /* @__PURE__ */ new Map();
+	for (const [name, schema] of Object.entries(schemas)) {
+		const pascalName = cleanSchemaName(toPascalCase(name));
+		if (schema.enum) enums.push(extractEnum(pascalName, schema));
+		else {
+			const model = extractModel(pascalName, schema, schemas);
+			const existing = modelsByCleanName.get(pascalName);
+			if (existing) {
+				if (model.fields.length > existing.fields.length) modelsByCleanName.set(pascalName, model);
+			} else modelsByCleanName.set(pascalName, model);
+		}
+	}
+	const models = [...modelsByCleanName.values()];
+	const modelNames = new Set(models.map((m) => m.name));
+	const inlineQueue = [...models];
+	while (inlineQueue.length > 0) {
+		const model = inlineQueue.pop();
+		for (const field of model.fields) collectNestedInlineModels(field.type, field.name, model.name, schemas ?? {}, models, modelNames, inlineQueue);
+	}
+	for (const model of models) collectInlineEnums(model.fields, enums);
+	return {
+		models,
+		enums
+	};
+}
+/**
+* Walk a single TypeRef and extract inline enum refs as top-level enum definitions.
+* Shared by both schemas.ts (field-level) and parse.ts (model-level) collection passes.
+*/
+function collectInlineEnumFromRef(ref, enums, seen) {
+	walkTypeRef(ref, { enum: (r) => {
+		if (r.values && !seen.has(r.name)) {
+			seen.add(r.name);
+			enums.push({
+				name: r.name,
+				values: r.values.map((v) => ({
+					name: toUpperSnakeCase(String(v)),
+					value: v,
+					description: void 0
+				}))
+			});
+		}
+	} });
+}
+/**
+* Walk model fields and extract inline enum refs as top-level enum definitions.
+* This ensures type alias files are generated for inline enums.
+*/
+function collectInlineEnums(fields, enums) {
+	const seen = new Set(enums.map((e) => e.name));
+	for (const field of fields) collectInlineEnumFromRef(field.type, enums, seen);
+}
+/**
+* Walk a TypeRef tree and extract inline models for any model refs that point
+* to schemas with inline object properties (not in components/schemas).
+* This handles nested objects like `totp: { oneOf: [{ type: object, properties: {...} }] }`
+* that schemaToTypeRef turns into model refs but aren't extracted from components.
+*/
+function collectNestedInlineModels(ref, fieldName, parentModelName, schemas, models, modelNames, queue) {
+	walkTypeRef(ref, { model: (modelRef) => {
+		if (modelNames.has(modelRef.name)) return;
+		if (Object.keys(schemas).some((k) => cleanSchemaName(toPascalCase(k)) === modelRef.name)) return;
+		const parentSchema = findSchemaByName(parentModelName, schemas);
+		if (!parentSchema) return;
+		const fieldSchema = findNestedFieldSchema(fieldName, parentSchema, schemas);
+		if (!fieldSchema) return;
+		const extracted = extractNestedSchema(modelRef.name, fieldSchema);
+		for (const m of extracted) if (!modelNames.has(m.name)) {
+			models.push(m);
+			modelNames.add(m.name);
+			queue.push(m);
+		}
+	} });
+}
+/** Find a component schema by PascalCase name. */
+function findSchemaByName(pascalName, schemas) {
+	for (const [k, v] of Object.entries(schemas)) if (cleanSchemaName(toPascalCase(k)) === pascalName) return v;
+	return null;
+}
+/** Walk into a schema to find a field's sub-schema, resolving allOf. */
+function findNestedFieldSchema(fieldName, parentSchema, schemas) {
+	if (parentSchema.properties?.[fieldName]) return parentSchema.properties[fieldName];
+	if (parentSchema.allOf) for (const sub of parentSchema.allOf) {
+		let resolved = sub;
+		if (sub.$ref) {
+			const segments = sub.$ref.split("/");
+			const refName = segments[segments.length - 1];
+			if (refName && schemas[refName]) resolved = schemas[refName];
+		}
+		if (resolved.properties?.[fieldName]) return resolved.properties[fieldName];
+	}
+	return null;
+}
+/** Extract a model (and nested models) from an inline field schema. */
+function extractNestedSchema(name, schema) {
+	if (schema.oneOf) {
+		const models = [];
+		for (const variant of schema.oneOf) {
+			if (variant.$ref) continue;
+			if (variant.properties && (variant.type === "object" || !variant.type)) {
+				const requiredSet = new Set(variant.required ?? []);
+				const fields = [];
+				for (const [fn, fs] of Object.entries(variant.properties)) {
+					if (!fs) continue;
+					fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
+				}
+				const variantName = models.length === 0 ? name : `${name}${models.length + 1}`;
+				models.push({
+					name: variantName,
+					description: variant.description,
+					fields
+				});
+			}
+		}
+		return models;
+	}
+	if (schema.properties && (schema.type === "object" || !schema.type)) {
+		const requiredSet = new Set(schema.required ?? []);
+		const fields = [];
+		for (const [fn, fs] of Object.entries(schema.properties)) {
+			if (!fs) continue;
+			fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
+		}
+		return [{
+			name,
+			description: schema.description,
+			fields
+		}];
+	}
+	if (schema.type === "array" && schema.items?.properties) {
+		const requiredSet = new Set(schema.items.required ?? []);
+		const fields = [];
+		for (const [fn, fs] of Object.entries(schema.items.properties)) {
+			if (!fs) continue;
+			fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
+		}
+		return [{
+			name,
+			description: schema.items.description,
+			fields
+		}];
+	}
+	return [];
+}
+/** Build a single Field from a schema property entry. Shared across all extraction sites. */
+function buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet) {
+	return {
+		name: fieldName,
+		type: schemaToTypeRef(fieldSchema, fieldName, contextName),
+		required: requiredSet.has(fieldName),
+		description: fieldSchema.description,
+		readOnly: fieldSchema.readOnly || void 0,
+		writeOnly: fieldSchema.writeOnly || void 0,
+		deprecated: fieldSchema.deprecated || void 0,
+		default: fieldSchema.default,
+		example: fieldSchema.example
+	};
+}
+function extractEnum(name, schema) {
+	return {
+		name,
+		values: (schema.enum ?? []).map((v) => ({
+			name: toUpperSnakeCase(String(v)),
+			value: typeof v === "number" ? v : String(v),
+			description: void 0
+		}))
+	};
+}
+function extractModel(name, schema, schemas) {
+	if (schema.allOf) return extractAllOfModel(name, schema, schemas);
+	const requiredSet = new Set(schema.required ?? []);
+	const fields = [];
+	for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
+		if (!fieldSchema) continue;
+		fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
+	}
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schema.properties) {
+		if (Object.keys(schema.additionalProperties).length > 0) {
+			const valueType = schemaToTypeRef(schema.additionalProperties, "additionalProperties", name);
+			fields.push({
+				name: "additionalProperties",
+				type: {
+					kind: "map",
+					valueType
+				},
+				required: false,
+				description: "Additional properties not captured by named fields"
+			});
+		}
+	}
+	return {
+		name,
+		description: schema.description,
+		fields
+	};
+}
+function extractAllOfModel(name, schema, schemas) {
+	const fields = [];
+	const requiredSet = /* @__PURE__ */ new Set();
+	for (const subSchema of schema.allOf ?? []) {
+		let resolved = subSchema;
+		if (subSchema.$ref && schemas) {
+			const segments = subSchema.$ref.split("/");
+			const refName = segments[segments.length - 1];
+			if (refName && schemas[refName]) resolved = schemas[refName];
+		}
+		if (resolved.allOf) {
+			const nested = extractAllOfModel(name, resolved, schemas);
+			for (const f of nested.fields) {
+				fields.push({
+					...f,
+					required: false
+				});
+				if (f.required) requiredSet.add(f.name);
+			}
+		} else {
+			if (resolved.required) for (const r of resolved.required) requiredSet.add(r);
+			if (resolved.properties) {
+				const emptyRequired = /* @__PURE__ */ new Set();
+				for (const [fieldName, fieldSchema] of Object.entries(resolved.properties)) {
+					if (!fieldSchema) continue;
+					fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
+				}
+			}
+		}
+	}
+	if (schema.required) for (const r of schema.required) requiredSet.add(r);
+	for (const f of fields) f.required = requiredSet.has(f.name);
+	return {
+		name,
+		description: schema.description,
+		fields
+	};
+}
+function schemaToTypeRef(schema, contextName, parentModelName) {
+	if (schema.$ref) {
+		const segments = schema.$ref.split("/");
+		const rawName = segments[segments.length - 1];
+		return {
+			kind: "model",
+			name: cleanSchemaName(toPascalCase(rawName))
+		};
+	}
+	if (Array.isArray(schema.type)) {
+		const nonNullTypes = schema.type.filter((t) => t !== "null");
+		if (nonNullTypes.length === 0) return {
+			kind: "nullable",
+			inner: {
+				kind: "primitive",
+				type: "unknown"
+			}
+		};
+		if (schema.type.includes("null") && nonNullTypes.length === 1) return {
+			kind: "nullable",
+			inner: schemaToTypeRef({
+				...schema,
+				type: nonNullTypes[0],
+				nullable: false
+			}, contextName)
+		};
+		if (nonNullTypes.length > 1) {
+			const ref = {
+				kind: "union",
+				variants: nonNullTypes.map((t) => schemaToTypeRef({
+					...schema,
+					type: t
+				}, contextName))
+			};
+			if (schema.type.includes("null")) return {
+				kind: "nullable",
+				inner: ref
+			};
+			return ref;
+		}
+	}
+	if (schema.nullable && schema.type) return {
+		kind: "nullable",
+		inner: schemaToTypeRef({
+			...schema,
+			nullable: false
+		}, contextName)
+	};
+	if (schema.allOf) {
+		const refItem = schema.allOf.find((s) => s.$ref);
+		if (refItem) {
+			if (schema.allOf.some((s) => !s.$ref && (s.properties || s.type === "object"))) return {
+				kind: "model",
+				name: qualifyInlineModelName(toPascalCase(contextName ?? "UnknownModel"), parentModelName)
+			};
+			return schemaToTypeRef(refItem, contextName, parentModelName);
+		}
+		if (schema.allOf.length === 1) return schemaToTypeRef(schema.allOf[0], contextName, parentModelName);
+		if (schema.allOf.some((s) => s.properties)) return {
+			kind: "model",
+			name: qualifyInlineModelName(toPascalCase(contextName ?? "UnknownModel"), parentModelName)
+		};
+	}
+	if (schema.oneOf || schema.anyOf) {
+		const compositionKind = schema.oneOf ? "oneOf" : "anyOf";
+		const rawVariants = schema.oneOf ?? schema.anyOf ?? [];
+		const nullVariant = rawVariants.find((v) => v.type === "null" || Array.isArray(v.type) && v.type.length === 1 && v.type[0] === "null");
+		const nonNullVariants = rawVariants.filter((v) => v !== nullVariant);
+		if (nullVariant && nonNullVariants.length === 1) return {
+			kind: "nullable",
+			inner: schemaToTypeRef(nonNullVariants[0], contextName, parentModelName)
+		};
+		const variants = rawVariants.filter((v) => v.type !== "null").map((v) => schemaToTypeRef(v, contextName, parentModelName));
+		const hasNull = !!nullVariant;
+		const union = {
+			kind: "union",
+			variants,
+			compositionKind,
+			...schema.discriminator ? { discriminator: {
+				property: schema.discriminator.propertyName,
+				mapping: Object.fromEntries(Object.entries(schema.discriminator.mapping ?? {}).map(([k, v]) => [k, v.replace(/^#\/components\/schemas\//, "")]))
+			} } : {}
+		};
+		return hasNull ? {
+			kind: "nullable",
+			inner: union
+		} : union;
+	}
+	if (schema.const !== void 0) {
+		if (typeof schema.const === "string" || typeof schema.const === "number" || typeof schema.const === "boolean") return {
+			kind: "literal",
+			value: schema.const
+		};
+		if (schema.const === null) return {
+			kind: "nullable",
+			inner: {
+				kind: "primitive",
+				type: "unknown"
+			}
+		};
+		if (typeof schema.const === "object") {
+			if (Array.isArray(schema.const)) return {
+				kind: "array",
+				items: {
+					kind: "primitive",
+					type: "unknown"
+				}
+			};
+			return {
+				kind: "map",
+				valueType: {
+					kind: "primitive",
+					type: "unknown"
+				}
+			};
+		}
+	}
+	if (schema.enum && schema.enum.length === 1) {
+		const v = schema.enum[0];
+		return {
+			kind: "literal",
+			value: typeof v === "number" ? v : String(v)
+		};
+	}
+	if (schema.enum) {
+		const baseName = toPascalCase(contextName ?? "UnknownEnum");
+		const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+		return {
+			kind: "enum",
+			name: cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName,
+			values: schema.enum.map((v) => typeof v === "number" ? v : String(v))
+		};
+	}
+	if (schema.type === "array" && schema.items) return {
+		kind: "array",
+		items: schemaToTypeRef(schema.items, contextName, parentModelName)
+	};
+	if (!schema.type && schema.items) return {
+		kind: "array",
+		items: schemaToTypeRef(schema.items, contextName, parentModelName)
+	};
+	if (schema.type === "object" && schema.properties) return {
+		kind: "model",
+		name: qualifyInlineModelName(toPascalCase(contextName ?? "UnknownModel"), parentModelName)
+	};
+	if (schema.type === "object" && !schema.properties) {
+		let valueType = {
+			kind: "primitive",
+			type: "unknown"
+		};
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+			if (Object.keys(schema.additionalProperties).length > 0) valueType = schemaToTypeRef(schema.additionalProperties, contextName);
+		} else if (schema.patternProperties) {
+			const patterns = Object.values(schema.patternProperties);
+			if (patterns.length > 0) valueType = schemaToTypeRef(patterns[0], contextName);
+		}
+		return {
+			kind: "map",
+			valueType
+		};
+	}
+	const primitiveMap = {
+		string: "string",
+		integer: "integer",
+		number: "number",
+		boolean: "boolean"
+	};
+	const typeStr = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+	if (typeStr && primitiveMap[typeStr]) return {
+		kind: "primitive",
+		type: primitiveMap[typeStr],
+		...schema.format ? { format: schema.format } : {}
+	};
+	if (!schema.type && schema.properties) return {
+		kind: "model",
+		name: qualifyInlineModelName(toPascalCase(contextName ?? "UnknownModel"), parentModelName)
+	};
+	if (!schema.type && !schema.$ref && !schema.oneOf && !schema.anyOf && !schema.allOf && !schema.enum && !schema.properties && !schema.items) return {
+		kind: "primitive",
+		type: "unknown"
+	};
+	if (contextName) console.warn(`[oagen] Warning: Unknown schema shape treated as unknown (context: ${contextName})`);
+	return {
+		kind: "primitive",
+		type: "unknown"
+	};
+}
+//#endregion
+//#region src/parser/pagination.ts
+const CURSOR_PARAMS = [
+	"cursor",
+	"after",
+	"before",
+	"starting_after",
+	"ending_before",
+	"page_token",
+	"next_token"
+];
+const OFFSET_PARAMS = [
+	"offset",
+	"page",
+	"page_number",
+	"skip"
+];
+const LIMIT_PARAMS = [
+	"limit",
+	"page_size",
+	"per_page",
+	"size",
+	"count"
+];
+/**
+* Detect if an operation uses pagination and return structured metadata
+* for auto-paging iterator generation.
+*
+* Supports two strategies:
+* 1. **Cursor-based**: query params include a cursor-like parameter
+* 2. **Offset-based**: query params include both an offset-like and limit-like parameter
+*
+* Returns null if no pagination pattern is detected.
+*/
+function detectPagination(response, queryParams, dataPath) {
+	const cursorParam = queryParams.find((p) => CURSOR_PARAMS.includes(p.name));
+	if (cursorParam) {
+		const itemType = response.kind === "array" ? response.items : response;
+		return {
+			strategy: "cursor",
+			param: cursorParam.name,
+			dataPath,
+			itemType
+		};
+	}
+	const offsetParam = queryParams.find((p) => OFFSET_PARAMS.includes(p.name));
+	const limitParam = queryParams.find((p) => LIMIT_PARAMS.includes(p.name));
+	if (offsetParam && limitParam) {
+		const itemType = response.kind === "array" ? response.items : response;
+		return {
+			strategy: "offset",
+			param: offsetParam.name,
+			limitParam: limitParam.name,
+			dataPath,
+			itemType
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/parser/responses.ts
+function classifyAndExtractResponse(schema, contextName) {
+	if (schema.$ref) return {
+		response: schemaToTypeRef(schema, contextName),
+		inlineModels: [],
+		isPaginated: false
+	};
+	const envelope = detectListEnvelope(schema);
+	if (envelope.isEnvelope) return extractListResponse(schema, contextName, envelope.dataPath);
+	if (isSingleResourceWrapper(schema)) return extractWrappedResource(schema, contextName);
+	return extractDirectResource(schema, contextName);
+}
+const KNOWN_DATA_PATHS = new Set([
+	"data",
+	"items",
+	"results",
+	"records",
+	"entries",
+	"values",
+	"nodes",
+	"edges"
+]);
+const PAGINATION_METADATA_PATTERNS = [
+	"metadata",
+	"pagination",
+	"cursor",
+	"has_more",
+	"page_info",
+	"total",
+	"next_page",
+	"previous_page",
+	"offset"
+];
+function detectListEnvelope(schema) {
+	const propSources = [];
+	if (schema.allOf) {
+		for (const sub of schema.allOf) if (sub.properties) propSources.push(sub.properties);
+	}
+	if (schema.properties) propSources.push(schema.properties);
+	if (propSources.length === 0) return {
+		isEnvelope: false,
+		dataPath: null
+	};
+	const mergedProps = {};
+	for (const source of propSources) Object.assign(mergedProps, source);
+	const arrayProps = [];
+	const nonArrayKeys = [];
+	for (const [key, propSchema] of Object.entries(mergedProps)) {
+		if (!propSchema) continue;
+		if (propSchema.type === "array") arrayProps.push(key);
+		else nonArrayKeys.push(key);
+	}
+	if (arrayProps.length === 1 && nonArrayKeys.length >= 1) {
+		const arrayPropName = arrayProps[0];
+		if (KNOWN_DATA_PATHS.has(arrayPropName)) return {
+			isEnvelope: true,
+			dataPath: arrayPropName
+		};
+		if (nonArrayKeys.some((key) => PAGINATION_METADATA_PATTERNS.some((pattern) => key.toLowerCase().includes(pattern)))) return {
+			isEnvelope: true,
+			dataPath: arrayPropName
+		};
+	}
+	return {
+		isEnvelope: false,
+		dataPath: null
+	};
+}
+function extractListResponse(schema, contextName, dataPath) {
+	let itemTypeRef = {
+		kind: "primitive",
+		type: "string"
+	};
+	const inlineModels = [];
+	const propSources = [];
+	if (schema.allOf) {
+		for (const sub of schema.allOf) if (sub.properties) propSources.push(sub.properties);
+	}
+	if (schema.properties) propSources.push(schema.properties);
+	for (const props of propSources) {
+		const dataProp = props[dataPath];
+		if (!dataProp) continue;
+		if (dataProp.type === "array" && dataProp.items) {
+			const items = dataProp.items;
+			if (items.$ref) itemTypeRef = schemaToTypeRef(items, contextName);
+			else if (items.type === "object" && items.properties) {
+				const itemName = contextName.replace(/Response$/, "") + "Item";
+				itemTypeRef = {
+					kind: "model",
+					name: itemName
+				};
+				inlineModels.push(...extractInlineModel(itemName, items));
+			}
+		}
+	}
+	return {
+		response: {
+			kind: "array",
+			items: itemTypeRef
+		},
+		inlineModels,
+		isPaginated: true,
+		dataPath,
+		itemType: itemTypeRef
+	};
+}
+function hasDiscriminantConstField(schema) {
+	if (!schema.properties) return null;
+	for (const name of ["object", "type"]) {
+		const field = schema.properties[name];
+		if (!field) continue;
+		if (field.const !== void 0 && typeof field.const === "string") return {
+			property: name,
+			value: field.const
+		};
+		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return {
+			property: name,
+			value: field.enum[0]
+		};
+	}
+	for (const [name, field] of Object.entries(schema.properties)) {
+		if (!field) continue;
+		if (field.const !== void 0 && typeof field.const === "string") return {
+			property: name,
+			value: field.const
+		};
+		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return {
+			property: name,
+			value: field.enum[0]
+		};
+	}
+	return null;
+}
+function isSingleResourceWrapper(schema) {
+	if (schema.type !== "object") return false;
+	if (!schema.properties) return false;
+	let wrapperKey;
+	if (schema.required && schema.required.length === 1) wrapperKey = schema.required[0];
+	else {
+		const propKeys = Object.keys(schema.properties);
+		if (propKeys.length === 1) wrapperKey = propKeys[0];
+	}
+	if (!wrapperKey) return false;
+	const propSchema = schema.properties[wrapperKey];
+	if (!propSchema) return false;
+	if (propSchema.type === "object" && hasDiscriminantConstField(propSchema) !== null) return true;
+	if (propSchema.oneOf) return propSchema.oneOf.some((v) => v.type === "object" && hasDiscriminantConstField(v) !== null);
+	return false;
+}
+function extractWrappedResource(schema, contextName) {
+	const props = schema.properties;
+	const propSchema = props[schema.required && schema.required.length === 1 ? schema.required[0] : Object.keys(props)[0]];
+	const inlineModels = [];
+	const resourceName = contextName.replace(/Response$/, "");
+	if (propSchema.oneOf) {
+		const objectVariant = propSchema.oneOf.find((v) => v.type === "object" && hasDiscriminantConstField(v) !== null);
+		if (objectVariant) {
+			const modelName = deriveModelName(objectVariant, resourceName);
+			inlineModels.push(...extractInlineModel(modelName, objectVariant));
+			const hasNullVariant = propSchema.oneOf.some((v) => v.type === "null" || Array.isArray(v.type) && v.type.includes("null"));
+			const modelRef = {
+				kind: "model",
+				name: modelName
+			};
+			return {
+				response: hasNullVariant ? {
+					kind: "nullable",
+					inner: modelRef
+				} : modelRef,
+				inlineModels,
+				isPaginated: false
+			};
+		}
+	}
+	const modelName = deriveModelName(propSchema, resourceName);
+	inlineModels.push(...extractInlineModel(modelName, propSchema));
+	return {
+		response: {
+			kind: "model",
+			name: modelName
+		},
+		inlineModels,
+		isPaginated: false
+	};
+}
+function extractDirectResource(schema, contextName) {
+	const inlineModels = [];
+	if (schema.properties && (schema.type === "object" || !schema.type)) {
+		const modelName = deriveModelName(schema, contextName);
+		inlineModels.push(...extractInlineModel(modelName, schema));
+		return {
+			response: {
+				kind: "model",
+				name: modelName
+			},
+			inlineModels,
+			isPaginated: false
+		};
+	}
+	if (schema.allOf) {
+		const mergedProperties = {};
+		const mergedRequired = [];
+		for (const sub of schema.allOf) {
+			if (sub.properties) Object.assign(mergedProperties, sub.properties);
+			if (sub.required) mergedRequired.push(...sub.required);
+		}
+		if (Object.keys(mergedProperties).length > 0) {
+			const merged = {
+				type: "object",
+				properties: mergedProperties,
+				required: mergedRequired
+			};
+			const modelName = deriveModelName(merged, contextName);
+			inlineModels.push(...extractInlineModel(modelName, merged));
+			return {
+				response: {
+					kind: "model",
+					name: modelName
+				},
+				inlineModels,
+				isPaginated: false
+			};
+		}
+	}
+	if (schema.oneOf) {
+		for (const variant of schema.oneOf) if (variant.properties && (variant.type === "object" || !variant.type)) {
+			const modelName = deriveModelName(variant, contextName);
+			if (!new Set(inlineModels.map((m) => m.name)).has(modelName)) inlineModels.push(...extractInlineModel(modelName, variant));
+		}
+	}
+	if (schema.type === "array" && schema.items) {
+		const items = schema.items;
+		if (items.$ref) return {
+			response: {
+				kind: "array",
+				items: schemaToTypeRef(items, contextName)
+			},
+			inlineModels,
+			isPaginated: false
+		};
+		if (items.properties && (items.type === "object" || !items.type)) {
+			const itemName = contextName.replace(/Response$/, "") + "Item";
+			inlineModels.push(...extractInlineModel(itemName, items));
+			return {
+				response: {
+					kind: "array",
+					items: {
+						kind: "model",
+						name: itemName
+					}
+				},
+				inlineModels,
+				isPaginated: false
+			};
+		}
+	}
+	return {
+		response: schemaToTypeRef(schema, contextName),
+		inlineModels,
+		isPaginated: false
+	};
+}
+function deriveModelName(schema, fallback) {
+	if (!schema.properties) return toPascalCase(fallback);
+	for (const name of ["object", "type"]) {
+		const field = schema.properties[name];
+		if (field && field.const && typeof field.const === "string") return toPascalCase(field.const);
+	}
+	for (const [, field] of Object.entries(schema.properties)) if (field && field.const && typeof field.const === "string") return toPascalCase(field.const);
+	return toPascalCase(fallback);
+}
+/**
+* Qualify a nested inline model name with its parent to avoid generic names.
+* e.g., parent="Connection" + field="domains" → "ConnectionDomain" (singularized)
+* Only qualifies when the field name alone would be too generic.
+*/
+function qualifyNestedName(parentName, fieldName) {
+	const pascalField = toPascalCase(fieldName);
+	if (pascalField.startsWith(parentName)) return pascalField;
+	const qualified = `${stripListItemMarkers(parentName)}${pascalField}`;
+	const match = qualified.match(/^(.+?)([A-Z][a-z]+s?)$/);
+	if (match && match[2]) {
+		const trailing = singularize(match[2]);
+		return match[1] + trailing;
+	}
+	return qualified;
+}
+function extractInlineModel(name, schema) {
+	const requiredSet = new Set(schema.required ?? []);
+	const fields = [];
+	const properties = schema.properties ?? {};
+	const nestedModels = [];
+	for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+		if (!fieldSchema) continue;
+		fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
+		if (fieldSchema.type === "object" && fieldSchema.properties) {
+			const nestedName = qualifyNestedName(name, fieldName);
+			nestedModels.push(...extractInlineModel(nestedName, fieldSchema));
+		}
+		if (fieldSchema.type === "array" && fieldSchema.items) {
+			const items = fieldSchema.items;
+			if (items.type === "object" && items.properties) {
+				const nestedName = qualifyNestedName(name, fieldName);
+				nestedModels.push(...extractInlineModel(nestedName, items));
+			}
+		}
+		if (fieldSchema.allOf) {
+			const mergedProperties = {};
+			const mergedRequired = [];
+			for (const sub of fieldSchema.allOf) {
+				if (sub.properties) Object.assign(mergedProperties, sub.properties);
+				if (sub.required) mergedRequired.push(...sub.required);
+			}
+			if (Object.keys(mergedProperties).length > 0) {
+				const nestedName = qualifyNestedName(name, fieldName);
+				const merged = {
+					type: "object",
+					properties: mergedProperties,
+					required: mergedRequired
+				};
+				if (!new Set(nestedModels.map((m) => m.name)).has(nestedName)) nestedModels.push(...extractInlineModel(nestedName, merged));
+			}
+		}
+		if (fieldSchema.oneOf) {
+			const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
+			if (objectVariant) {
+				const nestedName = qualifyNestedName(name, fieldName);
+				if (!new Set(nestedModels.map((m) => m.name)).has(nestedName)) nestedModels.push(...extractInlineModel(nestedName, objectVariant));
+			}
+		}
+	}
+	return [{
+		name,
+		description: schema.description,
+		fields
+	}, ...nestedModels];
+}
+//#endregion
+//#region src/parser/operations.ts
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"head",
+	"options",
+	"trace"
+];
+function extractOperations(paths, operationIdTransform) {
+	if (!paths) return {
+		services: [],
+		inlineModels: []
+	};
+	const serviceMap = /* @__PURE__ */ new Map();
+	const inlineModels = [];
+	for (const [path, pathItem] of Object.entries(paths)) {
+		const pathLevelParams = pathItem.parameters ?? [];
+		for (const method of HTTP_METHODS) {
+			const op = pathItem[method];
+			if (!op) continue;
+			const serviceName = inferServiceName(path, op.tags?.[0]);
+			const { operation, inlineModels: opModels } = buildOperation(method, path, op, pathLevelParams, operationIdTransform);
+			inlineModels.push(...opModels);
+			const ops = serviceMap.get(serviceName) ?? [];
+			ops.push(operation);
+			serviceMap.set(serviceName, ops);
+		}
+	}
+	for (const [, operations] of serviceMap) disambiguateOperationNames(operations);
+	return {
+		services: Array.from(serviceMap.entries()).map(([name, operations]) => ({
+			name,
+			operations
+		})),
+		inlineModels
+	};
+}
+function inferServiceName(path, tag) {
+	if (tag) return toPascalCase(tag);
+	const first = path.split("/").filter(Boolean)[0] ?? "Default";
+	if (first.startsWith("{")) return "Default";
+	return toPascalCase(first);
+}
+function inferOperationName(method, path, operationId, operationIdTransform) {
+	if (operationId) {
+		if (operationIdTransform) return operationIdTransform(operationId);
+		return toCamelCase(operationId);
+	}
+	const verb = inferVerb(method, path);
+	const resource = inferResourceFromPath(path);
+	return resource ? toCamelCase(`${verb}_${resource}`) : verb;
+}
+/**
+* Infer the CRUD verb from HTTP method and path shape.
+*/
+function inferVerb(method, path) {
+	const segments = path.split("/").filter(Boolean);
+	const hasTrailingParam = segments.length > 0 && segments[segments.length - 1].startsWith("{");
+	switch (method) {
+		case "get": return hasTrailingParam ? "get" : "list";
+		case "post": return "create";
+		case "put":
+		case "patch": return "update";
+		case "delete": return "delete";
+		case "head": return "check";
+		case "options": return "options";
+		case "trace": return "trace";
+		default: return method;
+	}
+}
+/**
+* Extract a resource noun from the path for operation naming.
+* Uses the last non-param segment (the resource being operated on).
+*
+* Examples:
+*   /user_management/users → "Users"
+*   /user_management/users/{id} → "User" (singular for item operations)
+*   /user_management/users/{id}/auth_factors → "AuthFactors"
+*   /organizations/{id}/api_keys → "ApiKeys"
+*   /sso/authorize → "Authorize" (action endpoint)
+*/
+function inferResourceFromPath(path) {
+	const segments = path.split("/").filter(Boolean);
+	if (segments.length <= 1) return null;
+	let resourceSegment = null;
+	for (let i = segments.length - 1; i >= 0; i--) if (!segments[i].startsWith("{")) {
+		resourceSegment = segments[i];
+		break;
+	}
+	if (!resourceSegment) return null;
+	if (resourceSegment === segments[0]) return null;
+	return toPascalCase(resourceSegment);
+}
+/**
+* Detect and resolve name collisions within a service's operations.
+*
+* When multiple operations share the same name (e.g., several "list" from
+* different sub-resources), disambiguate by appending the resource noun
+* from the path. Only renames operations on DIFFERENT paths — same-name
+* operations on the same path (e.g., PUT + PATCH both "update") are left as-is
+* since they represent the same logical resource.
+*/
+function disambiguateOperationNames(operations) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const op of operations) {
+		const group = byName.get(op.name) ?? [];
+		group.push(op);
+		byName.set(op.name, group);
+	}
+	for (const [name, group] of byName) {
+		if (group.length <= 1) continue;
+		if (new Set(group.map((op) => op.path)).size <= 1) continue;
+		for (const op of group) {
+			const resource = inferResourceFromPath(op.path);
+			if (resource) op.name = toCamelCase(`${name}_${resource}`);
+		}
+		const renamed = /* @__PURE__ */ new Map();
+		for (const op of group) {
+			const rGroup = renamed.get(op.name) ?? [];
+			rGroup.push(op);
+			renamed.set(op.name, rGroup);
+		}
+		for (const [, rGroup] of renamed) {
+			if (rGroup.length <= 1) continue;
+			for (const op of rGroup) {
+				const deeper = inferDeeperContext(op.path);
+				if (deeper) op.name = toCamelCase(`${op.name}_${deeper}`);
+			}
+		}
+	}
+}
+/**
+* Extract a deeper disambiguation context from the path when the last
+* segment isn't unique enough. Uses the second-to-last non-param segment.
+*
+* /users/{id}/auth_factors → already captured as "AuthFactors"
+* /users/external_id/{external_id} → "ExternalId" (special path, not a sub-resource)
+*/
+function inferDeeperContext(path) {
+	const nonParams = path.split("/").filter(Boolean).filter((s) => !s.startsWith("{"));
+	if (nonParams.length >= 3) return toPascalCase(nonParams.slice(1, -1).join("_"));
+	return null;
+}
+function buildOperation(method, path, op, pathLevelParams, operationIdTransform) {
+	const allParams = [...pathLevelParams, ...op.parameters ?? []];
+	const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
+	const pathParams = extractParams(allParams, "path");
+	const queryParams = extractParams(allParams, "query");
+	const headerParams = extractParams(allParams, "header").filter((p) => p.name.toLowerCase() !== "idempotency-key");
+	const cookieParams = extractParams(allParams, "cookie");
+	const reqBodyModels = [];
+	const { body: requestBody, encoding: requestBodyEncoding } = extractRequestBody(op.requestBody, op, reqBodyModels);
+	const { response, successResponses, errors, inlineModels, isPaginated, dataPath: responseDataPath, itemType: responseItemType } = extractResponses(op.responses, op, path, method);
+	inlineModels.push(...reqBodyModels);
+	const paginationFromParams = detectPagination(response, queryParams, responseDataPath);
+	let pagination;
+	if (isPaginated) {
+		const itemType = responseItemType ?? (response.kind === "array" ? response.items : response);
+		pagination = {
+			strategy: paginationFromParams?.strategy ?? "cursor",
+			param: paginationFromParams?.param ?? "after",
+			limitParam: paginationFromParams?.limitParam,
+			dataPath: responseDataPath ?? paginationFromParams?.dataPath,
+			itemType
+		};
+	} else if (paginationFromParams) pagination = paginationFromParams;
+	return {
+		operation: {
+			name: inferOperationName(method, path, op.operationId, operationIdTransform),
+			description: buildDescription(op.summary, op.description),
+			httpMethod: method,
+			path,
+			pathParams,
+			queryParams,
+			headerParams,
+			cookieParams: cookieParams.length > 0 ? cookieParams : void 0,
+			requestBody,
+			requestBodyEncoding,
+			response,
+			successResponses,
+			errors,
+			pagination,
+			injectIdempotencyKey: hasIdempotencyHeader,
+			deprecated: op.deprecated || void 0,
+			async: op["x-oagen-async"]
+		},
+		inlineModels
+	};
+}
+function buildDescription(summary, description) {
+	if (summary && description && summary !== description) return `${summary}\n\n${description}`;
+	return description ?? summary;
+}
+function extractParams(params, location) {
+	return params.filter((p) => p.in === location).map((p) => ({
+		name: p.name,
+		type: p.schema ? schemaToTypeRef(p.schema, p.name) : {
+			kind: "primitive",
+			type: "string"
+		},
+		required: p.required ?? false,
+		description: p.description,
+		deprecated: p.deprecated || p.schema?.deprecated || void 0,
+		default: p.schema?.default,
+		example: p.example ?? p.schema?.example
+	}));
+}
+function extractRequestBody(body, op, inlineModels) {
+	if (!body?.content) return {};
+	let encoding = "json";
+	let schema;
+	if (body.content["application/json"]?.schema) {
+		encoding = "json";
+		schema = body.content["application/json"].schema;
+	} else if (body.content["multipart/form-data"]?.schema) {
+		encoding = "form-data";
+		schema = body.content["multipart/form-data"].schema;
+	} else if (body.content["application/x-www-form-urlencoded"]?.schema) {
+		encoding = "form-urlencoded";
+		schema = body.content["application/x-www-form-urlencoded"].schema;
+	} else if (body.content["application/octet-stream"]) {
+		encoding = "binary";
+		schema = body.content["application/octet-stream"].schema;
+	} else if (body.content["text/plain"]) {
+		encoding = "text";
+		schema = body.content["text/plain"].schema;
+	}
+	if (!schema) {
+		if (encoding === "binary") return {
+			body: {
+				kind: "primitive",
+				type: "string",
+				format: "binary"
+			},
+			encoding
+		};
+		if (encoding === "text") return {
+			body: {
+				kind: "primitive",
+				type: "string"
+			},
+			encoding
+		};
+		return {};
+	}
+	const contextName = cleanSchemaName(op?.operationId ? toPascalCase(op.operationId) + "Request" : "RequestBody");
+	if (schema.properties && (schema.type === "object" || !schema.type)) {
+		const requiredSet = new Set(schema.required ?? []);
+		const fields = [];
+		for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+			if (!fieldSchema) continue;
+			fields.push(buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet));
+		}
+		inlineModels.push({
+			name: contextName,
+			description: void 0,
+			fields
+		});
+		return {
+			body: {
+				kind: "model",
+				name: contextName
+			},
+			encoding
+		};
+	}
+	if (schema.oneOf) {
+		const variants = [];
+		for (const variant of schema.oneOf) if (variant.$ref) {
+			const ref = schemaToTypeRef(variant, contextName);
+			variants.push(ref);
+		} else if (variant.type === "null") {} else if (variant.properties && (variant.type === "object" || !variant.type)) {
+			const variantName = deriveOneOfVariantName(variant, contextName, inlineModels);
+			const requiredSet = new Set(variant.required ?? []);
+			const fields = [];
+			for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+				if (!fieldSchema) continue;
+				fields.push(buildFieldFromSchema(fieldName, fieldSchema, variantName, requiredSet));
+			}
+			inlineModels.push({
+				name: variantName,
+				description: variant.description,
+				fields
+			});
+			variants.push({
+				kind: "model",
+				name: variantName
+			});
+		} else variants.push(schemaToTypeRef(variant, contextName));
+		const hasNull = schema.oneOf.some((v) => v.type === "null" || Array.isArray(v.type) && v.type.includes("null"));
+		const union = {
+			kind: "union",
+			variants,
+			...schema.discriminator ? { discriminator: {
+				property: schema.discriminator.propertyName,
+				mapping: schema.discriminator.mapping ?? {}
+			} } : {}
+		};
+		return {
+			body: hasNull ? {
+				kind: "nullable",
+				inner: union
+			} : union,
+			encoding
+		};
+	}
+	return {
+		body: schemaToTypeRef(schema, contextName),
+		encoding
+	};
+}
+/** Derive a unique variant name for a oneOf inline model. */
+function deriveOneOfVariantName(variant, baseName, existingModels) {
+	if (variant.properties) {
+		for (const [, propSchema] of Object.entries(variant.properties)) if (propSchema?.const && typeof propSchema.const === "string") return toPascalCase(propSchema.const) + baseName.replace(/Request$/, "") + "Request";
+	}
+	const existingNames = new Set(existingModels.map((m) => m.name));
+	let name = baseName;
+	let suffix = 2;
+	while (existingNames.has(name)) {
+		name = `${baseName}${suffix}`;
+		suffix++;
+	}
+	return name;
+}
+function deriveResponseName(op, path, method) {
+	if (op?.operationId) return cleanSchemaName(toPascalCase(op.operationId) + "Response");
+	return toPascalCase(path.split("/").filter(Boolean)[0] ?? "Unknown") + toPascalCase(method) + "Response";
+}
+function extractResponses(responses, op, path, method) {
+	const errors = [];
+	let response = {
+		kind: "primitive",
+		type: "string"
+	};
+	let inlineModels = [];
+	let isPaginated = false;
+	let dataPath;
+	let itemType;
+	if (!responses) return {
+		response,
+		errors,
+		inlineModels,
+		isPaginated
+	};
+	const allSuccessResponses = [];
+	for (const [statusCode, resp] of Object.entries(responses)) {
+		const code = parseInt(statusCode, 10);
+		if (code >= 200 && code < 300) {
+			let extractedType = {
+				kind: "primitive",
+				type: "unknown"
+			};
+			const jsonContent = resp.content?.["application/json"];
+			if (jsonContent?.schema) {
+				const contextName = deriveResponseName(op, path ?? "/", method ?? "get");
+				const result = classifyAndExtractResponse(jsonContent.schema, contextName);
+				extractedType = result.response;
+				inlineModels = result.inlineModels;
+				isPaginated = result.isPaginated;
+				dataPath = result.dataPath;
+				itemType = result.itemType;
+			} else if (resp.content) if (resp.content["application/octet-stream"] || resp.content["application/pdf"]) extractedType = {
+				kind: "primitive",
+				type: "string",
+				format: "binary"
+			};
+			else if (resp.content["text/plain"] || resp.content["text/html"] || resp.content["text/xml"] || resp.content["application/xml"]) extractedType = {
+				kind: "primitive",
+				type: "string"
+			};
+			else {
+				const firstKey = Object.keys(resp.content)[0];
+				if (firstKey) {
+					const firstContent = resp.content[firstKey];
+					if (firstContent?.schema) extractedType = schemaToTypeRef(firstContent.schema, deriveResponseName(op, path ?? "/", method ?? "get"));
+				}
+			}
+			allSuccessResponses.push({
+				statusCode: code,
+				type: extractedType
+			});
+		} else if (code >= 400) {
+			const jsonContent = resp.content?.["application/json"];
+			const type = jsonContent?.schema ? schemaToTypeRef(jsonContent.schema, `Error${code}`) : void 0;
+			errors.push({
+				statusCode: code,
+				type
+			});
+		}
+	}
+	if (allSuccessResponses.length > 0) {
+		const sorted = [...allSuccessResponses].sort((a, b) => a.statusCode - b.statusCode);
+		response = (sorted.find((r) => r.type.kind !== "primitive" || r.type.type !== "unknown") ?? sorted[0]).type;
+	}
+	const successResponses = allSuccessResponses.length > 1 ? allSuccessResponses : void 0;
+	return {
+		response,
+		successResponses,
+		errors,
+		inlineModels,
+		isPaginated,
+		dataPath,
+		itemType
+	};
+}
+//#endregion
+//#region src/parser/normalize-inline-models.ts
+function keepLargestByName(models) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const existing = byName.get(model.name);
+		if (!existing || model.fields.length > existing.fields.length) byName.set(model.name, model);
+	}
+	return [...byName.values()];
+}
+function rewriteModelRef(ref, oldName, newName) {
+	walkTypeRef(ref, { model: (r) => {
+		if (r.name === oldName) r.name = newName;
+	} });
+}
+function rewriteModelRefs(models, services, oldName, newName) {
+	for (const model of models) for (const field of model.fields) rewriteModelRef(field.type, oldName, newName);
+	for (const service of services) for (const op of service.operations) {
+		rewriteModelRef(op.response, oldName, newName);
+		if (op.requestBody) rewriteModelRef(op.requestBody, oldName, newName);
+	}
+}
+function mergeInlineResponseModels(schemaModels, inlineModels) {
+	const mergedSchemaModels = [...schemaModels];
+	const schemaModelNames = new Set(mergedSchemaModels.map((m) => m.name));
+	const schemaModelsByName = new Map(mergedSchemaModels.map((m) => [m.name, m]));
+	const deduplicatedInlineModels = inlineModels.filter((model) => {
+		if (!schemaModelNames.has(model.name)) return true;
+		const existing = schemaModelsByName.get(model.name);
+		const existingFieldNames = new Set(existing.fields.map((f) => f.name));
+		const inlineFieldNames = new Set(model.fields.map((f) => f.name));
+		const hasDifference = model.fields.some((f) => !existingFieldNames.has(f.name)) || existing.fields.some((f) => !inlineFieldNames.has(f.name));
+		if (hasDifference && model.fields.length > existing.fields.length) {
+			const idx = mergedSchemaModels.indexOf(existing);
+			if (idx !== -1) mergedSchemaModels[idx] = model;
+			schemaModelsByName.set(model.name, model);
+			console.warn(`[oagen] Warning: Inline model "${model.name}" has more fields than component schema (${model.fields.length} vs ${existing.fields.length}) — using inline response model`);
+		} else if (hasDifference) console.warn(`[oagen] Warning: Inline model "${model.name}" has different fields than component schema — using component schema`);
+		return false;
+	});
+	return [...mergedSchemaModels, ...keepLargestByName(deduplicatedInlineModels)];
+}
+function mergeFieldInlineModels(existingModels, fieldInlineModels) {
+	const modelNames = new Set(existingModels.map((m) => m.name));
+	const modelsByName = new Map(existingModels.map((m) => [m.name, m]));
+	const deduplicatedFieldModels = fieldInlineModels.filter((model) => {
+		if (!modelNames.has(model.name)) return true;
+		const existing = modelsByName.get(model.name);
+		const existingFieldNames = new Set(existing.fields.map((f) => f.name));
+		const inlineFieldNames = new Set(model.fields.map((f) => f.name));
+		if (model.fields.some((f) => !existingFieldNames.has(f.name)) || existing.fields.some((f) => !inlineFieldNames.has(f.name))) console.warn(`[oagen] Warning: Inline model "${model.name}" has different fields than component schema — using component schema`);
+		return false;
+	});
+	return [...existingModels, ...keepLargestByName(deduplicatedFieldModels)];
+}
+function hasModelConstDiscriminant(model) {
+	return model.fields.some((f) => (f.name === "object" || f.name === "type") && f.type.kind === "literal" && typeof f.type.value === "string");
+}
+function isModelReferencedByOthers(name, models, excludeNames) {
+	for (const model of models) {
+		if (excludeNames.has(model.name)) continue;
+		for (const field of model.fields) {
+			let found = false;
+			walkTypeRef(field.type, { model: (r) => {
+				if (r.name === name) found = true;
+			} });
+			if (found) return true;
+		}
+	}
+	return false;
+}
+function collapseJsonSuffixModels(models, services) {
+	const normalizedModels = [...models];
+	const byName = new Map(normalizedModels.map((m) => [m.name, m]));
+	const mergeCandidates = [];
+	for (const model of normalizedModels) {
+		if (!model.name.endsWith("Json")) continue;
+		const baseName = model.name.slice(0, -4);
+		const baseModel = byName.get(baseName);
+		if (!baseModel || model.fields.length <= baseModel.fields.length) continue;
+		if (!baseModel.fields.every((f) => model.fields.some((mf) => mf.name === f.name))) continue;
+		if (hasModelConstDiscriminant(model) && hasModelConstDiscriminant(baseModel)) continue;
+		if (isModelReferencedByOthers(model.name, normalizedModels, new Set([model.name, baseName]))) continue;
+		mergeCandidates.push({
+			jsonModel: model,
+			baseModel
+		});
+	}
+	const toRemove = /* @__PURE__ */ new Set();
+	for (const { jsonModel, baseModel } of mergeCandidates) {
+		baseModel.fields = jsonModel.fields;
+		toRemove.add(jsonModel.name);
+		rewriteModelRefs(normalizedModels, services, jsonModel.name, baseModel.name);
+		console.warn(`[oagen] Merged "${jsonModel.name}" into "${baseModel.name}" (${jsonModel.fields.length} fields, superset)`);
+	}
+	return normalizedModels.filter((m) => !toRemove.has(m.name));
+}
+//#endregion
+//#region src/parser/collect-inline-enums.ts
+function collectInlineEnumsFromModels(models, enums) {
+	const enumNames = new Set(enums.map((e) => e.name));
+	for (const model of models) for (const field of model.fields) collectInlineEnumFromRef(field.type, enums, enumNames);
+}
+//#endregion
+//#region src/parser/normalize-model-refs.ts
+function validateModelRefs(spec) {
+	const knownNames = /* @__PURE__ */ new Set();
+	for (const m of spec.models) knownNames.add(m.name);
+	for (const e of spec.enums) knownNames.add(e.name);
+	function walkRef(ref, context) {
+		walkTypeRef(ref, { model: (r) => {
+			if (!knownNames.has(r.name)) console.warn(`[oagen] Warning: Unresolved model reference "${r.name}" (context: ${context})`);
+		} });
+	}
+	for (const model of spec.models) for (const field of model.fields) walkRef(field.type, `${model.name}.${field.name}`);
+	for (const service of spec.services) for (const op of service.operations) {
+		for (const p of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams
+		]) walkRef(p.type, `${service.name}.${op.name}.${p.name}`);
+		if (op.requestBody) walkRef(op.requestBody, `${service.name}.${op.name}.requestBody`);
+		walkRef(op.response, `${service.name}.${op.name}.response`);
+	}
+}
+//#endregion
+//#region src/parser/parse.ts
+async function parseSpec(specPath, options) {
+	const { parsed } = await loadAndBundleSpec(specPath);
+	const spec = parsed;
+	const version = spec.openapi ?? "";
+	if (!version.startsWith("3.")) throw new SpecParseError(`Unsupported OpenAPI version: ${version}. oagen requires OpenAPI 3.x`, `Update the spec to OpenAPI 3.0 or 3.1. If you are using Swagger 2.x, convert it first with \`npx swagger2openapi ${specPath}\`.`);
+	const { models, enums } = extractSchemas(spec.components?.schemas);
+	const { services, inlineModels } = extractOperations(spec.paths, options?.operationIdTransform);
+	const finalModels = collapseJsonSuffixModels(mergeFieldInlineModels(mergeInlineResponseModels(models, inlineModels), extractInlineModelsFromSchemas(spec.components?.schemas)), services);
+	collectInlineEnumsFromModels(finalModels, enums);
+	const auth = extractAuthSchemes(spec.components?.securitySchemes);
+	const serverEntries = (spec.servers ?? []).map((s) => ({
+		url: s.url ?? "",
+		description: s.description
+	})).filter((s) => s.url);
+	const result = {
+		name: spec.info?.title ?? "Unknown API",
+		version: spec.info?.version ?? "0.0.0",
+		description: spec.info?.description,
+		baseUrl: serverEntries[0]?.url ?? "",
+		servers: serverEntries.length > 0 ? serverEntries : void 0,
+		services,
+		models: finalModels,
+		enums,
+		auth
+	};
+	validateModelRefs(result);
+	return result;
+}
+/** Extract authentication schemes from OpenAPI securitySchemes. */
+function extractAuthSchemes(securitySchemes) {
+	if (!securitySchemes) return void 0;
+	const schemes = [];
+	for (const [, scheme] of Object.entries(securitySchemes)) if (scheme.type === "http" && scheme.scheme === "bearer") schemes.push({ kind: "bearer" });
+	else if (scheme.type === "apiKey" && scheme.in && scheme.name) schemes.push({
+		kind: "apiKey",
+		in: scheme.in,
+		name: scheme.name
+	});
+	else if (scheme.type === "oauth2" && scheme.flows) schemes.push({
+		kind: "oauth2",
+		flows: scheme.flows
+	});
+	return schemes.length > 0 ? schemes : void 0;
+}
+//#endregion
+//#region src/engine/operation-plan.ts
+function planOperation(op) {
+	const isDelete = op.httpMethod === "delete";
+	const hasBody = !!op.requestBody;
+	const isIdempotentPost = op.injectIdempotencyKey && op.httpMethod === "post";
+	const hasQueryParams = op.queryParams.length > 0;
+	const pathParamsInOptions = op.pathParams.length > 1 || op.pathParams.length > 0 && (hasBody || hasQueryParams);
+	const isPaginated = op.pagination !== void 0;
+	const responseModelName = resolveResponseModelName(op);
+	return {
+		operation: op,
+		isDelete,
+		hasBody,
+		isIdempotentPost,
+		pathParamsInOptions,
+		isPaginated,
+		responseModelName,
+		paginatedItemModelName: isPaginated && op.pagination?.itemType.kind === "model" ? op.pagination.itemType.name : null,
+		isModelResponse: responseModelName !== null,
+		hasQueryParams,
+		isAsync: op.async ?? true
+	};
+}
+function resolveResponseModelName(op) {
+	if (op.httpMethod === "delete") return null;
+	return extractModelName(op.response);
+}
+function extractModelName(ref) {
+	switch (ref.kind) {
+		case "model": return ref.name;
+		case "array": return ref.items.kind === "model" ? ref.items.name : null;
+		case "nullable": return extractModelName(ref.inner);
+		case "union": {
+			const firstModel = ref.variants.find((v) => v.kind === "model");
+			return firstModel && firstModel.kind === "model" ? firstModel.name : null;
+		}
+		case "map":
+		case "enum":
+		case "primitive":
+		case "literal": return null;
+		default: return assertNever(ref);
+	}
+}
+//#endregion
+export { ACRONYM_SET, CommandError, ConfigError, ConfigLoadError, ConfigVersionMismatchError, ExtractorError, InternalError, OagenError, RegistryError, SpecParseError, applyFileHeaders, assertNever, assignModelsToServices, buildEmitterContext, cleanSchemaName, collectEnumRefs, collectFieldDependencies, collectModelRefs, collectReferencedNames, collectRequestBodyModels, diffSpecs, generate, generateAllFiles, generateFiles, getEmitter, integrateGeneratedFiles, mapFilesForTargetIntegration, mapTypeRef, parseSpec, planOperation, registerEmitter, stripBackendPrefixes, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, toUpperSnakeCase, treeShakeFiles, walkTypeRef };
+
+//# sourceMappingURL=index.mjs.map