@kubb/plugin-ts 5.0.0-alpha.3 → 5.0.0-alpha.31

package/src/printers/functionPrinter.ts

@@ -0,0 +1,196 @@
+import type { PrinterFactoryOptions } from '@kubb/ast'
+import { createPrinterFactory } from '@kubb/ast'
+import type { FunctionNode, FunctionNodeType, FunctionParameterNode, FunctionParametersNode, ParameterGroupNode, TypeNode } from '@kubb/ast/types'
+import { PARAM_RANK } from '../constants.ts'
+
+/**
+ * Maps each function-printer handler key to its concrete node type.
+ */
+export type FunctionNodeByType = {
+  functionParameter: FunctionParameterNode
+  parameterGroup: ParameterGroupNode
+  functionParameters: FunctionParametersNode
+  type: TypeNode
+}
+
+const kindToHandlerKey = {
+  FunctionParameter: 'functionParameter',
+  ParameterGroup: 'parameterGroup',
+  FunctionParameters: 'functionParameters',
+  Type: 'type',
+} satisfies Record<string, FunctionNodeType>
+
+/**
+ * Creates a function-parameter printer factory.
+ *
+ * Uses `createPrinterFactory` and dispatches handlers by `node.kind`
+ * (for function nodes) rather than by `node.type` (for schema nodes).
+ */
+export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>((node) => kindToHandlerKey[node.kind])
+
+export type FunctionPrinterOptions = {
+  /**
+   * Rendering modes supported by `functionPrinter`.
+   *
+   * | Mode          | Output example                              | Use case                        |
+   * |---------------|---------------------------------------------|---------------------------------|
+   * | `declaration` | `id: string, config: Config = {}`           | Function parameter declaration |
+   * | `call`        | `id, { method, url }`                       | Function call arguments |
+   * | `keys`        | `{ id, config }`                            | Key names only (destructuring) |
+   * | `values`      | `{ id: id, config: config }`                | Key/value object entries |
+   */
+  mode: 'declaration' | 'call' | 'keys' | 'values'
+  /**
+   * Optional transformation applied to every parameter name before printing.
+   */
+  transformName?: (name: string) => string
+  /**
+   * Optional transformation applied to every type string before printing.
+   */
+  transformType?: (type: string) => string
+}
+
+type DefaultPrinter = PrinterFactoryOptions<'functionParameters', FunctionPrinterOptions, string>
+
+function rank(param: FunctionParameterNode | ParameterGroupNode): number {
+  if (param.kind === 'ParameterGroup') {
+    if (param.default) return PARAM_RANK.withDefault
+    const isOptional = param.optional ?? param.properties.every((p) => p.optional || p.default !== undefined)
+    return isOptional ? PARAM_RANK.optional : PARAM_RANK.required
+  }
+  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: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>): Array<FunctionParameterNode | ParameterGroupNode> {
+  return [...params].sort((a, b) => rank(a) - rank(b))
+}
+
+function sortChildParams(params: Array<FunctionParameterNode>): Array<FunctionParameterNode> {
+  return [...params].sort((a, b) => rank(a) - rank(b))
+}
+
+/**
+ * Default function-signature printer.
+ * Covers the four standard output modes used across Kubb plugins.
+ *
+ * @example
+ * ```ts
+ * const printer = functionPrinter({ mode: 'declaration' })
+ *
+ * const sig = createFunctionParameters({
+ *   params: [
+ *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
+ *     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),
+ *   ],
+ * })
+ *
+ * printer.print(sig)  // → "petId: string, config: Config = {}"
+ * ```
+ */
+export const functionPrinter = defineFunctionPrinter<DefaultPrinter>((options) => ({
+  name: 'functionParameters',
+  options,
+  nodes: {
+    type(node) {
+      if (node.variant === 'member') {
+        return `${node.base}['${node.key}']`
+      }
+      if (node.variant === 'struct') {
+        const parts = node.properties.map((p) => {
+          const typeStr = this.transform(p.type)
+          const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name)
+          return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`
+        })
+        return `{ ${parts.join('; ')} }`
+      }
+      if (node.variant === 'reference') {
+        return node.name
+      }
+      return null
+    },
+    functionParameter(node) {
+      const { mode, transformName, transformType } = this.options
+      const name = transformName ? transformName(node.name) : node.name
+
+      const rawType = node.type ? this.transform(node.type) : undefined
+      const type = rawType != null && transformType ? transformType(rawType) : rawType
+
+      if (mode === 'keys' || mode === 'values') {
+        return node.rest ? `...${name}` : name
+      }
+
+      if (mode === 'call') {
+        return node.rest ? `...${name}` : name
+      }
+
+      if (node.rest) {
+        return type ? `...${name}: ${type}` : `...${name}`
+      }
+      if (type) {
+        if (node.optional) return `${name}?: ${type}`
+        return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`
+      }
+      return node.default ? `${name} = ${node.default}` : name
+    },
+    parameterGroup(node) {
+      const { mode, transformName, transformType } = this.options
+      const sorted = sortChildParams(node.properties)
+      const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== undefined)
+
+      if (node.inline) {
+        return sorted
+          .map((p) => this.transform(p))
+          .filter(Boolean)
+          .join(', ')
+      }
+
+      if (mode === 'keys' || mode === 'values') {
+        const keys = sorted.map((p) => p.name).join(', ')
+        return `{ ${keys} }`
+      }
+
+      if (mode === 'call') {
+        const keys = sorted.map((p) => p.name).join(', ')
+        return `{ ${keys} }`
+      }
+
+      const names = sorted.map((p) => {
+        const n = transformName ? transformName(p.name) : p.name
+
+        return n
+      })
+
+      const nameStr = names.length ? `{ ${names.join(', ')} }` : undefined
+      if (!nameStr) return null
+
+      let typeAnnotation: string | undefined = node.type ? (this.transform(node.type) ?? undefined) : undefined
+      if (!typeAnnotation) {
+        const typeParts = sorted
+          .filter((p) => p.type)
+          .map((p) => {
+            const rawT = p.type ? this.transform(p.type) : undefined
+            const t = rawT != null && transformType ? transformType(rawT) : rawT
+            return p.optional || p.default !== undefined ? `${p.name}?: ${t}` : `${p.name}: ${t}`
+          })
+        typeAnnotation = typeParts.length ? `{ ${typeParts.join('; ')} }` : undefined
+      }
+
+      if (typeAnnotation) {
+        if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? '{}'}`
+        return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`
+      }
+
+      return node.default ? `${nameStr} = ${node.default}` : nameStr
+    },
+    functionParameters(node) {
+      const sorted = sortParams(node.params)
+
+      return sorted
+        .map((p) => this.transform(p))
+        .filter(Boolean)
+        .join(', ')
+    },
+  },
+}))

