@kubb/plugin-ts 5.0.0-alpha.12 → 5.0.0-alpha.14

package/dist/resolvers-DDZC7d43.cjs

@@ -0,0 +1,193 @@
+const require_casing = require("./casing-D2uQKLWS.cjs");
+let _kubb_core = require("@kubb/core");
+//#region src/resolvers/resolverTs.ts
+function resolveName(name, type) {
+	return require_casing.pascalCase(name, { isFile: type === "file" });
+}
+/**
+* Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
+* helpers used by the plugin. Import this in other plugins to resolve the exact names and
+* paths that `plugin-ts` generates without hardcoding the conventions.
+*
+* The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
+* for identifiers/files and `pascalCase` for type names.
+*
+* @example
+* ```ts
+* import { resolver } from '@kubb/plugin-ts'
+*
+* resolver.default('list pets', 'type')              // → 'ListPets'
+* resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
+* resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
+* resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+* ```
+*/
+const resolverTs = (0, _kubb_core.defineResolver)(() => {
+	return {
+		name: "default",
+		default(name, type) {
+			return resolveName(name, type);
+		},
+		resolveName(name) {
+			return this.default(name, "function");
+		},
+		resolveTypedName(name) {
+			return this.default(name, "type");
+		},
+		resolvePathName(name, type) {
+			return this.default(name, type);
+		},
+		resolveParamName(node, param) {
+			return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
+		},
+		resolveParamTypedName(node, param) {
+			return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
+		},
+		resolveResponseStatusName(node, statusCode) {
+			return this.resolveName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveResponseStatusTypedName(node, statusCode) {
+			return this.resolveTypedName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveDataName(node) {
+			return this.resolveName(`${node.operationId} Data`);
+		},
+		resolveDataTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} Data`);
+		},
+		resolveRequestConfigName(node) {
+			return this.resolveName(`${node.operationId} RequestConfig`);
+		},
+		resolveRequestConfigTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} RequestConfig`);
+		},
+		resolveResponsesName(node) {
+			return this.resolveName(`${node.operationId} Responses`);
+		},
+		resolveResponsesTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} Responses`);
+		},
+		resolveResponseName(node) {
+			return this.resolveName(`${node.operationId} Response`);
+		},
+		resolveResponseTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} Response`);
+		},
+		resolveEnumKeyTypedName(node) {
+			return `${this.resolveTypedName(node.name ?? "")}Key`;
+		},
+		resolvePathParamsName(_node) {
+			throw new Error("resolvePathParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.");
+		},
+		resolvePathParamsTypedName(_node) {
+			throw new Error("resolvePathParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.");
+		},
+		resolveQueryParamsName(node) {
+			return this.resolveName(`${node.operationId} QueryParams`);
+		},
+		resolveQueryParamsTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} QueryParams`);
+		},
+		resolveHeaderParamsName(_node) {
+			throw new Error("resolveHeaderParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.");
+		},
+		resolveHeaderParamsTypedName(_node) {
+			throw new Error("resolveHeaderParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.");
+		}
+	};
+});
+//#endregion
+//#region src/resolvers/resolverTsLegacy.ts
+/**
+* Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions
+* used before the v2 resolver refactor. Enable via `legacy: true` in plugin options.
+*
+* Key differences from the default resolver:
+* - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`
+* - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`
+* - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)
+* - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`
+* - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`
+*
+* @example
+* ```ts
+* import { resolverTsLegacy } from '@kubb/plugin-ts'
+*
+* resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'
+* resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'
+* resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)
+* resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)
+* resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)
+* ```
+*/
+const resolverTsLegacy = (0, _kubb_core.defineResolver)(() => {
+	return {
+		...resolverTs,
+		name: "legacy",
+		resolveResponseStatusName(node, statusCode) {
+			if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
+			return this.resolveName(`${node.operationId} ${statusCode}`);
+		},
+		resolveResponseStatusTypedName(node, statusCode) {
+			if (statusCode === "default") return this.resolveTypedName(`${node.operationId} Error`);
+			return this.resolveTypedName(`${node.operationId} ${statusCode}`);
+		},
+		resolveDataName(node) {
+			const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolveDataTypedName(node) {
+			const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+			return this.resolveTypedName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponsesName(node) {
+			const suffix = node.method === "GET" ? "Query" : "Mutation";
+			return `${this.default(node.operationId, "function")}${suffix}`;
+		},
+		resolveResponsesTypedName(node) {
+			const suffix = node.method === "GET" ? "Query" : "Mutation";
+			return `${this.default(node.operationId, "type")}${suffix}`;
+		},
+		resolveResponseName(node) {
+			const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponseTypedName(node) {
+			const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+			return this.resolveTypedName(`${node.operationId} ${suffix}`);
+		},
+		resolvePathParamsName(node) {
+			return this.resolveName(`${node.operationId} PathParams`);
+		},
+		resolvePathParamsTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} PathParams`);
+		},
+		resolveQueryParamsName(node) {
+			return this.resolveName(`${node.operationId} QueryParams`);
+		},
+		resolveQueryParamsTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} QueryParams`);
+		},
+		resolveHeaderParamsName(node) {
+			return this.resolveName(`${node.operationId} HeaderParams`);
+		},
+		resolveHeaderParamsTypedName(node) {
+			return this.resolveTypedName(`${node.operationId} HeaderParams`);
+		}
+	};
+});
+//#endregion
+Object.defineProperty(exports, "resolverTs", {
+	enumerable: true,
+	get: function() {
+		return resolverTs;
+	}
+});
+Object.defineProperty(exports, "resolverTsLegacy", {
+	enumerable: true,
+	get: function() {
+		return resolverTsLegacy;
+	}
+});
+
+//# sourceMappingURL=resolvers-DDZC7d43.cjs.map

package/dist/resolvers-DDZC7d43.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers-DDZC7d43.cjs","names":["pascalCase"],"sources":["../src/resolvers/resolverTs.ts","../src/resolvers/resolverTsLegacy.ts"],"sourcesContent":["import { pascalCase } from '@internals/utils'\nimport { defineResolver } from '@kubb/core'\nimport type { PluginTs } from '../types.ts'\n\nfunction resolveName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string {\n  return pascalCase(name, { isFile: type === 'file' })\n}\n\n/**\n * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution\n * helpers used by the plugin. Import this in other plugins to resolve the exact names and\n * paths that `plugin-ts` generates without hardcoding the conventions.\n *\n * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`\n * for identifiers/files and `pascalCase` for type names.\n *\n * @example\n * ```ts\n * import { resolver } from '@kubb/plugin-ts'\n *\n * resolver.default('list pets', 'type')              // → 'ListPets'\n * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'\n * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'\n * resolver.resolvePathName('list pets', 'file')       // → 'listPets'\n * ```\n */\nexport const resolverTs = defineResolver<PluginTs>(() => {\n  return {\n    name: 'default',\n    default(name, type) {\n      return resolveName(name, type)\n    },\n    resolveName(name) {\n      return this.default(name, 'function')\n    },\n    resolveTypedName(name) {\n      return this.default(name, 'type')\n    },\n    resolvePathName(name, type) {\n      return this.default(name, type)\n    },\n    resolveParamName(node, param) {\n      return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`)\n    },\n    resolveParamTypedName(node, param) {\n      return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`)\n    },\n    resolveResponseStatusName(node, statusCode) {\n      return this.resolveName(`${node.operationId} Status ${statusCode}`)\n    },\n    resolveResponseStatusTypedName(node, statusCode) {\n      return this.resolveTypedName(`${node.operationId} Status ${statusCode}`)\n    },\n    resolveDataName(node) {\n      return this.resolveName(`${node.operationId} Data`)\n    },\n    resolveDataTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} Data`)\n    },\n    resolveRequestConfigName(node) {\n      return this.resolveName(`${node.operationId} RequestConfig`)\n    },\n    resolveRequestConfigTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} RequestConfig`)\n    },\n    resolveResponsesName(node) {\n      return this.resolveName(`${node.operationId} Responses`)\n    },\n    resolveResponsesTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} Responses`)\n    },\n    resolveResponseName(node) {\n      return this.resolveName(`${node.operationId} Response`)\n    },\n    resolveResponseTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} Response`)\n    },\n    resolveEnumKeyTypedName(node) {\n      return `${this.resolveTypedName(node.name ?? '')}Key`\n    },\n    resolvePathParamsName(_node) {\n      throw new Error('resolvePathParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.')\n    },\n    resolvePathParamsTypedName(_node) {\n      throw new Error('resolvePathParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.')\n    },\n    resolveQueryParamsName(node) {\n      return this.resolveName(`${node.operationId} QueryParams`)\n    },\n    resolveQueryParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} QueryParams`)\n    },\n    resolveHeaderParamsName(_node) {\n      throw new Error('resolveHeaderParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.')\n    },\n    resolveHeaderParamsTypedName(_node) {\n      throw new Error(\n        'resolveHeaderParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.',\n      )\n    },\n  }\n})\n","import { defineResolver } from '@kubb/core'\nimport type { PluginTs } from '../types.ts'\nimport { resolverTs } from './resolverTs.ts'\n\n/**\n * Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions\n * used before the v2 resolver refactor. Enable via `legacy: true` in plugin options.\n *\n * Key differences from the default resolver:\n * - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`\n * - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`\n * - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)\n * - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`\n * - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`\n *\n * @example\n * ```ts\n * import { resolverTsLegacy } from '@kubb/plugin-ts'\n *\n * resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'\n * resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'\n * resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)\n * resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)\n * resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)\n * ```\n */\nexport const resolverTsLegacy = defineResolver<PluginTs>(() => {\n  return {\n    ...resolverTs,\n    name: 'legacy',\n    resolveResponseStatusName(node, statusCode) {\n      if (statusCode === 'default') {\n        return this.resolveName(`${node.operationId} Error`)\n      }\n      return this.resolveName(`${node.operationId} ${statusCode}`)\n    },\n    resolveResponseStatusTypedName(node, statusCode) {\n      if (statusCode === 'default') {\n        return this.resolveTypedName(`${node.operationId} Error`)\n      }\n      return this.resolveTypedName(`${node.operationId} ${statusCode}`)\n    },\n    resolveDataName(node) {\n      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'\n      return this.resolveName(`${node.operationId} ${suffix}`)\n    },\n    resolveDataTypedName(node) {\n      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'\n      return this.resolveTypedName(`${node.operationId} ${suffix}`)\n    },\n    resolveResponsesName(node) {\n      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'\n      return `${this.default(node.operationId, 'function')}${suffix}`\n    },\n    resolveResponsesTypedName(node) {\n      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'\n      return `${this.default(node.operationId, 'type')}${suffix}`\n    },\n    resolveResponseName(node) {\n      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'\n      return this.resolveName(`${node.operationId} ${suffix}`)\n    },\n    resolveResponseTypedName(node) {\n      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'\n      return this.resolveTypedName(`${node.operationId} ${suffix}`)\n    },\n    resolvePathParamsName(node) {\n      return this.resolveName(`${node.operationId} PathParams`)\n    },\n    resolvePathParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} PathParams`)\n    },\n    resolveQueryParamsName(node) {\n      return this.resolveName(`${node.operationId} QueryParams`)\n    },\n    resolveQueryParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} QueryParams`)\n    },\n    resolveHeaderParamsName(node) {\n      return this.resolveName(`${node.operationId} HeaderParams`)\n    },\n    resolveHeaderParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} HeaderParams`)\n    },\n  }\n})\n"],"mappings":"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"}

