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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.25",
+  "version": "5.0.0-alpha.27",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -53,8 +53,8 @@
     "@kubb/react-fabric": "0.15.1",
     "remeda": "^2.33.7",
     "typescript": "5.9.3",
-    "@kubb/ast": "5.0.0-alpha.25",
-    "@kubb/core": "5.0.0-alpha.25"
+    "@kubb/ast": "5.0.0-alpha.27",
+    "@kubb/core": "5.0.0-alpha.27"
   },
   "peerDependencies": {
     "@kubb/react-fabric": "0.15.1"

package/src/components/Type.tsx

@@ -1,46 +1,27 @@
+import type { Printer } from '@kubb/ast'
 import { collect, narrowSchema, schemaTypes } from '@kubb/ast'
 import type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'
 import { File } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import { printerTs } from '../printers/printerTs.ts'
+import type { PrinterTsFactory } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types.ts'
 import { Enum, getEnumNames } from './Enum.tsx'
 
 type Props = {
   name: string
   node: SchemaNode
-  optionalType: PluginTs['resolvedOptions']['optionalType']
-  arrayType: PluginTs['resolvedOptions']['arrayType']
+  /**
+   * Pre-configured printer instance created by the generator.
+   * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
+   */
+  printer: Printer<PrinterTsFactory>
   enumType: PluginTs['resolvedOptions']['enumType']
   enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
-  syntaxType: PluginTs['resolvedOptions']['syntaxType']
   resolver: PluginTs['resolver']
-  description?: string
-  keysToOmit?: string[]
-  /**
-   * Names of top-level schemas that are enums.
-   * Used so the printer's `ref` handler can use the suffixed type name (e.g. `StatusKey`)
-   * instead of the plain PascalCase name (e.g. `Status`) when resolving `$ref` enum targets.
-   */
-  enumSchemaNames?: Set<string>
 }
 
-export function Type({
-  name,
-  node,
-  keysToOmit,
-  optionalType,
-  arrayType,
-  syntaxType,
-  enumType,
-  enumTypeSuffix,
-  enumKeyCasing,
-  description,
-  resolver,
-  enumSchemaNames,
-}: Props): FabricReactNode {
-  const resolvedDescription = description || node?.description
+export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): FabricReactNode {
   const enumSchemaNodes = collect<EnumSchemaNode>(node, {
     schema(n): EnumSchemaNode | undefined {
       const enumNode = narrowSchema(n, schemaTypes.enum)
@@ -48,18 +29,6 @@ export function Type({
     },
   })
 
-  const printer = printerTs({
-    optionalType,
-    arrayType,
-    enumType,
-    enumTypeSuffix,
-    name,
-    syntaxType,
-    description: resolvedDescription,
-    keysToOmit,
-    resolver,
-    enumSchemaNames,
-  })
   const output = printer.print(node)
 
   if (!output) {

package/src/generators/typeGenerator.tsx

@@ -1,20 +1,21 @@
 import path from 'node:path'
-import { caseParams, composeTransformers, narrowSchema, schemaTypes, transform } from '@kubb/ast'
+import { caseParams, narrowSchema, schemaTypes, transform } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
 import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
+import { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types'
 import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
-  Schema({ node, adapter, options, config, resolver }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options
+  Schema({ node, adapter, options, config, resolver, plugin }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     if (!transformedNode.name) {
       return
@@ -30,7 +31,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
         return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
       }
-      return resolver.default(schemaName, 'type')
+      return resolver.resolveTypeName(schemaName)
     }
 
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
@@ -44,10 +45,23 @@ export const typeGenerator = defineGenerator<PluginTs>({
       name:
         ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema
           ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix)
-          : resolver.resolveName(transformedNode.name),
+          : resolver.resolveTypeName(transformedNode.name),
       file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
     } as const
 
+    const schemaPrinter = printerTs({
+      optionalType,
+      arrayType,
+      enumType,
+      enumTypeSuffix,
+      name: meta.name,
+      syntaxType,
+      description: transformedNode.description,
+      resolver,
+      enumSchemaNames,
+      nodes: printer?.nodes,
+    })
+
     return (
       <File
         baseName={meta.file.baseName}
@@ -66,19 +80,16 @@ export const typeGenerator = defineGenerator<PluginTs>({
           enumType={enumType}
           enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
-          optionalType={optionalType}
-          arrayType={arrayType}
-          syntaxType={syntaxType}
           resolver={resolver}
-          enumSchemaNames={enumSchemaNames}
+          printer={schemaPrinter}
         />
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options
+  Operation({ node, adapter, options, config, resolver, plugin }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -100,7 +111,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
         return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
       }
-      return resolver.default(schemaName, 'type')
+      return resolver.resolveTypeName(schemaName)
     }
 
     function renderSchemaType({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
@@ -111,6 +122,20 @@ export const typeGenerator = defineGenerator<PluginTs>({
         path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
 
+      const schemaPrinter = printerTs({
+        optionalType,
+        arrayType,
+        enumType,
+        enumTypeSuffix,
+        name,
+        syntaxType,
+        description: schema.description,
+        keysToOmit,
+        resolver,
+        enumSchemaNames,
+        nodes: printer?.nodes,
+      })
+
       return (
         <>
           {mode === 'split' &&
@@ -123,12 +148,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
             enumType={enumType}
             enumTypeSuffix={enumTypeSuffix}
             enumKeyCasing={enumKeyCasing}
-            optionalType={optionalType}
-            arrayType={arrayType}
-            syntaxType={syntaxType}
             resolver={resolver}
-            keysToOmit={keysToOmit}
-            enumSchemaNames={enumSchemaNames}
+            printer={schemaPrinter}
           />
         </>
       )

package/src/generators/typeGeneratorLegacy.tsx

@@ -1,11 +1,12 @@
 import path from 'node:path'
 import { pascalCase } from '@internals/utils'
-import { caseParams, composeTransformers, createProperty, createSchema, narrowSchema, schemaTypes, transform } from '@kubb/ast'
+import { caseParams, createProperty, createSchema, narrowSchema, schemaTypes, transform } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
 import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
+import { printerTs } from '../printers/printerTs.ts'
 import { resolverTsLegacy } from '../resolvers/resolverTsLegacy.ts'
 import type { PluginTs, ResolverTs } from '../types'
 
@@ -158,10 +159,10 @@ function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
 export const typeGeneratorLegacy = defineGenerator<PluginTs>({
   name: 'typescript-legacy',
   type: 'react',
-  Schema({ node, adapter, options, config, resolver }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options
+  Schema({ node, adapter, options, config, resolver, plugin }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     if (!transformedNode.name) {
       return
@@ -171,7 +172,7 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     const mode = getMode(path.resolve(root, output.path))
 
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
-      name: resolver.default(schemaName, 'type'),
+      name: resolver.resolveTypeName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
@@ -181,10 +182,21 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       name:
         ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema
           ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix)
-          : resolver.resolveName(transformedNode.name),
+          : resolver.resolveTypeName(transformedNode.name),
       file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
     } as const
 
+    const schemaPrinter = printerTs({
+      optionalType,
+      arrayType,
+      enumType,
+      enumTypeSuffix,
+      name: meta.name,
+      syntaxType,
+      description: transformedNode.description,
+      resolver,
+    })
+
     return (
       <File
         baseName={meta.file.baseName}
@@ -203,18 +215,16 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
           enumType={enumType}
           enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
-          optionalType={optionalType}
-          arrayType={arrayType}
-          syntaxType={syntaxType}
           resolver={resolver}
+          printer={schemaPrinter}
         />
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options
+  Operation({ node, adapter, options, config, resolver, plugin }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -241,10 +251,22 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       if (!schema) return null
 
       const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolver.default(schemaName, 'type'),
+        name: resolver.resolveTypeName(schemaName),
         path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
 
+      const opPrinter = printerTs({
+        optionalType,
+        arrayType,
+        enumType,
+        enumTypeSuffix,
+        name,
+        syntaxType,
+        description,
+        keysToOmit,
+        resolver,
+      })
+
       return (
         <>
           {mode === 'split' &&
@@ -254,15 +276,11 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
           <Type
             name={name}
             node={schema}
-            description={description}
             enumType={enumType}
             enumTypeSuffix={enumTypeSuffix}
             enumKeyCasing={enumKeyCasing}
-            optionalType={optionalType}
-            arrayType={arrayType}
-            syntaxType={syntaxType}
             resolver={resolver}
-            keysToOmit={keysToOmit}
+            printer={opPrinter}
           />
         </>
       )

package/src/index.ts

@@ -3,6 +3,7 @@ export { Type } from './components/Type.tsx'
 export { typeGenerator } from './generators/typeGenerator.tsx'
 export { pluginTs, pluginTsName } from './plugin.ts'
 export { functionPrinter } from './printers/functionPrinter.ts'
+export type { PrinterTsFactory, PrinterTsNodes, PrinterTsOptions } from './printers/printerTs.ts'
 export { printerTs } from './printers/printerTs.ts'
 export { resolverTs } from './resolvers/resolverTs.ts'
 export { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'

package/src/plugin.ts

@@ -41,17 +41,18 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     arrayType = 'array',
     syntaxType = 'type',
     paramsCasing,
+    printer,
     compatibilityPreset = 'default',
-    resolvers: userResolvers = [],
-    transformers: userTransformers = [],
+    resolver: userResolver,
+    transformer: userTransformer,
     generators: userGenerators = [],
   } = options
 
   const preset = getPreset({
     preset: compatibilityPreset,
     presets: presets,
-    resolvers: userResolvers,
-    transformers: userTransformers,
+    resolver: userResolver,
+    transformer: userTransformer,
     generators: userGenerators,
   })
 
@@ -63,6 +64,9 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     get resolver() {
       return preset.resolver
     },
+    get transformer() {
+      return preset.transformer
+    },
     get options() {
       return {
         output,
@@ -84,7 +88,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         enumKeyCasing,
         syntaxType,
         paramsCasing,
-        transformers: preset.transformers,
+        printer,
       }
     },
     resolvePath(baseName, pathMode, options) {

package/src/presets.ts

@@ -1,6 +1,7 @@
 import { definePresets } from '@kubb/core'
 import { typeGenerator } from './generators/typeGenerator.tsx'
 import { typeGeneratorLegacy } from './generators/typeGeneratorLegacy.tsx'
+import { printerTs } from './printers/printerTs.ts'
 import { resolverTs } from './resolvers/resolverTs.ts'
 import { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
 import type { ResolverTs } from './types.ts'
@@ -14,12 +15,14 @@ import type { ResolverTs } from './types.ts'
 export const presets = definePresets<ResolverTs>({
   default: {
     name: 'default',
-    resolvers: [resolverTs],
+    resolver: resolverTs,
     generators: [typeGenerator],
+    printer: printerTs,
   },
   kubbV4: {
     name: 'kubbV4',
-    resolvers: [resolverTsLegacy],
+    resolver: resolverTsLegacy,
     generators: [typeGeneratorLegacy],
+    printer: printerTs,
   },
 })

package/src/printers/printerTs.ts

@@ -1,5 +1,5 @@
 import { extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef } from '@kubb/ast'
-import type { PrinterFactoryOptions } from '@kubb/core'
+import type { PrinterFactoryOptions, PrinterPartial } from '@kubb/core'
 import { definePrinter } from '@kubb/core'
 import { safePrint } from '@kubb/fabric-core/parsers/typescript'
 import type ts from 'typescript'
@@ -8,7 +8,29 @@ import * as factory from '../factory.ts'
 import type { PluginTs, ResolverTs } from '../types.ts'
 import { buildPropertyJSDocComments } from '../utils.ts'
 
-type TsOptions = {
+/**
+ * Partial map of node-type overrides for the TypeScript printer.
+ *
+ * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function
+ * replaces the built-in handler for that node type. Use `this.transform` to
+ * recurse into nested schema nodes, and `this.options` to read printer options.
+ *
+ * @example Override the `date` handler
+ * ```ts
+ * pluginTs({
+ *   printer: {
+ *     nodes: {
+ *       date(node) {
+ *         return ts.factory.createTypeReferenceNode('Date', [])
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export type PrinterTsNodes = PrinterPartial<ts.TypeNode, PrinterTsOptions>
+
+export type PrinterTsOptions = {
   /**
    * @default `'questionToken'`
    */
@@ -57,12 +79,18 @@ type TsOptions = {
    * instead of the plain PascalCase name, so imports align with what the enum file actually exports.
    */
   enumSchemaNames?: Set<string>
+  /**
+   * Partial map of node-type overrides. Each entry replaces the built-in handler for that node type.
+   */
+  nodes?: PrinterTsNodes
 }
 
 /**
  * TypeScript printer factory options: maps `SchemaNode` → `ts.TypeNode` (raw) or `ts.Node` (full declaration).
  */
-type TsPrinter = PrinterFactoryOptions<'typescript', TsOptions, ts.TypeNode, string>
+export type PrinterTsFactory = PrinterFactoryOptions<'typescript', PrinterTsOptions, ts.TypeNode, string>
+
+type PrinterTs = PrinterTsFactory
 
 /**
  * TypeScript type printer built with `definePrinter`.
@@ -87,7 +115,7 @@ type TsPrinter = PrinterFactoryOptions<'typescript', TsOptions, ts.TypeNode, str
  * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
  * ```
  */
-export const printerTs = definePrinter<TsPrinter>((options) => {
+export const printerTs = definePrinter<PrinterTs>((options) => {
   const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType)
 
   return {
@@ -227,6 +255,7 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
 
         return factory.createTypeLiteralNode(allElements)
       },
+      ...options.nodes,
     },
     print(node) {
       const { name, syntaxType = 'type', description, keysToOmit } = this.options

package/src/resolvers/resolverTs.ts

@@ -2,10 +2,6 @@ import { pascalCase } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginTs } from '../types.ts'
 
-function toTypeName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string {
-  return 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
@@ -28,34 +24,34 @@ export const resolverTs = defineResolver<PluginTs>(() => {
     name: 'default',
     pluginName: 'plugin-ts',
     default(name, type) {
-      return toTypeName(name, type)
+      return pascalCase(name, { isFile: type === 'file' })
     },
-    resolveName(name) {
-      return this.default(name, 'function')
+    resolveTypeName(name) {
+      return pascalCase(name)
     },
     resolvePathName(name, type) {
-      return this.default(name, type)
+      return pascalCase(name, { isFile: type === 'file' })
     },
     resolveParamName(node, param) {
-      return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+      return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`)
     },
     resolveResponseStatusName(node, statusCode) {
-      return this.resolveName(`${node.operationId} Status ${statusCode}`)
+      return this.resolveTypeName(`${node.operationId} Status ${statusCode}`)
     },
     resolveDataName(node) {
-      return this.resolveName(`${node.operationId} Data`)
+      return this.resolveTypeName(`${node.operationId} Data`)
     },
     resolveRequestConfigName(node) {
-      return this.resolveName(`${node.operationId} RequestConfig`)
+      return this.resolveTypeName(`${node.operationId} RequestConfig`)
     },
     resolveResponsesName(node) {
-      return this.resolveName(`${node.operationId} Responses`)
+      return this.resolveTypeName(`${node.operationId} Responses`)
     },
     resolveResponseName(node) {
-      return this.resolveName(`${node.operationId} Response`)
+      return this.resolveTypeName(`${node.operationId} Response`)
     },
     resolveEnumKeyName(node, enumTypeSuffix = 'key') {
-      return `${this.resolveName(node.name ?? '')}${enumTypeSuffix}`
+      return `${this.resolveTypeName(node.name ?? '')}${enumTypeSuffix}`
     },
     resolvePathParamsName(node, param) {
       return this.resolveParamName(node, param)

package/src/resolvers/resolverTsLegacy.ts

@@ -31,30 +31,30 @@ export const resolverTsLegacy = defineResolver<PluginTs>(() => {
     pluginName: 'plugin-ts',
     resolveResponseStatusName(node, statusCode) {
       if (statusCode === 'default') {
-        return this.resolveName(`${node.operationId} Error`)
+        return this.resolveTypeName(`${node.operationId} Error`)
       }
-      return this.resolveName(`${node.operationId} ${statusCode}`)
+      return this.resolveTypeName(`${node.operationId} ${statusCode}`)
     },
     resolveDataName(node) {
       const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
-      return this.resolveName(`${node.operationId} ${suffix}`)
+      return this.resolveTypeName(`${node.operationId} ${suffix}`)
     },
     resolveResponsesName(node) {
       const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
-      return this.resolveName(`${node.operationId} ${suffix}`)
+      return this.resolveTypeName(`${node.operationId} ${suffix}`)
     },
     resolveResponseName(node) {
       const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
-      return this.resolveName(`${node.operationId} ${suffix}`)
+      return this.resolveTypeName(`${node.operationId} ${suffix}`)
     },
     resolvePathParamsName(node, _param) {
-      return this.resolveName(`${node.operationId} PathParams`)
+      return this.resolveTypeName(`${node.operationId} PathParams`)
     },
     resolveQueryParamsName(node, _param) {
-      return this.resolveName(`${node.operationId} QueryParams`)
+      return this.resolveTypeName(`${node.operationId} QueryParams`)
     },
     resolveHeaderParamsName(node, _param) {
-      return this.resolveName(`${node.operationId} HeaderParams`)
+      return this.resolveTypeName(`${node.operationId} HeaderParams`)
     },
   }
 })