package/src/printers/printerTs.ts

@@ -0,0 +1,310 @@
+import { extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef } from '@kubb/ast'
+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'
+import { ENUM_TYPES_WITH_KEY_SUFFIX, OPTIONAL_ADDS_QUESTION_TOKEN, OPTIONAL_ADDS_UNDEFINED } from '../constants.ts'
+import * as factory from '../factory.ts'
+import type { PluginTs, ResolverTs } from '../types.ts'
+import { buildPropertyJSDocComments } from '../utils.ts'
+
+/**
+ * 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'`
+   */
+  optionalType: PluginTs['resolvedOptions']['optionalType']
+  /**
+   * @default `'array'`
+   */
+  arrayType: PluginTs['resolvedOptions']['arrayType']
+  /**
+   * @default `'inlineLiteral'`
+   */
+  enumType: PluginTs['resolvedOptions']['enumType']
+  /**
+   * Suffix appended to the generated type alias name when `enumType` is `asConst` or `asPascalConst`.
+   *
+   * @default `'Key'`
+   */
+  enumTypeSuffix?: PluginTs['resolvedOptions']['enumTypeSuffix']
+  /**
+   * Controls whether a `type` alias or `interface` declaration is emitted.
+   * @default `'type'`
+   */
+  syntaxType?: PluginTs['resolvedOptions']['syntaxType']
+  /**
+   * When set, `printer.print(node)` produces a full `type Name = …` declaration.
+   * When omitted, `printer.print(node)` returns the raw type node.
+   */
+  name?: string
+
+  /**
+   * JSDoc `@description` comment added to the generated type or interface declaration.
+   */
+  description?: string
+  /**
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Forces type-alias syntax even when `syntaxType` is `'interface'`.
+   */
+  keysToOmit?: Array<string>
+  /**
+   * Resolver used to transform raw schema names into valid TypeScript identifiers.
+   */
+  resolver: ResolverTs
+  /**
+   * Names of top-level schemas that are enums.
+   * When set, the `ref` handler uses the suffixed type name (e.g. `StatusKey`) for enum refs
+   * 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).
+ */
+export type PrinterTsFactory = PrinterFactoryOptions<'typescript', PrinterTsOptions, ts.TypeNode, string>
+
+type PrinterTs = PrinterTsFactory
+
+/**
+ * TypeScript type printer built with `definePrinter`.
+ *
+ * Converts a `SchemaNode` AST node into a TypeScript AST node:
+ * - **`printer.print(node)`** — when `options.typeName` is set, returns a full
+ *   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).
+ *   Without `typeName`, returns the raw `ts.TypeNode` for the schema.
+ *
+ * Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
+ * over per printer instance, so each call to `printerTs(options)` produces an independent printer.
+ *
+ * @example Raw type node (no `typeName`)
+ * ```ts
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral' })
+ * const typeNode = printer.print(schemaNode) // ts.TypeNode
+ * ```
+ *
+ * @example Full declaration (with `typeName`)
+ * ```ts
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral', typeName: 'MyType' })
+ * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
+ * ```
+ */
+export const printerTs = definePrinter<PrinterTs>((options) => {
+  const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType)
+
+  return {
+    name: 'typescript',
+    options,
+    nodes: {
+      any: () => factory.keywordTypeNodes.any,
+      unknown: () => factory.keywordTypeNodes.unknown,
+      void: () => factory.keywordTypeNodes.void,
+      never: () => factory.keywordTypeNodes.never,
+      boolean: () => factory.keywordTypeNodes.boolean,
+      null: () => factory.keywordTypeNodes.null,
+      blob: () => factory.createTypeReferenceNode('Blob', []),
+      string: () => factory.keywordTypeNodes.string,
+      uuid: () => factory.keywordTypeNodes.string,
+      email: () => factory.keywordTypeNodes.string,
+      url: (node) => {
+        if (node.path) {
+          return factory.createUrlTemplateType(node.path)
+        }
+        return factory.keywordTypeNodes.string
+      },
+      ipv4: () => factory.keywordTypeNodes.string,
+      ipv6: () => factory.keywordTypeNodes.string,
+      datetime: () => factory.keywordTypeNodes.string,
+      number: () => factory.keywordTypeNodes.number,
+      integer: () => factory.keywordTypeNodes.number,
+      bigint: () => factory.keywordTypeNodes.bigint,
+      date: factory.dateOrStringNode,
+      time: factory.dateOrStringNode,
+      ref(node) {
+        if (!node.name) {
+          return undefined
+        }
+        // Parser-generated refs (with $ref) carry raw schema names that need resolving.
+        // Use the canonical name from the $ref path — node.name may have been overridden
+        // (e.g. by single-member allOf flatten using the property-derived child name).
+        // Inline refs (without $ref) from utils already carry resolved type names.
+        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
+
+        // When a Key suffix is configured, enum refs must use the suffixed name (e.g. `StatusKey`)
+        // so the reference matches what the enum file actually exports.
+        const isEnumRef =
+          node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && this.options.enumSchemaNames?.has(refName)
+
+        const name = isEnumRef
+          ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix!)
+          : node.ref
+            ? this.options.resolver.default(refName, 'type')
+            : refName
+
+        return factory.createTypeReferenceNode(name, undefined)
+      },
+      enum(node) {
+        const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []
+
+        if (this.options.enumType === 'inlineLiteral' || !node.name) {
+          const literalNodes = values
+            .filter((v): v is string | number | boolean => v !== null && v !== undefined)
+            .map((value) => factory.constToTypeNode(value, typeof value as 'string' | 'number' | 'boolean'))
+            .filter(Boolean)
+
+          return factory.createUnionDeclaration({ withParentheses: true, nodes: literalNodes }) ?? undefined
+        }
+
+        const resolvedName =
+          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')
+
+        return factory.createTypeReferenceNode(resolvedName, undefined)
+      },
+      union(node) {
+        const members = node.members ?? []
+
+        const hasStringLiteral = members.some((m) => {
+          const enumNode = narrowSchema(m, schemaTypes.enum)
+          return enumNode?.primitive === 'string'
+        })
+        const hasPlainString = members.some((m) => isStringType(m))
+
+        if (hasStringLiteral && hasPlainString) {
+          const memberNodes = members
+            .map((m) => {
+              if (isStringType(m)) {
+                return factory.createIntersectionDeclaration({
+                  nodes: [factory.keywordTypeNodes.string, factory.createTypeLiteralNode([])],
+                  withParentheses: true,
+                })
+              }
+
+              return this.transform(m)
+            })
+            .filter(Boolean)
+
+          return factory.createUnionDeclaration({ withParentheses: true, nodes: memberNodes }) ?? undefined
+        }
+
+        return factory.createUnionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(members, this.transform) }) ?? undefined
+      },
+      intersection(node) {
+        return factory.createIntersectionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(node.members, this.transform) }) ?? undefined
+      },
+      array(node) {
+        const itemNodes = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
+
+        return factory.createArrayDeclaration({ nodes: itemNodes, arrayType: this.options.arrayType }) ?? undefined
+      },
+      tuple(node) {
+        return factory.buildTupleNode(node, this.transform)
+      },
+      object(node) {
+        const { transform, options } = this
+
+        const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType)
+
+        const propertyNodes: Array<ts.TypeElement> = node.properties.map((prop) => {
+          const baseType = transform(prop.schema) ?? factory.keywordTypeNodes.unknown
+          const type = factory.buildPropertyType(prop.schema, baseType, options.optionalType)
+          const propMeta = syncSchemaRef(prop.schema)
+
+          const propertyNode = factory.createPropertySignature({
+            questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
+            name: prop.name,
+            type,
+            readOnly: propMeta?.readOnly,
+          })
+
+          return factory.appendJSDocToNode({ node: propertyNode, comments: buildPropertyJSDocComments(prop.schema) })
+        })
+
+        const allElements = [...propertyNodes, ...factory.buildIndexSignatures(node, propertyNodes.length, transform)]
+
+        if (!allElements.length) {
+          return factory.keywordTypeNodes.object
+        }
+
+        return factory.createTypeLiteralNode(allElements)
+      },
+      ...options.nodes,
+    },
+    print(node) {
+      const { name, syntaxType = 'type', description, keysToOmit } = this.options
+
+      let base = this.transform(node)
+      if (!base) return null
+
+      // For ref nodes, structural metadata lives on node.schema rather than the ref node itself.
+      const meta = syncSchemaRef(node)
+
+      // Without name, apply modifiers inline and return.
+      if (!name) {
+        if (meta.nullable) {
+          base = factory.createUnionDeclaration({ nodes: [base, factory.keywordTypeNodes.null] })
+        }
+        if ((meta.nullish || meta.optional) && addsUndefined) {
+          base = factory.createUnionDeclaration({ nodes: [base, factory.keywordTypeNodes.undefined] })
+        }
+        return safePrint(base)
+      }
+
+      // When keysToOmit is present, wrap with Omit first, then apply nullable/optional
+      // modifiers so they are not swallowed by NonNullable inside createOmitDeclaration.
+      let inner: ts.TypeNode = keysToOmit?.length ? factory.createOmitDeclaration({ keys: keysToOmit, type: base, nonNullable: true }) : base
+
+      if (meta.nullable) {
+        inner = factory.createUnionDeclaration({ nodes: [inner, factory.keywordTypeNodes.null] })
+      }
+
+      // For named type declarations (type aliases), optional/nullish always produces | undefined
+      // regardless of optionalType — the questionToken ? modifier only applies to object properties.
+      if (meta.nullish || meta.optional) {
+        inner = factory.createUnionDeclaration({ nodes: [inner, factory.keywordTypeNodes.undefined] })
+      }
+
+      const useTypeGeneration = syntaxType === 'type' || inner.kind === factory.syntaxKind.union || !!keysToOmit?.length
+
+      const typeNode = factory.createTypeDeclaration({
+        name,
+        isExportable: true,
+        type: inner,
+        syntax: useTypeGeneration ? 'type' : 'interface',
+        comments: buildPropertyJSDocComments({
+          ...meta,
+          description,
+        }),
+      })
+
+      return safePrint(typeNode)
+    },
+  }
+})