package/dist/resolvers.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_resolvers = require("./resolvers-DDZC7d43.cjs");
+exports.resolverTs = require_resolvers.resolverTs;
+exports.resolverTsLegacy = require_resolvers.resolverTsLegacy;

package/dist/resolvers.d.ts

@@ -0,0 +1,2 @@
+import { n as resolverTs, t as resolverTsLegacy } from "./index-B5pSjbZv.js";
+export { resolverTs, resolverTsLegacy };

package/dist/resolvers.js

@@ -0,0 +1,2 @@
+import { n as resolverTs, t as resolverTsLegacy } from "./resolvers-C_vYX56l.js";
+export { resolverTs, resolverTsLegacy };

package/dist/{types-BA1ZCQ5p.d.ts → types-D9zzvE0V.d.ts}

@@ -1,6 +1,6 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { Group, Output, PluginFactoryOptions, ResolveNameParams, Resolver } from "@kubb/core";
-import { OperationNode, ParameterNode, SchemaNode, StatusCode } from "@kubb/ast/types";
+import { Group, Output, PluginFactoryOptions, Resolver } from "@kubb/core";
+import { OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from "@kubb/ast/types";
 import { Oas, contentType } from "@kubb/oas";
 import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
 import { Generator } from "@kubb/plugin-oas/generators";
@@ -261,12 +261,6 @@ type Options = {
    * @default 'array'
    */
   arrayType?: 'generic' | 'array';
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-  };
   /**
    * How to style your params, by default no casing is applied
    * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams property names
@@ -284,15 +278,39 @@ type Options = {
   UNSTABLE_NAMING?: true;
   /**
    * Enable legacy naming conventions for backwards compatibility.
-   * When enabled, operation-level types use the old naming scheme:
-   * - GET responses → `<OperationId>QueryResponse`, `<OperationId>Query`
-   * - Non-GET responses → `<OperationId>MutationResponse`, `<OperationId>Mutation`
-   * - Request body → `<OperationId>QueryRequest` / `<OperationId>MutationRequest`
-   * - Response status codes → `<OperationId><StatusCode>` (e.g. `CreatePets201`)
-   * - Default/error response → `<OperationId>Error`
    * @default false
    */
   legacy?: boolean;
+  /**
+   * Array of named resolvers that control naming conventions.
+   * Later entries override earlier ones (last wins).
+   * Built-in: `resolverTs` (default), `resolverTsLegacy`.
+   * @default [resolverTs]
+   */
+  resolvers?: Array<ResolverTs>;
+  /**
+   * Array of AST visitors applied to each SchemaNode/OperationNode before printing.
+   * Uses `transform()` from `@kubb/ast` — visitors can modify, replace, or annotate nodes.
+   *
+   * @example Remove writeOnly properties from response types
+   * ```ts
+   * transformers: [{
+   *   property(node) {
+   *     if (node.schema.writeOnly) return undefined
+   *   }
+   * }]
+   * ```
+   *
+   * @example Force all dates to plain strings
+   * ```ts
+   * transformers: [{
+   *   schema(node) {
+   *     if (node.type === 'date') return { ...node, type: 'string' }
+   *   }
+   * }]
+   * ```
+   */
+  transformers?: Array<Visitor>;
 };
 type ResolvedOptions = {
   output: Output<Oas>;
@@ -302,13 +320,19 @@ type ResolvedOptions = {
   enumKeyCasing: NonNullable<Options['enumKeyCasing']>;
   optionalType: NonNullable<Options['optionalType']>;
   arrayType: NonNullable<Options['arrayType']>;
-  transformers: NonNullable<Options['transformers']>;
   syntaxType: NonNullable<Options['syntaxType']>;
   paramsCasing: Options['paramsCasing'];
   legacy: NonNullable<Options['legacy']>;
   resolver: ResolverTs;
+  /**
+   * The resolver without user naming overrides applied.
+   * Used internally to derive stable names for unnamed enums and grouped params
+   * so that the schema tree stays consistent regardless of `transformers.name` / custom resolvers.
+   */
+  baseResolver: ResolverTs;
+  transformers: Array<Visitor>;
 };
 type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>;
 //#endregion
 export { PluginTs as n, ResolverTs as r, Options as t };
-//# sourceMappingURL=types-BA1ZCQ5p.d.ts.map
+//# sourceMappingURL=types-D9zzvE0V.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.12",
+  "version": "5.0.0-alpha.14",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -39,6 +39,10 @@
       "import": "./dist/generators.js",
       "require": "./dist/generators.cjs"
     },
