@abapify/openai-codegen 0.4.33 → 0.4.36

package/dist/{generate-DgXsowgP.mjs → generate-BevNTSFF.mjs}

@@ -166,77 +166,91 @@ function normalizeSecuritySchemes(raw) {
 	if (!isRecord$4(raw)) return out;
 	for (const [name, schemeRaw] of Object.entries(raw)) {
 		if (!isRecord$4(schemeRaw)) continue;
-		const type = asString(schemeRaw.type);
-		const description = asString(schemeRaw.description);
-		switch (type) {
-			case "apiKey": {
-				const inLoc = asString(schemeRaw.in);
-				if (inLoc !== "header" && inLoc !== "query" && inLoc !== "cookie") continue;
-				const scheme = {
-					type: "apiKey",
-					name: asString(schemeRaw.name) ?? name,
-					in: inLoc
-				};
-				if (description !== void 0) scheme.description = description;
-				out[name] = scheme;
-				break;
-			}
-			case "http": {
-				const scheme = {
-					type: "http",
-					scheme: asString(schemeRaw.scheme) ?? "bearer"
-				};
-				const bf = asString(schemeRaw.bearerFormat);
-				if (bf !== void 0) scheme.bearerFormat = bf;
-				if (description !== void 0) scheme.description = description;
-				out[name] = scheme;
-				break;
-			}
-			case "oauth2": {
-				const flowsRaw = isRecord$4(schemeRaw.flows) ? schemeRaw.flows : {};
-				const scheme = {
-					type: "oauth2",
-					flows: {}
-				};
-				for (const flowName of [
-					"implicit",
-					"password",
-					"clientCredentials",
-					"authorizationCode"
-				]) {
-					const f = flowsRaw[flowName];
-					if (!isRecord$4(f)) continue;
-					const flow = { scopes: {} };
-					if (isRecord$4(f.scopes)) {
-						for (const [k, v] of Object.entries(f.scopes)) if (typeof v === "string") flow.scopes[k] = v;
-					}
-					const au = asString(f.authorizationUrl);
-					if (au !== void 0) flow.authorizationUrl = au;
-					const tu = asString(f.tokenUrl);
-					if (tu !== void 0) flow.tokenUrl = tu;
-					const ru = asString(f.refreshUrl);
-					if (ru !== void 0) flow.refreshUrl = ru;
-					scheme.flows[flowName] = flow;
-				}
-				if (description !== void 0) scheme.description = description;
-				out[name] = scheme;
-				break;
-			}
-			case "openIdConnect": {
-				const url = asString(schemeRaw.openIdConnectUrl);
-				if (url === void 0) continue;
-				const scheme = {
-					type: "openIdConnect",
-					openIdConnectUrl: url
-				};
-				if (description !== void 0) scheme.description = description;
-				out[name] = scheme;
-				break;
-			}
-		}
+		const scheme = normalizeSecurityScheme(name, schemeRaw);
+		if (scheme !== void 0) out[name] = scheme;
 	}
 	return out;
 }