package/src/resolvers/resolverTs.ts

@@ -0,0 +1,66 @@
+import { pascalCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginTs } from '../types.ts'
+
+/**
+ * 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.resolvePathName('list pets', 'file')       // → 'listPets'
+ * ```
+ */
+export const resolverTs = defineResolver<PluginTs>(() => {
+  return {
+    name: 'default',
+    pluginName: 'plugin-ts',
+    default(name, type) {
+      return pascalCase(name, { isFile: type === 'file' })
+    },
+    resolveTypeName(name) {
+      return pascalCase(name)
+    },
+    resolvePathName(name, type) {
+      return pascalCase(name, { isFile: type === 'file' })
+    },
+    resolveParamName(node, param) {
+      return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`)
+    },
+    resolveResponseStatusName(node, statusCode) {
+      return this.resolveTypeName(`${node.operationId} Status ${statusCode}`)
+    },
+    resolveDataName(node) {
+      return this.resolveTypeName(`${node.operationId} Data`)
+    },
+    resolveRequestConfigName(node) {
+      return this.resolveTypeName(`${node.operationId} RequestConfig`)
+    },
+    resolveResponsesName(node) {
+      return this.resolveTypeName(`${node.operationId} Responses`)
+    },
+    resolveResponseName(node) {
+      return this.resolveTypeName(`${node.operationId} Response`)
+    },
+    resolveEnumKeyName(node, enumTypeSuffix = 'key') {
+      return `${this.resolveTypeName(node.name ?? '')}${enumTypeSuffix}`
+    },
+    resolvePathParamsName(node, param) {
+      return this.resolveParamName(node, param)
+    },
+    resolveQueryParamsName(node, param) {
+      return this.resolveParamName(node, param)
+    },
+    resolveHeaderParamsName(node, param) {
+      return this.resolveParamName(node, param)
+    },
+  }
+})

package/src/resolvers/resolverTsLegacy.ts

@@ -0,0 +1,60 @@
+import { defineResolver } from '@kubb/core'
+import type { PluginTs } from '../types.ts'
+import { resolverTs } from './resolverTs.ts'
+
+/**
+ * Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions
+ * used before the v2 resolver refactor. Enable via `compatibilityPreset: 'kubbV4'`
+ * (or by composing this resolver manually).
+ *
+ * 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)
+ * ```
+ */
+export const resolverTsLegacy = defineResolver<PluginTs>(() => {
+  return {
+    ...resolverTs,
+    pluginName: 'plugin-ts',
+    resolveResponseStatusName(node, statusCode) {
+      if (statusCode === 'default') {
+        return this.resolveTypeName(`${node.operationId} Error`)
+      }
+      return this.resolveTypeName(`${node.operationId} ${statusCode}`)
+    },
+    resolveDataName(node) {
+      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
+      return this.resolveTypeName(`${node.operationId} ${suffix}`)
+    },
+    resolveResponsesName(node) {
+      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
+      return this.resolveTypeName(`${node.operationId} ${suffix}`)
+    },
+    resolveResponseName(node) {
+      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
+      return this.resolveTypeName(`${node.operationId} ${suffix}`)
+    },
+    resolvePathParamsName(node, _param) {
+      return this.resolveTypeName(`${node.operationId} PathParams`)
+    },
+    resolveQueryParamsName(node, _param) {
+      return this.resolveTypeName(`${node.operationId} QueryParams`)
+    },
+    resolveHeaderParamsName(node, _param) {
+      return this.resolveTypeName(`${node.operationId} HeaderParams`)
+    },
+  }
+})