@orval/mock 8.17.0 → 8.18.0

package/dist/index.mjs

@@ -20,13 +20,65 @@ export type MockWithNullableOverrides<
   [K in Extract<KeysWithNull<O>, keyof T>]: M[K] | null;
 };`;
 }
-function getStrictMockTypeDeclaration(typeName) {
-	return `export type ${getStrictMockTypeName(typeName)} = {\n  [K in keyof Required<${typeName}>]: NonNullable<Required<${typeName}>[K]>;\n};`;
+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") {
+		if (context) {
+			const { schema: resolved } = resolveRef(schema, context);
+			return classifyStrictMockSchemaType(resolved, context);
+		}
+		return "object";
+	}
+	if (schema.type === "object" || schema.properties || isComposedObjectSchema(schema)) return "object";
+	return "alias";
 }
-function getStrictMockTypeDeclarations(typeNames) {
+function isComposedObjectSchema(schema) {
+	const branches = schema.oneOf ?? schema.anyOf ?? schema.allOf;
+	if (!branches?.length) return false;
+	return branches.some((branch) => {
+		const item = branch;
+		if (typeof item.$ref === "string" || item.type === "object" || item.properties) return true;
+		return isComposedObjectSchema(item);
+	});
+}
+function getStrictMockTypeDeclaration(typeName, kind = "object", options) {
+	const mockTypeName = getStrictMockTypeName(typeName);
+	if (kind === "alias") return `export type ${mockTypeName} = ${typeName};`;
+	if (kind === "binary") return `export type ${mockTypeName} = ArrayBuffer;`;
+	const mappedType = `{\n  [K in keyof Required<NonNullable<${typeName}>>]: NonNullable<Required<NonNullable<${typeName}>>[K]>;\n}`;
+	return `export type ${mockTypeName} = ${options?.schemaNullableAtRoot ? `${mappedType} | null` : mappedType};`;
+}
+function getStrictMockTypeDeclarations(typeNames, kinds, nullableAtRoot) {
 	const unique = [...new Set(typeNames)];
 	if (unique.length === 0) return "";
-	return unique.map((typeName) => getStrictMockTypeDeclaration(typeName)).join("\n\n");
+	return unique.map((typeName) => getStrictMockTypeDeclaration(typeName, kinds?.[typeName] ?? "object", { schemaNullableAtRoot: nullableAtRoot?.[typeName] })).join("\n\n");
+}
+function strictMockResolvedImportMatches(typeName, resolvedImport, importBareName) {
+	const resolvedName = resolvedImport?.name;
+	if (!resolvedName) return false;
+	if (typeName === resolvedName) return true;
+	if (resolvedImport.alias && typeName === resolvedImport.alias) return true;
+	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;
+	if (branches?.length) {
+		for (const branch of branches) {
+			if (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 (strictMockResolvedImportMatches(typeName, resolved.imports[0], importBareName)) return resolved.schema;
+		return;
+	}
+	return originalSchema;
 }
 function getMockFactoryReturnType(typeName, mockOptions) {
 	return isStrictMock(mockOptions) ? getStrictMockTypeName(typeName) : typeName;
@@ -73,8 +125,33 @@ function getSchemaTypeNamesFromResponses(responses) {
 	}
 	return [...names];
 }
-function buildStrictMockTypeFileHeader(schemaTypeNames) {
-	const schemaBlock = getStrictMockTypeDeclarations([...new Set(schemaTypeNames)]);
+function getStrictMockSchemaKindsFromResponses(responses, context) {
+	const kinds = {};
+	for (const response of responses) {
+		for (const imp of response.imports) {
+			if (imp.values || imp.schemaFactory) continue;
+			const importName = imp.alias ?? imp.name;
+			if (!/^[A-Z]\w*$/.test(importName)) continue;
+			const schemaForImport = resolveStrictMockSchemaForTypeName(importName, response.originalSchema, context, imp.name);
+			if (!schemaForImport) continue;
+			kinds[importName] = classifyStrictMockSchemaType(schemaForImport, context);
+		}
+		const { value } = response;
+		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);
+			continue;
+		}
+		kinds[baseType] = classifyStrictMockSchemaType(resolveStrictMockSchemaForTypeName(baseType, response.originalSchema, context) ?? response.originalSchema, context);
+	}
+	return kinds;
+}
+function buildStrictMockTypeFileHeader(schemaTypeNames, kinds) {
+	const schemaBlock = getStrictMockTypeDeclarations([...new Set(schemaTypeNames)], kinds);
 	return [getStrictMockHelperTypeDeclarations(), schemaBlock].filter(Boolean).join("\n\n");
 }
 /**
@@ -88,7 +165,7 @@ function dedupeStrictMockTypeDeclarations(implementation, options = {}) {
 	if (!isStrictMock(options.mockOptions)) return implementation;
 	const schemaTypeNames = options.strictSchemaTypeNames ? [...new Set(options.strictSchemaTypeNames)] : [];
 	if (schemaTypeNames.length === 0) return implementation;
-	return `${buildStrictMockTypeFileHeader(schemaTypeNames)}\n\n${implementation.trimStart()}`;
+	return `${buildStrictMockTypeFileHeader(schemaTypeNames, options.strictMockSchemaKinds)}\n\n${implementation.trimStart()}`;
 }
 function applyStrictMockReturnType(returnType, schemaTypeNames) {
 	if (schemaTypeNames.length === 0) return returnType;
@@ -128,6 +205,54 @@ function mergeStrictMockSchemaTypeNames(...groups) {
 	}
 	return names.size > 0 ? [...names] : void 0;
 }
+function mergeStrictMockSchemaKinds(...groups) {
+	const merged = {};
+	for (const group of groups) {
+		if (!group) continue;
+		for (const [name, kind] of Object.entries(group)) merged[name] ??= kind;
+	}
+	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) => {
@@ -180,6 +305,13 @@ const DEFAULT_OBJECT_KEY_MOCK = "faker.string.alphanumeric(5)";
 //#endregion
 //#region src/faker/getters/object.ts
 const overrideVarName = "overrideResponse";
+function wrapRootNullableObjectValue(value, schemaItem, mockOptions, combine) {
+	const nullableAtRoot = !combine && isNullableSchema(schemaItem) && !mockOptions?.nonNullable;
+	return {
+		value: nullableAtRoot ? getNullable(value, true) : value,
+		nullWrapped: nullableAtRoot
+	};
+}
 function getReferenceName$1(ref, context) {
 	if (!ref) return "";
 	return getRefInfo(ref, context).name;
@@ -222,10 +354,44 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		splitMockImplementations
 	});
 	if (Array.isArray(itemType)) {
+		const nonNullTypes = mockOptions?.nonNullable ? itemType.filter((type) => type !== "null") : itemType;
+		if (nonNullTypes.length === 0) return {
+			value: "null",
+			imports: [],
+			name: schemaItem.name
+		};
+		if (nonNullTypes.length === 1) return getMockObject({
+			item: {
+				...schemaItem,
+				type: nonNullTypes[0]
+			},
+			mockOptions,
+			operationId,
+			tags,
+			combine,
+			context,
+			imports,
+			existingReferencedProperties,
+			existingReferencedAllOfRefs,
+			splitMockImplementations,
+			allowOverride
+		});
+		if (!itemProperties && (!itemRequired || itemRequired.length === 0) && !itemAdditionalProperties && nonNullTypes.includes("object") && nonNullTypes.includes("null") && nonNullTypes.every((type) => type === "object" || type === "null")) {
+			if (mockOptions?.nonNullable) return {
+				value: "{}",
+				imports: [],
+				name: schemaItem.name
+			};
+			return {
+				value: "faker.helpers.arrayElement([{}, null])",
+				imports: [],
+				name: schemaItem.name
+			};
+		}
 		const baseItem = schemaItem;
 		return combineSchemasMock({
 			item: {
-				anyOf: itemType.map((type) => ({
+				anyOf: nonNullTypes.map((type) => ({
 					...baseItem,
 					type
 				})),
@@ -259,6 +425,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 				if (isRequired) return `${getKey(key)}: null`;
 				return;
 			}
+			const importsBefore = imports.length;
 			const resolvedValue = resolveMockValue({
 				schema: {
 					...prop,
@@ -275,7 +442,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 				existingReferencedAllOfRefs: [],
 				splitMockImplementations
 			});
-			imports.push(...resolvedValue.imports);
+			mergeReturnedMockImports(imports, importsBefore, resolvedValue.imports);
 			includedProperties.push(key);
 			const keyDefinition = getKey(key);
 			const hasDefault = "default" in prop && prop.default !== void 0;
@@ -289,25 +456,35 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		if (allowOverride) propertyScalars.push(`...${overrideVarName}`);
 		value += propertyScalars.join(", ");
 		value += !combine || combine.separator === "oneOf" || combine.separator === "anyOf" ? "}" : "";
+		const { value: finalValue, nullWrapped } = wrapRootNullableObjectValue(value, schemaItem, mockOptions, combine);
 		return {
-			value,
+			value: finalValue,
+			nullWrapped,
 			imports,
 			name: schemaItem.name,
 			includedProperties
 		};
 	}
 	if (itemAdditionalProperties) {
-		if (itemAdditionalProperties === true) return {
-			value: `{}`,
-			imports: [],
-			name: schemaItem.name
-		};
+		if (itemAdditionalProperties === true) {
+			const { value: finalValue, nullWrapped } = wrapRootNullableObjectValue(`{}`, schemaItem, mockOptions, combine);
+			return {
+				value: finalValue,
+				nullWrapped,
+				imports: [],
+				name: schemaItem.name
+			};
+		}
 		const additionalProperties = itemAdditionalProperties;
-		if (isReference(additionalProperties) && existingReferencedProperties.includes(getReferenceName$1(additionalProperties.$ref, context))) return {
-			value: `{}`,
-			imports: [],
-			name: schemaItem.name
-		};
+		if (isReference(additionalProperties) && existingReferencedProperties.includes(getReferenceName$1(additionalProperties.$ref, context))) {
+			const { value: finalValue, nullWrapped } = wrapRootNullableObjectValue(`{}`, schemaItem, mockOptions, combine);
+			return {
+				value: finalValue,
+				nullWrapped,
+				imports: [],
+				name: schemaItem.name
+			};
+		}
 		const resolvedValue = resolveMockValue({
 			schema: {
 				...additionalProperties,
@@ -323,15 +500,19 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			existingReferencedAllOfRefs: [],
 			splitMockImplementations
 		});
+		const { value: finalValue, nullWrapped } = wrapRootNullableObjectValue(`{
+        [${DEFAULT_OBJECT_KEY_MOCK}]: ${resolvedValue.value}
+      }`, schemaItem, mockOptions, combine);
 		return {
 			...resolvedValue,
-			value: `{
-        [${DEFAULT_OBJECT_KEY_MOCK}]: ${resolvedValue.value}
-      }`
+			value: finalValue,
+			nullWrapped
 		};
 	}
+	const { value: finalValue, nullWrapped } = wrapRootNullableObjectValue("{}", schemaItem, mockOptions, combine);
 	return {
-		value: "{}",
+		value: finalValue,
+		nullWrapped,
 		imports: [],
 		name: schemaItem.name
 	};
@@ -463,8 +644,8 @@ function extractArrayItemMock({ items, propertyName, parentName, operationId, ta
 	if (!names) return;
 	const { factoryName, typeName } = names;
 	const fileLevelFactories = getFileLevelExtractedFactories(context, getArrayItemMockFileScope(context, tags));
+	const mockOptions = context.output.override.mock;
 	if (!(fileLevelFactories.has(factoryName) || splitMockImplementations.some((f) => f.includes(`export const ${factoryName}`)))) {
-		const mockOptions = context.output.override.mock;
 		const { param, returnType, returnCast } = getMockFactorySignatureParts(typeName, mockOptions, {
 			isOverridable: true,
 			overrideType: `Partial<${typeName}>`
@@ -474,7 +655,116 @@ function extractArrayItemMock({ items, propertyName, parentName, operationId, ta
 		fileLevelFactories.add(factoryName);
 	}
 	imports.push({ name: typeName });
-	return `{...${factoryName}()}`;
+	return `{...${factoryName}()${isStrictMock(mockOptions) ? ` as ${getStrictMockTypeName(typeName)}` : ""}}`;
+}
+//#endregion
+//#region src/faker/format-example-value.ts
+const DATE_FORMATS = 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
@@ -497,7 +787,7 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 	if (context.output.override.mock?.useExamples || safeMockOptions.useExamples) {
 		const propertyExample = item.example === void 0 ? Array.isArray(item.examples) && item.examples.length > 0 ? item.examples[0] : void 0 : item.example;
 		if (propertyExample !== void 0) return {
-			value: JSON.stringify(propertyExample),
+			value: formatSchemaExampleValue(propertyExample, item, context),
 			imports: [],
 			name: item.name,
 			overrided: true
@@ -878,19 +1168,28 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 		const newSeparator = newSchema.allOf ? "allOf" : newSchema.oneOf ? "oneOf" : "anyOf";
 		if (shouldDelegateToSchemaFactories(context) && isComponentsSchemaRef(refPaths) && !hasOverrideTouchingSchema(schemaRef?.properties, mockOptions, operationId, tags, schemaReference.path)) {
 			const factoryName = `get${pascal(name)}Mock`;
-			imports.push({
+			const factoryImport = {
 				name: factoryName,
 				values: true,
 				schemaFactory: true
-			});
+			};
+			const isObjectLike = newSchema.type === "object" || !!newSchema.allOf || resolvesToObjectLike(newSchema, context);
+			const mockTypeName = getStrictMockTypeName(pascal(name));
+			const strictMockTypeImport = isStrictMock(mockOptions) && isObjectLike ? {
+				name: mockTypeName,
+				values: false,
+				schemaFactory: true
+			} : void 0;
+			const strictObjectCast = isStrictMock(mockOptions) && isObjectLike ? ` as ${mockTypeName}` : "";
 			return {
-				value: getNullable(newSchema.type === "object" || !!newSchema.allOf || resolvesToObjectLike(newSchema, context) ? `{ ...${factoryName}() }` : `${factoryName}()`, Boolean(newSchema.nullable), mockOptions?.nonNullable),
-				imports,
+				value: getNullable(isObjectLike ? `{ ...${factoryName}()${strictObjectCast} }` : `${factoryName}()`, Boolean(newSchema.nullable), mockOptions?.nonNullable),
+				imports: strictMockTypeImport ? [factoryImport, strictMockTypeImport] : [factoryImport],
 				name: newSchema.name,
 				type: getType(newSchema),
 				nullWrapped: Boolean(newSchema.nullable) && !mockOptions?.nonNullable
 			};
 		}
+		const importsBefore = imports.length;
 		const scalar = getMockScalar({
 			item: newSchema,
 			mockOptions,
@@ -921,27 +1220,36 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 				splitMockImplementations.push(func);
 			}
 			scalar.value = newSchema.nullable ? `${funcName}()` : `{...${funcName}()}`;
-			scalar.imports.push({ name: newSchema.name });
+			const typeImport = {
+				name: newSchema.name,
+				values: false
+			};
+			scalar.imports.push(typeImport);
+			if (scalar.imports !== imports) imports.push(typeImport);
 		}
+		mergeReturnedMockImports(imports, importsBefore, scalar.imports);
 		return {
 			...scalar,
 			type: getType(newSchema)
 		};
 	}
+	const importsBefore = imports.length;
+	const scalar = getMockScalar({
+		item: schema,
+		mockOptions,
+		operationId,
+		tags,
+		combine,
+		context,
+		imports,
+		existingReferencedProperties,
+		existingReferencedAllOfRefs,
+		splitMockImplementations,
+		allowOverride
+	});
+	mergeReturnedMockImports(imports, importsBefore, scalar.imports);
 	return {
-		...getMockScalar({
-			item: schema,
-			mockOptions,
-			operationId,
-			tags,
-			combine,
-			context,
-			imports,
-			existingReferencedProperties,
-			existingReferencedAllOfRefs,
-			splitMockImplementations,
-			allowOverride
-		}),
+		...scalar,
 		type: getType(schema)
 	};
 }
@@ -1201,7 +1509,8 @@ function getResponsesMockDefinition({ operationId, tags, returnType, responses,
 		if (context.output.override.mock?.useExamples || mockOptions?.useExamples) {
 			const exampleValue = unwrapExampleValue(example ?? originalSchema?.example ?? getExampleEntries(examples)[0] ?? getExampleEntries(originalSchema?.examples)[0]);
 			if (exampleValue !== void 0) {
-				result.definitions.push(transformer ? transformer(exampleValue, returnType) : JSON.stringify(exampleValue));
+				const formatted = formatSchemaExampleValue(exampleValue, originalSchema, context);
+				result.definitions.push(transformer ? transformer(formatted, returnType) : formatted);
 				continue;
 			}
 		}
@@ -1216,13 +1525,15 @@ function getResponsesMockDefinition({ operationId, tags, returnType, responses,
 		};
 		else if (!originalSchema) continue;
 		const resolvedSchema = resolveRef(originalSchema, context).schema;
+		const responseImports = imports ?? [];
+		const importsBefore = responseImports.length;
 		const scalar = getMockScalar({
 			item: {
 				...resolvedSchema,
 				name: definition,
 				...context.output.override.enumGenerationType === "enum" && isRef ? { isRef: true } : {}
 			},
-			imports,
+			imports: responseImports,
 			mockOptions: mockOptionsWithoutFunc,
 			operationId,
 			tags,
@@ -1231,9 +1542,11 @@ function getResponsesMockDefinition({ operationId, tags, returnType, responses,
 			splitMockImplementations,
 			allowOverride: true
 		});
-		result.imports.push(...scalar.imports);
+		appendImportsDelta(result.imports, responseImports, importsBefore);
+		if (scalar.imports !== responseImports) appendImportsDelta(result.imports, scalar.imports, 0);
 		result.definitions.push(transformer ? transformer(scalar.value, returnType) : scalar.value);
 	}
+	appendImportsDelta(result.imports, collectSplitMockTypeImports(splitMockImplementations), 0);
 	return result;
 }
 function getMockDefinition({ operationId, tags, returnType, responses, override, transformer, context, mockOptions, splitMockImplementations }) {
@@ -1437,7 +1750,8 @@ export const ${handlerName} = (overrideResponse?: ${mockReturnType} | ((${infoPa
 			handler: handlerImplementation
 		},
 		imports: includeResponseImports,
-		strictMockSchemaTypeNames: strictMock ? mergeStrictMockSchemaTypeNames(schemaTypeNames, collectStrictMockSchemaTypeNamesFromImplementation(mockImplementation)) : void 0
+		strictMockSchemaTypeNames: strictMock ? mergeStrictMockSchemaTypeNames(schemaTypeNames, collectStrictMockSchemaTypeNamesFromImplementation(mockImplementation)) : void 0,
+		strictMockSchemaKinds: strictMock ? mergeStrictMockSchemaKinds(getStrictMockSchemaKindsFromResponses(responses, context), Object.fromEntries((collectStrictMockSchemaTypeNamesFromImplementation(mockImplementation) ?? []).map((name) => [name, "object"]))) : void 0
 	};
 }
 function generateMSW(generatorVerbOptions, generatorOptions) {
@@ -1454,12 +1768,14 @@ function generateMSW(generatorVerbOptions, generatorOptions) {
 	const handlerImplementations = [baseDefinition.implementation.handler];
 	const imports = [...baseDefinition.imports];
 	const strictMockSchemaTypeNames = new Set(baseDefinition.strictMockSchemaTypeNames);
+	const strictMockSchemaKinds = { ...baseDefinition.strictMockSchemaKinds };
 	if (generatorOptions.mock && isObject(generatorOptions.mock) && generatorOptions.mock.generateEachHttpStatus) for (const statusResponse of [...response.types.success, ...response.types.errors]) {
 		const definition = generateDefinition(statusResponse.key, route, getResponseMockFunctionName, handlerName, generatorVerbOptions, generatorOptions, statusResponse.value, statusResponse.key, response.imports, [statusResponse], [statusResponse.contentType], splitMockImplementations);
 		mockImplementations.push(definition.implementation.function);
 		handlerImplementations.push(definition.implementation.handler);
 		imports.push(...definition.imports);
 		for (const name of definition.strictMockSchemaTypeNames ?? []) strictMockSchemaTypeNames.add(name);
+		if (definition.strictMockSchemaKinds) for (const [name, kind] of Object.entries(definition.strictMockSchemaKinds)) strictMockSchemaKinds[name] ??= kind;
 	}
 	const aggregatedStrictNames = [...strictMockSchemaTypeNames];
 	return {
@@ -1469,7 +1785,8 @@ function generateMSW(generatorVerbOptions, generatorOptions) {
 			handler: handlerImplementations.join("\n")
 		},
 		imports,
-		strictMockSchemaTypeNames: aggregatedStrictNames.length > 0 ? aggregatedStrictNames : void 0
+		strictMockSchemaTypeNames: aggregatedStrictNames.length > 0 ? aggregatedStrictNames : void 0,
+		strictMockSchemaKinds: mergeStrictMockSchemaKinds(strictMockSchemaKinds)
 	};
 }
 //#endregion
@@ -1507,7 +1824,8 @@ function generateFaker(generatorVerbOptions, generatorOptions) {
 			handlerName: ""
 		},
 		imports: result.imports,
-		strictMockSchemaTypeNames: result.strictMockSchemaTypeNames
+		strictMockSchemaTypeNames: result.strictMockSchemaTypeNames,
+		strictMockSchemaKinds: result.strictMockSchemaKinds
 	};
 }
 /**
@@ -1522,38 +1840,47 @@ function generateFaker(generatorVerbOptions, generatorOptions) {
 function generateFakerForSchemas(schemas, context, options) {
 	const factories = [];
 	const strictMockTypeNames = /* @__PURE__ */ new Set();
+	const strictMockSchemaKinds = {};
 	const allImports = [];
 	const splitMockImplementations = [];
 	const localFactoryNames = new Set(schemas.filter((s) => !!s.schema).map((s) => `get${pascal(s.name)}Mock`));
+	const localMockTypeNames = new Set(schemas.filter((s) => !!s.schema).map((s) => getStrictMockTypeName(pascal(s.name))));
 	const mockOptions = getMockWithoutFunc(context.spec, context.output.override);
 	for (const generatorSchema of schemas) {
 		const { name, schema } = generatorSchema;
 		if (!schema) continue;
 		const factoryName = `get${pascal(name)}Mock`;
 		const factoryImports = [];
+		const factoryImportsBefore = factoryImports.length;
+		const schemaName = pascal(name);
 		const result = getMockScalar({
 			item: {
 				...schema,
-				name
+				name: schemaName
 			},
 			imports: factoryImports,
 			mockOptions,
 			operationId: name,
 			tags: [],
 			context,
-			existingReferencedProperties: [],
+			existingReferencedProperties: [schemaName],
+			existingReferencedAllOfRefs: [schemaName],
 			splitMockImplementations,
 			allowOverride: true,
 			isRef: false
 		});
-		allImports.push(...result.imports, ...factoryImports);
+		appendImportsDelta(allImports, factoryImports, factoryImportsBefore);
+		if (result.imports !== factoryImports) appendImportsDelta(allImports, result.imports, 0);
 		const typeName = pascal(name);
 		const { param, returnType, returnCast } = getMockFactorySignatureParts(typeName, mockOptions, {
 			isOverridable: result.value.includes("overrideResponse"),
 			overrideType: `Partial<${typeName}>`
 		});
 		const factory = formatMockFactoryDeclaration(factoryName, param, returnType, result.value, returnCast);
-		if (isStrictMock(mockOptions)) strictMockTypeNames.add(typeName);
+		if (isStrictMock(mockOptions)) {
+			strictMockTypeNames.add(typeName);
+			strictMockSchemaKinds[typeName] = classifyStrictMockSchemaType(schema);
+		}
 		factories.push(factory);
 		allImports.push({
 			name: pascal(name),
@@ -1563,6 +1890,7 @@ function generateFakerForSchemas(schemas, context, options) {
 	const mergedImports = /* @__PURE__ */ new Map();
 	for (const imp of allImports) {
 		if (imp.schemaFactory && localFactoryNames.has(imp.name)) continue;
+		if (imp.schemaFactory && !imp.values && localMockTypeNames.has(imp.name)) continue;
 		const key = `${imp.name}::${imp.alias ?? ""}`;
 		const existing = mergedImports.get(key);
 		if (!existing) {
@@ -1573,11 +1901,16 @@ function generateFakerForSchemas(schemas, context, options) {
 	}
 	const uniqueImports = [...mergedImports.values()];
 	const implementation = [...splitMockImplementations, ...factories].filter(Boolean).join("\n\n");
+	for (const name of collectStrictMockSchemaTypeNamesFromImplementation(implementation)) {
+		strictMockTypeNames.add(name);
+		strictMockSchemaKinds[name] ??= "object";
+	}
 	const aggregatedStrictNames = [...strictMockTypeNames];
 	return {
 		implementation,
 		imports: uniqueImports,
-		strictMockSchemaTypeNames: aggregatedStrictNames.length > 0 ? aggregatedStrictNames : void 0
+		strictMockSchemaTypeNames: aggregatedStrictNames.length > 0 ? aggregatedStrictNames : void 0,
+		strictMockSchemaKinds: mergeStrictMockSchemaKinds(strictMockSchemaKinds)
 	};
 }
 //#endregion