@kubb/plugin-ts 5.0.0-alpha.23 → 5.0.0-alpha.25

package/dist/index.js

@@ -2,11 +2,11 @@ import "./chunk--u3MIqq1.js";
 import path from "node:path";
 import { safePrint } from "@kubb/fabric-core/parsers/typescript";
 import { File } from "@kubb/react-fabric";
+import { caseParams, collect, composeTransformers, createPrinterFactory, createProperty, createSchema, extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef, transform, walk } from "@kubb/ast";
 import { isNumber } from "remeda";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-import { caseParams, collect, composeTransformers, createPrinterFactory, createProperty, createSchema, isStringType, narrowSchema, schemaTypes, transform, walk } from "@kubb/ast";
-import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getBarrelFiles, getMode, getPreset, renderOperation, renderSchema } from "@kubb/core";
+import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getBarrelFiles, getMode, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from "@kubb/core";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -176,6 +176,15 @@ const ENUM_TYPES_WITH_TYPE_ONLY = new Set([
 	"literal",
 	void 0
 ]);
+/**
+* Ordering priority for function parameters: lower = sorted earlier.
+*/
+const PARAM_RANK = {
+	required: 0,
+	optional: 1,
+	withDefault: 2,
+	rest: 3
+};
 //#endregion
 //#region src/factory.ts
 const { SyntaxKind, factory } = ts;
@@ -264,7 +273,7 @@ function createInterfaceDeclaration({ modifiers, name, typeParameters, members }
 function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
 	if (syntax === "interface" && "members" in type) return appendJSDocToNode({
 		node: createInterfaceDeclaration({
-			members: type.members,
+			members: [...type.members],
 			modifiers: isExportable ? [modifiers.export] : [],
 			name,
 			typeParameters: void 0
@@ -397,64 +406,6 @@ const createFalse = factory.createFalse;
 factory.createIndexedAccessTypeNode;
 factory.createTypeOperatorNode;
 const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
-//#endregion
-//#region src/components/Enum.tsx
-/**
-* Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
-*
-* The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
-* valid TypeScript identifier. The resolver normalizes it; for inline enum
-* properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
-*/
-function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
-	const resolved = resolver.default(node.name, "type");
-	return {
-		enumName: enumType === "asPascalConst" ? resolved : camelCase(node.name),
-		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved,
-		refName: resolved
-	};
-}
-/**
-* Renders the enum declaration(s) for a single named `EnumSchemaNode`.
-*
-* Depending on `enumType` this may emit:
-* - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
-* - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
-* - A union literal type alias (`literal`)
-*
-* The emitted `File.Source` nodes carry the resolved names so that the barrel
-* index picks up the correct export identifiers.
-*/
-function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
-	const { enumName, typeName } = getEnumNames({
-		node,
-		enumType,
-		enumTypeSuffix,
-		resolver
-	});
-	const [nameNode, typeNode] = createEnumDeclaration({
-		name: enumName,
-		typeName,
-		enums: node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
-		type: enumType,
-		enumKeyCasing
-	});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
-		name: enumName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: false,
-		children: safePrint(nameNode)
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isIndexable: true,
-		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
-		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
-		children: safePrint(typeNode)
-	})] });
-}
-//#endregion
-//#region src/printers/printerTs.ts
 /**
 * Converts a primitive const value to a TypeScript literal type node.
 * Handles negative numbers via a prefix unary expression.
@@ -500,28 +451,13 @@ function buildTupleNode(node, print) {
 */
 function buildPropertyType(schema, baseType, optionalType) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
+	const meta = syncSchemaRef(schema);
 	let type = baseType;
