@workos/oagen 0.1.1 → 0.3.0

package/dist/scripts/smoke/baseline.mjs

@@ -0,0 +1,1951 @@
+import { readFileSync, writeFileSync } from "node:fs";
+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";
+import "dotenv/config";
+//#region src/errors.ts
+/**
+* Structured error hierarchy for oagen.
+*
+* Every error carries a human-readable `hint` that suggests a recovery action.
+* The hint is appended to the `message` so it appears in stack traces and logs.
+*/
+/** Base class for all oagen errors. */
+var OagenError = class extends Error {
+	hint;
+	constructor(message, hint) {
+		const fullMessage = hint ? `${message}\nHint: ${hint}` : message;
+		super(fullMessage);
+		this.name = "OagenError";
+		this.hint = hint;
+	}
+};
+/** Thrown when an OpenAPI spec cannot be parsed or has an unsupported version. */
+var SpecParseError = class extends OagenError {
+	constructor(message, hint) {
+		super(message, hint);
+		this.name = "SpecParseError";
+	}
+};
+//#endregion
+//#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/ir/types.ts
+/**
+* Exhaustive check helper for TypeRef switches.
+* If a new kind is added to TypeRef, any switch that doesn't handle it
+* will fail to compile because `never` won't accept the unhandled variant.
+*
+* Usage:
+*   switch (ref.kind) {
+*     case 'primitive': ...
+*     case 'array': ...
+*     // If you forget 'literal', TypeScript errors here:
+*     default: assertNever(ref);
+*   }
+*/
+function assertNever(x) {
+	const kind = x.kind;
+	const err = /* @__PURE__ */ new Error(`Unexpected TypeRef kind: ${kind}\nHint: If you added a new TypeRef variant, handle it in every switch/case that calls assertNever.`);
+	err.name = "InternalError";
+	throw err;
+}
+/**
+* Generic depth-first walker for TypeRef trees.
+* Handles recursion into array/nullable/union/map children and provides
+* an exhaustive `assertNever` check so callers don't need to repeat the
+* switch boilerplate.  Supply callbacks only for the leaf kinds you care about.
+*/
+function walkTypeRef(ref, visitor) {
+	switch (ref.kind) {
+		case "model":
+			visitor.model?.(ref);
+			break;
+		case "enum":
+			visitor.enum?.(ref);
+			break;
+		case "array":
+			walkTypeRef(ref.items, visitor);
+			break;
+		case "nullable":
+			walkTypeRef(ref.inner, visitor);
+			break;
+		case "union":
+			for (const v of ref.variants) walkTypeRef(v, visitor);
+			break;
+		case "map":
+			if (ref.keyType) walkTypeRef(ref.keyType, visitor);
+			walkTypeRef(ref.valueType, visitor);
+			break;
+		case "literal":
+			visitor.literal?.(ref);
+			break;
+		case "primitive":
+			visitor.primitive?.(ref);
+			break;
+		default: assertNever(ref);
+	}
+}
+//#endregion
+//#region src/utils/naming.ts
+/**
+* Known compound tokens that the regex-based splitter over-splits.
+* Each entry is [lowercase-word-sequence, canonical-form].
+* Sorted longest-first so greedy matching works correctly.
+*/
+const COMPOUND_WORDS = [[[
+	"m",
+	"2",
+	"m"
+], "M2M"], [["o", "auth"], "OAuth"]];
+/**
+* Recombine adjacent words that form a known compound token.
+*/
+function recombineCompounds(words) {
+	const result = [];
+	let i = 0;
+	while (i < words.length) {
+		let matched = false;
+		for (const [pattern, canonical] of COMPOUND_WORDS) if (i + pattern.length <= words.length) {
+			if (pattern.every((p, j) => words[i + j].toLowerCase() === p)) {
+				result.push(canonical);
+				i += pattern.length;
+				matched = true;
+				break;
+			}
+		}
+		if (!matched) {
+			result.push(words[i]);
+			i++;
+		}
+	}
+	return result;
+}
+/**
+* Split a string into words, handling:
+* - camelCase / PascalCase boundaries
+* - snake_case / kebab-case separators
+* - Consecutive capitals (e.g., "HTTPClient" → ["HTTP", "Client"])
+* - Numbers as word boundaries (e.g., "OAuth2Token" → ["OAuth", "2", "Token"])
+* - Known compounds are recombined (e.g., "M2M" stays as one word)
+*/
+function splitWords(s) {
+	if (!s) return [];
+	return recombineCompounds(s.replace(/[^a-zA-Z0-9_\-\s.]/g, "_").replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").replace(/([a-zA-Z])(\d)/g, "$1\0$2").replace(/(\d)([a-zA-Z])/g, "$1\0$2").split(/[\0_\-\s.]+/).filter((w) => w.length > 0));
+}
+const ACRONYM_SET = new Set([
+	"SSO",
+	"FGA",
+	"SAML",
+	"SCIM",
+	"JWT",
+	"HMAC",
+	"M2M"
+]);
+function toPascalCase(s, acronyms) {
+	const merged = acronyms ? new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
+	return splitWords(s).map((w) => {
+		const upper = w.toUpperCase();
+		if (merged.has(upper)) return upper;
+		if (upper === "OAUTH") return "OAuth";
+		return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
+	}).join("");
+}
+function toCamelCase(s, acronyms) {
+	const merged = acronyms ? new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
+	const words = splitWords(s);
+	if (words.length === 0) return "";
+	return words.map((w, i) => {
+		if (i === 0) return w.toLowerCase();
+		const upper = w.toUpperCase();
+		if (merged.has(upper)) return upper;
+		if (upper === "OAUTH") return "OAuth";
+		return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
+	}).join("");
+}
+function toSnakeCase(s) {
+	return splitWords(s).map((w) => w.toLowerCase()).join("_");
+}
+function toUpperSnakeCase(s) {
+	return splitWords(s).map((w) => w.toUpperCase()).join("_");
+}
+const BACKEND_SUFFIXES = [
+	"Dto",
+	"DTO",
+	"Controller"
+];
+function stripBackendSuffixes(name) {
+	for (const suffix of BACKEND_SUFFIXES) if (name.endsWith(suffix) && name.length > suffix.length) return name.slice(0, -suffix.length);
+	return name;
+}
+function stripBackendPrefixes(name) {
+	return name.replace(/Userland/g, "").replace(/Controller/g, "");
+}
+/**
+* Remove ListItem / ByExternalId / ByResourceId / ForResource markers from PascalCase names.
+* E.g. "DirectoriesListItemState" → "DirectoriesState"
+*/
+function stripListItemMarkers(name) {
+	return name.replace(/ListItem/g, "").replace(/ByExternalId/g, "").replace(/ByResourceId/g, "").replace(/ForResource/g, "");
+}
+/** Words that look plural but must NOT be singularized. */
+const SINGULAR_SAFE_LIST = new Set([
+	"Status",
+	"Address",
+	"Access",
+	"Process",
+	"Progress",
+	"Success",
+	"Radius",
+	"Canvas",
+	"Alias",
+	"Basis",
+	"Bus"
+]);
+/**
+* Conservative singularize for the leading PascalCase word.
+* Only applied to the first word of a PascalCase name (the resource word).
+* - `ies` → `y` (e.g. Directories → Directory)
+* - trailing `s` for words >4 chars (e.g. Organizations → Organization)
+* Safe-listed words are never singularized.
+*/
+function singularize(word) {
+	if (SINGULAR_SAFE_LIST.has(word)) return word;
+	if (word.endsWith("ies") && word.length > 4) return word.slice(0, -3) + "y";
+	if (word.endsWith("ses") && word.length > 4) return word.slice(0, -2);
+	if (word.endsWith("s") && !word.endsWith("ss") && word.length > 4) return word.slice(0, -1);
+	return word;
+}
+function cleanSchemaName(name) {
+	let result = stripBackendPrefixes(stripBackendSuffixes(name));
+	result = stripListItemMarkers(result);
+	const match = result.match(/^([A-Z][a-z]*)/);
+	if (match) {
+		const leadWord = match[1];
+		const singular = singularize(leadWord);
+		if (singular !== leadWord) result = singular + result.slice(leadWord.length);
+	}
+	return result;
+}
+//#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 scripts/smoke/shared.ts
+/** Operations that require complex preconditions and can't be auto-tested */
+let SKIP_OPERATIONS = /* @__PURE__ */ new Set();
+/** Services to skip entirely */
+let SKIP_SERVICES = /* @__PURE__ */ new Set();
+/**
+* Services that produce IDs other services depend on should run first.
+* Lower number = runs earlier. Unlisted services default to 50.
+*/
+let SERVICE_PRIORITY = {};
+/** Load smoke test configuration from a JSON file */
+function loadSmokeConfig(configPath) {
+	if (!configPath) return;
+	const raw = readFileSync(configPath, "utf-8");
+	const config = JSON.parse(raw);
+	if (config.skipOperations) SKIP_OPERATIONS = new Set(config.skipOperations);
+	if (config.skipServices) SKIP_SERVICES = new Set(config.skipServices);
+	if (config.servicePriority) SERVICE_PRIORITY = config.servicePriority;
+	if (config.servicePropertyMap) config.servicePropertyMap;
+}
+/**
+* Assign a numeric sort key to an operation so that ID-producing operations
+* (parameterless creates and lists) run before ID-consuming ones.
+*/
+function operationSortKey(op) {
+	const hasParams = op.pathParams.length > 0;
+	const method = op.httpMethod;
+	if (method === "post" && !hasParams) return 0;
+	if (method === "get" && !hasParams && op.pagination) return 1;
+	if (method === "get" && !hasParams) return 2;
+	if (method === "post" && hasParams) return 3;
+	if (method === "get" && hasParams && op.pagination) return 4;
+	if (method === "get" && hasParams) return 5;
+	if (method === "put" || method === "patch") return 6;
+	if (method === "delete") return 7;
+	return 99;
+}
+function planOperations(spec) {
+	const groups = [];
+	for (const service of spec.services) {
+		if (SKIP_SERVICES.has(service.name)) continue;
+		const ops = [];
+		for (const op of service.operations) {
+			if (SKIP_OPERATIONS.has(op.name)) continue;
+			ops.push({
+				service: service.name,
+				operation: op
+			});
+		}
+		if (ops.length === 0) continue;
+		ops.sort((a, b) => {
+			return operationSortKey(a.operation) - operationSortKey(b.operation);
+		});
+		groups.push({
+			service: service.name,
+			operations: ops
+		});
+	}
+	groups.sort((a, b) => {
+		return (SERVICE_PRIORITY[a.service] ?? 50) - (SERVICE_PRIORITY[b.service] ?? 50);
+	});
+	return groups;
+}
+function generateFixtureValue(typeRef, fieldName, spec) {
+	switch (typeRef.kind) {
+		case "primitive": return generatePrimitiveFixture(typeRef.type, typeRef.format, fieldName);
+		case "array": return [generateFixtureValue(typeRef.items, fieldName, spec)];
+		case "model": {
+			const model = spec.models.find((m) => m.name === typeRef.name);
+			if (model) {
+				const obj = {};
+				for (const field of model.fields) if (field.required) obj[toSnakeCase(field.name)] = generateFixtureValue(field.type, field.name, spec);
+				return obj;
+			}
+			return {};
+		}
+		case "enum": return spec.enums.find((en) => en.name === typeRef.name)?.values[0]?.value ?? "unknown";
+		case "nullable": return generateFixtureValue(typeRef.inner, fieldName, spec);
+		case "union":
+			if (typeRef.variants.length > 0) return generateFixtureValue(typeRef.variants[0], fieldName, spec);
+			return null;
+	}
+}
+function generatePrimitiveFixture(type, format, fieldName) {
+	if (type === "string") {
+		if (format === "uuid") return "550e8400-e29b-41d4-a716-446655440000";
+		if (format === "date") return "2024-01-01";
+		if (format === "date-time") return "2024-01-01T00:00:00Z";
+		if (format === "email") return "test@example.com";
+		if (format === "uri" || format === "url") return "https://example.com";
+		return `test_${toSnakeCase(fieldName)}`;
+	}
+	if (type === "integer") return 1;
+	if (type === "number") return 1;
+	if (type === "boolean") return true;
+	return null;
+}
+/** Generate a snake_case request body payload from an operation's requestBody type */
+function generatePayload(op, spec) {
+	if (!op.requestBody) return null;
+	const bodyType = op.requestBody;
+	if (bodyType.kind === "model") {
+		const model = spec.models.find((m) => m.name === bodyType.name);
+		if (!model) return {};
+		const payload = {};
+		for (const field of model.fields) {
+			if (!field.required) continue;
+			const key = toSnakeCase(field.name);
+			let value = generateFixtureValue(field.type, field.name, spec);
+			if ((key === "name" || key === "slug") && typeof value === "string") value = `smoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+			payload[key] = value;
+		}
+		return payload;
+	}
+	return {};
+}
+/** Generate query params for an operation (required params only, plus limit=1 for lists) */
+function generateQueryParams(op, spec) {
+	const params = {};
+	if (op.pagination) params["limit"] = "1";
+	for (const p of op.queryParams) {
+		if (!p.required) continue;
+		const value = generateFixtureValue(p.type, p.name, spec);
+		params[toSnakeCase(p.name)] = String(value);
+	}
+	const sorted = {};
+	for (const key of Object.keys(params).sort()) sorted[key] = params[key];
+	return sorted;
+}
+function resolvePath(op, pathParams) {
+	let path = op.path;
+	for (const [name, value] of Object.entries(pathParams)) path = path.replace(`{${name}}`, value);
+	return path;
+}
+function parseCliArgs() {
+	const args = process.argv.slice(2);
+	const specIdx = args.indexOf("--spec");
+	const spec = specIdx !== -1 && args[specIdx + 1] ? args[specIdx + 1] : process.env.OPENAPI_SPEC_PATH;
+	if (!spec) {
+		console.error("OpenAPI spec path is required. Set OPENAPI_SPEC_PATH env var or pass --spec <path>.");
+		process.exit(1);
+	}
+	const sdkPathIdx = args.indexOf("--sdk-path");
+	const sdkPath = sdkPathIdx !== -1 && args[sdkPathIdx + 1] ? args[sdkPathIdx + 1] : void 0;
+	const configIdx = args.indexOf("--smoke-config");
+	return {
+		spec,
+		sdkPath,
+		smokeConfig: configIdx !== -1 && args[configIdx + 1] ? args[configIdx + 1] : process.env.SMOKE_CONFIG
+	};
+}
+//#endregion
+//#region scripts/smoke/baseline.ts
+/**
+* Spec-only baseline generator.
+*
+* Generates expected request structure from the OpenAPI spec alone — no live
+* API needed. Produces a SmokeResults file that the diff tool can compare
+* against SDK smoke test output for offline CRITICAL-level verification.
+*
+* Usage:
+*   OPENAPI_SPEC_PATH=path/to/spec.yaml npm run smoke:baseline
+*/
+async function main() {
+	const { spec: specPath, smokeConfig } = parseCliArgs();
+	loadSmokeConfig(smokeConfig);
+	console.log("Parsing spec...");
+	const spec = await parseSpec(specPath);
+	console.log(`Spec: ${spec.name} v${spec.version}`);
+	const groups = planOperations(spec);
+	const exchanges = [];
+	for (const group of groups) for (const planned of group.operations) {
+		const op = planned.operation;
+		const operationId = `${group.service}.${op.name}`;
+		const placeholderParams = {};
+		for (const p of op.pathParams) placeholderParams[p.name] = "<ID>";
+		const path = resolvePath(op, placeholderParams);
+		const queryParams = generateQueryParams(op, spec);
+		const body = generatePayload(op, spec);
+		const status = {
+			post: 201,
+			get: 200,
+			put: 200,
+			patch: 200,
+			delete: 204
+		}[op.httpMethod] ?? 200;
+		exchanges.push({
+			operationId,
+			service: group.service,
+			operationName: op.name,
+			request: {
+				method: op.httpMethod.toUpperCase(),
+				path,
+				queryParams,
+				body
+			},
+			response: {
+				status,
+				body: null
+			},
+			outcome: "success",
+			durationMs: 0
+		});
+	}
+	const results = {
+		source: "spec-baseline",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		specVersion: spec.version,
+		exchanges
+	};
+	writeFileSync("smoke-results-spec-baseline.json", JSON.stringify(results, null, 2));
+	console.log(`\nGenerated ${exchanges.length} operations from spec`);
+	console.log("Written to smoke-results-spec-baseline.json");
+}
+main().catch((err) => {
+	console.error("Baseline generation failed:", err);
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=baseline.mjs.map