@orval/mock 8.37.0 → 8.38.0

package/dist/index.mjs

@@ -1,6 +1,9 @@
-import { EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camelPathParamName, compareNatural, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getOperationTagKey, getRefInfo, getRequiredKeys, getStringLiteralType, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isSchemaNullable, isString, jsStringLiteralEscape, mergeDeep, pascal, resolveRef, safeNumericConstraint, stringify, toColonRoutePath } from "@orval/core";
-import { prop } from "remeda";
+import { EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camelPathParamName, compareNatural, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getAtPath, getKey, getOperationTagKey, getRefInfo, getRequiredKeys, getStringLiteralType, isBoolean, isFunction, isInlineSchema, isMswMock, isNullOnlyEnum, isNumber, isObject, isSchemaNullable, isString, jsStringLiteralEscape, mergeDeep, pascal, resolveRef, safeNumericConstraint, stringify, toColonRoutePath, toJsLiteral, toObjectSchema } from "@orval/core";
 //#region src/mock-types.ts
+function asObjectSchema(schema) {
+	if (!schema || typeof schema !== "object") return;
+	return schema;
+}
 function isStrictMock(mockOptions) {
 	return Boolean(mockOptions && mockOptions.required && mockOptions.nonNullable);
 }
@@ -21,23 +24,25 @@ export type MockWithNullableOverrides<
 };`;
 }
 function classifyStrictMockSchemaType(schema, context) {
-	if (!schema) return "object";
-	if (schema.format === "binary" || schema.contentMediaType === "application/octet-stream" && !schema.contentEncoding) return "binary";
-	if (typeof schema.$ref === "string") {
+	const objectSchema = asObjectSchema(schema);
+	if (!objectSchema) return "object";
+	if (objectSchema.format === "binary" || objectSchema.contentMediaType === "application/octet-stream" && !objectSchema.contentEncoding) return "binary";
+	if (typeof objectSchema.$ref === "string") {
 		if (context) {
-			const { schema: resolved } = resolveRef(schema, context);
+			const { schema: resolved } = resolveRef(objectSchema, context);
 			return classifyStrictMockSchemaType(resolved, context);
 		}
 		return "object";
 	}
-	if (schema.type === "object" || schema.properties || isComposedObjectSchema(schema)) return "object";
+	if (objectSchema.type === "object" || objectSchema.properties || isComposedObjectSchema(objectSchema)) return "object";
 	return "alias";
 }
 function isComposedObjectSchema(schema) {
 	const branches = schema.oneOf ?? schema.anyOf ?? schema.allOf;
 	if (!branches?.length) return false;
 	return branches.some((branch) => {
-		const item = branch;
+		const item = asObjectSchema(branch);
+		if (!item) return false;
 		if (typeof item.$ref === "string" || item.type === "object" || item.properties) return true;
 		return isComposedObjectSchema(item);
 	});
@@ -62,23 +67,24 @@ function strictMockResolvedImportMatches(typeName, resolvedImport, importBareNam
 	return importBareName !== void 0 && importBareName === resolvedName;
 }
 function resolveStrictMockSchemaForTypeName(typeName, originalSchema, context, importBareName) {
-	if (!originalSchema) return;
-	if (!context) return originalSchema;
-	const branches = originalSchema.oneOf ?? originalSchema.anyOf ?? originalSchema.allOf;
+	const objectSchema = asObjectSchema(originalSchema);
+	if (!objectSchema) return;
+	if (!context) return objectSchema;
+	const branches = objectSchema.oneOf ?? objectSchema.anyOf ?? objectSchema.allOf;
 	if (branches?.length) {
 		for (const branch of branches) {
-			if (typeof branch.$ref !== "string") continue;
+			if (typeof branch !== "object" || branch === null || !("$ref" in branch) || typeof branch.$ref !== "string") continue;
 			const resolved = resolveRef(branch, context);
 			if (strictMockResolvedImportMatches(typeName, resolved.imports[0], importBareName)) return resolved.schema;
 		}
 		return;
 	}
-	if (typeof originalSchema.$ref === "string") {
-		const resolved = resolveRef(originalSchema, context);
+	if (typeof objectSchema.$ref === "string") {
+		const resolved = resolveRef(objectSchema, context);
 		if (strictMockResolvedImportMatches(typeName, resolved.imports[0], importBareName)) return resolved.schema;
 		return;
 	}
-	return originalSchema;
+	return objectSchema;
 }
 function getMockFactoryReturnType(typeName, mockOptions) {
 	return isStrictMock(mockOptions) ? getStrictMockTypeName(typeName) : typeName;
@@ -140,10 +146,9 @@ function getStrictMockSchemaKindsFromResponses(responses, context) {
 		if (!value || !response.originalSchema) continue;
 		const baseType = value.endsWith("[]") ? value.slice(0, -2) : value;
 		if (!/^[A-Z]\w*$/.test(baseType)) continue;
-		const schema = response.originalSchema;
-		if (value.endsWith("[]") && schema.type === "array" && schema.items) {
-			const items = schema.items;
-			kinds[baseType] = classifyStrictMockSchemaType(items, context);
+		const schema = asObjectSchema(response.originalSchema);
+		if (value.endsWith("[]") && schema?.type === "array" && schema.items && typeof schema.items === "object") {
+			kinds[baseType] = classifyStrictMockSchemaType(schema.items, context);
 			continue;
 		}
 		kinds[baseType] = classifyStrictMockSchemaType(resolveStrictMockSchemaForTypeName(baseType, response.originalSchema, context) ?? response.originalSchema, context);
@@ -214,46 +219,6 @@ function mergeStrictMockSchemaKinds(...groups) {
 	return Object.keys(merged).length > 0 ? merged : void 0;
 }
 //#endregion
-//#region src/faker/imports.ts
-/**
-* Appends entries added to `source` since `sinceIndex`. Uses indexed push
-* instead of spread so large import batches (common with `schemas: true`
-* delegation on wide objects) do not overflow the call stack.
-*/
-function appendImportsDelta(target, source, sinceIndex) {
-	for (let i = sinceIndex; i < source.length; i++) target.push(source[i]);
-}
-/**
-* Merge imports returned from mock resolution when the shared imports array
-* was not mutated in place. Enum mocks and nested object factories return
-* their imports separately; schema-factory delegation mutates `sharedImports`
-* directly and must not be merged again from `resolvedImports`.
-*/
-function mergeReturnedMockImports(sharedImports, sharedBefore, resolvedImports) {
-	if (sharedImports.length === sharedBefore) appendImportsDelta(sharedImports, resolvedImports, 0);
-}
-/** Recover type imports referenced by nested oneOf split mock helpers. */
-function collectSplitMockTypeImports(implementations) {
-	const seen = /* @__PURE__ */ new Set();
-	const imports = [];
-	const addType = (name) => {
-		if (!name || seen.has(name)) return;
-		seen.add(name);
-		imports.push({
-			name,
-			values: false
-		});
-	};
-	for (const impl of implementations) {
-		for (const match of impl.matchAll(/export const get\w+Mock = \(\s*overrideResponse: Partial<(\w+)[^)]*\):\s*(\w+)\s*=>/g)) {
-			addType(match[1]);
-			addType(match[2]);
-		}
-		for (const match of impl.matchAll(/export const get\w+Mock[\s\S]*?MockWithNullableOverrides<(?:Extract<(\w+),[^>]+>|(\w+)),/g)) addType(match[1] ?? match[2]);
-	}
-	return imports;
-}
-//#endregion
 //#region src/delay.ts
 const getDelay = (override, options) => {
 	const mswOptions = options && isMswMock(options) ? options : void 0;
@@ -268,12 +233,12 @@ const getDelay = (override, options) => {
 //#region src/faker/getters/all-of-required.ts
 function derefAllOfMember(member, context, seen) {
 	let current = member;
-	while (current && typeof current === "object" && isReference(current)) {
+	while (current && typeof current === "object" && "$ref" in current && typeof current.$ref === "string") {
 		const ref = current.$ref;
-		if (typeof ref !== "string" || seen.has(ref)) return;
+		if (seen.has(ref)) return;
 		seen.add(ref);
 		const { refPaths } = getRefInfo(ref, context);
-		current = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
+		current = Array.isArray(refPaths) ? getAtPath(context.spec, refPaths) : void 0;
 	}
 	return current && typeof current === "object" ? current : void 0;
 }
@@ -340,6 +305,161 @@ const DEFAULT_FORMAT_MOCK = {
 };
 const DEFAULT_OBJECT_KEY_MOCK = "faker.string.alphanumeric(5)";
 //#endregion
+//#region src/faker/format-example-value.ts
+const DATE_FORMATS = /* @__PURE__ */ new Set(["date", "date-time"]);
+function isDateFormat(format) {
+	return format !== void 0 && DATE_FORMATS.has(format);
+}
+function isSchemaObject(schema) {
+	return typeof schema === "object" && schema !== null && !Array.isArray(schema);
+}
+function resolveSchema(schema, context) {
+	if (!schema || typeof schema !== "object") return;
+	if (typeof schema.$ref === "string") {
+		const resolved = resolveRef(schema, context).schema;
+		return resolved && typeof resolved === "object" ? resolved : void 0;
+	}
+	return schema;
+}
+function mergePropertySchemas(...schemas) {
+	const merged = {};
+	for (const schema of schemas) {
+		if (!schema?.properties) continue;
+		for (const [key, prop] of Object.entries(schema.properties)) if (isSchemaObject(prop)) merged[key] = prop;
+	}
+	return merged;
+}
+function getEffectiveScalarFormat(resolved, context) {
+	if (!resolved) return;
+	if (isDateFormat(resolved.format)) return resolved.format;
+	const oneOf = resolved.oneOf;
+	const anyOf = resolved.anyOf;
+	for (const variant of [...oneOf ?? [], ...anyOf ?? []]) {
+		const resolvedVariant = resolveSchema(isSchemaObject(variant) ? variant : void 0, context);
+		if (isDateFormat(resolvedVariant?.format)) return resolvedVariant.format;
+	}
+}
+/**
+* Resolves compositional schemas (allOf / oneOf / anyOf) so example formatting
+* can see property formats on nested and referenced types.
+*/
+function resolveExampleSchema(schema, context, seenRefs = /* @__PURE__ */ new Set()) {
+	if (!schema || typeof schema !== "object") return;
+	if (typeof schema.$ref === "string") {
+		const ref = schema.$ref;
+		if (seenRefs.has(ref)) {
+			const resolved = resolveRef(schema, context).schema;
+			return resolved && typeof resolved === "object" ? resolved : void 0;
+		}
+		seenRefs = new Set(seenRefs).add(ref);
+	}
+	const resolved = resolveSchema(schema, context);
+	if (!resolved) return;
+	const allOf = resolved.allOf;
+	const oneOf = resolved.oneOf;
+	const anyOf = resolved.anyOf;
+	const compositors = [
+		...allOf ?? [],
+		...oneOf ?? [],
+		...anyOf ?? []
+	];
+	const properties = mergePropertySchemas(resolved, ...compositors.map((sub) => resolveExampleSchema(sub, context, seenRefs)));
+	const baseResolved = resolved;
+	if (resolved.type === "array" && isSchemaObject(resolved.items)) {
+		const items = resolveExampleSchema(resolved.items, context, seenRefs);
+		const itemProperties = items?.properties;
+		const normalizedItems = itemProperties && Object.keys(itemProperties).length > 0 ? {
+			type: "object",
+			properties: itemProperties
+		} : items;
+		return {
+			...baseResolved,
+			...Object.keys(properties).length > 0 ? { properties } : {},
+			items: normalizedItems ?? resolved.items
+		};
+	}
+	if (Object.keys(properties).length > 0) return {
+		...baseResolved,
+		properties
+	};
+	if (compositors.length > 0 && (oneOf ?? anyOf)) {
+		const variantProperties = mergePropertySchemas(...compositors.map((sub) => resolveExampleSchema(sub, context, seenRefs)));
+		if (Object.keys(variantProperties).length > 0) return {
+			type: "object",
+			properties: variantProperties
+		};
+	}
+	const scalarFormat = getEffectiveScalarFormat(resolved, context);
+	if (scalarFormat) return {
+		...baseResolved,
+		format: scalarFormat
+	};
+	return resolved;
+}
+function formatLiteralValue(example, schema, context) {
+	if (example === null) return "null";
+	if (example === void 0) return "undefined";
+	const resolved = resolveExampleSchema(schema, context);
+	if (Array.isArray(example)) {
+		const itemsSchema = resolved?.type === "array" && isSchemaObject(resolved.items) ? resolveExampleSchema(resolved.items, context) : resolved;
+		return `[${example.map((item) => formatLiteralValue(item, itemsSchema, context)).join(", ")}]`;
+	}
+	if (typeof example === "object") {
+		const properties = resolved?.properties ?? {};
+		return `{ ${Object.entries(example).map(([key, value]) => {
+			const propSchema = properties[key];
+			const resolvedProp = isSchemaObject(propSchema) ? resolveExampleSchema(propSchema, context) : void 0;
+			return `${/^[a-zA-Z_$][\w$]*$/.test(key) ? key : JSON.stringify(key)}: ${formatLiteralValue(value, resolvedProp, context)}`;
+		}).join(", ")} }`;
+	}
+	if (context.output.override.useDates && typeof example === "string" && isDateFormat(getEffectiveScalarFormat(resolved, context))) return `new Date(${JSON.stringify(example)})`;
+	return JSON.stringify(example);
+}
+function formatSchemaExampleValue(example, schema, context) {
+	if (!context.output.override.useDates || schema === void 0) return JSON.stringify(example);
+	return formatLiteralValue(example, schema, context);
+}
+//#endregion
+//#region src/faker/imports.ts
+/**
+* Appends entries added to `source` since `sinceIndex`. Uses indexed push
+* instead of spread so large import batches (common with `schemas: true`
+* delegation on wide objects) do not overflow the call stack.
+*/
+function appendImportsDelta(target, source, sinceIndex) {
+	for (let i = sinceIndex; i < source.length; i++) target.push(source[i]);
+}
+/**
+* Merge imports returned from mock resolution when the shared imports array
+* was not mutated in place. Enum mocks and nested object factories return
+* their imports separately; schema-factory delegation mutates `sharedImports`
+* directly and must not be merged again from `resolvedImports`.
+*/
+function mergeReturnedMockImports(sharedImports, sharedBefore, resolvedImports) {
+	if (sharedImports.length === sharedBefore) appendImportsDelta(sharedImports, resolvedImports, 0);
+}
+/** Recover type imports referenced by nested oneOf split mock helpers. */
+function collectSplitMockTypeImports(implementations) {
+	const seen = /* @__PURE__ */ new Set();
+	const imports = [];
+	const addType = (name) => {
+		if (!name || seen.has(name)) return;
+		seen.add(name);
+		imports.push({
+			name,
+			values: false
+		});
+	};
+	for (const impl of implementations) {
+		for (const match of impl.matchAll(/export const get\w+Mock = \(\s*overrideResponse: Partial<(\w+)[^)]*\):\s*(\w+)\s*=>/g)) {
+			addType(match[1]);
+			addType(match[2]);
+		}
+		for (const match of impl.matchAll(/export const get\w+Mock[\s\S]*?MockWithNullableOverrides<(?:Extract<(\w+),[^>]+>|(\w+)),/g)) addType(match[1] ?? match[2]);
+	}
+	return imports;
+}
+//#endregion
 //#region src/faker/getters/object.ts
 const overrideVarName = "overrideResponse";
 function wrapRootNullableObjectValue(value, schemaItem, mockOptions, combine) {
@@ -362,13 +482,13 @@ function reExpansionWouldCollapse(ref, context, existingReferencedProperties, no
 	const targetRequired = target?.required;
 	if (!targetProperties || !Array.isArray(targetRequired)) return false;
 	return Object.entries(targetProperties).some(([key, property]) => {
-		if (!targetRequired.includes(key) || !isReference(property)) return false;
+		if (!targetRequired.includes(key) || isInlineSchema(property)) return false;
 		if (!existingReferencedProperties.includes(getReferenceName$1(property.$ref, context))) return false;
 		return nonNullable || !isNullableRefTarget(property.$ref, context);
 	});
 }
 function getMockObject({ item, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride = false }) {
-	if (isReference(item)) return resolveMockValue({
+	if (typeof item.$ref === "string") return resolveMockValue({
 		schema: {
 			...item,
 			name: item.name,
@@ -476,14 +596,14 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		const propertyScalars = entries.map(([key, prop]) => {
 			if (combine?.includedProperties.includes(key)) return;
 			const isRequired = mockOptions?.required ?? (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
-			const hasNullable = !isReference(prop) && isSchemaNullable(prop);
-			const refName = isReference(prop) ? getReferenceName$1(prop.$ref, context) : "";
+			const hasNullable = isInlineSchema(prop) && isSchemaNullable(prop);
+			const refName = !isInlineSchema(prop) ? getReferenceName$1(prop.$ref, context) : "";
 			const isRecursiveRef = !!refName && existingReferencedProperties.includes(refName);
 			if (isRecursiveRef) {
 				if (!isRequired) return;
 				const keyDefinition = getKey(key);
-				if (!mockOptions?.nonNullable && (hasNullable || isReference(prop) && isNullableRefTarget(prop.$ref, context))) return `${keyDefinition}: null`;
-				if (new Set(existingReferencedProperties).size !== existingReferencedProperties.length || isReference(prop) && reExpansionWouldCollapse(prop.$ref, context, existingReferencedProperties, mockOptions?.nonNullable)) {
+				if (!mockOptions?.nonNullable && (hasNullable || !isInlineSchema(prop) && isNullableRefTarget(prop.$ref, context))) return `${keyDefinition}: null`;
+				if (new Set(existingReferencedProperties).size !== existingReferencedProperties.length || !isInlineSchema(prop) && reExpansionWouldCollapse(prop.$ref, context, existingReferencedProperties, mockOptions?.nonNullable)) {
 					imports.push({ name: refName });
 					return `${keyDefinition}: {} as unknown as ${refName}`;
 				}
@@ -516,14 +636,14 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 				imports.push({ name: refName });
 				return `${keyDefinition}: {} as unknown as ${refName}`;
 			}
-			const hasDefault = "default" in prop && prop.default !== void 0;
+			const hasDefault = typeof prop === "object" && prop !== null && "default" in prop && prop.default !== void 0;
 			if (!isRequired && !resolvedValue.overrided && !hasDefault) {
 				if (resolvedValue.nullWrapped) return `${keyDefinition}: ${resolvedValue.value}`;
 				const omitValue = mockOptions?.nonNullable || !hasNullable ? "undefined" : "null";
 				if (omitValue === "undefined" && mockOptions?.exactOptional) return `...(faker.datatype.boolean() ? {${keyDefinition}: ${resolvedValue.value}} : {})`;
 				return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, ${omitValue}])`;
 			}