+    "./resolvers": {
+      "import": "./dist/resolvers.js",
+      "require": "./dist/resolvers.cjs"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
@@ -49,6 +53,9 @@
       ],
       "generators": [
         "./dist/generators.d.ts"
+      ],
+      "resolvers": [
+        "./dist/resolvers.d.ts"
       ]
     }
   },
@@ -71,10 +78,10 @@
     "@kubb/react-fabric": "0.14.0",
     "remeda": "^2.33.6",
     "typescript": "5.9.3",
-    "@kubb/oas": "5.0.0-alpha.12",
-    "@kubb/plugin-oas": "5.0.0-alpha.12",
-    "@kubb/ast": "5.0.0-alpha.12",
-    "@kubb/core": "5.0.0-alpha.12"
+    "@kubb/ast": "5.0.0-alpha.14",
+    "@kubb/core": "5.0.0-alpha.14",
+    "@kubb/oas": "5.0.0-alpha.14",
+    "@kubb/plugin-oas": "5.0.0-alpha.14"
   },
   "peerDependencies": {
     "@kubb/react-fabric": "0.14.0"

package/src/components/Type.tsx

@@ -17,6 +17,7 @@ type Props = {
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
   syntaxType: PluginTs['resolvedOptions']['syntaxType']
   resolver: PluginTs['resolvedOptions']['resolver']
+  legacy?: boolean
   description?: string
   keysToOmit?: string[]
 }

package/src/generators/typeGenerator.tsx

@@ -1,4 +1,4 @@
-import { applyParamsCasing } from '@kubb/ast'
+import { applyParamsCasing, composeTransformers, transform } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
 import { defineGenerator } from '@kubb/core'
 import { useKubb } from '@kubb/core/hooks'
@@ -11,6 +11,7 @@ import {
   buildGroupedParamsSchema,
   buildLegacyResponsesSchemaNode,
   buildLegacyResponseUnionSchemaNode,
+  buildParamsSchema,
   buildResponsesSchemaNode,
   buildResponseUnionSchemaNode,
   nameUnnamedEnums,
@@ -20,7 +21,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
   Operation({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, resolver, legacy } = options
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, resolver, baseResolver, legacy, transformers = [] } = options
     const { mode, getFile, resolveBanner, resolveFooter } = useKubb<PluginTs>()
 
     const file = getFile({
@@ -50,7 +51,9 @@ export const typeGenerator = defineGenerator<PluginTs>({
         return null
       }
 
-      const imports = adapter.getImports(schemaNode, (schemaName) => ({
+      const transformedNode = transform(schemaNode, composeTransformers(...transformers))
+
+      const imports = adapter.getImports(transformedNode, (schemaName) => ({
         name: resolver.default(schemaName, 'type'),
         path: getFile({ name: schemaName, extname: '.ts', mode }).path,
       }))
@@ -62,7 +65,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
           <Type
             name={name}
             typedName={typedName}
-            node={schemaNode}
+            node={transformedNode}
             description={description}
             enumType={enumType}
             enumKeyCasing={enumKeyCasing}
@@ -71,6 +74,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
             syntaxType={syntaxType}
             resolver={resolver}
             keysToOmit={keysToOmit}
+            legacy={legacy}
           />
         </>
       )
@@ -79,9 +83,10 @@ export const typeGenerator = defineGenerator<PluginTs>({
     const responseTypes = legacy
       ? node.responses.map((res) => {
           const responseName = resolver.resolveResponseStatusName(node, res.statusCode)
+          const baseResponseName = baseResolver.resolveResponseStatusName(node, res.statusCode)
 
           return renderSchemaType({
-            node: res.schema ? nameUnnamedEnums(res.schema, responseName) : res.schema,
+            node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
             name: responseName,
             typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
             description: res.description,
@@ -100,10 +105,10 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     const requestType = node.requestBody?.schema
       ? renderSchemaType({
-          node: legacy ? nameUnnamedEnums(node.requestBody.schema, resolver.resolveDataName(node)) : node.requestBody.schema,
+          node: legacy ? nameUnnamedEnums(node.requestBody.schema, baseResolver.resolveDataName(node)) : node.requestBody.schema,
           name: resolver.resolveDataName(node),
           typedName: resolver.resolveDataTypedName(node),
-          description: node.requestBody.schema.description,
+          description: node.requestBody.description ?? node.requestBody.schema.description,
           keysToOmit: node.requestBody.keysToOmit,
         })
       : null
@@ -116,21 +121,21 @@ export const typeGenerator = defineGenerator<PluginTs>({
       const legacyParamTypes = [
         pathParams.length > 0
           ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: pathParams, parentName: resolver.resolvePathParamsName!(node) }),
+              node: buildGroupedParamsSchema({ params: pathParams, parentName: baseResolver.resolvePathParamsName!(node) }),
               name: resolver.resolvePathParamsName!(node),
               typedName: resolver.resolvePathParamsTypedName!(node),
             })
           : null,
         queryParams.length > 0
           ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: queryParams, parentName: resolver.resolveQueryParamsName!(node) }),
+              node: buildGroupedParamsSchema({ params: queryParams, parentName: baseResolver.resolveQueryParamsName!(node) }),
               name: resolver.resolveQueryParamsName!(node),
               typedName: resolver.resolveQueryParamsTypedName!(node),
             })
           : null,
         headerParams.length > 0
           ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: headerParams, parentName: resolver.resolveHeaderParamsName!(node) }),
+              node: buildGroupedParamsSchema({ params: headerParams, parentName: baseResolver.resolveHeaderParamsName!(node) }),
               name: resolver.resolveHeaderParamsName!(node),
               typedName: resolver.resolveHeaderParamsTypedName!(node),
             })
@@ -154,8 +159,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
           {legacyParamTypes}
           {responseTypes}
           {requestType}
-          {legacyResponsesType}
           {legacyResponseType}
+          {legacyResponsesType}
         </File>
       )
     }
@@ -168,6 +173,16 @@ export const typeGenerator = defineGenerator<PluginTs>({
       }),
     )
 
+    const queryParamsList = params.filter((p) => p.in === 'query')
+    const queryParamsType =
+      queryParamsList.length > 0
+        ? renderSchemaType({
+            node: buildParamsSchema({ params: queryParamsList, node, resolver }),
+            name: resolver.resolveQueryParamsName!(node),
+            typedName: resolver.resolveQueryParamsTypedName!(node),
+          })
+        : null
+
     const dataType = renderSchemaType({
       node: buildDataSchemaNode({ node: { ...node, parameters: params }, resolver }),
       name: resolver.resolveRequestConfigName(node),
@@ -190,6 +205,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
     return (
       <File baseName={file.baseName} path={file.path} meta={file.meta} banner={resolveBanner()} footer={resolveFooter()}>
         {paramTypes}
+        {queryParamsType}
         {responseTypes}
         {requestType}
         {dataType}
@@ -199,14 +215,16 @@ export const typeGenerator = defineGenerator<PluginTs>({
     )
   },
   Schema({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, resolver } = options
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, resolver, legacy, transformers = [] } = options
     const { mode, getFile, resolveBanner, resolveFooter } = useKubb<PluginTs>()
 
     if (!node.name) {
       return
     }
 
-    const imports = adapter.getImports(node, (schemaName) => ({
+    const transformedNode = transform(node, composeTransformers(...transformers))
+
+    const imports = adapter.getImports(transformedNode, (schemaName) => ({
       name: resolver.default(schemaName, 'type'),
       path: getFile({ name: schemaName, extname: '.ts', mode }).path,
     }))
@@ -230,13 +248,14 @@ export const typeGenerator = defineGenerator<PluginTs>({
         <Type
           name={type.name}
           typedName={type.typedName}
-          node={node}
+          node={transformedNode}
           enumType={enumType}
           enumKeyCasing={enumKeyCasing}
           optionalType={optionalType}
           arrayType={arrayType}
           syntaxType={syntaxType}
           resolver={resolver}
+          legacy={legacy}
         />
       </File>
     )

package/src/generators/utils.ts

@@ -21,10 +21,10 @@ export function buildParamsSchema({ params, node, resolver }: BuildParamsSchemaO
     properties: params.map((param) =>
       createProperty({
         name: param.name,
+        required: param.required,
         schema: createSchema({
           type: 'ref',
           name: resolver.resolveParamName(node, param),
-          optional: !param.required,
         }),
       }),
     ),
@@ -65,7 +65,8 @@ export function buildDataSchemaNode({ node, resolver }: BuildOperationSchemaOpti
       }),
       createProperty({
         name: 'pathParams',
-        schema: pathParams.length > 0 ? buildParamsSchema({ params: pathParams, node, resolver }) : createSchema({ type: 'never', optional: true }),
+        required: pathParams.length > 0,
+        schema: pathParams.length > 0 ? buildParamsSchema({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
       }),
       createProperty({
         name: 'queryParams',
@@ -83,6 +84,7 @@ export function buildDataSchemaNode({ node, resolver }: BuildOperationSchemaOpti
       }),
       createProperty({
         name: 'url',
+        required: true,
         schema: createSchema({ type: 'url', path: node.path }),
       }),
     ],
@@ -104,6 +106,7 @@ export function buildResponsesSchemaNode({ node, resolver }: BuildOperationSchem
     properties: node.responses.map((res) =>
       createProperty({
         name: String(res.statusCode),
+        required: true,
         schema: createSchema({
           type: 'ref',
           name: resolver.resolveResponseStatusTypedName(node, res.statusCode),
@@ -154,13 +157,13 @@ export function buildGroupedParamsSchema({ params, parentName }: BuildGroupedPar
   return createSchema({
     type: 'object',
     properties: params.map((param) => {
-      let schema = { ...param.schema, optional: !param.required } as SchemaNode
-      // Name unnamed enum properties so they are emitted as enum declarations
+      let schema = param.schema
       if (narrowSchema(schema, 'enum') && !schema.name && parentName) {
         schema = { ...schema, name: pascalCase([parentName, param.name, 'enum'].join(' ')) }
       }
       return createProperty({
         name: param.name,
+        required: param.required,
         schema,
       })
     }),
@@ -169,7 +172,7 @@ export function buildGroupedParamsSchema({ params, parentName }: BuildGroupedPar
 
 /**
  * Builds the legacy wrapper `ObjectSchemaNode` for `<OperationId>Mutation` / `<OperationId>Query`.
- * Structure: `{ Response, Request (mutation) | QueryParams (query), Errors }`.
+ * Structure: `{ Response, Request?, QueryParams?, PathParams?, HeaderParams?, Errors }`.
  * Mirrors the v4 naming convention where this type acts as a namespace for the operation's shapes.
  *
  * @deprecated Legacy only — will be removed in v6.
@@ -202,20 +205,24 @@ export function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperatio
           })
       : createSchema({ type: 'any' })
 
-  const properties = [createProperty({ name: 'Response', schema: responseSchema })]
+  const properties = [createProperty({ name: 'Response', required: true, schema: responseSchema })]
 
   if (!isGet && node.requestBody?.schema) {
     properties.push(
       createProperty({
         name: 'Request',
+        required: true,
         schema: createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node) }),
       }),
     )
-  } else if (isGet && node.parameters.some((p) => p.in === 'query')) {
+  }
+
+  if (node.parameters.some((p) => p.in === 'query') && resolver.resolveQueryParamsTypedName) {
     properties.push(
       createProperty({
         name: 'QueryParams',
-        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsTypedName!(node) }),
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsTypedName(node) }),
       }),
     )
   }
@@ -224,6 +231,7 @@ export function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperatio
     properties.push(
       createProperty({
         name: 'PathParams',
+        required: true,
         schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsTypedName(node) }),
       }),
     )
@@ -233,12 +241,13 @@ export function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperatio
     properties.push(
       createProperty({
         name: 'HeaderParams',
+        required: true,
         schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsTypedName(node) }),
       }),
     )
   }
 
-  properties.push(createProperty({ name: 'Errors', schema: errorsSchema }))
+  properties.push(createProperty({ name: 'Errors', required: true, schema: errorsSchema }))
 
   return createSchema({ type: 'object', properties })
 }

package/src/index.ts

@@ -1,3 +1,3 @@
 export { pluginTs, pluginTsName } from './plugin.ts'
-export { resolverTs, resolverTsLegacy } from './resolverTs.ts'
-export type { PluginTs } from './types.ts'
+export { resolverTs, resolverTsLegacy } from './resolvers/index.ts'
+export type { PluginTs, ResolverTs } from './types.ts'