@hey-api/shared 0.1.2 → 0.2.1

package/dist/index.mjs

@@ -5,6 +5,7 @@ import ts from "typescript";
 import { sync } from "cross-spawn";
 import * as semver from "semver";
 import { getResolvedInput, sendRequest } from "@hey-api/json-schema-ref-parser";
+import { fromRef, ref } from "@hey-api/codegen-core";
 import { EOL } from "node:os";
 
 //#region src/tsConfig.ts
@@ -709,7 +710,8 @@ function getParser(userConfig) {
 						case: "preserve",
 						name: "{{name}}"
 					}
-				}
+				},
+				schemaName: void 0
 			},
 			validate_EXPERIMENTAL: false
 		},
@@ -763,7 +765,8 @@ function getParser(userConfig) {
 							})
 						},
 						value: fields$1.readWrite
-					})
+					}),
+					schemaName: fields$1.schemaName !== void 0 ? fields$1.schemaName : defaultValue$1.schemaName
 				}) },
 				value: fields.transforms
 			}),
@@ -1384,9 +1387,10 @@ async function getSpec({ fetchOptions, inputPath, timeout, watch }) {
 				};
 				response = request.response;
 			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
 				return {
 					error: "not-ok",
-					response: new Response(error instanceof Error ? error.message : String(error))
+					response: new Response(message, { status: 500 })
 				};
 			}
 			if (!response.ok && watch.isHeadMethodSupported) return {
@@ -1432,9 +1436,10 @@ async function getSpec({ fetchOptions, inputPath, timeout, watch }) {
 			};
 			response = request.response;
 		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
 			return {
 				error: "not-ok",
-				response: new Response(error instanceof Error ? error.message : String(error))
+				response: new Response(message, { status: 500 })
 			};
 		}
 		if (!response.ok) return {
@@ -1782,7 +1787,7 @@ function pathToJsonPointer(path$1) {
 	return "#" + (segments ? `/${segments}` : "");
 }
 /**
-* Checks if a $ref points to a top-level component (not a deep path reference).
+* Checks if a $ref or path points to a top-level component (not a deep path reference).
 *
 * Top-level component references:
 * - OpenAPI 3.x: #/components/{type}/{name} (3 segments)
@@ -1791,11 +1796,11 @@ function pathToJsonPointer(path$1) {
 * Deep path references (4+ segments for 3.x, 3+ for 2.0) should be inlined
 * because they don't have corresponding registered symbols.
 *
-* @param $ref - The $ref string to check
+* @param refOrPath - The $ref string or path array to check
 * @returns true if the ref points to a top-level component, false otherwise
 */
-function isTopLevelComponentRef($ref) {
-	const path$1 = jsonPointerToPath($ref);
+function isTopLevelComponent(refOrPath) {
+	const path$1 = refOrPath instanceof Array ? refOrPath : jsonPointerToPath(refOrPath);
 	if (path$1[0] === "components") return path$1.length === 3;
 	if (path$1[0] === "definitions") return path$1.length === 2;
 	return false;
@@ -2272,6 +2277,112 @@ var IntentContext = class {
 	}
 };
 
+//#endregion
+//#region src/ir/schema-processor.ts
+function createSchemaProcessor() {
+	const emitted = /* @__PURE__ */ new Set();
+	let contextTags;
+	let contextAnchor;
+	return {
+		get context() {
+			return {
+				anchor: contextAnchor,
+				tags: contextTags
+			};
+		},
+		hasEmitted(path$1) {
+			return emitted.has(pathToJsonPointer(path$1));
+		},
+		markEmitted(path$1) {
+			const pointer = pathToJsonPointer(path$1);
+			if (emitted.has(pointer)) return false;
+			emitted.add(pointer);
+			return true;
+		},
+		withContext(ctx, fn) {
+			const prevTags = contextTags;
+			const prevAnchor = contextAnchor;
+			contextTags = ctx.tags;
+			contextAnchor = ctx.anchor;
+			try {
+				return fn();
+			} finally {
+				contextTags = prevTags;
+				contextAnchor = prevAnchor;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/ir/schema-walker.ts
+/**
+* Create a schema walker from a visitor.
+*
+* The walker handles:
+* - Dispatch order ($ref → type → items → fallback)
+* - Deduplication of union/intersection schemas
+* - Path tracking for child schemas
+*/
+function createSchemaWalker(visitor) {
+	const walk$1 = (schema, ctx) => {
+		if (visitor.intercept) {
+			const intercepted = visitor.intercept(schema, ctx, walk$1);
+			if (intercepted !== void 0) return intercepted;
+		}
+		if (schema.$ref) return visitor.reference(schema.$ref, schema, ctx);
+		if (schema.type) {
+			let result = visitTyped(schema, ctx, visitor, walk$1);
+			if (visitor.postProcess) result = visitor.postProcess(result, schema, ctx);
+			return result;
+		}
+		if (schema.items) {
+			const deduplicated = deduplicateSchema({ schema });
+			if (!deduplicated.items) return walk$1(deduplicated, ctx);
+			const itemResults = deduplicated.items.map((item, index) => walk$1(item, {
+				...ctx,
+				path: ref([
+					...fromRef(ctx.path),
+					"items",
+					index
+				])
+			}));
+			return deduplicated.logicalOperator === "and" ? visitor.intersection(itemResults, deduplicated.items, schema, ctx) : visitor.union(itemResults, deduplicated.items, schema, ctx);
+		}
+		return visitor.unknown({ type: "unknown" }, ctx);
+	};
+	return walk$1;
+}
+/**
+* Dispatch to the appropriate visitor method based on schema type.
+*/
+function visitTyped(schema, ctx, visitor, walk$1) {
+	switch (schema.type) {
+		case "array": return visitor.array(schema, ctx, walk$1);
+		case "boolean": return visitor.boolean(schema, ctx);
+		case "enum": return visitor.enum(schema, ctx, walk$1);
+		case "integer": return visitor.integer(schema, ctx);
+		case "never": return visitor.never(schema, ctx);
+		case "null": return visitor.null(schema, ctx);
+		case "number": return visitor.number(schema, ctx);
+		case "object": return visitor.object(schema, ctx, walk$1);
+		case "string": return visitor.string(schema, ctx);
+		case "tuple": return visitor.tuple(schema, ctx, walk$1);
+		case "undefined": return visitor.undefined(schema, ctx);
+		case "unknown": return visitor.unknown(schema, ctx);
+		case "void": return visitor.void(schema, ctx);
+	}
+}
+/**
+* Helper to create a child context with an extended path.
+*/
+function childContext(ctx, ...segments) {
+	return {
+		...ctx,
+		path: ref([...fromRef(ctx.path), ...segments])
+	};
+}
+
 //#endregion
 //#region src/openApi/shared/utils/filter.ts
 const namespaceNeedle = "/";
@@ -2841,7 +2952,8 @@ const childSchemaRelationships = [
 	["patternProperties", "objectMap"],
 	["properties", "objectMap"],
 	["propertyNames", "single"],
-	["then", "single"]
+	["then", "single"],
+	["unevaluatedProperties", "single"]
 ];
 
 //#endregion
@@ -3444,7 +3556,8 @@ const schemaKeys = new Set([
 	"oneOf",
 	"patternProperties",
 	"properties",
-	"schema"
+	"schema",
+	"unevaluatedProperties"
 ]);
 const getComponentContext = (path$1) => {
 	if (path$1.length === 3 && path$1[0] === "components") {
@@ -3961,11 +4074,56 @@ const readWriteTransform = ({ config, logger, spec }) => {
 	});
 };
 
+//#endregion
+//#region src/openApi/shared/transforms/schemas.ts
+/**
+* Recursively walks the entire spec object and replaces all $ref strings
+* according to the provided rename mapping.
+*/
+const rewriteRefs = (node, renameMap) => {
+	if (node instanceof Array) node.forEach((item) => rewriteRefs(item, renameMap));
+	else if (node && typeof node === "object") for (const [key, value] of Object.entries(node)) if (key === "$ref" && typeof value === "string" && value in renameMap) node[key] = renameMap[value];
+	else rewriteRefs(value, renameMap);
+};
+/**
+* Renames schema component keys and updates all $ref pointers throughout
+* the spec. Handles collisions by skipping renames when the target name
+* already exists or conflicts with another rename.
+*/
+const schemaNameTransform = ({ config, spec }) => {
+	if (!config) return;
+	const schemasObj = getSchemasObject(spec);
+	if (!schemasObj) return;
+	const schemasPointerNamespace = specToSchemasPointerNamespace(spec);
+	if (!schemasPointerNamespace) return;
+	const renameMap = {};
+	const newNames = /* @__PURE__ */ new Set();
+	const namingConfig = { name: config };
+	for (const oldName of Object.keys(schemasObj)) {
+		const newName = applyNaming(oldName, namingConfig);
+		if (newName === oldName || newName in schemasObj || newNames.has(newName)) continue;
+		renameMap[`${schemasPointerNamespace}${oldName}`] = `${schemasPointerNamespace}${newName}`;
+		newNames.add(newName);
+	}
+	for (const [oldPointer, newPointer] of Object.entries(renameMap)) {
+		const oldName = oldPointer.slice(schemasPointerNamespace.length);
+		const newName = newPointer.slice(schemasPointerNamespace.length);
+		const schema = schemasObj[oldName];
+		delete schemasObj[oldName];
+		schemasObj[newName] = schema;
+	}
+	if (Object.keys(renameMap).length > 0) rewriteRefs(spec, renameMap);
+};
+
 //#endregion
 //#region src/openApi/shared/transforms/index.ts
 const transformOpenApiSpec = ({ context }) => {
 	const { logger } = context;
 	const eventTransformOpenApiSpec = logger.timeEvent("transform-openapi-spec");
+	if (context.config.parser.transforms.schemaName) schemaNameTransform({
+		config: context.config.parser.transforms.schemaName,
+		spec: context.spec
+	});
 	if (context.config.parser.transforms.enums.enabled) enumsTransform({
 		config: context.config.parser.transforms.enums,
 		spec: context.spec
@@ -4132,6 +4290,64 @@ function getPaginationKeywordsRegExp(pagination) {
 
 //#endregion
 //#region src/openApi/shared/utils/discriminator.ts
+/**
+* Converts a string discriminator mapping value to the appropriate type based on
+* the actual property type in the schema.
+*
+* OpenAPI discriminator mappings always use string keys, but the actual discriminator
+* property may be a boolean, number, or integer. This function converts the string
+* key to the correct runtime value and IR type.
+*/
+const convertDiscriminatorValue = (value, propertyType) => {
+	switch (propertyType) {
+		case "boolean": {
+			const lowerValue = value.toLowerCase();
+			if (lowerValue !== "true" && lowerValue !== "false") {
+				console.warn("🚨", `non-boolean discriminator mapping value "${value}" for boolean property, falling back to string`);
+				return {
+					const: value,
+					type: "string"
+				};
+			}
+			return {
+				const: lowerValue === "true",
+				type: "boolean"
+			};
+		}
+		case "integer": {
+			const parsed = parseInt(value, 10);
+			if (Number.isNaN(parsed)) {
+				console.warn("🚨", `non-numeric discriminator mapping value "${value}" for integer property, falling back to string`);
+				return {
+					const: value,
+					type: "string"
+				};
+			}
+			return {
+				const: parsed,
+				type: "integer"
+			};
+		}
+		case "number": {
+			const parsed = parseFloat(value);
+			if (Number.isNaN(parsed)) {
+				console.warn("🚨", `non-numeric discriminator mapping value "${value}" for number property, falling back to string`);
+				return {
+					const: value,
+					type: "string"
+				};
+			}
+			return {
+				const: parsed,
+				type: "number"
+			};
+		}
+		default: return {
+			const: value,
+			type: "string"
+		};
+	}
+};
 const discriminatorValues = ($ref, mapping, shouldUseRefAsValue) => {
 	const values = [];
 	for (const name in mapping) if (mapping[name] === $ref) values.push(name);
@@ -4263,20 +4479,20 @@ const parseAllOf$2 = ({ context, schema, state }) => {
 		else irCompositionSchema.required = schema.required;
 		schemaItems.push(irCompositionSchema);
 		if (compositionSchema.$ref) {
-			const ref = context.resolveRef(compositionSchema.$ref);
-			if (ref.discriminator && state.$ref) {
+			const ref$1 = context.resolveRef(compositionSchema.$ref);
+			if (ref$1.discriminator && state.$ref) {
 				const valueSchemas = discriminatorValues(state.$ref).map((value) => ({
 					const: value,
 					type: "string"
 				}));
 				const irDiscriminatorSchema = {
-					properties: { [ref.discriminator]: valueSchemas.length > 1 ? {
+					properties: { [ref$1.discriminator]: valueSchemas.length > 1 ? {
 						items: valueSchemas,
 						logicalOperator: "or"
 					} : valueSchemas[0] },
 					type: "object"
 				};
-				if (ref.required?.includes(ref.discriminator)) irDiscriminatorSchema.required = [ref.discriminator];
+				if (ref$1.required?.includes(ref$1.discriminator)) irDiscriminatorSchema.required = [ref$1.discriminator];
 				schemaItems.push(irDiscriminatorSchema);
 			}
 		}
@@ -4364,7 +4580,7 @@ const parseEnum$2 = ({ context, schema, state }) => {
 };
 const parseRef$2 = ({ context, schema, state }) => {
 	const irSchema = {};
-	if (!isTopLevelComponentRef(schema.$ref)) {
+	if (!isTopLevelComponent(schema.$ref)) {
 		if (!state.circularReferenceTracker.has(schema.$ref)) {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
@@ -4542,19 +4758,19 @@ const isPaginationType$2 = (schemaType) => schemaType === "boolean" || schemaTyp
 const paginationField$2 = ({ context, name, schema }) => {
 	if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) return true;
 	if ("$ref" in schema) {
-		const ref = context.resolveRef(schema.$ref ?? "");
-		if ("in" in ref && ref.in) return paginationField$2({
+		const ref$1 = context.resolveRef(schema.$ref ?? "");
+		if ("in" in ref$1 && ref$1.in) return paginationField$2({
 			context,
 			name,
-			schema: "schema" in ref ? ref.schema : {
-				...ref,
+			schema: "schema" in ref$1 ? ref$1.schema : {
+				...ref$1,
 				in: void 0
 			}
 		});
 		return paginationField$2({
 			context,
 			name,
-			schema: ref
+			schema: ref$1
 		});
 	}
 	if ("in" in schema) {
@@ -5275,6 +5491,29 @@ const getSchemaType = ({ schema }) => {
 	if (schema.properties) return "object";
 };
 /**
+* Finds the type of a discriminator property by looking it up in the provided schemas.
+* Searches through properties and allOf chains to find the property definition.
+*/
+const findDiscriminatorPropertyType$1 = ({ context, propertyName, schemas }) => {
+	for (const schema of schemas) {
+		const resolved = "$ref" in schema ? context.resolveRef(schema.$ref) : schema;
+		const property = resolved.properties?.[propertyName];
+		if (property) {
+			const resolvedProperty = "$ref" in property ? context.resolveRef(property.$ref) : property;
+			if (resolvedProperty.type === "boolean" || resolvedProperty.type === "integer" || resolvedProperty.type === "number") return resolvedProperty.type;
+		}
+		if (resolved.allOf) {
+			const foundType = findDiscriminatorPropertyType$1({
+				context,
+				propertyName,
+				schemas: resolved.allOf
+			});
+			if (foundType !== "string") return foundType;
+		}
+	}
+	return "string";
+};
+/**
 * Recursively finds discriminators in a schema, including nested allOf compositions.
 * This is needed when a schema extends another schema via allOf, and that parent
 * schema is itself an allOf composition with discriminators in inline schemas.
@@ -5427,17 +5666,17 @@ const parseAllOf$1 = ({ context, schema, state }) => {
 		else irCompositionSchema.required = schema.required;
 		schemaItems.push(irCompositionSchema);
 		if ("$ref" in compositionSchema) {
-			const ref = context.resolveRef(compositionSchema.$ref);
+			const ref$1 = context.resolveRef(compositionSchema.$ref);
 			if (state.$ref) {
 				const discriminators = findDiscriminatorsInSchema$1({
 					context,
-					schema: ref
+					schema: ref$1
 				});
 				for (const { discriminator, oneOf } of discriminators) {
 					if (addedDiscriminators.has(discriminator.propertyName)) continue;
 					const values = discriminatorValues(state.$ref, discriminator.mapping, oneOf ? () => oneOf.some((o) => "$ref" in o && o.$ref === state.$ref) : void 0);
 					if (values.length > 0) {
-						const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref.required?.includes(d.discriminator.propertyName) || ref.allOf && ref.allOf.some((item) => {
+						const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref$1.required?.includes(d.discriminator.propertyName) || ref$1.allOf && ref$1.allOf.some((item) => {
 							return ("$ref" in item ? context.resolveRef(item.$ref) : item).required?.includes(d.discriminator.propertyName);
 						})));
 						discriminatorsToAdd.push({
@@ -5456,10 +5695,13 @@ const parseAllOf$1 = ({ context, schema, state }) => {
 			discriminator,
 			schemaRef: state.$ref
 		});
-		const valueSchemas = (allValues.length > 0 ? allValues : values).map((value) => ({
-			const: value,
-			type: "string"
-		}));
+		const finalValues = allValues.length > 0 ? allValues : values;
+		const propertyType = findDiscriminatorPropertyType$1({
+			context,
+			propertyName: discriminator.propertyName,
+			schemas: compositionSchemas
+		});
+		const valueSchemas = finalValues.map((value) => convertDiscriminatorValue(value, propertyType));
 		const discriminatorProperty = valueSchemas.length > 1 ? {
 			items: valueSchemas,
 			logicalOperator: "or"
@@ -5557,6 +5799,11 @@ const parseAnyOf$1 = ({ context, schema, state }) => {
 	const schemaItems = [];
 	const schemaType = getSchemaType({ schema });
 	const compositionSchemas = schema.anyOf;
+	const discriminatorPropertyType = schema.discriminator ? findDiscriminatorPropertyType$1({
+		context,
+		propertyName: schema.discriminator.propertyName,
+		schemas: compositionSchemas
+	}) : void 0;
 	for (const compositionSchema of compositionSchemas) {
 		let irCompositionSchema = schemaToIrSchema$1({
 			context,
@@ -5564,10 +5811,7 @@ const parseAnyOf$1 = ({ context, schema, state }) => {
 			state
 		});
 		if (schema.discriminator && irCompositionSchema.$ref != null) {
-			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => ({
-				const: value,
-				type: "string"
-			}));
+			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => convertDiscriminatorValue(value, discriminatorPropertyType));
 			irCompositionSchema = {
 				items: [{
 					properties: { [schema.discriminator.propertyName]: valueSchemas.length > 1 ? {
@@ -5641,6 +5885,11 @@ const parseOneOf$1 = ({ context, schema, state }) => {
 	let schemaItems = [];
 	const schemaType = getSchemaType({ schema });
 	const compositionSchemas = schema.oneOf;
+	const discriminatorPropertyType = schema.discriminator ? findDiscriminatorPropertyType$1({
+		context,
+		propertyName: schema.discriminator.propertyName,
+		schemas: compositionSchemas
+	}) : void 0;
 	for (const compositionSchema of compositionSchemas) {
 		let irCompositionSchema = schemaToIrSchema$1({
 			context,
@@ -5648,10 +5897,7 @@ const parseOneOf$1 = ({ context, schema, state }) => {
 			state
 		});
 		if (schema.discriminator && irCompositionSchema.$ref != null) {
-			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => ({
-				const: value,
-				type: "string"
-			}));
+			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => convertDiscriminatorValue(value, discriminatorPropertyType));
 			irCompositionSchema = {
 				items: [{
 					properties: { [schema.discriminator.propertyName]: valueSchemas.length > 1 ? {
@@ -5690,7 +5936,7 @@ const parseOneOf$1 = ({ context, schema, state }) => {
 	return irSchema;
 };
 const parseRef$1 = ({ context, schema, state }) => {
-	if (!isTopLevelComponentRef(schema.$ref)) {
+	if (!isTopLevelComponent(schema.$ref)) {
 		if (!state.circularReferenceTracker.has(schema.$ref)) {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
@@ -5878,12 +6124,12 @@ const isPaginationType$1 = (schemaType) => schemaType === "boolean" || schemaTyp
 const paginationField$1 = ({ context, name, schema }) => {
 	if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) return true;
 	if ("$ref" in schema) {
-		const ref = context.resolveRef(schema.$ref);
-		if ("content" in ref || "in" in ref) {
+		const ref$1 = context.resolveRef(schema.$ref);
+		if ("content" in ref$1 || "in" in ref$1) {
 			let refSchema;
-			if ("in" in ref) refSchema = ref.schema;
+			if ("in" in ref$1) refSchema = ref$1.schema;
 			if (!refSchema) {
-				const contents = mediaTypeObjects$1({ content: ref.content });
+				const contents = mediaTypeObjects$1({ content: ref$1.content });
 				const content = contents.find((content$1) => content$1.type === "json") || contents[0];
 				if (content?.schema) refSchema = content.schema;
 			}
@@ -5897,7 +6143,7 @@ const paginationField$1 = ({ context, name, schema }) => {
 		return paginationField$1({
 			context,
 			name,
-			schema: ref
+			schema: ref$1
 		});
 	}
 	for (const name$1 in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name$1)) {
@@ -6572,6 +6818,31 @@ const getSchemaTypes = ({ schema }) => {
 	return [];
 };
 /**
+* Finds the type of a discriminator property by looking it up in the provided schemas.
+* Searches through properties and allOf chains to find the property definition.
+*/
+const findDiscriminatorPropertyType = ({ context, propertyName, schemas }) => {
+	for (const schema of schemas) {
+		const resolved = schema.$ref ? context.resolveRef(schema.$ref) : schema;
+		const property = resolved.properties?.[propertyName];
+		if (property === true) continue;
+		if (property) {
+			const resolvedProperty = property.$ref ? context.resolveRef(property.$ref) : property;
+			const propertyTypes = Array.isArray(resolvedProperty.type) ? resolvedProperty.type : resolvedProperty.type ? [resolvedProperty.type] : [];
+			for (const propType of propertyTypes) if (propType === "boolean" || propType === "integer" || propType === "number") return propType;
+		}
+		if (resolved.allOf) {
+			const foundType = findDiscriminatorPropertyType({
+				context,
+				propertyName,
+				schemas: resolved.allOf
+			});
+			if (foundType !== "string") return foundType;
+		}
+	}
+	return "string";
+};
+/**
 * Recursively finds discriminators in a schema, including nested allOf compositions.
 * This is needed when a schema extends another schema via allOf, and that parent
 * schema is itself an allOf composition with discriminators in inline schemas.
@@ -6629,6 +6900,7 @@ const parseSchemaMeta = ({ irSchema, schema }) => {
 	if (schema.exclusiveMaximum !== void 0) irSchema.exclusiveMaximum = schema.exclusiveMaximum;
 	if (schema.exclusiveMinimum !== void 0) irSchema.exclusiveMinimum = schema.exclusiveMinimum;
 	if (schema.format) irSchema.format = schema.format;
+	else if (schema.contentMediaType && isMediaTypeFileLike({ mediaType: schema.contentMediaType })) irSchema.format = "binary";
 	if (schema.maximum !== void 0) irSchema.maximum = schema.maximum;
 	if (schema.maxItems !== void 0) irSchema.maxItems = schema.maxItems;
 	if (schema.maxLength !== void 0) irSchema.maxLength = schema.maxLength;
@@ -6770,17 +7042,17 @@ const parseAllOf = ({ context, schema, state }) => {
 		else irCompositionSchema.required = schema.required;
 		schemaItems.push(irCompositionSchema);
 		if (compositionSchema.$ref) {
-			const ref = context.resolveRef(compositionSchema.$ref);
+			const ref$1 = context.resolveRef(compositionSchema.$ref);
 			if (state.$ref) {
 				const discriminators = findDiscriminatorsInSchema({
 					context,
-					schema: ref
+					schema: ref$1
 				});
 				for (const { discriminator, oneOf } of discriminators) {
 					if (addedDiscriminators.has(discriminator.propertyName)) continue;
 					const values = discriminatorValues(state.$ref, discriminator.mapping, oneOf ? () => oneOf.some((o) => "$ref" in o && o.$ref === state.$ref) : void 0);
 					if (values.length > 0) {
-						const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref.required?.includes(d.discriminator.propertyName) || ref.allOf && ref.allOf.some((item) => {
+						const isRequired = discriminators.some((d) => d.discriminator.propertyName === discriminator.propertyName && (ref$1.required?.includes(d.discriminator.propertyName) || ref$1.allOf && ref$1.allOf.some((item) => {
 							return (item.$ref ? context.resolveRef(item.$ref) : item).required?.includes(d.discriminator.propertyName);
 						})));
 						discriminatorsToAdd.push({
@@ -6799,10 +7071,13 @@ const parseAllOf = ({ context, schema, state }) => {
 			discriminator,
 			schemaRef: state.$ref
 		});
-		const valueSchemas = (allValues.length > 0 ? allValues : values).map((value) => ({
-			const: value,
-			type: "string"
-		}));
+		const finalValues = allValues.length > 0 ? allValues : values;
+		const propertyType = findDiscriminatorPropertyType({
+			context,
+			propertyName: discriminator.propertyName,
+			schemas: compositionSchemas
+		});
+		const valueSchemas = finalValues.map((value) => convertDiscriminatorValue(value, propertyType));
 		const discriminatorProperty = valueSchemas.length > 1 ? {
 			items: valueSchemas,
 			logicalOperator: "or"
@@ -6902,6 +7177,11 @@ const parseAnyOf = ({ context, schema, state }) => {
 	const schemaItems = [];
 	const schemaTypes = getSchemaTypes({ schema });
 	const compositionSchemas = schema.anyOf;
+	const discriminatorPropertyType = schema.discriminator ? findDiscriminatorPropertyType({
+		context,
+		propertyName: schema.discriminator.propertyName,
+		schemas: compositionSchemas
+	}) : void 0;
 	for (const compositionSchema of compositionSchemas) {
 		let irCompositionSchema = schemaToIrSchema({
 			context,
@@ -6909,10 +7189,7 @@ const parseAnyOf = ({ context, schema, state }) => {
 			state
 		});
 		if (schema.discriminator && irCompositionSchema.$ref != null) {
-			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => ({
-				const: value,
-				type: "string"
-			}));
+			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => convertDiscriminatorValue(value, discriminatorPropertyType));
 			irCompositionSchema = {
 				items: [{
 					properties: { [schema.discriminator.propertyName]: valueSchemas.length > 1 ? {
@@ -6989,6 +7266,11 @@ const parseOneOf = ({ context, schema, state }) => {
 	let schemaItems = [];
 	const schemaTypes = getSchemaTypes({ schema });
 	const compositionSchemas = schema.oneOf;
+	const discriminatorPropertyType = schema.discriminator ? findDiscriminatorPropertyType({
+		context,
+		propertyName: schema.discriminator.propertyName,
+		schemas: compositionSchemas
+	}) : void 0;
 	for (const compositionSchema of compositionSchemas) {
 		let irCompositionSchema = schemaToIrSchema({
 			context,
@@ -6996,10 +7278,7 @@ const parseOneOf = ({ context, schema, state }) => {
 			state
 		});
 		if (schema.discriminator && irCompositionSchema.$ref != null) {
-			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => ({
-				const: value,
-				type: "string"
-			}));
+			const valueSchemas = discriminatorValues(irCompositionSchema.$ref, schema.discriminator.mapping).map((value) => convertDiscriminatorValue(value, discriminatorPropertyType));
 			irCompositionSchema = {
 				items: [{
 					properties: { [schema.discriminator.propertyName]: valueSchemas.length > 1 ? {
@@ -7038,7 +7317,7 @@ const parseOneOf = ({ context, schema, state }) => {
 	return irSchema;
 };
 const parseRef = ({ context, schema, state }) => {
-	if (!isTopLevelComponentRef(schema.$ref)) {
+	if (!isTopLevelComponent(schema.$ref)) {
 		if (!state.circularReferenceTracker.has(schema.$ref)) {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
@@ -7227,6 +7506,14 @@ const schemaToIrSchema = ({ context, schema, state }) => {
 		schema,
 		state
 	});
+	if (schema.contentMediaType && isMediaTypeFileLike({ mediaType: schema.contentMediaType })) return parseType({
+		context,
+		schema: {
+			...schema,
+			type: "string"
+		},
+		state
+	});
 	return parseUnknown({
 		context,
 		schema
@@ -7251,12 +7538,12 @@ const isPaginationType = (schemaTypes) => schemaTypes.includes("boolean") || sch
 const paginationField = ({ context, name, schema }) => {
 	if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name)) return true;
 	if (schema.$ref) {
-		const ref = context.resolveRef(schema.$ref);
-		if ("content" in ref || "in" in ref) {
+		const ref$1 = context.resolveRef(schema.$ref);
+		if ("content" in ref$1 || "in" in ref$1) {
 			let refSchema;
-			if ("in" in ref) refSchema = ref.schema;
+			if ("in" in ref$1) refSchema = ref$1.schema;
 			if (!refSchema) {
-				const contents = mediaTypeObjects({ content: ref.content });
+				const contents = mediaTypeObjects({ content: ref$1.content });
 				const content = contents.find((content$1) => content$1.type === "json") || contents[0];
 				if (content?.schema) refSchema = content.schema;
 			}
@@ -7270,7 +7557,7 @@ const paginationField = ({ context, name, schema }) => {
 		return paginationField({
 			context,
 			name,
-			schema: ref
+			schema: ref$1
 		});
 	}
 	for (const name$1 in schema.properties) if (getPaginationKeywordsRegExp(context.config.parser.pagination).test(name$1)) {
@@ -8080,19 +8367,43 @@ const OperationPath = {
 
 //#endregion
 //#region src/openApi/shared/utils/patch.ts
-function patchOpenApiSpec({ patchOptions, spec: _spec }) {
+async function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 	if (!patchOptions) return;
 	const spec = _spec;
+	if (typeof patchOptions === "function") {
+		await patchOptions(spec);
+		return;
+	}
+	if (patchOptions.input) await patchOptions.input(spec);
 	if ("swagger" in spec) {
 		if (patchOptions.version && spec.swagger) spec.swagger = typeof patchOptions.version === "string" ? patchOptions.version : patchOptions.version(spec.swagger);
 		if (patchOptions.meta && spec.info) patchOptions.meta(spec.info);
-		if (patchOptions.schemas && spec.definitions) for (const key in patchOptions.schemas) {
+		if (patchOptions.schemas && spec.definitions) if (typeof patchOptions.schemas === "function") {
+			for (const [key, schema] of Object.entries(spec.definitions)) if (schema && typeof schema === "object") await patchOptions.schemas(key, schema);
+		} else for (const key in patchOptions.schemas) {
 			const schema = spec.definitions[key];
 			if (!schema || typeof schema !== "object") continue;
 			const patchFn = patchOptions.schemas[key];
-			patchFn(schema);
+			await patchFn(schema);
+		}
+		if (patchOptions.operations && spec.paths) if (typeof patchOptions.operations === "function") for (const [path$1, pathItem] of Object.entries(spec.paths)) {
+			if (!pathItem || typeof pathItem !== "object") continue;
+			for (const method of [
+				"get",
+				"put",
+				"post",
+				"delete",
+				"options",
+				"head",
+				"patch",
+				"trace"
+			]) {
+				const operation = pathItem[method];
+				if (!operation || typeof operation !== "object") continue;
+				await patchOptions.operations(method, path$1, operation);
+			}
 		}
-		if (patchOptions.operations && spec.paths) for (const key in patchOptions.operations) {
+		else for (const key in patchOptions.operations) {
 			const [method, path$1] = key.split(" ");
 			if (!method || !path$1) continue;
 			const pathItem = spec.paths[path$1];
@@ -8100,18 +8411,20 @@ function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 			const operation = pathItem[method.toLocaleLowerCase()] || pathItem[method.toLocaleUpperCase()];
 			if (!operation || typeof operation !== "object") continue;
 			const patchFn = patchOptions.operations[key];
-			patchFn(operation);
+			await patchFn(operation);
 		}
 		return;
 	}
 	if (patchOptions.version && spec.openapi) spec.openapi = typeof patchOptions.version === "string" ? patchOptions.version : patchOptions.version(spec.openapi);
 	if (patchOptions.meta && spec.info) patchOptions.meta(spec.info);
 	if (spec.components) {
-		if (patchOptions.schemas && spec.components.schemas) for (const key in patchOptions.schemas) {
+		if (patchOptions.schemas && spec.components.schemas) if (typeof patchOptions.schemas === "function") {
+			for (const [key, schema] of Object.entries(spec.components.schemas)) if (schema && typeof schema === "object") await patchOptions.schemas(key, schema);
+		} else for (const key in patchOptions.schemas) {
 			const schema = spec.components.schemas[key];
 			if (!schema || typeof schema !== "object") continue;
 			const patchFn = patchOptions.schemas[key];
-			patchFn(schema);
+			await patchFn(schema);
 		}
 		if (patchOptions.parameters && spec.components.parameters) for (const key in patchOptions.parameters) {
 			const schema = spec.components.parameters[key];
@@ -8132,7 +8445,24 @@ function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 			patchFn(schema);
 		}
 	}
-	if (patchOptions.operations && spec.paths) for (const key in patchOptions.operations) {
+	if (patchOptions.operations && spec.paths) if (typeof patchOptions.operations === "function") for (const [path$1, pathItem] of Object.entries(spec.paths)) {
+		if (!pathItem || typeof pathItem !== "object") continue;
+		for (const method of [
+			"get",
+			"put",
+			"post",
+			"delete",
+			"options",
+			"head",
+			"patch",
+			"trace"
+		]) {
+			const operation = pathItem[method];
+			if (!operation || typeof operation !== "object") continue;
+			await patchOptions.operations(method, path$1, operation);
+		}
+	}
+	else for (const key in patchOptions.operations) {
 		const [method, path$1] = key.split(" ");
 		if (!method || !path$1) continue;
 		const pathItem = spec.paths[path$1];
@@ -8140,7 +8470,7 @@ function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 		const operation = pathItem[method.toLocaleLowerCase()] || pathItem[method.toLocaleUpperCase()];
 		if (!operation || typeof operation !== "object") continue;
 		const patchFn = patchOptions.operations[key];
-		patchFn(operation);
+		await patchFn(operation);
 	}
 }
 
@@ -8181,5 +8511,109 @@ const utils = {
 };
 
 //#endregion
-export { ConfigError, ConfigValidationError, Context, HeyApiError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, applyNaming, buildGraph, checkNodeVersion, compileInputPath, createOperationKey, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponentRef, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
+//#region src/utils/path.ts
+/**
+* After these structural segments, the next segment has a known role.
+* This is what makes a property literally named "properties" safe —
+* it occupies the name position, never the structural position.
+*/
+const STRUCTURAL_ROLE = {
+	items: "index",
+	patternProperties: "name",
+	properties: "name"
+};
+/**
+* These structural segments have no following name/index —
+* they are the terminal structural node. Append a suffix
+* to disambiguate from the parent.
+*/
+const STRUCTURAL_SUFFIX = { additionalProperties: "Value" };
+/**
+* Root context configuration.
+*/
+const ROOT_CONTEXT = {
+	components: {
+		names: 1,
+		skip: 2
+	},
+	definitions: {
+		names: 1,
+		skip: 1
+	},
+	paths: {
+		names: 2,
+		skip: 1
+	},
+	webhooks: {
+		names: 2,
+		skip: 1
+	}
+};
+/**
+* Sanitizes a path segment for use in a derived name.
+*
+* Handles API path segments like `/api/v1/users/{id}` → `ApiV1UsersId`.
+*/
+function sanitizeSegment(segment) {
+	const str = String(segment);
+	if (str.startsWith("/")) return str.split("/").filter(Boolean).map((part) => {
+		const clean = part.replace(/[{}]/g, "");
+		return clean.charAt(0).toUpperCase() + clean.slice(1);
+	}).join("");
+	return str;
+}
+/**
+* Derives a composite name from a path.
+*
+* Examples:
+*   .../User                                    → 'User'
+*   .../User/properties/address                 → 'UserAddress'
+*   .../User/properties/properties              → 'UserProperties'
+*   .../User/properties/address/properties/city → 'UserAddressCity'
+*   .../Pet/additionalProperties                → 'PetValue'
+*   .../Order/properties/items/items/0          → 'OrderItems'
+*   paths//event/get/properties/query           → 'EventGetQuery'
+*
+* With anchor:
+*   paths//event/get/properties/query, { anchor: 'event.subscribe' }
+*                                               → 'event.subscribe-Query'
+*/
+function pathToName(path$1, options) {
+	const names = [];
+	let index = 0;
+	const rootContext = ROOT_CONTEXT[path$1[0]];
+	if (rootContext) {
+		index = rootContext.skip;
+		if (options?.anchor) {
+			names.push(options.anchor);
+			index += rootContext.names;
+		} else for (let n = 0; n < rootContext.names && index < path$1.length; n++) {
+			names.push(sanitizeSegment(path$1[index]));
+			index++;
+		}
+	} else if (options?.anchor) {
+		names.push(options.anchor);
+		index++;
+	} else if (index < path$1.length) {
+		names.push(sanitizeSegment(path$1[index]));
+		index++;
+	}
+	while (index < path$1.length) {
+		const segment = String(path$1[index]);
+		const role = STRUCTURAL_ROLE[segment];
+		if (role === "name") {
+			index++;
+			if (index < path$1.length) names.push(sanitizeSegment(path$1[index]));
+		} else if (role === "index") {
+			index++;
+			if (index < path$1.length && typeof path$1[index] === "number") index++;
+			continue;
+		} else if (STRUCTURAL_SUFFIX[segment]) names.push(STRUCTURAL_SUFFIX[segment]);
+		index++;
+	}
+	return decodeURI(names.join("-"));
+}
+
+//#endregion
+export { ConfigError, ConfigValidationError, Context, HeyApiError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, addItemsToSchema, applyNaming, buildGraph, checkNodeVersion, childContext, compileInputPath, createOperationKey, createSchemaProcessor, createSchemaWalker, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponent, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
 //# sourceMappingURL=index.mjs.map