-			if (Array.isArray(prop.type) && prop.type.includes("null") && !resolvedValue.nullWrapped && !resolvedValue.overrided && !mockOptions?.nonNullable) return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, null])`;
+			if (typeof prop === "object" && prop !== null && "type" in prop && Array.isArray(prop.type) && prop.type.includes("null") && !resolvedValue.nullWrapped && !resolvedValue.overrided && !mockOptions?.nonNullable) return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, null])`;
 			return `${keyDefinition}: ${resolvedValue.value}`;
 		}).filter(Boolean);
 		if (allowOverride) propertyScalars.push(`...${overrideVarName}`);
@@ -549,7 +669,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			};
 		}
 		const additionalProperties = itemAdditionalProperties;
-		if (isReference(additionalProperties) && existingReferencedProperties.includes(getReferenceName$1(additionalProperties.$ref, context))) {
+		if (!isInlineSchema(additionalProperties) && existingReferencedProperties.includes(getReferenceName$1(additionalProperties.$ref, context))) {
 			const { value: finalValue, nullWrapped } = wrapRootNullableObjectValue(`{}`, schemaItem, mockOptions, combine);
 			return {
 				value: finalValue,
@@ -662,11 +782,12 @@ function shouldExtractArrayItem(items, context, operationId, parentName) {
 	const itemsRef = extractItemsRef(items);
 	if (itemsRef) try {
 		const { schema } = resolveRef({ $ref: itemsRef }, context);
+		if (typeof schema !== "object" || schema === null) return false;
 		return isResolvedSchemaObjectLike(schema);
 	} catch {
 		return false;
 	}
-	if (isReference(items)) return false;
+	if (!isInlineSchema(items)) return false;
 	const schema = items;
 	if (isNullableArrayItem(schema)) return false;
 	if (schema.oneOf || schema.anyOf) return false;
@@ -747,115 +868,6 @@ function extractArrayItemMock({ items, propertyName, parentName, operationId, ta
 	return `{...${factoryName}()${isStrictMock(mockOptions) ? ` as ${getStrictMockTypeName(typeName)}` : ""}}`;
 }
 //#endregion
-//#region src/faker/format-example-value.ts
-const DATE_FORMATS = /* @__PURE__ */ new Set(["date", "date-time"]);
-function isDateFormat(format) {
-	return format !== void 0 && DATE_FORMATS.has(format);
-}
-function isSchemaObject(schema) {
-	return typeof schema === "object" && schema !== null && !Array.isArray(schema);
-}
-function resolveSchema(schema, context) {
-	if (!schema) return;
-	if (isReference(schema)) return resolveRef(schema, context).schema;
-	return schema;
-}
-function mergePropertySchemas(...schemas) {
-	const merged = {};
-	for (const schema of schemas) {
-		if (!schema?.properties) continue;
-		for (const [key, prop] of Object.entries(schema.properties)) if (isSchemaObject(prop)) merged[key] = prop;
-	}
-	return merged;
-}
-function getEffectiveScalarFormat(resolved, context) {
-	if (!resolved) return;
-	if (isDateFormat(resolved.format)) return resolved.format;
-	const oneOf = resolved.oneOf;
-	const anyOf = resolved.anyOf;
-	for (const variant of [...oneOf ?? [], ...anyOf ?? []]) {
-		const resolvedVariant = resolveSchema(isReference(variant) || isSchemaObject(variant) ? variant : void 0, context);
-		if (isDateFormat(resolvedVariant?.format)) return resolvedVariant.format;
-	}
-}
-/**
-* Resolves compositional schemas (allOf / oneOf / anyOf) so example formatting
-* can see property formats on nested and referenced types.
-*/
-function resolveExampleSchema(schema, context, seenRefs = /* @__PURE__ */ new Set()) {
-	if (!schema) return;
-	if (isReference(schema)) {
-		const ref = schema.$ref;
-		if (ref && seenRefs.has(ref)) return resolveRef(schema, context).schema;
-		if (ref) seenRefs = new Set(seenRefs).add(ref);
-	}
-	const resolved = resolveSchema(schema, context);
-	if (!resolved) return;
-	const allOf = resolved.allOf;
-	const oneOf = resolved.oneOf;
-	const anyOf = resolved.anyOf;
-	const compositors = [
-		...allOf ?? [],
-		...oneOf ?? [],
-		...anyOf ?? []
-	];
-	const properties = mergePropertySchemas(resolved, ...compositors.map((sub) => resolveExampleSchema(sub, context, seenRefs)));
-	const baseResolved = resolved;
-	if (resolved.type === "array" && isSchemaObject(resolved.items)) {
-		const items = resolveExampleSchema(resolved.items, context, seenRefs);
-		const itemProperties = items?.properties;
-		const normalizedItems = itemProperties && Object.keys(itemProperties).length > 0 ? {
-			type: "object",
-			properties: itemProperties
-		} : items;
-		return {
-			...baseResolved,
-			...Object.keys(properties).length > 0 ? { properties } : {},
-			items: normalizedItems ?? resolved.items
-		};
-	}
-	if (Object.keys(properties).length > 0) return {
-		...baseResolved,
-		properties
-	};
-	if (compositors.length > 0 && (oneOf ?? anyOf)) {
-		const variantProperties = mergePropertySchemas(...compositors.map((sub) => resolveExampleSchema(sub, context, seenRefs)));
-		if (Object.keys(variantProperties).length > 0) return {
-			type: "object",
-			properties: variantProperties
-		};
-	}
-	const scalarFormat = getEffectiveScalarFormat(resolved, context);
-	if (scalarFormat) return {
-		...baseResolved,
-		format: scalarFormat
-	};
-	return resolved;
-}
-function formatLiteralValue(example, schema, context) {
-	if (example === null) return "null";
-	if (example === void 0) return "undefined";
-	const resolved = resolveExampleSchema(schema, context);
-	if (Array.isArray(example)) {
-		const itemsSchema = resolved?.type === "array" && isSchemaObject(resolved.items) ? resolveExampleSchema(resolved.items, context) : resolved;
-		return `[${example.map((item) => formatLiteralValue(item, itemsSchema, context)).join(", ")}]`;
-	}
-	if (typeof example === "object") {
-		const properties = resolved?.properties ?? {};
-		return `{ ${Object.entries(example).map(([key, value]) => {
-			const propSchema = properties[key];
-			const resolvedProp = isSchemaObject(propSchema) ? resolveExampleSchema(propSchema, context) : void 0;
-			return `${/^[a-zA-Z_$][\w$]*$/.test(key) ? key : JSON.stringify(key)}: ${formatLiteralValue(value, resolvedProp, context)}`;
-		}).join(", ")} }`;
-	}
-	if (context.output.override.useDates && typeof example === "string" && isDateFormat(getEffectiveScalarFormat(resolved, context))) return `new Date(${JSON.stringify(example)})`;
-	return JSON.stringify(example);
-}
-function formatSchemaExampleValue(example, schema, context) {
-	if (!context.output.override.useDates || schema === void 0) return JSON.stringify(example);
-	return formatLiteralValue(example, schema, context);
-}
-//#endregion
 //#region src/faker/getters/scalar.ts
 function getMockScalar({ item, imports, mockOptions, operationId, tags, combine, context, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride = false }) {
 	const safeMockOptions = mockOptions ?? {};
@@ -885,6 +897,18 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 			overrided: true
 		};
 	}
+	if (isNullOnlyEnum(item)) return {
+		value: "null",
+		imports: [],
+		name: item.name,
+		nullWrapped: true
+	};
+	if ("const" in item && item.type === void 0) return {
+		value: toJsLiteral(item.const),
+		imports: [],
+		name: item.name,
+		nullWrapped: item.const === null
+	};
 	const formatOverrides = safeMockOptions.format ?? {};
 	const ALL_FORMAT = {
 		...DEFAULT_FORMAT_MOCK,
@@ -993,18 +1017,19 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 					name: item.name
 				};
 			}
-			if (!item.items) return {
+			if (!item.items || typeof item.items !== "object") return {
 				value: "[]",
 				imports: [],
 				name: item.name
 			};
-			const itemsRef = extractItemsRef(item.items);
+			const itemsSchema = item.items;
+			const itemsRef = extractItemsRef(itemsSchema);
 			if (itemsRef && existingReferencedProperties.includes(getRefInfo(itemsRef, context).name)) return {
 				value: "[]",
 				imports: [],
 				name: item.name
 			};
-			const resolvedItems = itemsRef && !("$ref" in item.items) ? { $ref: itemsRef } : item.items;
+			const resolvedItems = itemsRef && !("$ref" in itemsSchema) ? { $ref: itemsRef } : itemsSchema;
 			const { value, enums, imports: resolvedImports } = resolveMockValue({
 				schema: {
 					...resolvedItems,
@@ -1132,14 +1157,14 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 	}
 }
 function extractItemsRef(items) {
-	if (isReference(items)) return items.$ref;
+	if (!isInlineSchema(items)) return items.$ref;
 	for (const key of [
 		"allOf",
 		"oneOf",
 		"anyOf"
 	]) {
 		const composed = items[key];
-		if (Array.isArray(composed) && composed.length === 1 && isReference(composed[0])) return composed[0].$ref;
+		if (Array.isArray(composed) && composed.length === 1 && !isInlineSchema(composed[0])) return composed[0].$ref;
 	}
 }
 function getItemType(item) {
@@ -1258,7 +1283,7 @@ function resolveRefTarget(ref, context) {
 	if (!fragment) return void 0;
 	const { refPaths } = getRefInfo(ref, context);
 	if (!Array.isArray(refPaths)) return void 0;
-	return prop(context.spec, ...refPaths);
+	return getAtPath(context.spec, refPaths);
 }
 /**
 * Whether a schema accepts `null`, in any of the spellings orval sees.
@@ -1334,7 +1359,7 @@ function hasOverrideTouchingSchema(schemaProperties, mockOptions, operationId, t
 	});
 }
 function resolveMockValue({ schema, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride }) {
-	if (isReference(schema)) {
+	if (!isInlineSchema(schema)) {
 		const schemaReference = schema;
 		const schemaRefPath = typeof schema.$ref === "string" ? schema.$ref : "";
 		const { name, refPaths } = getRefInfo(schemaRefPath, context);
@@ -1345,7 +1370,7 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 			path: schemaReference.path,
 			isRef: true,
 			required: [...schemaRef?.required ?? [], ...getRequiredKeys(schemaReference, name)],
-			...Array.isArray(schemaReference.type) ? { type: schemaReference.type } : {}
+			..."type" in schemaReference && Array.isArray(schemaReference.type) ? { type: schemaReference.type } : {}
 		};
 		if (combine?.separator === "allOf" && newSchema.discriminator && newSchema.oneOf) {
 			const parentDiscriminator = newSchema.discriminator;
@@ -1462,12 +1487,12 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 	};
 }
 function getType(schema) {
-	if (isReference(schema)) return;
+	if (!isInlineSchema(schema)) return;
 	return schema.type ?? (schema.properties ? "object" : schema.items ? "array" : void 0);
 }
 function resolvesToObjectLike(schema, context, seen = /* @__PURE__ */ new Set()) {
 	let resolved;
-	if (isReference(schema)) {
+	if (!isInlineSchema(schema)) {
 		if (typeof schema.$ref !== "string" || seen.has(schema.$ref)) return false;
 		seen = new Set(seen).add(schema.$ref);
 		resolved = resolveRefTarget(schema.$ref, context);
@@ -1489,7 +1514,7 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 	const includedProperties = [...combine?.includedProperties ?? []];
 	const separatorItems = item[separator] ?? [];
 	const itemRequired = item.required;
-	const isRefAndNotExisting = isReference(item) && !existingReferencedProperties.includes(item.name);
+	const isRefAndNotExisting = typeof item.$ref === "string" && !existingReferencedProperties.includes(item.name);
 	const discriminator = item.discriminator;
 	const itemProperties = item.properties;
 	const discriminatorPropertyName = separator === "oneOf" && discriminator?.mapping && discriminator.propertyName && itemProperties && discriminator.propertyName in itemProperties ? discriminator.propertyName : void 0;
@@ -1537,9 +1562,10 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 	includedProperties.push(...itemResolvedValue?.includedProperties ?? []);
 	combineImports.push(...itemResolvedValue?.imports ?? []);
 	let containsOnlyPrimitiveValues = true;
+	let hasNullMember = false;
 	let value = separator === "allOf" ? "" : "faker.helpers.arrayElement([";
 	for (const val of separatorItems) {
-		const refName = isReference(val) ? getReferenceName(val.$ref, context) : "";
+		const refName = isInlineSchema(val) ? "" : getReferenceName(val.$ref, context);
 		if (separator === "allOf" ? refName && (refName === item.name || existingReferencedProperties.includes(refName) && !item.isRef || existingReferencedAllOfRefs.includes(refName)) : refName && existingReferencedProperties.includes(refName)) {
 			if (separatorItems.length === 1) value = "undefined";
 			continue;
@@ -1591,6 +1617,10 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 				continue;
 			}
 		}
+		if (separator !== "allOf" && resolvedValue.value === "null") {
+			if (hasNullMember) continue;
+			hasNullMember = true;
+		}
 		value += `${resolvedValue.value},`;
 	}
 	let finalValue = value === "undefined" || separator !== "allOf" && value === "faker.helpers.arrayElement([" ? "undefined" : `${separator === "allOf" && !containsOnlyPrimitiveValues ? "{" : ""}${value}${separator === "allOf" ? containsOnlyPrimitiveValues ? "" : "}" : "])"}`;
@@ -1706,8 +1736,9 @@ function getResponsesMockDefinition({ operationId, tags, returnType, responses,
 	for (const response of responses) {
 		const { value: definition, example, examples, imports, isRef } = response;
 		let { originalSchema } = response;
+		const schemaObject = originalSchema && typeof originalSchema === "object" ? originalSchema : void 0;
 		if (context.output.override.mock?.useExamples || mockOptions?.useExamples) {
-			const exampleValue = unwrapExampleValue(example ?? originalSchema?.example ?? getExampleEntries(examples)[0] ?? getExampleEntries(originalSchema?.examples)[0]);
+			const exampleValue = unwrapExampleValue(example ?? schemaObject?.example ?? getExampleEntries(examples)[0] ?? getExampleEntries(schemaObject?.examples)[0]);
 			if (exampleValue !== void 0) {
 				const formatted = formatSchemaExampleValue(exampleValue, originalSchema, context);
 				result.definitions.push(transformer ? transformer(formatted, returnType) : formatted);
@@ -1724,7 +1755,7 @@ function getResponsesMockDefinition({ operationId, tags, returnType, responses,
 			format: "binary"
 		};
 		else if (!originalSchema) continue;
-		const resolvedSchema = resolveRef(originalSchema, context).schema;
+		const resolvedSchema = toObjectSchema(resolveRef(originalSchema, context).schema);
 		const responseImports = imports ? [...imports] : [];
 		const importsBefore = responseImports.length;
 		const scalar = getMockScalar({
@@ -1857,7 +1888,11 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	const hasTextLikeContentType = contentTypes.some((ct) => isTextLikeContentType(ct));
 	const isExactlyStringReturnType = isTypeExactlyString(returnType);
 	const isTextResponse = isExactlyStringReturnType && hasTextLikeContentType || contentTypesByPreference.some((ct) => isTextLikeContentType(ct));
-	const isSchemaBinary = (r) => r.originalSchema?.format === "binary" || r.originalSchema?.contentMediaType === "application/octet-stream" && !r.originalSchema.contentEncoding;
+	const isSchemaBinary = (r) => {
+		const schema = r.originalSchema;
+		if (!schema || typeof schema !== "object") return false;
+		return schema.format === "binary" || schema.contentMediaType === "application/octet-stream" && !schema.contentEncoding;
+	};
 	const isBinaryResponse = preferredContentTypeMatch ? responsesByPreference.some((r) => isSchemaBinary(r)) : contentTypesByPreference.some((ct) => isBinaryLikeContentType(ct)) || responsesByPreference.some((r) => isSchemaBinary(r));
 	const isReturnHttpResponse = value && value !== "undefined";
 	const getResponseMockFunctionName = `${getResponseMockFunctionNameBase}${pascal(name)}`;