@kubb/plugin-ts 5.0.0-alpha.34 → 5.0.0-alpha.35

package/dist/index.js

@@ -1,11 +1,10 @@
 import "./chunk--u3MIqq1.js";
 import { safePrint } from "@kubb/parser-ts";
-import { File } from "@kubb/renderer-jsx";
-import { caseParams, collect, createPrinterFactory, createProperty, createSchema, extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef, transform } from "@kubb/ast";
+import { File, jsxRenderer } from "@kubb/renderer-jsx";
+import { ast, defineGenerator, definePlugin, definePrinter, defineResolver } from "@kubb/core";
 import { isNumber } from "remeda";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getPreset, mergeGenerators } from "@kubb/core";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -450,7 +449,7 @@ function buildTupleNode(node, print) {
 */
 function buildPropertyType(schema, baseType, optionalType) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = syncSchemaRef(schema);
+	const meta = ast.syncSchemaRef(schema);
 	let type = baseType;
 	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
 	if ((meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
@@ -533,8 +532,8 @@ function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
 //#endregion
 //#region src/components/Type.tsx
 function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
-	const enumSchemaNodes = collect(node, { schema(n) {
-		const enumNode = narrowSchema(n, schemaTypes.enum);
+	const enumSchemaNodes = ast.collect(node, { schema(n) {
+		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
 		if (enumNode?.name) return enumNode;
 	} });
 	const output = printer.print(node);
@@ -576,7 +575,7 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 
 */
 function buildPropertyJSDocComments(schema) {
-	const meta = syncSchemaRef(schema);
+	const meta = ast.syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
 	return [
 		meta && "description" in meta && meta.description ? `@description ${jsStringEscape(meta.description)}` : void 0,
@@ -590,12 +589,12 @@ function buildPropertyJSDocComments(schema) {
 	].filter(Boolean);
 }
 function buildParams(node, { params, resolver }) {
-	return createSchema({
+	return ast.createSchema({
 		type: "object",
-		properties: params.map((param) => createProperty({
+		properties: params.map((param) => ast.createProperty({
 			name: param.name,
 			required: param.required,
-			schema: createSchema({
+			schema: ast.createSchema({
 				type: "ref",
 				name: resolver.resolveParamName(node, param)
 			})
@@ -606,65 +605,65 @@ 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({
+	return ast.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
 		properties: [
-			createProperty({
+			ast.createProperty({
 				name: "data",
-				schema: node.requestBody?.schema ? createSchema({
+				schema: node.requestBody?.schema ? ast.createSchema({
 					type: "ref",
 					name: resolver.resolveDataName(node),
 					optional: true
-				}) : createSchema({
+				}) : ast.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			createProperty({
+			ast.createProperty({
 				name: "pathParams",
 				required: pathParams.length > 0,
 				schema: pathParams.length > 0 ? buildParams(node, {
 					params: pathParams,
 					resolver
-				}) : createSchema({
+				}) : ast.createSchema({
 					type: "never",
 					primitive: void 0
 				})
 			}),
-			createProperty({
+			ast.createProperty({
 				name: "queryParams",
-				schema: queryParams.length > 0 ? createSchema({
+				schema: queryParams.length > 0 ? ast.createSchema({
 					...buildParams(node, {
 						params: queryParams,
 						resolver
 					}),
 					optional: true
-				}) : createSchema({
+				}) : ast.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			createProperty({
+			ast.createProperty({
 				name: "headerParams",
-				schema: headerParams.length > 0 ? createSchema({
+				schema: headerParams.length > 0 ? ast.createSchema({
 					...buildParams(node, {
 						params: headerParams,
 						resolver
 					}),
 					optional: true
-				}) : createSchema({
+				}) : ast.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			createProperty({
+			ast.createProperty({
 				name: "url",
 				required: true,
-				schema: createSchema({
+				schema: ast.createSchema({
 					type: "url",
 					path: node.path
 				})
@@ -674,12 +673,12 @@ function buildData(node, { resolver }) {
 }
 function buildResponses(node, { resolver }) {
 	if (node.responses.length === 0) return null;
-	return createSchema({
+	return ast.createSchema({
 		type: "object",
-		properties: node.responses.map((res) => createProperty({
+		properties: node.responses.map((res) => ast.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: createSchema({
+			schema: ast.createSchema({
 				type: "ref",
 				name: resolver.resolveResponseStatusName(node, res.statusCode)
 			})
@@ -689,9 +688,9 @@ function buildResponses(node, { resolver }) {
 function buildResponseUnion(node, { resolver }) {
 	const responsesWithSchema = node.responses.filter((res) => res.schema);
 	if (responsesWithSchema.length === 0) return null;
-	return createSchema({
+	return ast.createSchema({
 		type: "union",
-		members: responsesWithSchema.map((res) => createSchema({
+		members: responsesWithSchema.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
@@ -752,7 +751,7 @@ const printerTs = definePrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return;
-				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
+				const refName = node.ref ? ast.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) {
@@ -766,13 +765,13 @@ const printerTs = definePrinter((options) => {
 			union(node) {
 				const members = node.members ?? [];
 				const hasStringLiteral = members.some((m) => {
-					return narrowSchema(m, schemaTypes.enum)?.primitive === "string";
+					return ast.narrowSchema(m, ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => isStringType(m));
+				const hasPlainString = members.some((m) => ast.isStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (isStringType(m)) return createIntersectionDeclaration({
+						if (ast.isStringType(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -805,7 +804,7 @@ 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);
+					const propMeta = ast.syncSchemaRef(prop.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
 							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
@@ -826,7 +825,7 @@ const printerTs = definePrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			let base = this.transform(node);
 			if (!base) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.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] });
@@ -857,12 +856,13 @@ const printerTs = definePrinter((options) => {
 //#region src/generators/typeGenerator.tsx
 const typeGenerator = defineGenerator({
 	name: "typescript",
-	schema(node, options) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = options;
-		const { adapter, config, resolver, root } = this;
+	renderer: jsxRenderer,
+	schema(node, ctx) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
+		const { adapter, config, resolver, root } = ctx;
 		if (!node.name) return;
-		const mode = this.getMode(output);
-		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+		const mode = ctx.getMode(output);
+		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.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.resolveTypeName(schemaName);
@@ -878,7 +878,7 @@ const typeGenerator = defineGenerator({
 				group
 			}).path
 		}));
-		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
+		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
 		const meta = {
 			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
@@ -934,11 +934,11 @@ const typeGenerator = defineGenerator({
 			})]
 		});
 	},
-	operation(node, options) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = options;
-		const { adapter, config, resolver, root } = this;
-		const mode = this.getMode(output);
-		const params = caseParams(node.parameters, paramsCasing);
+	operation(node, ctx) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
+		const { adapter, config, resolver, root } = ctx;
+		const mode = ctx.getMode(output);
+		const params = ast.caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -949,7 +949,7 @@ const typeGenerator = defineGenerator({
 			output,
 			group
 		}) };
-		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.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.resolveTypeName(schemaName);
@@ -1058,9 +1058,6 @@ const typeGenerator = defineGenerator({
 	}
 });
 //#endregion
-//#region package.json
-var version = "5.0.0-alpha.34";
-//#endregion
 //#region src/resolvers/resolverTs.ts
 /**
 * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
@@ -1183,11 +1180,11 @@ const resolverTsLegacy = defineResolver(() => {
 //#endregion
 //#region src/generators/typeGeneratorLegacy.tsx
 function buildGroupedParamsSchema({ params, parentName }) {
-	return createSchema({
+	return ast.createSchema({
 		type: "object",
 		properties: params.map((param) => {
 			let schema = param.schema;
-			if (narrowSchema(schema, "enum") && !schema.name && parentName) schema = {
+			if (ast.narrowSchema(schema, "enum") && !schema.name && parentName) schema = {
 				...schema,
 				name: pascalCase([
 					parentName,
@@ -1195,7 +1192,7 @@ function buildGroupedParamsSchema({ params, parentName }) {
 					"enum"
 				].join(" "))
 			};
-			return createProperty({
+			return ast.createProperty({
 				name: param.name,
 				required: param.required,
 				schema
@@ -1210,78 +1207,78 @@ function buildLegacyResponsesSchemaNode(node, { resolver }) {
 		return !Number.isNaN(code) && code >= 200 && code < 300;
 	});
 	const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
-	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? createSchema({
+	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? ast.createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
-	}) : createSchema({
+	}) : ast.createSchema({
 		type: "union",
-		members: successResponses.map((res) => createSchema({
+		members: successResponses.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
-	}) : createSchema({
+	}) : ast.createSchema({
 		type: "any",
 		primitive: void 0
 	});
-	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
+	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? ast.createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
-	}) : createSchema({
+	}) : ast.createSchema({
 		type: "union",
-		members: errorResponses.map((res) => createSchema({
+		members: errorResponses.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
-	}) : createSchema({
+	}) : ast.createSchema({
 		type: "any",
 		primitive: void 0
 	});
-	const properties = [createProperty({
+	const properties = [ast.createProperty({
 		name: "Response",
 		required: true,
 		schema: responseSchema
 	})];
-	if (!isGet && node.requestBody?.schema) properties.push(createProperty({
+	if (!isGet && node.requestBody?.schema) properties.push(ast.createProperty({
 		name: "Request",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolveDataName(node)
 		})
 	}));
 	const queryParam = node.parameters.find((p) => p.in === "query");
-	if (queryParam) properties.push(createProperty({
+	if (queryParam) properties.push(ast.createProperty({
 		name: "QueryParams",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolveQueryParamsName(node, queryParam)
 		})
 	}));
 	const pathParam = node.parameters.find((p) => p.in === "path");
-	if (pathParam) properties.push(createProperty({
+	if (pathParam) properties.push(ast.createProperty({
 		name: "PathParams",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolvePathParamsName(node, pathParam)
 		})
 	}));
 	const headerParam = node.parameters.find((p) => p.in === "header");
-	if (headerParam) properties.push(createProperty({
+	if (headerParam) properties.push(ast.createProperty({
 		name: "HeaderParams",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolveHeaderParamsName(node, headerParam)
 		})
 	}));
-	properties.push(createProperty({
+	properties.push(ast.createProperty({
 		name: "Errors",
 		required: true,
 		schema: errorsSchema
 	}));
-	return createSchema({
+	return ast.createSchema({
 		type: "object",
 		properties
 	});
@@ -1291,33 +1288,33 @@ function buildLegacyResponseUnionSchemaNode(node, { resolver }) {
 		const code = Number(res.statusCode);
 		return !Number.isNaN(code) && code >= 200 && code < 300;
 	});
-	if (successResponses.length === 0) return createSchema({
+	if (successResponses.length === 0) return ast.createSchema({
 		type: "any",
 		primitive: void 0
 	});
-	if (successResponses.length === 1) return createSchema({
+	if (successResponses.length === 1) return ast.createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
 	});
-	return createSchema({
+	return ast.createSchema({
 		type: "union",
-		members: successResponses.map((res) => createSchema({
+		members: successResponses.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
 	});
 }
 function nameUnnamedEnums(node, parentName) {
-	return transform(node, {
+	return ast.transform(node, {
 		schema(n) {
-			const enumNode = narrowSchema(n, "enum");
+			const enumNode = ast.narrowSchema(n, "enum");
 			if (enumNode && !enumNode.name) return {
 				...enumNode,
 				name: pascalCase([parentName, "enum"].join(" "))
 			};
 		},
 		property(p) {
-			const enumNode = narrowSchema(p.schema, "enum");
+			const enumNode = ast.narrowSchema(p.schema, "enum");
 			if (enumNode && !enumNode.name) return {
 				...p,
 				schema: {
@@ -1334,11 +1331,12 @@ function nameUnnamedEnums(node, parentName) {
 }
 const typeGeneratorLegacy = defineGenerator({
 	name: "typescript-legacy",
-	schema(node, options) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = options;
-		const { adapter, config, resolver, root } = this;
+	renderer: jsxRenderer,
+	schema(node, ctx) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = ctx.options;
+		const { adapter, config, resolver, root } = ctx;
 		if (!node.name) return;
-		const mode = this.getMode(output);
+		const mode = ctx.getMode(output);
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveTypeName(schemaName),
 			path: resolver.resolveFile({
@@ -1350,7 +1348,7 @@ const typeGeneratorLegacy = defineGenerator({
 				group
 			}).path
 		}));
-		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
+		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
 		const meta = {
 			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
@@ -1404,11 +1402,11 @@ const typeGeneratorLegacy = defineGenerator({
 			})]
 		});
 	},
-	operation(node, options) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = options;
-		const { adapter, config, resolver, root } = this;
-		const mode = this.getMode(output);
-		const params = caseParams(node.parameters, paramsCasing);
+	operation(node, ctx) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = ctx.options;
+		const { adapter, config, resolver, root } = ctx;
+		const mode = ctx.getMode(output);
+		const params = ast.caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1535,28 +1533,6 @@ const typeGeneratorLegacy = defineGenerator({
 	}
 });
 //#endregion
-//#region src/presets.ts
-/**
-* Built-in preset registry for `@kubb/plugin-ts`.
-*
-* - `default` — uses `resolverTs` and `typeGenerator` (current naming conventions).
-* - `kubbV4` — uses `resolverTsLegacy` and `typeGeneratorLegacy` (Kubb v4 naming conventions).
-*/
-const presets = definePresets({
-	default: {
-		name: "default",
-		resolver: resolverTs,
-		generators: [typeGenerator],
-		printer: printerTs
-	},
-	kubbV4: {
-		name: "kubbV4",
-		resolver: resolverTsLegacy,
-		generators: [typeGeneratorLegacy],
-		printer: printerTs
-	}
-});
-//#endregion
 //#region src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-ts`, used to identify the plugin in driver lookups and warnings.
@@ -1578,44 +1554,31 @@ const pluginTsName = "plugin-ts";
 * })
 * ```
 */
-const pluginTs = createPlugin((options) => {
+const pluginTs = definePlugin((options) => {
 	const { output = {
 		path: "types",
 		barrelType: "named"
-	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, compatibilityPreset = "default", resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const preset = getPreset({
-		preset: compatibilityPreset,
-		presets,
-		resolver: userResolver,
-		transformer: userTransformer,
-		generators: userGenerators
-	});
-	const mergedGenerator = mergeGenerators(preset.generators ?? []);
-	let resolveNameWarning = false;
-	let resolvePathWarning = false;
+	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [], compatibilityPreset = "default" } = options;
+	const defaultResolver = compatibilityPreset === "kubbV4" ? resolverTsLegacy : resolverTs;
+	const defaultGenerator = compatibilityPreset === "kubbV4" ? typeGeneratorLegacy : typeGenerator;
+	const groupConfig = group ? {
+		...group,
+		name: (ctx) => {
+			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+			return `${camelCase(ctx.group)}Controller`;
+		}
+	} : void 0;
 	return {
 		name: pluginTsName,
-		version,
-		get resolver() {
-			return preset.resolver;
-		},
-		get transformer() {
-			return preset.transformer;
-		},
-		get options() {
-			return {
+		options,
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions({
 				output,
 				exclude,
 				include,
 				override,
 				optionalType,
-				group: group ? {
-					...group,
-					name: (ctx) => {
-						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-						return `${camelCase(ctx.group)}Controller`;
-					}
-				} : void 0,
+				group: groupConfig,
 				arrayType,
 				enumType,
 				enumTypeSuffix,
@@ -1623,43 +1586,15 @@ const pluginTs = createPlugin((options) => {
 				syntaxType,
 				paramsCasing,
 				printer
-			};
-		},
-		resolvePath(baseName, pathMode, options) {
-			if (!resolvePathWarning) {
-				this.warn("Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
-				resolvePathWarning = true;
-			}
-			return this.plugin.resolver.resolvePath({
-				baseName,
-				pathMode,
-				tag: options?.group?.tag,
-				path: options?.group?.path
-			}, {
-				root: this.root,
-				output,
-				group: this.plugin.options.group
 			});
-		},
-		resolveName(name, type) {
-			if (!resolveNameWarning) {
-				this.warn("Do not use resolveName for pluginTs, use resolverTs.default instead");
-				resolveNameWarning = true;
-			}
-			return this.plugin.resolver.default(name, type);
-		},
-		async schema(node, options) {
-			return mergedGenerator.schema?.call(this, node, options);
-		},
-		async operation(node, options) {
-			return mergedGenerator.operation?.call(this, node, options);
-		},
-		async operations(nodes, options) {
-			return mergedGenerator.operations?.call(this, nodes, options);
-		},
-		async buildStart() {
-			await this.openInStudio({ ast: true });
-		}
+			ctx.setResolver(userResolver ? {
+				...defaultResolver,
+				...userResolver
+			} : defaultResolver);
+			if (userTransformer) ctx.setTransformer(userTransformer);
+			ctx.addGenerator(defaultGenerator);
+			for (const gen of userGenerators) ctx.addGenerator(gen);
+		} }
 	};
 });
 //#endregion
@@ -1676,7 +1611,7 @@ const kindToHandlerKey = {
 * Uses `createPrinterFactory` and dispatches handlers by `node.kind`
 * (for function nodes) rather than by `node.type` (for schema nodes).
 */
-const defineFunctionPrinter = createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+const defineFunctionPrinter = ast.createPrinterFactory((node) => kindToHandlerKey[node.kind]);
 function rank(param) {
 	if (param.kind === "ParameterGroup") {
 		if (param.default) return PARAM_RANK.withDefault;