+function normalizeSecurityScheme(name, schemeRaw) {
+	const type = asString(schemeRaw.type);
+	let scheme;
+	switch (type) {
+		case "apiKey":
+			scheme = normalizeApiKeyScheme(name, schemeRaw);
+			break;
+		case "http":
+			scheme = normalizeHttpScheme(schemeRaw);
+			break;
+		case "oauth2":
+			scheme = normalizeOAuth2Scheme(schemeRaw);
+			break;
+		case "openIdConnect":
+			scheme = normalizeOpenIdConnectScheme(schemeRaw);
+			break;
+		default: scheme = void 0;
+	}
+	if (scheme === void 0) return void 0;
+	const description = asString(schemeRaw.description);
+	if (description !== void 0) scheme.description = description;
+	return scheme;
+}
+function normalizeApiKeyScheme(name, raw) {
+	const inLoc = asString(raw.in);
+	if (inLoc !== "header" && inLoc !== "query" && inLoc !== "cookie") return;
+	return {
+		type: "apiKey",
+		name: asString(raw.name) ?? name,
+		in: inLoc
+	};
+}
+function normalizeHttpScheme(raw) {
+	const scheme = {
+		type: "http",
+		scheme: asString(raw.scheme) ?? "bearer"
+	};
+	const bf = asString(raw.bearerFormat);
+	if (bf !== void 0) scheme.bearerFormat = bf;
+	return scheme;
+}
+function normalizeOAuth2Scheme(raw) {
+	const flowsRaw = isRecord$4(raw.flows) ? raw.flows : {};
+	const scheme = {
+		type: "oauth2",
+		flows: {}
+	};
+	for (const flowName of [
+		"implicit",
+		"password",
+		"clientCredentials",
+		"authorizationCode"
+	]) {
+		const f = flowsRaw[flowName];
+		if (!isRecord$4(f)) continue;
+		scheme.flows[flowName] = normalizeOAuth2Flow(f);
+	}
+	return scheme;
+}
+function normalizeOAuth2Flow(f) {
+	const flow = { scopes: {} };
+	if (isRecord$4(f.scopes)) {
+		for (const [k, v] of Object.entries(f.scopes)) if (typeof v === "string") flow.scopes[k] = v;
+	}
+	const au = asString(f.authorizationUrl);
+	if (au !== void 0) flow.authorizationUrl = au;
+	const tu = asString(f.tokenUrl);
+	if (tu !== void 0) flow.tokenUrl = tu;
+	const ru = asString(f.refreshUrl);
+	if (ru !== void 0) flow.refreshUrl = ru;
+	return flow;
+}
+function normalizeOpenIdConnectScheme(raw) {
+	const url = asString(raw.openIdConnectUrl);
+	if (url === void 0) return void 0;
+	return {
+		type: "openIdConnect",
+		openIdConnectUrl: url
+	};
+}
 function normalizeSecurityRequirements(raw) {
 	return asArray(raw).filter(isRecord$4).map((req) => {
 		const out = {};
@@ -253,28 +267,31 @@ function normalizeOperations(pathsRaw, topLevelSecurity) {
 		for (const method of HTTP_METHODS) {
 			const opRaw = pathItemRaw[method];
 			if (!isRecord$4(opRaw)) continue;
-			const parameters = mergeParameters(pathLevelParams, normalizeParameters(opRaw.parameters));
-			const op = {
-				operationId: asString(opRaw.operationId) ?? synthesizeOperationId(method, path),
-				method,
-				path,
-				tags: asStringArray(opRaw.tags),
-				deprecated: asBool(opRaw.deprecated, false),
-				parameters,
-				responses: normalizeResponses(opRaw.responses),
-				security: opRaw.security === void 0 ? topLevelSecurity : normalizeSecurityRequirements(opRaw.security)
-			};
-			const summary = asString(opRaw.summary);
-			if (summary !== void 0) op.summary = summary;
-			const description = asString(opRaw.description);
-			if (description !== void 0) op.description = description;
-			const requestBody = normalizeRequestBody(opRaw.requestBody);
-			if (requestBody !== void 0) op.requestBody = requestBody;
-			ops.push(op);
+			ops.push(buildOperation(method, path, opRaw, pathLevelParams, topLevelSecurity));
 		}
 	}
 	return ops;
 }
+function buildOperation(method, path, opRaw, pathLevelParams, topLevelSecurity) {
+	const parameters = mergeParameters(pathLevelParams, normalizeParameters(opRaw.parameters));
+	const op = {
+		operationId: asString(opRaw.operationId) ?? synthesizeOperationId(method, path),
+		method,
+		path,
+		tags: asStringArray(opRaw.tags),
+		deprecated: asBool(opRaw.deprecated, false),
+		parameters,
+		responses: normalizeResponses(opRaw.responses),
+		security: opRaw.security === void 0 ? topLevelSecurity : normalizeSecurityRequirements(opRaw.security)
+	};
+	const summary = asString(opRaw.summary);
+	if (summary !== void 0) op.summary = summary;
+	const description = asString(opRaw.description);
+	if (description !== void 0) op.description = description;
+	const requestBody = normalizeRequestBody(opRaw.requestBody);
+	if (requestBody !== void 0) op.requestBody = requestBody;
+	return op;
+}
 function normalizeParameters(raw) {
 	return asArray(raw).filter(isRecord$4).map((p) => {
 		const inLoc = asString(p.in);
@@ -303,16 +320,19 @@ function mergeParameters(pathLevel, opLevel) {
 	for (const p of opLevel) merged.set(key(p), p);
 	return [...merged.values()];
 }
-function normalizeRequestBody(raw) {
-	if (!isRecord$4(raw)) return void 0;
+function normalizeContentMap(raw) {
 	const content = {};
-	if (isRecord$4(raw.content)) for (const [mt, mtRaw] of Object.entries(raw.content)) {
+	if (isRecord$4(raw)) for (const [mt, mtRaw] of Object.entries(raw)) {
 		if (!isRecord$4(mtRaw)) continue;
 		content[mt] = { schema: isRecord$4(mtRaw.schema) ? mtRaw.schema : {} };
 	}
+	return content;
+}
+function normalizeRequestBody(raw) {
+	if (!isRecord$4(raw)) return void 0;
 	const body = {
 		required: asBool(raw.required, false),
-		content
+		content: normalizeContentMap(raw.content)
 	};
 	const desc = asString(raw.description);
 	if (desc !== void 0) body.description = desc;
@@ -322,37 +342,40 @@ function normalizeResponses(raw) {
 	if (!isRecord$4(raw)) return [];
 	const entries = Object.entries(raw).filter((entry) => isRecord$4(entry[1]));
 	const has2xx = entries.some(([code]) => /^2\d\d$/.test(code));
-	return entries.map(([statusCode, respRaw]) => {
-		const isSuccess = /^2\d\d$/.test(statusCode) || statusCode === "default" && !has2xx;
-		const isError = /^(4|5)\d\d$/.test(statusCode) || statusCode === "default" && has2xx;
-		const content = {};
-		if (isRecord$4(respRaw.content)) for (const [mt, mtRaw] of Object.entries(respRaw.content)) {
-			if (!isRecord$4(mtRaw)) continue;
-			content[mt] = { schema: isRecord$4(mtRaw.schema) ? mtRaw.schema : {} };
-		}
-		const headers = {};
-		if (isRecord$4(respRaw.headers)) for (const [hn, hRaw] of Object.entries(respRaw.headers)) {
-			if (!isRecord$4(hRaw)) continue;
-			const header = { schema: isRecord$4(hRaw.schema) ? hRaw.schema : {} };
-			const desc = asString(hRaw.description);
-			if (desc !== void 0) header.description = desc;
-			if (typeof hRaw.required === "boolean") header.required = hRaw.required;
-			if (typeof hRaw.deprecated === "boolean") header.deprecated = hRaw.deprecated;
-			headers[hn] = header;
-		}
-		const resp = {
-			statusCode,
-			isSuccess,
-			isError,
-			content,
-			headers
-		};
-		const desc = asString(respRaw.description);
-		if (desc !== void 0) resp.description = desc;
-		return resp;
-	});
-}
-function synthesizeOperationId(method, path) {
+	return entries.map(([statusCode, respRaw]) => normalizeResponse(statusCode, respRaw, has2xx));
+}
+function normalizeResponse(statusCode, respRaw, has2xx) {
+	const resp = {
+		statusCode,
+		isSuccess: /^2\d\d$/.test(statusCode) || statusCode === "default" && !has2xx,
+		isError: /^[45]\d\d$/.test(statusCode) || statusCode === "default" && has2xx,
+		content: normalizeContentMap(respRaw.content),
+		headers: normalizeResponseHeaders(respRaw.headers)
+	};
+	const desc = asString(respRaw.description);
+	if (desc !== void 0) resp.description = desc;
+	return resp;
+}
+function normalizeResponseHeaders(raw) {
+	const headers = {};
+	if (isRecord$4(raw)) for (const [hn, hRaw] of Object.entries(raw)) {
+		if (!isRecord$4(hRaw)) continue;
+		headers[hn] = normalizeHeader(hRaw);
+	}
+	return headers;
+}
+function normalizeHeader(hRaw) {
+	const header = { schema: isRecord$4(hRaw.schema) ? hRaw.schema : {} };
+	const desc = asString(hRaw.description);
+	if (desc !== void 0) header.description = desc;
+	if (typeof hRaw.required === "boolean") header.required = hRaw.required;
+	if (typeof hRaw.deprecated === "boolean") header.deprecated = hRaw.deprecated;
+	return header;
+}
+function isAlnumChar(ch) {
+	return ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9";
+}
+function sanitizePathChars(path) {
 	const out = [];
 	let underscore = false;
 	let braceDepth = 0;
@@ -365,7 +388,7 @@ function synthesizeOperationId(method, path) {
 			if (braceDepth > 0) braceDepth -= 1;
 			continue;
 		}
-		if (ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9") {
+		if (isAlnumChar(ch)) {
 			out.push(ch);
 			underscore = false;
 		} else if (!underscore) {
@@ -373,6 +396,10 @@ function synthesizeOperationId(method, path) {
 			underscore = true;
 		}
 	}
+	return out;
+}
+function synthesizeOperationId(method, path) {
+	const out = sanitizePathChars(path);
 	let start = 0;
 	let end = out.length;
 	while (start < end && out[start] === "_") start += 1;
@@ -408,7 +435,7 @@ function sanitizeIdent(raw, kind, opts = {}) {
 	if (kind === "class") base = words.map((w) => w.toUpperCase()).join(joiner);
 	else base = words.map((w) => w.toLowerCase()).join(joiner);
 	if (!base) base = kind === "class" ? "X" : "x";
-	if (/^[0-9]/.test(base)) base = (kind === "class" ? "N_" : "n_") + base;
+	if (/^\d/.test(base)) base = (kind === "class" ? "N_" : "n_") + base;
 	let full = prefix + base;
 	if (full.length > maxLen) {
 		const suffix = "_" + shortHash(raw, 4);
@@ -487,67 +514,86 @@ function isNonTrivialInline(schema) {
 */
 function collectFromSchema(rootId, rootSchema, plannedIds, enqueueInline, schemaToId) {
 	const deps = /* @__PURE__ */ new Set();
+	const ctx = {
+		rootId,
+		deps,
+		plannedIds,
+		enqueueInline,
+		schemaToId
+	};
 	const visit = (schema, path, atRoot) => {
 		if (!isRecord$3(schema)) return;
-		if (isRef(schema)) {
-			const name = componentNameFromRef$2(schema.$ref);
-			if (name) {
-				const depId = `components.schemas.${name}`;
-				deps.add(depId);
-			}
-			return;
+		if (classifyVisit(schema, path, atRoot, ctx)) return;
+		descendSchema(schema, path, visit);
+	};
+	visit(rootSchema, [], true);
+	return [...deps];
+}
+/** Classify a non-trivial schema node: register a dep (or inline entry) and
+*  report whether descent should stop. */
+function classifyVisit(schema, path, atRoot, ctx) {
+	const { rootId, deps, schemaToId } = ctx;
+	if (isRef(schema)) {
+		const name = componentNameFromRef$2(schema.$ref);
+		if (name) {
+			const depId = `components.schemas.${name}`;
+			deps.add(depId);
 		}
-		if (!atRoot) {
-			const hitId = schemaToId.get(schema);
-			if (hitId && hitId !== rootId) {
-				deps.add(hitId);
-				return;
-			}
-			if (hitId === rootId) {
-				deps.add(rootId);
-				return;
-			}
+		return true;
+	}
+	if (!atRoot) {
+		const hitId = schemaToId.get(schema);
+		if (hitId && hitId !== rootId) {
+			deps.add(hitId);
+			return true;
 		}
-		if (!atRoot && isNonTrivialInline(schema)) {
-			const id = `${rootId}.${path.join(".")}`;
-			if (!plannedIds.has(id)) {
-				enqueueInline(id, schema);
-				schemaToId.set(schema, id);
-			}
-			deps.add(id);
-			return;
+		if (hitId === rootId) {
+			deps.add(rootId);
+			return true;
 		}
-		const rec = schema;
-		if (isRecord$3(rec.properties)) for (const [name, sub] of Object.entries(rec.properties)) visit(sub, [
-			...path,
-			"properties",
-			name
-		], false);
-		if (rec.items !== void 0) visit(rec.items, [...path, "items"], false);
-		if (isRecord$3(rec.additionalProperties)) visit(rec.additionalProperties, [...path, "additionalProperties"], false);
-		for (const c of [
-			"allOf",
-			"anyOf",
-			"oneOf"
-		]) {
-			const arr = rec[c];
-			if (Array.isArray(arr)) arr.forEach((sub, idx) => {
-				visit(sub, [
-					...path,
-					c,
-					String(idx)
-				], false);
-			});
+		if (isNonTrivialInline(schema)) {
+			deps.add(registerInlineEntry(schema, path, ctx));
+			return true;
 		}
-	};
-	visit(rootSchema, [], true);
-	return [...deps];
+	}
+	return false;
+}
+function registerInlineEntry(schema, path, ctx) {
+	const { rootId, plannedIds, enqueueInline, schemaToId } = ctx;
+	const id = `${rootId}.${path.join(".")}`;
+	if (!plannedIds.has(id)) {
+		enqueueInline(id, schema);
+		schemaToId.set(schema, id);
+	}
+	return id;
+}
+function descendSchema(schema, path, visit) {
+	if (isRecord$3(schema.properties)) for (const [name, sub] of Object.entries(schema.properties)) visit(sub, [
+		...path,
+		"properties",
+		name
+	], false);
+	if (schema.items !== void 0) visit(schema.items, [...path, "items"], false);
+	if (isRecord$3(schema.additionalProperties)) visit(schema.additionalProperties, [...path, "additionalProperties"], false);
+	for (const c of [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	]) {
+		const arr = schema[c];
+		if (Array.isArray(arr)) arr.forEach((sub, idx) => {
+			visit(sub, [
+				...path,
+				c,
+				String(idx)
+			], false);
+		});
+	}
 }
 /** Plan the ABAP type universe for a normalized spec. */
 function planTypes(spec, opts) {
 	const alloc = makeNameAllocator(/* @__PURE__ */ new Set());
 	const entries = [];
-	const byId = /* @__PURE__ */ new Map();
 	const plannedIds = /* @__PURE__ */ new Set();
 	const schemaToId = /* @__PURE__ */ new Map();
 	const queue = [];
@@ -573,15 +619,13 @@ function planTypes(spec, opts) {
 			source: item.source
 		};
 		entries.push(entry);
-		byId.set(item.id, entry);
 		entry.dependencies = collectFromSchema(item.id, item.schema, plannedIds, (id, schema) => {
 			enqueue(id, schema, "inline");
 		}, schemaToId);
 	}
 	if (entries.some((e) => hasOpenAdditional(e.schema))) {
-		const kvId = "aux.kv";
 		const kvEntry = {
-			id: kvId,
+			id: "aux.kv",
 			abapName: alloc("kv", "type", { prefix: "ty_" + (opts.typePrefix ?? "") }),
 			schema: {
 				type: "object",
@@ -594,7 +638,6 @@ function planTypes(spec, opts) {
 			source: "auxiliary"
 		};
 		entries.push(kvEntry);
-		byId.set(kvId, kvEntry);
 	}
 	const sorted = topoSort(entries);
 	return {
@@ -636,16 +679,7 @@ function topoSort(entries) {
 		const entry = byId.get(id);
 		if (!entry) return;
 		if (s === "gray") {
-			const cycleStart = stack.indexOf(id);
-			const cycle = cycleStart >= 0 ? stack.slice(cycleStart) : [id];
-			if (cycle.length === 1) {
-				entry.selfReferential = true;
-				return;
-			}
-			for (const pid of cycle) {
-				const ent = byId.get(pid);
-				if (ent) ent.selfReferential = true;
-			}
+			markCycleParticipants(id, stack, byId, entry);
 			return;
 		}
 		state.set(id, "gray");
@@ -657,12 +691,7 @@ function topoSort(entries) {
 			}
 			if (!byId.has(dep)) continue;
 			if (state.get(dep) === "gray") {
-				const cycleStart = stack.indexOf(dep);
-				const cycle = cycleStart >= 0 ? stack.slice(cycleStart) : [dep];
-				for (const pid of [...cycle, id]) {
-					const ent = byId.get(pid);
-					if (ent) ent.selfReferential = true;
-				}
+				markBackEdgeCycle(dep, id, stack, byId);
 				continue;
 			}
 			visit(dep, stack);
@@ -675,6 +704,30 @@ function topoSort(entries) {
 	if (out.length !== entries.length) throw new CyclicTypeError(`planTypes: unable to topologically sort ${entries.length} entries (got ${out.length}).`);
 	return out;
 }
+/** Mark the participants of a cycle discovered on a gray node and allow the
+*  traversal to continue — the emitter will insert a TYPE REF TO indirection
+*  for the back edge. */
+function markCycleParticipants(id, stack, byId, entry) {
+	const cycleStart = stack.indexOf(id);
+	const cycle = cycleStart >= 0 ? stack.slice(cycleStart) : [id];
+	if (cycle.length === 1) {
+		entry.selfReferential = true;
+		return;
+	}
+	for (const pid of cycle) {
+		const ent = byId.get(pid);
+		if (ent) ent.selfReferential = true;
+	}
+}
+/** Mark participants of a back-edge cycle (dep already on the gray stack). */
+function markBackEdgeCycle(dep, id, stack, byId) {
+	const cycleStart = stack.indexOf(dep);
+	const cycle = cycleStart >= 0 ? stack.slice(cycleStart) : [dep];
+	for (const pid of [...cycle, id]) {
+		const ent = byId.get(pid);
+		if (ent) ent.selfReferential = true;
+	}
+}
 
 // src/types/map.ts
 function isRecord$2(x) {
@@ -719,11 +772,7 @@ function isNullable$1(schema) {
 }
 /** Resolve a schema to an ABAP TypeRef. */
 function mapSchemaToTypeRef(schema, plan, ctx = {}) {
-	if (isRef(schema)) {
-		const entry = refToEntry(schema.$ref, plan);
-		if (!entry) throw new UnsupportedSchemaError(`mapSchemaToTypeRef: unresolved $ref "${schema.$ref}"`);
-		return namedTypeRef({ name: entry.abapName });
-	}
+	if (isRef(schema)) return refTypeRef(schema.$ref, plan);
 	const type = pluckType$2(schema);
 	if (type === "array") {
 		const items = schema.items;
@@ -733,26 +782,33 @@ function mapSchemaToTypeRef(schema, plan, ctx = {}) {
 			tableKind: "standard"
 		});
 	}
-	if (type === "object" || isRecord$2(schema.properties)) {
+	if (type === "object" || isRecord$2(schema.properties)) return objectTypeRef(schema, plan, ctx);
+	if (type === void 0) return untypedTypeRef(schema, plan, ctx);
+	return builtinType({ name: mapPrimitive(schema) });
+}
+function refTypeRef(ref, plan) {
+	const entry = refToEntry(ref, plan);
+	if (!entry) throw new UnsupportedSchemaError(`mapSchemaToTypeRef: unresolved $ref "${ref}"`);
+	return namedTypeRef({ name: entry.abapName });
+}
+function objectTypeRef(schema, plan, ctx) {
+	const matched = findPlannedEntryBySchema$1(schema, plan, ctx.entryId);
+	if (matched) return namedTypeRef({ name: matched.abapName });
+	const fields = buildStructureFields$1(schema, plan, ctx);
+	if (fields.length === 0) return builtinType({ name: "string" });
+	return structureType({ fields });
+}
+function untypedTypeRef(schema, plan, ctx) {
+	for (const c of [
+		"allOf",
+		"oneOf",
+		"anyOf"
+	]) if (Array.isArray(schema[c])) {
 		const matched = findPlannedEntryBySchema$1(schema, plan, ctx.entryId);
 		if (matched) return namedTypeRef({ name: matched.abapName });
-		const fields = buildStructureFields$1(schema, plan, ctx);
-		if (fields.length === 0) return builtinType({ name: "string" });
-		return structureType({ fields });
-	}
-	if (type === void 0) {
-		for (const c of [
-			"allOf",
-			"oneOf",
-			"anyOf"
-		]) if (Array.isArray(schema[c])) {
-			const matched = findPlannedEntryBySchema$1(schema, plan, ctx.entryId);
-			if (matched) return namedTypeRef({ name: matched.abapName });
-			return builtinType({ name: "string" });
-		}
 		return builtinType({ name: "string" });
 	}
-	return builtinType({ name: mapPrimitive(schema) });
+	return builtinType({ name: "string" });
 }
 /** If a schema is identical-by-reference to a planned entry, return it. */
 function findPlannedEntryBySchema$1(schema, plan, excludeId) {
@@ -780,49 +836,59 @@ function buildEnumMembers(values) {
 function buildStructureFields$1(schema, plan, ctx) {
 	const fields = [];
 	const seen = /* @__PURE__ */ new Map();
-	const addField = (name, type, src) => {
-		const sanitized = sanitizeIdent(name, "param");
-		const prev = seen.get(sanitized);
-		if (prev) {
-			if (prev === type || shallowTypeRefEqual(prev, type)) return;
-			throw new CollisionError(`buildStructureFields: duplicate field "${sanitized}" with conflicting types`);
-		}
-		seen.set(sanitized, type);
-		fields.push({
-			name: sanitized,
-			type
-		});
-		if (isNullable$1(src)) {
-			const flagName = sanitizeIdent(`${name}_is_null`, "param");
-			if (!seen.has(flagName)) {
-				const flagType = builtinType({ name: "abap_bool" });
-				seen.set(flagName, flagType);
-				fields.push({
-					name: flagName,
-					type: flagType
-				});
-			}
-		}
-	};
-	const allOf = schema.allOf;
-	if (Array.isArray(allOf)) for (const sub of allOf) {
-		if (!isRecord$2(sub)) continue;
-		const subSchema = sub;
-		const subProps = isRef(subSchema) ? (() => {
-			const entry = refToEntry(subSchema.$ref, plan);
-			if (!entry) return void 0;
-			return entry.schema.properties;
-		})() : subSchema.properties;
-		if (isRecord$2(subProps)) for (const [name, propSchema] of Object.entries(subProps)) {
-			if (!isRecord$2(propSchema)) continue;
-			addField(name, mapSchemaToTypeRef(propSchema, plan, ctx), propSchema);
+	addAllOfFields(schema, plan, ctx, fields, seen);
+	addPropertyFields(schema.properties, plan, ctx, fields, seen);
+	addUnionFields(schema, plan, ctx, fields, seen);
+	addExtraField(schema, plan, fields, seen);
+	return fields;
+}
+function addStructureField(fields, seen, name, type, src) {
+	const sanitized = sanitizeIdent(name, "param");
+	const prev = seen.get(sanitized);
+	if (prev) {
+		if (prev === type || shallowTypeRefEqual(prev, type)) return;
+		throw new CollisionError(`buildStructureFields: duplicate field "${sanitized}" with conflicting types`);
+	}
+	seen.set(sanitized, type);
+	fields.push({
+		name: sanitized,
+		type
+	});
+	if (isNullable$1(src)) {
+		const flagName = sanitizeIdent(`${name}_is_null`, "param");
+		if (!seen.has(flagName)) {
+			const flagType = builtinType({ name: "abap_bool" });
+			seen.set(flagName, flagType);
+			fields.push({
+				name: flagName,
+				type: flagType
+			});
 		}
 	}
-	const props = schema.properties;
-	if (isRecord$2(props)) for (const [name, propSchema] of Object.entries(props)) {
+}
+function addPropertyFields(props, plan, ctx, fields, seen) {
+	if (!isRecord$2(props)) return;
+	for (const [name, propSchema] of Object.entries(props)) {
 		if (!isRecord$2(propSchema)) continue;
-		addField(name, mapSchemaToTypeRef(propSchema, plan, ctx), propSchema);
+		addStructureField(fields, seen, name, mapSchemaToTypeRef(propSchema, plan, ctx), propSchema);
 	}
+}
+function addAllOfFields(schema, plan, ctx, fields, seen) {
+	const allOf = schema.allOf;
+	if (!Array.isArray(allOf)) return;
+	for (const sub of allOf) {
+		if (!isRecord$2(sub)) continue;
+		const subProps = resolvedProperties(sub, plan);
+		if (isRecord$2(subProps)) addPropertyFields(subProps, plan, ctx, fields, seen);
+	}
+}
+function resolvedProperties(subSchema, plan) {
+	if (!isRef(subSchema)) return subSchema.properties;
+	const entry = refToEntry(subSchema.$ref, plan);
+	if (!entry) return void 0;
+	return entry.schema.properties;
+}
+function addUnionFields(schema, plan, ctx, fields, seen) {
 	for (const combinator of ["oneOf", "anyOf"]) {
 		const arr = schema[combinator];
 		if (!Array.isArray(arr)) continue;
@@ -831,8 +897,7 @@ function buildStructureFields$1(schema, plan, ctx) {
 			addFieldRaw(fields, seen, "kind", builtinType({ name: "string" }));
 			arr.forEach((sub, idx) => {
 				if (!isRecord$2(sub)) return;
-				const variantName = variantFieldName(sub, idx);
-				addFieldRaw(fields, seen, variantName, mapSchemaToTypeRef(sub, plan, ctx));
+				addFieldRaw(fields, seen, variantFieldName(sub, idx), mapSchemaToTypeRef(sub, plan, ctx));
 			});
 		} else {
 			addFieldRaw(fields, seen, "variant_kind", builtinType({ name: "string" }));
@@ -844,17 +909,18 @@ function buildStructureFields$1(schema, plan, ctx) {
 			});
 		}
 	}
+}
+function addExtraField(schema, plan, fields, seen) {
 	const ap = schema.additionalProperties;
-	if (ap === true || isRecord$2(ap)) {
-		const kvEntry = plan.byId.get("aux.kv");
-		if (kvEntry) addFieldRaw(fields, seen, "_extra", tableType({
-			rowType: namedTypeRef({ name: kvEntry.abapName }),
-			tableKind: "hashed",
-			uniqueness: "unique",
-			keyFields: ["key"]
-		}));
-	}
-	return fields;
+	if (ap !== true && !isRecord$2(ap)) return;
+	const kvEntry = plan.byId.get("aux.kv");
+	if (!kvEntry) return;
+	addFieldRaw(fields, seen, "_extra", tableType({
+		rowType: namedTypeRef({ name: kvEntry.abapName }),
+		tableKind: "hashed",
+		uniqueness: "unique",
+		keyFields: ["key"]
+	}));
 }
 function addFieldRaw(fields, seen, rawName, type) {
 	const name = sanitizeIdent(rawName, "param");
@@ -959,7 +1025,7 @@ function validateLocal(field, value) {
 function deriveFromBase(base) {
 	const trimmed = base.trim();
 	if (trimmed.length === 0) throw new NamesConfigError("Invalid \"base\" name: value is empty or whitespace.");
-	if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(trimmed)) throw new NamesConfigError(`Invalid "base" name: "${base}" must start with a letter and contain only letters, digits, and underscores.`);
+	if (!/^[A-Za-z]\w*$/.test(trimmed)) throw new NamesConfigError(`Invalid "base" name: "${base}" must start with a letter and contain only letters, digits, and underscores.`);
 	const upper = trimmed.toUpperCase();
 	return {
 		typesInterface: `ZIF_${upper}_TYPES`,
@@ -1037,10 +1103,7 @@ function emitTypesInterface(spec, plan, opts) {
 	for (const entry of plan.entries) {
 		if (entry.source === "auxiliary") continue;
 		const aux = ctx.mapAux.get(entry.id);
-		if (aux) {
-			typeDefs.push(aux.entryTypeDef);
-			typeDefs.push(aux.mapTypeDef);
-		}
+		if (aux) typeDefs.push(aux.entryTypeDef, aux.mapTypeDef);
 		typeDefs.push(buildEntryTypeDef(entry, ctx));
 	}
 	return {
@@ -1080,7 +1143,7 @@ function originalNameFromId(id) {
 }
 /** Normalise a raw name for v2: replace `$` with `_`, then snake_case ≤ 30. */
 function v2Name(raw, allocator) {
-	return allocator(raw.replaceAll(/\$/g, "_"), "type");
+	return allocator(raw.replaceAll("$", "_"), "type");
 }
 function buildContext(spec, plan, opts) {
 	const alloc = makeNameAllocator(/* @__PURE__ */ new Set());
@@ -1153,45 +1216,10 @@ function deriveRawName(entry) {
 function buildEntryTypeDef(entry, ctx) {
 	const name = ctx.nameOf.get(entry.id);
 	const schema = entry.schema;
-	const leadingDoc = [];
-	const original = ctx.originalNameOf.get(entry.id);
-	if (original !== void 0) leadingDoc.push(`@openapi-schema ${original}`);
-	else if (entry.source === "inline") leadingDoc.push(`@openapi-path ${entry.id}`);
-	const description = schema.description;
-	if (typeof description === "string" && description.trim()) for (const line of description.split(/\r?\n/)) leadingDoc.push(`@openapi-description ${line}`);
-	const enumValues = schema.enum;
+	const leadingDoc = buildLeadingDoc(entry, ctx);
+	const enumDef = tryEnumTypeDef(entry, name, leadingDoc);
+	if (enumDef !== void 0) return enumDef;
 	const schemaType = pluckType$1(schema);
-	if (Array.isArray(enumValues) && (schemaType === "string" || schemaType === void 0)) {
-		const members = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const v of enumValues) if (typeof v === "string") {
-			let nm = sanitizeIdent(v, "type");
-			let i = 2;
-			while (seen.has(nm)) nm = `${nm}_${i++}`;
-			seen.add(nm);
-			members.push({
-				name: nm,
-				value: v
-			});
-		} else if (typeof v === "number") {
-			let nm = sanitizeIdent(`v_${v}`, "type");
-			let i = 2;
-			while (seen.has(nm)) nm = `${nm}_${i++}`;
-			seen.add(nm);
-			members.push({
-				name: nm,
-				value: v
-			});
-		}
-		if (members.length > 0) return typeDef({
-			name,
-			type: enumType({
-				baseType: builtinType({ name: "string" }),
-				members
-			}),
-			abapDoc: leadingDoc.length > 0 ? leadingDoc : void 0
-		});
-	}
 	if (schemaType === "array") {
 		const items = schema.items;
 		const rowSchema = isRecord$1(items) ? items : {};
@@ -1222,6 +1250,54 @@ function buildEntryTypeDef(entry, ctx) {
 		abapDoc: finaliseDoc(leadingDoc, ctx.backRefs.get(entry.id) ?? [])
 	});
 }
+function buildLeadingDoc(entry, ctx) {
+	const leadingDoc = [];
+	const original = ctx.originalNameOf.get(entry.id);
+	if (original !== void 0) leadingDoc.push(`@openapi-schema ${original}`);
+	else if (entry.source === "inline") leadingDoc.push(`@openapi-path ${entry.id}`);
+	const description = entry.schema.description;
+	if (typeof description === "string" && description.trim()) for (const line of description.split(/\r?\n/)) leadingDoc.push(`@openapi-description ${line}`);
+	return leadingDoc;
+}
+/** Enum shortcut: string with enum values. Returns undefined when the entry
+*  is not enum-shaped or has no usable members. */
+function tryEnumTypeDef(entry, name, leadingDoc) {
+	const schema = entry.schema;
+	const enumValues = schema.enum;
+	const schemaType = pluckType$1(schema);
+	if (!Array.isArray(enumValues)) return void 0;
+	if (schemaType !== "string" && schemaType !== void 0) return void 0;
+	const members = buildDedupedEnumMembers(enumValues);
+	if (members.length === 0) return void 0;
+	return typeDef({
+		name,
+		type: enumType({
+			baseType: builtinType({ name: "string" }),
+			members
+		}),
+		abapDoc: leadingDoc.length > 0 ? leadingDoc : void 0
+	});
+}
+function buildDedupedEnumMembers(enumValues) {
+	const members = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const v of enumValues) if (typeof v === "string") members.push({
+		name: uniqueEnumName(sanitizeIdent(v, "type"), seen),
+		value: v
+	});
+	else if (typeof v === "number") members.push({
+		name: uniqueEnumName(sanitizeIdent(`v_${v}`, "type"), seen),
+		value: v
+	});
+	return members;
+}
+function uniqueEnumName(base, seen) {
+	let nm = base;
+	let i = 2;
+	while (seen.has(nm)) nm = `${nm}_${i++}`;
+	seen.add(nm);
+	return nm;
+}
 function finaliseDoc(base, backRefs) {
 	const out = [...base];
 	for (const br of backRefs) out.push(br);
@@ -1233,7 +1309,7 @@ function buildStructureFields(entry, ctx) {
 	const seen = /* @__PURE__ */ new Map();
 	const addField = (rawName, rawType, src) => {
 		const type = asFieldTypeRef(rawType);
-		const fieldName = sanitizeIdent(rawName.replaceAll(/\$/g, "_"), "param");
+		const fieldName = sanitizeIdent(rawName.replaceAll("$", "_"), "param");
 		const prev = seen.get(fieldName);
 		if (prev !== void 0) {
 			if (!typeRefEqual(prev, type)) throw new PolymorphismConflictError(`buildStructureFields: conflicting types for field "${fieldName}" in "${entry.id}"`);
@@ -1264,26 +1340,9 @@ function buildStructureFields(entry, ctx) {
 			addField(propName, ref, propSchema);
 		}
 	};
-	const allOf = schema.allOf;
-	if (Array.isArray(allOf)) for (const sub of allOf) {
-		if (!isRecord$1(sub)) continue;
-		if (isRef(sub)) {
-			const refEntry = resolveRefEntry(sub.$ref, ctx);
-			if (refEntry !== void 0) mergeProperties(refEntry.schema);
-		} else mergeProperties(sub);
-	}
+	mergeVariantList(schema.allOf, ctx, mergeProperties);
 	mergeProperties(schema);
-	for (const combinator of ["oneOf", "anyOf"]) {
-		const arr = schema[combinator];
-		if (!Array.isArray(arr)) continue;
-		for (const sub of arr) {
-			if (!isRecord$1(sub)) continue;
-			if (isRef(sub)) {
-				const refEntry = resolveRefEntry(sub.$ref, ctx);
-				if (refEntry !== void 0) mergeProperties(refEntry.schema);
-			} else mergeProperties(sub);
-		}
-	}
+	for (const combinator of ["oneOf", "anyOf"]) mergeVariantList(schema[combinator], ctx, mergeProperties);
 	const aux = ctx.mapAux.get(entry.id);
 	if (aux) {
 		const fieldName = sanitizeIdent("entries", "param");
@@ -1298,6 +1357,17 @@ function buildStructureFields(entry, ctx) {
 	}
 	return fields;
 }
+function mergeVariantList(variants, ctx, merge) {
+	if (!Array.isArray(variants)) return;
+	for (const sub of variants) mergeVariantProperties(sub, ctx, merge);
+}
+function mergeVariantProperties(sub, ctx, merge) {
+	if (!isRecord$1(sub)) return;
+	if (isRef(sub)) {
+		const refEntry = resolveRefEntry(sub.$ref, ctx);
+		if (refEntry !== void 0) merge(refEntry.schema);
+	} else merge(sub);
+}
 function resolveRefEntry(ref, ctx) {
 	const name = componentNameFromRef$1(ref);
 	if (!name) return void 0;
@@ -1326,23 +1396,7 @@ function asFieldTypeRef(t) {
 	return namedTypeRef({ name: `STANDARD TABLE OF ${rowExpr} WITH EMPTY KEY` });
 }
 function resolveTypeRef(schema, ownerEntryId, ctx, fieldName) {
-	if (isRef(schema)) {
-		const target = resolveRefEntry(schema.$ref, ctx);
-		if (target === void 0) return builtinType({ name: "string" });
-		const ownerPos = ctx.positionOf.get(ownerEntryId) ?? -1;
-		const targetPos = ctx.positionOf.get(target.id) ?? -1;
-		const isBackEdge = targetPos >= 0 && ownerPos >= 0 && targetPos >= ownerPos;
-		if (target.id === ownerEntryId || isBackEdge) {
-			const targetOriginal = ctx.originalNameOf.get(target.id) ?? ctx.nameOf.get(target.id) ?? target.id;
-			const backRefs = ctx.backRefs.get(ownerEntryId);
-			if (backRefs !== void 0) {
-				const label = fieldName ? `${fieldName}:${targetOriginal}` : targetOriginal;
-				backRefs.push(`@openapi-ref ${label}`);
-			}
-			return namedTypeRef({ name: "REF TO data" });
-		}
-		return namedTypeRef({ name: ctx.nameOf.get(target.id) ?? target.abapName });
-	}
+	if (isRef(schema)) return resolveNamedTypeRef(schema, ownerEntryId, ctx, fieldName);
 	const type = pluckType$1(schema);
 	if (type === "array") {
 		const items = schema.items;
@@ -1353,31 +1407,45 @@ function resolveTypeRef(schema, ownerEntryId, ctx, fieldName) {
 		});
 	}
 	const props = schema.properties;
-	if (type === "object" || isRecord$1(props)) {
-		const matched = findPlannedEntryBySchema(schema, ctx.plan, ownerEntryId);
-		if (matched !== void 0) {
-			const name = ctx.nameOf.get(matched.id);
-			if (name !== void 0) return namedTypeRef({ name });
-		}
-		return builtinType({ name: "string" });
-	}
-	if (type === void 0) {
-		for (const c of [
-			"allOf",
-			"oneOf",
-			"anyOf"
-		]) if (Array.isArray(schema[c])) {
-			const matched = findPlannedEntryBySchema(schema, ctx.plan, ownerEntryId);
-			if (matched !== void 0) {
-				const name = ctx.nameOf.get(matched.id);
-				if (name !== void 0) return namedTypeRef({ name });
-			}
-			return builtinType({ name: "string" });
-		}
-		return builtinType({ name: "string" });
-	}
+	if (type === "object" || isRecord$1(props)) return plannedEntryRef(schema, ctx, ownerEntryId) ?? builtinType({ name: "string" });
+	if (type === void 0) return resolveUntypedTypeRef(schema, ctx, ownerEntryId);
 	return builtinType({ name: mapPrimitiveLocal(schema) });
 }
+function resolveNamedTypeRef(schema, ownerEntryId, ctx, fieldName) {
+	const target = resolveRefEntry(schema.$ref, ctx);
+	if (target === void 0) return builtinType({ name: "string" });
+	const ownerPos = ctx.positionOf.get(ownerEntryId) ?? -1;
+	const targetPos = ctx.positionOf.get(target.id) ?? -1;
+	const isBackEdge = targetPos >= 0 && ownerPos >= 0 && targetPos >= ownerPos;
+	if (target.id === ownerEntryId || isBackEdge) return buildBackEdgeRef(target, ownerEntryId, ctx, fieldName);
+	return namedTypeRef({ name: ctx.nameOf.get(target.id) ?? target.abapName });
+}
+function buildBackEdgeRef(target, ownerEntryId, ctx, fieldName) {
+	const targetOriginal = ctx.originalNameOf.get(target.id) ?? ctx.nameOf.get(target.id) ?? target.id;
+	const backRefs = ctx.backRefs.get(ownerEntryId);
+	if (backRefs !== void 0) {
+		const label = fieldName ? `${fieldName}:${targetOriginal}` : targetOriginal;
+		backRefs.push(`@openapi-ref ${label}`);
+	}
+	return namedTypeRef({ name: "REF TO data" });
+}
+/** Name ref for a schema object that has a planned entry; undefined when no
+*  planned entry (or no emitted name) exists. */
+function plannedEntryRef(schema, ctx, ownerEntryId) {
+	const matched = findPlannedEntryBySchema(schema, ctx.plan, ownerEntryId);
+	if (matched === void 0) return void 0;
+	const name = ctx.nameOf.get(matched.id);
+	if (name === void 0) return void 0;
+	return namedTypeRef({ name });
+}
+function resolveUntypedTypeRef(schema, ctx, ownerEntryId) {
+	for (const c of [
+		"allOf",
+		"oneOf",
+		"anyOf"
+	]) if (Array.isArray(schema[c])) return plannedEntryRef(schema, ctx, ownerEntryId) ?? builtinType({ name: "string" });
+	return builtinType({ name: "string" });
+}
 function findPlannedEntryBySchema(schema, plan, excludeId) {
 	for (const entry of plan.entries) {
 		if (entry.id === excludeId) continue;
@@ -1622,8 +1690,7 @@ function orderParams(params) {
 }
 function buildMethodAbapDoc(op, cookieSkipped) {
 	const lines = [];
-	lines.push(`@openapi-operation ${op.operationId}`);
-	lines.push(`@openapi-path ${op.method.toUpperCase()} ${op.path}`);
+	lines.push(`@openapi-operation ${op.operationId}`, `@openapi-path ${op.method.toUpperCase()} ${op.path}`);
 	if (op.summary) {
 		for (const l of op.summary.split(/\r?\n/)) if (l.trim().length > 0) lines.push(l.trim());
 	}
@@ -1639,81 +1706,95 @@ function emitOperationsInterface(spec, _plan, opts) {
 	const tableAliases = createTableAliasRegistry();
 	const opsInterfaceName = opts.name;
 	for (const op of spec.operations) {
-		const methodName = allocMethod(op.operationId, "method");
-		const { emitted, cookieSkipped } = orderParams(op.parameters);
-		const allocParam = makeNameAllocator(/* @__PURE__ */ new Set());
-		const abapParams = [];
-		const paramMappings = [];
-		for (const p of emitted) {
-			const abapName = allocParam(p.name, "param");
-			const ref = schemaToTypeRef(p.schema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
-			abapParams.push(methodParam({
-				paramKind: "importing",
-				name: abapName,
-				typeRef: ref,
-				optional: !p.required
-			}));
-			paramMappings.push({
-				name: abapName,
-				openapiName: p.name,
-				location: p.in,
-				required: p.required,
-				typeRefSource: renderTypeRefSource(ref),
-				isTable: pluckType(p.schema) === "array"
-			});
-		}
-		const bodySchema = pickRequestBodySchema$1(op);
-		const hasBody = bodySchema !== void 0;
-		if (hasBody) {
-			const bodyName = allocParam("body", "param");
-			const ref = schemaToTypeRef(bodySchema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
-			abapParams.push(methodParam({
-				paramKind: "importing",
-				name: bodyName,
-				typeRef: ref,
-				optional: op.requestBody?.required === false ? true : false
-			}));
-		}
-		const success = pickSuccess(op);
-		let successStatus;
-		let successIsEmptyBody;
-		let returningName;
-		let returningRef;
-		if (!success) {
-			successStatus = 200;
-			successIsEmptyBody = true;
-			returningName = allocParam("success", "param");
-			returningRef = builtinType({ name: "abap_bool" });
-		} else if (success.schema === void 0) {
-			successStatus = success.status;
-			successIsEmptyBody = true;
-			returningName = allocParam("success", "param");
-			returningRef = builtinType({ name: "abap_bool" });
-		} else {
-			successStatus = success.status;
-			successIsEmptyBody = false;
-			returningName = allocParam(deriveReturningName(success.schema, compIndex), "param");
-			returningRef = schemaToTypeRef(success.schema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
-		}
+		const { method, mapping } = buildOperationMethod(op, allocMethod(op.operationId, "method"), compIndex, opts, opsInterfaceName, tableAliases);
+		methods.push(method);
+		mappings.push(mapping);
+	}
+	const aliasTypeDefs = buildAliasTypeDefs(tableAliases);
+	return {
+		interface: interfaceDef({
+			name: opts.name.toLowerCase(),
+			members: [...aliasTypeDefs, ...methods],
+			abapDoc: opts.interfaceAbapDoc
+		}),
+		operations: mappings
+	};
+}
+function buildOperationMethod(op, methodName, compIndex, opts, opsInterfaceName, tableAliases) {
+	const { emitted, cookieSkipped } = orderParams(op.parameters);
+	const allocParam = makeNameAllocator(/* @__PURE__ */ new Set());
+	const abapParams = [];
+	const paramMappings = [];
+	for (const p of emitted) {
+		const abapName = allocParam(p.name, "param");
+		const ref = schemaToTypeRef(p.schema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
 		abapParams.push(methodParam({
-			paramKind: "returning",
-			name: returningName,
-			typeRef: returningRef
+			paramKind: "importing",
+			name: abapName,
+			typeRef: ref,
+			optional: !p.required
 		}));
-		const errorResponses = {};
-		for (const r of op.responses) {
-			if (!r.isError) continue;
-			errorResponses[r.statusCode] = r.description ? { description: r.description } : {};
-		}
-		const method = methodDef({
+		paramMappings.push({
+			name: abapName,
+			openapiName: p.name,
+			location: p.in,
+			required: p.required,
+			typeRefSource: renderTypeRefSource(ref),
+			isTable: pluckType(p.schema) === "array"
+		});
+	}
+	const bodySchema = pickRequestBodySchema$1(op);
+	const hasBody = bodySchema !== void 0;
+	if (hasBody) {
+		const bodyName = allocParam("body", "param");
+		const ref = schemaToTypeRef(bodySchema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
+		abapParams.push(methodParam({
+			paramKind: "importing",
+			name: bodyName,
+			typeRef: ref,
+			optional: op.requestBody?.required === false
+		}));
+	}
+	const success = pickSuccess(op);
+	let successStatus;
+	let successIsEmptyBody;
+	let returningName;
+	let returningRef;
+	if (!success) {
+		successStatus = 200;
+		successIsEmptyBody = true;
+		returningName = allocParam("success", "param");
+		returningRef = builtinType({ name: "abap_bool" });
+	} else if (success.schema === void 0) {
+		successStatus = success.status;
+		successIsEmptyBody = true;
+		returningName = allocParam("success", "param");
+		returningRef = builtinType({ name: "abap_bool" });
+	} else {
+		successStatus = success.status;
+		successIsEmptyBody = false;
+		returningName = allocParam(deriveReturningName(success.schema, compIndex), "param");
+		returningRef = schemaToTypeRef(success.schema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
+	}
+	abapParams.push(methodParam({
+		paramKind: "returning",
+		name: returningName,
+		typeRef: returningRef
+	}));
+	const errorResponses = {};
+	for (const r of op.responses) {
+		if (!r.isError) continue;
+		errorResponses[r.statusCode] = r.description ? { description: r.description } : {};
+	}
+	return {
+		method: methodDef({
 			name: methodName,
 			visibility: "public",
 			params: abapParams,
 			raising: [namedTypeRef({ name: opts.exceptionClassName.toLowerCase() })],
 			abapDoc: buildMethodAbapDoc(op, cookieSkipped)
-		});
-		methods.push(method);
-		mappings.push({
+		}),
+		mapping: {
 			operationId: op.operationId,
 			methodName,
 			method: op.method.toUpperCase(),
@@ -1724,16 +1805,7 @@ function emitOperationsInterface(spec, _plan, opts) {
 			successIsEmptyBody,
 			errorResponses,
 			returningName
-		});
-	}
-	const aliasTypeDefs = buildAliasTypeDefs(tableAliases);
-	return {
-		interface: interfaceDef({
-			name: opts.name.toLowerCase(),
-			members: [...aliasTypeDefs, ...methods],
-			abapDoc: opts.interfaceAbapDoc
-		}),
-		operations: mappings
+		}
 	};
 }
 function renderTypeRefSource(ref) {
@@ -1873,7 +1945,6 @@ function emitExceptionClass(opts) {
 // src/emit/templates/locals-def.abap.ts
 function buildLocalsDef(names) {
 	const { localJsonClass: JSON_CLS, localJsonParserClass: JSON_PARSER, localResponseClass: RESPONSE, localHttpClass: HTTP } = names;
-	names.exceptionClass;
 	return `* Generated by @abapify/openai-codegen - local class declarations.
 * ZERO Z-dependencies: these locals wrap SAP kernel APIs only.
 * Per-operation methods map HTTP status codes to the custom exception.
@@ -2240,9 +2311,7 @@ function renderSuccessBody(opts) {
 function renderErrorBranch(statusCode, description, opts) {
 	const responseVar = opts.responseVarName ?? "response";
 	const lines = [];
-	lines.push(`  WHEN ${statusCode}.`);
-	lines.push(`    RAISE EXCEPTION NEW ${opts.exceptionClassName}(`);
-	lines.push(`      status      = ${statusCode}`);
+	lines.push(`  WHEN ${statusCode}.`, `    RAISE EXCEPTION NEW ${opts.exceptionClassName}(`, `      status      = ${statusCode}`);
 	if (description !== void 0 && description.length > 0) lines.push(`      description = '${escapeAbapLiteral(description)}'`);
 	lines.push(`      body        = ${responseVar}->body( ) ).`);
 	return lines;
@@ -2250,9 +2319,7 @@ function renderErrorBranch(statusCode, description, opts) {
 function renderOthersBranch(description, opts) {
 	const responseVar = opts.responseVarName ?? "response";
 	const lines = [];
-	lines.push(`  WHEN OTHERS.`);
-	lines.push(`    RAISE EXCEPTION NEW ${opts.exceptionClassName}(`);
-	lines.push(`      status      = ${responseVar}->status( )`);
+	lines.push(`  WHEN OTHERS.`, `    RAISE EXCEPTION NEW ${opts.exceptionClassName}(`, `      status      = ${responseVar}->status( )`);
 	if (description !== void 0 && description.length > 0) lines.push(`      description = '${escapeAbapLiteral(description)}'`);
 	lines.push(`      body        = ${responseVar}->body( ) ).`);
 	return lines;
@@ -2262,23 +2329,18 @@ function mapResponseHandling(operation, opts) {
 	const lines = [];
 	lines.push(`CASE ${responseVar}->status( ).`);
 	const success = pickSuccessStatus(operation.responses);
-	const successConsumedOthers = success !== void 0 && success.whenLabel === "OTHERS";
-	if (success !== void 0 && !successConsumedOthers) {
-		lines.push(`  WHEN ${success.whenLabel}.`);
-		lines.push(`    ${renderSuccessBody(opts)}`);
-	}
+	const successConsumedOthers = success?.whenLabel === "OTHERS";
+	if (success !== void 0 && !successConsumedOthers) lines.push(`  WHEN ${success.whenLabel}.`, `    ${renderSuccessBody(opts)}`);
 	for (const resp of operation.responses) {
 		if (!resp.isError) continue;
 		if (resp.statusCode === "default") continue;
 		if (!/^\d+$/.test(resp.statusCode)) continue;
 		lines.push(...renderErrorBranch(resp.statusCode, resp.description, opts));
 	}
-	if (successConsumedOthers) {
-		lines.push(`  WHEN OTHERS.`);
-		lines.push(`    ${renderSuccessBody(opts)}`);
-	} else {
+	if (successConsumedOthers) lines.push(`  WHEN OTHERS.`, `    ${renderSuccessBody(opts)}`);
+	else {
 		const defaultResp = operation.responses.find((r) => r.statusCode === "default");
-		const description = defaultResp !== void 0 && defaultResp.isError ? defaultResp.description : void 0;
+		const description = defaultResp?.isError ? defaultResp.description : void 0;
 		lines.push(...renderOthersBranch(description, opts));
 	}
 	lines.push(`ENDCASE.`);
@@ -2353,7 +2415,7 @@ function buildClasXml(className, description, language) {
 `;
 }
 function escapeXml(value) {
-	return value.replaceAll(/&/g, "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
 }
 async function writeAbapgitLayout(artifact, outDir) {
 	assertValidClassName(artifact.className);
@@ -2575,15 +2637,13 @@ function writeLayout(artifact, format, outDir) {
 }
 async function writeClientBundle(artifacts, format, outDir) {
 	const all = /* @__PURE__ */ new Set();
-	for (const artifact of [
+	const layouts = await Promise.all([
 		artifacts.types,
 		artifacts.operations,
 		artifacts.exception,
 		artifacts.implementation
-	]) {
-		const r = await writeLayout(artifact, format, outDir);
-		for (const f of r.files) all.add(f);
-	}
+	].map((artifact) => writeLayout(artifact, format, outDir)));
+	for (const r of layouts) for (const f of r.files) all.add(f);
 	return { files: [...all].sort((a, b) => a.localeCompare(b)) };
 }
 
@@ -2693,8 +2753,7 @@ function renderFetchCall(mapping, bodyIsBinary, jsonLocalClass) {
 	args.push({
 		key: "method",
 		value: `'${mapping.method}'`
-	});
-	args.push({
+	}, {
 		key: "path",
 		value: renderPathValue(mapping)
 	});
@@ -2934,4 +2993,4 @@ async function generate(options) {
 }
 
 export { makeNameAllocator as C, isRef as D, normalizeSpec as E, UnsupportedSchemaError as S, loadSpec as T, mapSchemaToTypeDef as _, writeGctsLayout as a, CollisionError as b, mapResponseHandling as c, emitOperationsInterface as d, PolymorphismConflictError as f, mapPrimitive as g, resolveNames as h, writeGctsInterface as i, emitLocalClasses as l, NamesConfigError as m, writeClientBundle as n, writeAbapgitInterface as o, emitTypesInterface as p, writeLayout as r, writeAbapgitLayout as s, generate as t, emitExceptionClass as u, mapSchemaToTypeRef as v, sanitizeIdent as w, CyclicTypeError as x, planTypes as y };
-//# sourceMappingURL=generate-DgXsowgP.mjs.map
+//# sourceMappingURL=generate-BevNTSFF.mjs.map