-	if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-	if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+	if ((meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
 /**
-* Collects JSDoc annotation strings (description, deprecated, min/max, pattern, default, example, type) for a schema node.
-*/
-function buildPropertyJSDocComments(schema) {
-	const isArray = schema.type === "array";
-	return [
-		"description" in schema && schema.description ? `@description ${jsStringEscape(schema.description)}` : void 0,
-		"deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
-		!isArray && "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
-		!isArray && "max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
-		"pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
-		"default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify(schema.default) : schema.default}` : void 0,
-		"example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
-		"primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
-	];
-}
-/**
 * Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
 */
 function buildIndexSignatures(node, propertyCount, print) {
@@ -540,6 +476,194 @@ function buildIndexSignatures(node, propertyCount, print) {
 	}
 	return elements;
 }
+//#endregion
+//#region src/components/Enum.tsx
+/**
+* Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
+*
+* The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
+* valid TypeScript identifier. The resolver normalizes it; for inline enum
+* properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
+*/
+function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
+	const resolved = resolver.default(node.name, "type");
+	return {
+		enumName: enumType === "asPascalConst" ? resolved : camelCase(node.name),
+		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
+	};
+}
+/**
+* Renders the enum declaration(s) for a single named `EnumSchemaNode`.
+*
+* Depending on `enumType` this may emit:
+* - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
+* - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
+* - A union literal type alias (`literal`)
+*
+* The emitted `File.Source` nodes carry the resolved names so that the barrel
+* index picks up the correct export identifiers.
+*/
+function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
+	const { enumName, typeName } = getEnumNames({
+		node,
+		enumType,
+		enumTypeSuffix,
+		resolver
+	});
+	const [nameNode, typeNode] = createEnumDeclaration({
+		name: enumName,
+		typeName,
+		enums: node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
+		type: enumType,
+		enumKeyCasing
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
+		name: enumName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: false,
+		children: safePrint(nameNode)
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isIndexable: true,
+		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
+		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
+		children: safePrint(typeNode)
+	})] });
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Collects JSDoc annotation strings for a schema node.
+*
+* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
+* Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
+
+*/
+function buildPropertyJSDocComments(schema) {
+	const meta = syncSchemaRef(schema);
+	const isArray = meta?.primitive === "array";
+	return [
+		meta && "description" in meta && meta.description ? `@description ${jsStringEscape(meta.description)}` : void 0,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : void 0,
+		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : void 0,
+		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : void 0,
+		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : void 0,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? stringify(meta.default) : meta.default}` : void 0,
+		meta && "example" in meta && meta.example !== void 0 ? `@example ${meta.example}` : void 0,
+		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+	].filter(Boolean);
+}
+function buildParams(node, { params, resolver }) {
+	return createSchema({
+		type: "object",
+		properties: params.map((param) => createProperty({
+			name: param.name,
+			required: param.required,
+			schema: createSchema({
+				type: "ref",
+				name: resolver.resolveParamName(node, param)
+			})
+		}))
+	});
+}
+function buildData(node, { resolver }) {
+	const pathParams = node.parameters.filter((p) => p.in === "path");
+	const queryParams = node.parameters.filter((p) => p.in === "query");
+	const headerParams = node.parameters.filter((p) => p.in === "header");
+	return createSchema({
+		type: "object",
+		deprecated: node.deprecated,
+		properties: [
+			createProperty({
+				name: "data",
+				schema: node.requestBody?.schema ? createSchema({
+					type: "ref",
+					name: resolver.resolveDataName(node),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					primitive: void 0,
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "pathParams",
+				required: pathParams.length > 0,
+				schema: pathParams.length > 0 ? buildParams(node, {
+					params: pathParams,
+					resolver
+				}) : createSchema({
+					type: "never",
+					primitive: void 0
+				})
+			}),
+			createProperty({
+				name: "queryParams",
+				schema: queryParams.length > 0 ? createSchema({
+					...buildParams(node, {
+						params: queryParams,
+						resolver
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					primitive: void 0,
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "headerParams",
+				schema: headerParams.length > 0 ? createSchema({
+					...buildParams(node, {
+						params: headerParams,
+						resolver
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					primitive: void 0,
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "url",
+				required: true,
+				schema: createSchema({
+					type: "url",
+					path: node.path
+				})
+			})
+		]
+	});
+}
+function buildResponses(node, { resolver }) {
+	if (node.responses.length === 0) return null;
+	return createSchema({
+		type: "object",
+		properties: node.responses.map((res) => createProperty({
+			name: String(res.statusCode),
+			required: true,
+			schema: createSchema({
+				type: "ref",
+				name: resolver.resolveResponseStatusName(node, res.statusCode)
+			})
+		}))
+	});
+}
+function buildResponseUnion(node, { resolver }) {
+	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	if (responsesWithSchema.length === 0) return null;
+	return createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	});
+}
+//#endregion
+//#region src/printers/printerTs.ts
 /**
 * TypeScript type printer built with `definePrinter`.
 *
@@ -583,6 +707,8 @@ const printerTs = definePrinter((options) => {
 				if (node.path) return createUrlTemplateType(node.path);
 				return keywordTypeNodes.string;
 			},
+			ipv4: () => keywordTypeNodes.string,
+			ipv6: () => keywordTypeNodes.string,
 			datetime: () => keywordTypeNodes.string,
 			number: () => keywordTypeNodes.number,
 			integer: () => keywordTypeNodes.number,
@@ -591,14 +717,14 @@ const printerTs = definePrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return;
-				const refName = node.ref ? node.ref.split("/").at(-1) ?? node.name : node.name;
-				return createTypeReferenceNode(node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
 			},
 			enum(node) {
 				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
 				if (this.options.enumType === "inlineLiteral" || !node.name) return createUnionDeclaration({
 					withParentheses: true,
-					nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
 				}) ?? void 0;
 				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enumTypeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
 			},
@@ -644,12 +770,13 @@ const printerTs = definePrinter((options) => {
 				const propertyNodes = node.properties.map((prop) => {
 					const baseType = transform(prop.schema) ?? keywordTypeNodes.unknown;
 					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
+					const propMeta = syncSchemaRef(prop.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
 							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
 							name: prop.name,
 							type,
-							readOnly: prop.schema.readOnly
+							readOnly: propMeta?.readOnly
 						}),
 						comments: buildPropertyJSDocComments(prop.schema)
 					});
@@ -660,39 +787,39 @@ const printerTs = definePrinter((options) => {
 			}
 		},
 		print(node) {
-			let type = this.transform(node);
-			if (!type) return null;
-			if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-			if ((node.nullish || node.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
-			if (!name) return safePrint(type);
-			const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!keysToOmit?.length;
+			let base = this.transform(node);
+			if (!base) return null;
+			const meta = syncSchemaRef(node);
+			if (!name) {
+				if (meta.nullable) base = createUnionDeclaration({ nodes: [base, keywordTypeNodes.null] });
+				if ((meta.nullish || meta.optional) && addsUndefined) base = createUnionDeclaration({ nodes: [base, keywordTypeNodes.undefined] });
+				return safePrint(base);
+			}
+			let inner = keysToOmit?.length ? createOmitDeclaration({
+				keys: keysToOmit,
+				type: base,
+				nonNullable: true
+			}) : base;
+			if (meta.nullable) inner = createUnionDeclaration({ nodes: [inner, keywordTypeNodes.null] });
+			if (meta.nullish || meta.optional) inner = createUnionDeclaration({ nodes: [inner, keywordTypeNodes.undefined] });
+			const useTypeGeneration = syntaxType === "type" || inner.kind === syntaxKind.union || !!keysToOmit?.length;
 			return safePrint(createTypeDeclaration({
 				name,
 				isExportable: true,
-				type: keysToOmit?.length ? createOmitDeclaration({
-					keys: keysToOmit,
-					type,
-					nonNullable: true
-				}) : type,
+				type: inner,
 				syntax: useTypeGeneration ? "type" : "interface",
-				comments: [
-					node?.title ? jsStringEscape(node.title) : void 0,
-					description ? `@description ${jsStringEscape(description)}` : void 0,
-					node?.deprecated ? "@deprecated" : void 0,
-					node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
-					node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
-					node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
-					node?.default ? `@default ${node.default}` : void 0,
-					node?.example ? `@example ${node.example}` : void 0
-				]
+				comments: buildPropertyJSDocComments({
+					...meta,
+					description
+				})
 			}));
 		}
 	};
 });
 //#endregion
 //#region src/components/Type.tsx
-function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver }) {
+function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver, enumSchemaNames }) {
 	const resolvedDescription = description || node?.description;
 	const enumSchemaNodes = collect(node, { schema(n) {
 		const enumNode = narrowSchema(n, schemaTypes.enum);
@@ -707,7 +834,8 @@ function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enu
 		syntaxType,
 		description: resolvedDescription,
 		keysToOmit,
-		resolver
+		resolver,
+		enumSchemaNames
 	}).print(node);
 	if (!output) return;
 	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
@@ -731,144 +859,111 @@ function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enu
 		resolver
 	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
 		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
-//#region src/utils.ts
-function buildParams({ params, node, resolver }) {
-	return createSchema({
-		type: "object",
-		properties: params.map((param) => createProperty({
-			name: param.name,
-			required: param.required,
-			schema: createSchema({
-				type: "ref",
-				name: resolver.resolveParamName(node, param)
-			})
-		}))
-	});
-}
-function buildData({ node, resolver }) {
-	const pathParams = node.parameters.filter((p) => p.in === "path");
-	const queryParams = node.parameters.filter((p) => p.in === "query");
-	const headerParams = node.parameters.filter((p) => p.in === "header");
-	return createSchema({
-		type: "object",
-		deprecated: node.deprecated,
-		properties: [
-			createProperty({
-				name: "data",
-				schema: node.requestBody?.schema ? createSchema({
-					type: "ref",
-					name: resolver.resolveDataName(node),
-					optional: true
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "pathParams",
-				required: pathParams.length > 0,
-				schema: pathParams.length > 0 ? buildParams({
-					params: pathParams,
-					node,
-					resolver
-				}) : createSchema({ type: "never" })
-			}),
-			createProperty({
-				name: "queryParams",
-				schema: queryParams.length > 0 ? createSchema({
-					...buildParams({
-						params: queryParams,
-						node,
-						resolver
-					}),
-					optional: true
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "headerParams",
-				schema: headerParams.length > 0 ? createSchema({
-					...buildParams({
-						params: headerParams,
-						node,
-						resolver
-					}),
-					optional: true
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "url",
-				required: true,
-				schema: createSchema({
-					type: "url",
-					path: node.path
-				})
-			})
-		]
-	});
-}
-function buildResponses({ node, resolver }) {
-	if (node.responses.length === 0) return null;
-	return createSchema({
-		type: "object",
-		properties: node.responses.map((res) => createProperty({
-			name: String(res.statusCode),
-			required: true,
-			schema: createSchema({
-				type: "ref",
-				name: resolver.resolveResponseStatusName(node, res.statusCode)
-			})
-		}))
-	});
-}
-function buildResponseUnion({ node, resolver }) {
-	const responsesWithSchema = node.responses.filter((res) => res.schema);
-	if (responsesWithSchema.length === 0) return null;
-	return createSchema({
-		type: "union",
-		members: responsesWithSchema.map((res) => createSchema({
-			type: "ref",
-			name: resolver.resolveResponseStatusName(node, res.statusCode)
-		}))
-	});
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
 }
 //#endregion
 //#region src/generators/typeGenerator.tsx
 const typeGenerator = defineGenerator({
 	name: "typescript",
 	type: "react",
+	Schema({ node, adapter, options, config, resolver }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		if (!transformedNode.name) return;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+		function resolveImportName(schemaName) {
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			return resolver.default(schemaName, "type");
+		}
+		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+			name: resolveImportName(schemaName),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum);
+		const meta = {
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveName(transformedNode.name),
+			file: resolver.resolveFile({
+				name: transformedNode.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				transformedNode.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: meta.name,
+				node: transformedNode,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType,
+				resolver,
+				enumSchemaNames
+			})]
+		});
+	},
 	Operation({ node, adapter, options, config, resolver }) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
 		const root = path.resolve(config.root, config.output.path);
 		const mode = getMode(path.resolve(root, output.path));
-		const file = resolver.resolveFile({
-			name: node.operationId,
+		const params = caseParams(transformedNode.parameters, paramsCasing);
+		const meta = { file: resolver.resolveFile({
+			name: transformedNode.operationId,
 			extname: ".ts",
-			tag: node.tags[0] ?? "default",
-			path: node.path
+			tag: transformedNode.tags[0] ?? "default",
+			path: transformedNode.path
 		}, {
 			root,
 			output,
 			group
-		});
-		const params = caseParams(node.parameters, paramsCasing);
-		function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
-			if (!schemaNode) return null;
-			const transformedNode = transform(schemaNode, composeTransformers(...transformers));
-			const imports = adapter.getImports(transformedNode, (schemaName) => ({
-				name: resolver.default(schemaName, "type"),
+		}) };
+		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+		function resolveImportName(schemaName) {
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			return resolver.default(schemaName, "type");
+		}
+		function renderSchemaType({ schema, name, keysToOmit }) {
+			if (!schema) return null;
+			const imports = adapter.getImports(schema, (schemaName) => ({
+				name: resolveImportName(schemaName),
 				path: resolver.resolveFile({
 					name: schemaName,
 					extname: ".ts"
@@ -879,7 +974,7 @@ const typeGenerator = defineGenerator({
 				}).path
 			}));
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: file.path,
+				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
 				isTypeOnly: true
@@ -889,8 +984,7 @@ const typeGenerator = defineGenerator({
 				imp.isTypeOnly
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name,
-				node: transformedNode,
-				description,
+				node: schema,
 				enumType,
 				enumTypeSuffix,
 				enumKeyCasing,
@@ -898,54 +992,49 @@ const typeGenerator = defineGenerator({
 				arrayType,
 				syntaxType,
 				resolver,
-				keysToOmit
+				keysToOmit,
+				enumSchemaNames
 			})] });
 		}
 		const paramTypes = params.map((param) => renderSchemaType({
-			node: param.schema,
-			name: resolver.resolveParamName(node, param)
+			schema: param.schema,
+			name: resolver.resolveParamName(transformedNode, param)
 		}));
-		const requestType = node.requestBody?.schema ? renderSchemaType({
-			node: node.requestBody.schema,
-			name: resolver.resolveDataName(node),
-			description: node.requestBody.description ?? node.requestBody.schema.description,
-			keysToOmit: node.requestBody.keysToOmit
+		const requestType = transformedNode.requestBody?.schema ? renderSchemaType({
+			schema: {
+				...transformedNode.requestBody.schema,
+				description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description
+			},
+			name: resolver.resolveDataName(transformedNode),
+			keysToOmit: transformedNode.requestBody.keysToOmit
 		}) : null;
-		const responseTypes = node.responses.map((res) => renderSchemaType({
-			node: res.schema,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			description: res.description,
+		const responseTypes = transformedNode.responses.map((res) => renderSchemaType({
+			schema: res.schema,
+			name: resolver.resolveResponseStatusName(transformedNode, res.statusCode),
 			keysToOmit: res.keysToOmit
 		}));
 		const dataType = renderSchemaType({
-			node: buildData({
-				node: {
-					...node,
-					parameters: params
-				},
-				resolver
-			}),
-			name: resolver.resolveRequestConfigName(node)
+			schema: buildData({
+				...transformedNode,
+				parameters: params
+			}, { resolver }),
+			name: resolver.resolveRequestConfigName(transformedNode)
 		});
 		const responsesType = renderSchemaType({
-			node: buildResponses({
-				node,
-				resolver
-			}),
-			name: resolver.resolveResponsesName(node)
+			schema: buildResponses(transformedNode, { resolver }),
+			name: resolver.resolveResponsesName(transformedNode)
 		});
 		const responseType = renderSchemaType({
-			node: buildResponseUnion({
-				node,
-				resolver
-			}),
-			name: resolver.resolveResponseName(node),
-			description: "Union of all possible responses"
+			schema: transformedNode.responses.some((res) => res.schema) ? {
+				...buildResponseUnion(transformedNode, { resolver }),
+				description: "Union of all possible responses"
+			} : null,
+			name: resolver.resolveResponseName(transformedNode)
 		});
 		return /* @__PURE__ */ jsxs(File, {
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
 			banner: resolver.resolveBanner(adapter.rootNode, {
 				output,
 				config
@@ -963,74 +1052,11 @@ const typeGenerator = defineGenerator({
 				responseType
 			]
 		});
-	},
-	Schema({ node, adapter, options, config, resolver }) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		if (!node.name) return;
-		const transformedNode = transform(node, composeTransformers(...transformers));
-		const imports = adapter.getImports(transformedNode, (schemaName) => ({
-			name: resolver.default(schemaName, "type"),
-			path: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			}).path
-		}));
-		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
-		const type = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name),
-			file: resolver.resolveFile({
-				name: node.name,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			})
-		};
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: resolver.resolveBanner(adapter.rootNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.rootNode, {
-				output,
-				config
-			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: type.file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				node.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ jsx(Type, {
-				name: type.name,
-				node: transformedNode,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver
-			})]
-		});
 	}
 });
 //#endregion
 //#region src/resolvers/resolverTs.ts
-function resolveName(name, type) {
+function toTypeName(name, type) {
 	return pascalCase(name, { isFile: type === "file" });
 }
 /**
@@ -1055,7 +1081,7 @@ const resolverTs = defineResolver(() => {
 		name: "default",
 		pluginName: "plugin-ts",
 		default(name, type) {
-			return resolveName(name, type);
+			return toTypeName(name, type);
 		},
 		resolveName(name) {
 			return this.default(name, "function");
@@ -1174,7 +1200,7 @@ function buildGroupedParamsSchema({ params, parentName }) {
 		})
 	});
 }
-function buildLegacyResponsesSchemaNode({ node, resolver }) {
+function buildLegacyResponsesSchemaNode(node, { resolver }) {
 	const isGet = node.method.toLowerCase() === "get";
 	const successResponses = node.responses.filter((res) => {
 		const code = Number(res.statusCode);
@@ -1190,7 +1216,10 @@ function buildLegacyResponsesSchemaNode({ node, resolver }) {
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
-	}) : createSchema({ type: "any" });
+	}) : createSchema({
+		type: "any",
+		primitive: void 0
+	});
 	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
@@ -1200,7 +1229,10 @@ function buildLegacyResponsesSchemaNode({ node, resolver }) {
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
-	}) : createSchema({ type: "any" });
+	}) : createSchema({
+		type: "any",
+		primitive: void 0
+	});
 	const properties = [createProperty({
 		name: "Response",
 		required: true,
@@ -1251,12 +1283,15 @@ function buildLegacyResponsesSchemaNode({ node, resolver }) {
 		properties
 	});
 }
-function buildLegacyResponseUnionSchemaNode({ node, resolver }) {
+function buildLegacyResponseUnionSchemaNode(node, { resolver }) {
 	const successResponses = node.responses.filter((res) => {
 		const code = Number(res.statusCode);
 		return !Number.isNaN(code) && code >= 200 && code < 300;
 	});
-	if (successResponses.length === 0) return createSchema({ type: "any" });
+	if (successResponses.length === 0) return createSchema({
+		type: "any",
+		primitive: void 0
+	});
 	if (successResponses.length === 1) return createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
@@ -1297,25 +1332,88 @@ function nameUnnamedEnums(node, parentName) {
 const typeGeneratorLegacy = defineGenerator({
 	name: "typescript-legacy",
 	type: "react",
+	Schema({ node, adapter, options, config, resolver }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		if (!transformedNode.name) return;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+			name: resolver.default(schemaName, "type"),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum);
+		const meta = {
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix) : resolver.resolveName(transformedNode.name),
+			file: resolver.resolveFile({
+				name: transformedNode.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				transformedNode.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: meta.name,
+				node: transformedNode,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType,
+				resolver
+			})]
+		});
+	},
 	Operation({ node, adapter, options, config, resolver }) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
 		const root = path.resolve(config.root, config.output.path);
 		const mode = getMode(path.resolve(root, output.path));
-		const file = resolver.resolveFile({
-			name: node.operationId,
+		const params = caseParams(node.parameters, paramsCasing);
+		const meta = { file: resolver.resolveFile({
+			name: transformedNode.operationId,
 			extname: ".ts",
-			tag: node.tags[0] ?? "default",
-			path: node.path
+			tag: transformedNode.tags[0] ?? "default",
+			path: transformedNode.path
 		}, {
 			root,
 			output,
 			group
-		});
-		const params = caseParams(node.parameters, paramsCasing);
-		function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
-			if (!schemaNode) return null;
-			const transformedNode = transform(schemaNode, composeTransformers(...transformers));
-			const imports = adapter.getImports(transformedNode, (schemaName) => ({
+		}) };
+		function renderSchemaType({ schema, name, description, keysToOmit }) {
+			if (!schema) return null;
+			const imports = adapter.getImports(schema, (schemaName) => ({
 				name: resolver.default(schemaName, "type"),
 				path: resolver.resolveFile({
 					name: schemaName,
@@ -1327,7 +1425,7 @@ const typeGeneratorLegacy = defineGenerator({
 				}).path
 			}));
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: file.path,
+				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
 				isTypeOnly: true
@@ -1337,7 +1435,7 @@ const typeGeneratorLegacy = defineGenerator({
 				imp.isTypeOnly
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name,
-				node: transformedNode,
+				node: schema,
 				description,
 				enumType,
 				enumTypeSuffix,
@@ -1356,35 +1454,35 @@ const typeGeneratorLegacy = defineGenerator({
 			const responseName = resolver.resolveResponseStatusName(node, res.statusCode);
 			const baseResponseName = resolverTsLegacy.resolveResponseStatusName(node, res.statusCode);
 			return renderSchemaType({
-				node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
+				schema: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
 				name: responseName,
 				description: res.description,
 				keysToOmit: res.keysToOmit
 			});
 		});
 		const requestType = node.requestBody?.schema ? renderSchemaType({
-			node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
+			schema: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
 			name: resolver.resolveDataName(node),
 			description: node.requestBody.description ?? node.requestBody.schema.description,
 			keysToOmit: node.requestBody.keysToOmit
 		}) : null;
 		const legacyParamTypes = [
 			pathParams.length > 0 ? renderSchemaType({
-				node: buildGroupedParamsSchema({
+				schema: buildGroupedParamsSchema({
 					params: pathParams,
 					parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0])
 				}),
 				name: resolver.resolvePathParamsName(node, pathParams[0])
 			}) : null,
 			queryParams.length > 0 ? renderSchemaType({
-				node: buildGroupedParamsSchema({
+				schema: buildGroupedParamsSchema({
 					params: queryParams,
 					parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0])
 				}),
 				name: resolver.resolveQueryParamsName(node, queryParams[0])
 			}) : null,
 			headerParams.length > 0 ? renderSchemaType({
-				node: buildGroupedParamsSchema({
+				schema: buildGroupedParamsSchema({
 					params: headerParams,
 					parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0])
 				}),
@@ -1392,23 +1490,17 @@ const typeGeneratorLegacy = defineGenerator({
 			}) : null
 		];
 		const legacyResponsesType = renderSchemaType({
-			node: buildLegacyResponsesSchemaNode({
-				node,
-				resolver
-			}),
+			schema: buildLegacyResponsesSchemaNode(node, { resolver }),
 			name: resolver.resolveResponsesName(node)
 		});
 		const legacyResponseType = renderSchemaType({
-			node: buildLegacyResponseUnionSchemaNode({
-				node,
-				resolver
-			}),
+			schema: buildLegacyResponseUnionSchemaNode(node, { resolver }),
 			name: resolver.resolveResponseName(node)
 		});
 		return /* @__PURE__ */ jsxs(File, {
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
 			banner: resolver.resolveBanner(adapter.rootNode, {
 				output,
 				config
@@ -1425,69 +1517,6 @@ const typeGeneratorLegacy = defineGenerator({
 				legacyResponsesType
 			]
 		});
-	},
-	Schema({ node, adapter, options, config, resolver }) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
-		const root = path.resolve(config.root, config.output.path);
-		const mode = getMode(path.resolve(root, output.path));
-		if (!node.name) return;
-		const transformedNode = transform(node, composeTransformers(...transformers));
-		const imports = adapter.getImports(transformedNode, (schemaName) => ({
-			name: resolver.default(schemaName, "type"),
-			path: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			}).path
-		}));
-		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
-		const type = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name),
-			file: resolver.resolveFile({
-				name: node.name,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			})
-		};
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: resolver.resolveBanner(adapter.rootNode, {
-				output,
-				config
-			}),
-			footer: resolver.resolveFooter(adapter.rootNode, {
-				output,
-				config
-			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-				root: type.file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				node.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ jsx(Type, {
-				name: type.name,
-				node: transformedNode,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType,
-				resolver
-			})]
-		});
 	}
 });
 //#endregion
@@ -1556,9 +1585,9 @@ const pluginTs = createPlugin((options) => {
 				output,
 				optionalType,
 				group: group ? {
-					...options.group,
+					...group,
 					name: (ctx) => {
-						if (options.group?.type === "path") return `${ctx.group.split("/")[1]}`;
+						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
 						return `${camelCase(ctx.group)}Controller`;
 					}
 				} : void 0,
@@ -1597,59 +1626,37 @@ const pluginTs = createPlugin((options) => {
 		async install() {
 			const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this;
 			const root = path.resolve(config.root, config.output.path);
-			if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+			if (!adapter) throw new Error(`[${pluginTsName}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
 			await openInStudio({ ast: true });
+			const collectedOperations = [];
+			const generatorContext = {
+				generators: preset.generators,
+				plugin,
+				resolver,
+				exclude,
+				include,
+				override,
+				fabric,
+				adapter,
+				config,
+				driver
+			};
 			await walk(rootNode, {
 				depth: "shallow",
 				async schema(schemaNode) {
-					const writeTasks = preset.generators.map(async (generator) => {
-						if (generator.type === "react" && generator.version === "2") {
-							const options = resolver.resolveOptions(schemaNode, {
-								options: plugin.options,
-								exclude,
-								include,
-								override
-							});
-							if (options === null) return;
-							await renderSchema(schemaNode, {
-								options,
-								resolver,
-								adapter,
-								config,
-								fabric,
-								Component: generator.Schema,
-								plugin,
-								driver
-							});
-						}
-					});
-					await Promise.all(writeTasks);
+					await runGeneratorSchema(schemaNode, generatorContext);
 				},
 				async operation(operationNode) {
-					const writeTasks = preset.generators.map(async (generator) => {
-						if (generator.type === "react" && generator.version === "2") {
-							const options = resolver.resolveOptions(operationNode, {
-								options: plugin.options,
-								exclude,
-								include,
-								override
-							});
-							if (options === null) return;
-							await renderOperation(operationNode, {
-								options,
-								resolver,
-								adapter,
-								config,
-								fabric,
-								Component: generator.Operation,
-								plugin,
-								driver
-							});
-						}
-					});
-					await Promise.all(writeTasks);
+					if (resolver.resolveOptions(operationNode, {
+						options: plugin.options,
+						exclude,
+						include,
+						override
+					}) !== null) collectedOperations.push(operationNode);
+					await runGeneratorOperation(operationNode, generatorContext);
 				}
 			});
+			await runGeneratorOperations(collectedOperations, generatorContext);
 			const barrelFiles = await getBarrelFiles(this.fabric.files, {
 				type: output.barrelType ?? "named",
 				root,
@@ -1677,12 +1684,12 @@ const kindToHandlerKey = {
 const defineFunctionPrinter = createPrinterFactory((node) => kindToHandlerKey[node.kind]);
 function rank(param) {
 	if (param.kind === "ParameterGroup") {
-		if (param.default) return 2;
-		return param.optional ?? param.properties.every((p) => p.optional || p.default !== void 0) ? 1 : 0;
+		if (param.default) return PARAM_RANK.withDefault;
+		return param.optional ?? param.properties.every((p) => p.optional || p.default !== void 0) ? PARAM_RANK.optional : PARAM_RANK.required;
 	}
-	if (param.rest) return 3;
-	if (param.default) return 2;
-	return param.optional ? 1 : 0;
+	if (param.rest) return PARAM_RANK.rest;
+	if (param.default) return PARAM_RANK.withDefault;
+	return param.optional ? PARAM_RANK.optional : PARAM_RANK.required;
 }
 function sortParams(params) {
 	return [...params].sort((a, b) => rank(a) - rank(b));