@kubb/plugin-ts 5.0.0-alpha.20 → 5.0.0-alpha.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.20",
+  "version": "5.0.0-alpha.22",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -31,6 +31,10 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./builders": {
+      "import": "./dist/builders.js",
+      "require": "./dist/builders.cjs"
+    },
     "./components": {
       "import": "./dist/components.js",
       "require": "./dist/components.cjs"
@@ -39,6 +43,10 @@
       "import": "./dist/generators.js",
       "require": "./dist/generators.cjs"
     },
+    "./printers": {
+      "import": "./dist/printers.js",
+      "require": "./dist/printers.cjs"
+    },
     "./resolvers": {
       "import": "./dist/resolvers.js",
       "require": "./dist/resolvers.cjs"
@@ -56,6 +64,12 @@
       ],
       "resolvers": [
         "./dist/resolvers.d.ts"
+      ],
+      "builders": [
+        "./dist/builders.d.ts"
+      ],
+      "printers": [
+        "./dist/printers.d.ts"
       ]
     }
   },
@@ -78,10 +92,8 @@
     "@kubb/react-fabric": "0.15.1",
     "remeda": "^2.33.6",
     "typescript": "5.9.3",
-    "@kubb/ast": "5.0.0-alpha.20",
-    "@kubb/core": "5.0.0-alpha.20",
-    "@kubb/oas": "5.0.0-alpha.20",
-    "@kubb/plugin-oas": "5.0.0-alpha.20"
+    "@kubb/ast": "5.0.0-alpha.22",
+    "@kubb/core": "5.0.0-alpha.22"
   },
   "peerDependencies": {
     "@kubb/react-fabric": "0.15.1"

package/src/builders/builderTs.ts

@@ -0,0 +1,107 @@
+import { createProperty, createSchema } from '@kubb/ast'
+import { defineBuilder } from '@kubb/core'
+import type { PluginTs } from '../types.ts'
+
+/**
+ * Default schema builder for `@kubb/plugin-ts`.
+ *
+ * Implements the `buildParams`, `buildData`, `buildResponses`, and `buildResponseUnion` helpers
+ * used by the TypeScript type generator to construct AST schema nodes for operation parameters,
+ * request bodies, and responses.
+ *
+ * @example
+ * ```ts
+ * import { builderTs } from '@kubb/plugin-ts'
+ *
+ * builderTs.buildData({ node, resolver })
+ * // → object schema with pathParams, queryParams, headerParams, data, url properties
+ * ```
+ */
+export const builderTs = defineBuilder<PluginTs>(() => ({
+  name: 'default',
+  buildParams({ params, node, resolver }) {
+    return createSchema({
+      type: 'object',
+      properties: params.map((param) =>
+        createProperty({
+          name: param.name,
+          required: param.required,
+          schema: createSchema({
+            type: 'ref',
+            name: resolver.resolveParamName(node, param),
+          }),
+        }),
+      ),
+    })
+  },
+  buildData({ node, resolver }) {
+    const pathParams = node.parameters.filter((p) => p.in === 'path')
+    const queryParams = node.parameters.filter((p) => p.in === 'query')
+    const headerParams = node.parameters.filter((p) => p.in === 'header')
+
+    return createSchema({
+      type: 'object',
+      deprecated: node.deprecated,
+      properties: [
+        createProperty({
+          name: 'data',
+          schema: node.requestBody?.schema
+            ? createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+        }),
+        createProperty({
+          name: 'pathParams',
+          required: pathParams.length > 0,
+          schema: pathParams.length > 0 ? this.buildParams({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
+        }),
+        createProperty({
+          name: 'queryParams',
+          schema:
+            queryParams.length > 0
+              ? createSchema({ ...this.buildParams({ params: queryParams, node, resolver }), optional: true })
+              : createSchema({ type: 'never', optional: true }),
+        }),
+        createProperty({
+          name: 'headerParams',
+          schema:
+            headerParams.length > 0
+              ? createSchema({ ...this.buildParams({ params: headerParams, node, resolver }), optional: true })
+              : createSchema({ type: 'never', optional: true }),
+        }),
+        createProperty({
+          name: 'url',
+          required: true,
+          schema: createSchema({ type: 'url', path: node.path }),
+        }),
+      ],
+    })
+  },
+  buildResponses({ node, resolver }) {
+    if (node.responses.length === 0) {
+      return null
+    }
+
+    return createSchema({
+      type: 'object',
+      properties: node.responses.map((res) =>
+        createProperty({
+          name: String(res.statusCode),
+          required: true,
+          schema: createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) }),
+        }),
+      ),
+    })
+  },
+  buildResponseUnion({ node, resolver }) {
+    const responsesWithSchema = node.responses.filter((res) => res.schema)
+
+    if (responsesWithSchema.length === 0) {
+      return null
+    }
+
+    return createSchema({
+      type: 'union',
+      members: responsesWithSchema.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+    })
+  },
+}))

package/src/builders/index.ts

@@ -0,0 +1 @@
+export { builderTs } from './builderTs.ts'

package/src/components/Enum.tsx

@@ -10,6 +10,7 @@ import type { PluginTs, ResolverTs } from '../types.ts'
 type Props = {
   node: EnumSchemaNode
   enumType: PluginTs['resolvedOptions']['enumType']
+  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
   resolver: ResolverTs
 }
@@ -21,7 +22,17 @@ type Props = {
  * valid TypeScript identifier. The resolver normalizes it; for inline enum
  * properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
  */
-export function getEnumNames({ node, enumType, resolver }: { node: EnumSchemaNode; enumType: PluginTs['resolvedOptions']['enumType']; resolver: ResolverTs }): {
+export function getEnumNames({
+  node,
+  enumType,
+  enumTypeSuffix,
+  resolver,
+}: {
+  node: EnumSchemaNode
+  enumType: PluginTs['resolvedOptions']['enumType']
+  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
+  resolver: ResolverTs
+}): {
   enumName: string
   typeName: string
   /**
@@ -32,7 +43,7 @@ export function getEnumNames({ node, enumType, resolver }: { node: EnumSchemaNod
 } {
   const resolved = resolver.default(node.name!, 'type')
   const enumName = enumType === 'asPascalConst' ? resolved : camelCase(node.name!)
-  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : resolved
+  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyTypedName(node, enumTypeSuffix) : resolved
 
   return { enumName, typeName, refName: resolved }
 }
@@ -48,8 +59,8 @@ export function getEnumNames({ node, enumType, resolver }: { node: EnumSchemaNod
  * The emitted `File.Source` nodes carry the resolved names so that the barrel
  * index picks up the correct export identifiers.
  */
-export function Enum({ node, enumType, enumKeyCasing, resolver }: Props): FabricReactNode {
-  const { enumName, typeName, refName } = getEnumNames({ node, enumType, resolver })
+export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): FabricReactNode {
+  const { enumName, typeName } = getEnumNames({ node, enumType, enumTypeSuffix, resolver })
 
   const [nameNode, typeNode] = factory.createEnumDeclaration({
     name: enumName,
@@ -61,8 +72,6 @@ export function Enum({ node, enumType, enumKeyCasing, resolver }: Props): Fabric
     enumKeyCasing,
   })
 
-  const needsRefAlias = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && refName !== typeName
-
   return (
     <>
       {nameNode && (
@@ -73,11 +82,6 @@ export function Enum({ node, enumType, enumKeyCasing, resolver }: Props): Fabric
       <File.Source name={typeName} isIndexable isExportable={ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType)} isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumType)}>
         {safePrint(typeNode)}
       </File.Source>
-      {needsRefAlias && (
-        <File.Source name={refName} isExportable isIndexable isTypeOnly>
-          {`export type ${refName} = ${typeName}`}
-        </File.Source>
-      )}
     </>
   )
 }

package/src/components/Type.tsx

@@ -1,9 +1,8 @@
 import { collect, narrowSchema, schemaTypes } from '@kubb/ast'
 import type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'
-import { safePrint } from '@kubb/fabric-core/parsers/typescript'
 import { File } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import { printerTs } from '../printer.ts'
+import { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types.ts'
 import { Enum, getEnumNames } from './Enum.tsx'
 
@@ -14,10 +13,10 @@ type Props = {
   optionalType: PluginTs['resolvedOptions']['optionalType']
   arrayType: PluginTs['resolvedOptions']['arrayType']
   enumType: PluginTs['resolvedOptions']['enumType']
+  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
   syntaxType: PluginTs['resolvedOptions']['syntaxType']
   resolver: PluginTs['resolvedOptions']['resolver']
-  legacy?: boolean
   description?: string
   keysToOmit?: string[]
 }
@@ -31,6 +30,7 @@ export function Type({
   arrayType,
   syntaxType,
   enumType,
+  enumTypeSuffix,
   enumKeyCasing,
   description,
   resolver,
@@ -43,17 +43,27 @@ export function Type({
     },
   })
 
-  const printer = printerTs({ optionalType, arrayType, enumType, typeName: name, syntaxType, description: resolvedDescription, keysToOmit, resolver })
-  const typeNode = printer.print(node)
+  const printer = printerTs({
+    optionalType,
+    arrayType,
+    enumType,
+    enumTypeSuffix,
+    typeName: name,
+    syntaxType,
+    description: resolvedDescription,
+    keysToOmit,
+    resolver,
+  })
+  const output = printer.print(node)
 
-  if (!typeNode) {
+  if (!output) {
     return
   }
 
   const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
     return {
       node,
-      ...getEnumNames({ node, enumType, resolver }),
+      ...getEnumNames({ node, enumType, enumTypeSuffix, resolver }),
     }
   })
 
@@ -63,10 +73,11 @@ export function Type({
 
   return (
     <>
-      {shouldExportEnums && enums.map(({ node }) => <Enum node={node} enumType={enumType} enumKeyCasing={enumKeyCasing} resolver={resolver} />)}
+      {shouldExportEnums &&
+        enums.map(({ node }) => <Enum node={node} enumType={enumType} enumTypeSuffix={enumTypeSuffix} enumKeyCasing={enumKeyCasing} resolver={resolver} />)}
       {shouldExportType && (
         <File.Source name={typedName} isTypeOnly isExportable isIndexable>
-          {safePrint(typeNode)}
+          {output}
         </File.Source>
       )}
     </>

package/src/factory.ts

@@ -19,16 +19,6 @@ export const syntaxKind = {
   stringLiteral: SyntaxKind.StringLiteral,
 } as const
 
-export function getUnknownType(unknownType: 'any' | 'unknown' | 'void' | undefined) {
-  if (unknownType === 'any') {
-    return keywordTypeNodes.any
-  }
-  if (unknownType === 'void') {
-    return keywordTypeNodes.void
-  }
-
-  return keywordTypeNodes.unknown
-}
 function isValidIdentifier(str: string): boolean {
   if (!str.length || str.trim() !== str) {
     return false
@@ -76,28 +66,6 @@ export function createIntersectionDeclaration({ nodes, withParentheses }: { node
   return node
 }
 
-/**
- * Minimum nodes length of 2
- * @example `string & number`
- */
-export function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {
-  if (!nodes.length) {
-    return null
-  }
-
-  if (nodes.length === 1) {
-    return nodes[0] || null
-  }
-
-  const node = factory.createTupleTypeNode(nodes)
-
-  if (withParentheses) {
-    return factory.createParenthesizedType(node)
-  }
-
-  return node
-}
-
 export function createArrayDeclaration({ nodes, arrayType = 'array' }: { nodes: Array<ts.TypeNode>; arrayType?: 'array' | 'generic' }): ts.TypeNode | null {
   if (!nodes.length) {
     return factory.createTupleTypeNode([])

package/src/generators/index.ts

@@ -1 +1,2 @@
 export { typeGenerator } from './typeGenerator.tsx'
+export { typeGeneratorLegacy } from './typeGeneratorLegacy.tsx'

package/src/generators/typeGenerator.tsx

@@ -1,50 +1,24 @@
+import path from 'node:path'
 import { caseParams, composeTransformers, narrowSchema, schemaTypes, transform } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
-import { defineGenerator } from '@kubb/core'
-import { useKubb } from '@kubb/core/hooks'
+import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
+import { builderTs } from '../builders/builderTs.ts'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
 import type { PluginTs } from '../types'
-import {
-  buildDataSchemaNode,
-  buildGroupedParamsSchema,
-  buildLegacyResponsesSchemaNode,
-  buildLegacyResponseUnionSchemaNode,
-  buildParamsSchema,
-  buildResponsesSchemaNode,
-  buildResponseUnionSchemaNode,
-  nameUnnamedEnums,
-} from './utils.ts'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
-  Operation({ node, adapter, options }) {
-    const {
-      enumType,
-      enumKeyCasing,
-      optionalType,
-      arrayType,
-      syntaxType,
-      paramsCasing,
-      group,
-      resolver,
-      baseResolver,
-      compatibilityPreset,
-      transformers = [],
-    } = options
-    const isKubbV4Compatibility = compatibilityPreset === 'kubbV4'
-    const { mode, getFile, resolveBanner, resolveFooter } = useKubb<PluginTs>()
+  Operation({ node, adapter, options, config }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+
+    const file = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
 
-    const file = getFile({
-      name: node.operationId,
-      extname: '.ts',
-      mode,
-      options: {
-        group: group ? (group.type === 'tag' ? { tag: node.tags[0] ?? 'default' } : { path: node.path }) : undefined,
-      },
-    })
     const params = caseParams(node.parameters, paramsCasing)
 
     function renderSchemaType({
@@ -68,7 +42,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
       const imports = adapter.getImports(transformedNode, (schemaName) => ({
         name: resolver.default(schemaName, 'type'),
-        path: getFile({ name: schemaName, extname: '.ts', mode }).path,
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
 
       return (
@@ -81,44 +55,29 @@ export const typeGenerator = defineGenerator<PluginTs>({
             node={transformedNode}
             description={description}
             enumType={enumType}
+            enumTypeSuffix={enumTypeSuffix}
             enumKeyCasing={enumKeyCasing}
             optionalType={optionalType}
             arrayType={arrayType}
             syntaxType={syntaxType}
             resolver={resolver}
             keysToOmit={keysToOmit}
-            legacy={isKubbV4Compatibility}
           />
         </>
       )
     }
 
-    const responseTypes = isKubbV4Compatibility
-      ? 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, baseResponseName) : res.schema,
-            name: responseName,
-            typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
-            description: res.description,
-            keysToOmit: res.keysToOmit,
-          })
-        })
-      : node.responses.map((res) =>
-          renderSchemaType({
-            node: res.schema,
-            name: resolver.resolveResponseStatusName(node, res.statusCode),
-            typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
-            description: res.description,
-            keysToOmit: res.keysToOmit,
-          }),
-        )
+    const paramTypes = params.map((param) =>
+      renderSchemaType({
+        node: param.schema,
+        name: resolver.resolveParamName(node, param),
+        typedName: resolver.resolveParamTypedName(node, param),
+      }),
+    )
 
     const requestType = node.requestBody?.schema
       ? renderSchemaType({
-          node: isKubbV4Compatibility ? nameUnnamedEnums(node.requestBody.schema, baseResolver.resolveDataName(node)) : node.requestBody.schema,
+          node: node.requestBody.schema,
           name: resolver.resolveDataName(node),
           typedName: resolver.resolveDataTypedName(node),
           description: node.requestBody.description ?? node.requestBody.schema.description,
@@ -126,99 +85,44 @@ export const typeGenerator = defineGenerator<PluginTs>({
         })
       : null
 
-    if (isKubbV4Compatibility) {
-      const pathParams = params.filter((p) => p.in === 'path')
-      const queryParams = params.filter((p) => p.in === 'query')
-      const headerParams = params.filter((p) => p.in === 'header')
-
-      const legacyParamTypes = [
-        pathParams.length > 0
-          ? renderSchemaType({
-              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: baseResolver.resolveQueryParamsName!(node) }),
-              name: resolver.resolveQueryParamsName!(node),
-              typedName: resolver.resolveQueryParamsTypedName!(node),
-            })
-          : null,
-        headerParams.length > 0
-          ? renderSchemaType({
-              node: buildGroupedParamsSchema({ params: headerParams, parentName: baseResolver.resolveHeaderParamsName!(node) }),
-              name: resolver.resolveHeaderParamsName!(node),
-              typedName: resolver.resolveHeaderParamsTypedName!(node),
-            })
-          : null,
-      ]
-
-      const legacyResponsesType = renderSchemaType({
-        node: buildLegacyResponsesSchemaNode({ node, resolver }),
-        name: resolver.resolveResponsesName(node),
-        typedName: resolver.resolveResponsesTypedName(node),
-      })
-
-      const legacyResponseType = renderSchemaType({
-        node: buildLegacyResponseUnionSchemaNode({ node, resolver }),
-        name: resolver.resolveResponseName(node),
-        typedName: resolver.resolveResponseTypedName(node),
-      })
-
-      return (
-        <File baseName={file.baseName} path={file.path} meta={file.meta} banner={resolveBanner()} footer={resolveFooter()}>
-          {legacyParamTypes}
-          {responseTypes}
-          {requestType}
-          {legacyResponseType}
-          {legacyResponsesType}
-        </File>
-      )
-    }
-
-    const paramTypes = params.map((param) =>
+    const responseTypes = node.responses.map((res) =>
       renderSchemaType({
-        node: param.schema,
-        name: resolver.resolveParamName(node, param),
-        typedName: resolver.resolveParamTypedName(node, param),
+        node: res.schema,
+        name: resolver.resolveResponseStatusName(node, res.statusCode),
+        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+        description: res.description,
+        keysToOmit: res.keysToOmit,
       }),
     )
 
-    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 }),
+      node: builderTs.buildData({ node: { ...node, parameters: params }, resolver }),
       name: resolver.resolveRequestConfigName(node),
       typedName: resolver.resolveRequestConfigTypedName(node),
     })
 
     const responsesType = renderSchemaType({
-      node: buildResponsesSchemaNode({ node, resolver }),
+      node: builderTs.buildResponses({ node, resolver }),
       name: resolver.resolveResponsesName(node),
       typedName: resolver.resolveResponsesTypedName(node),
     })
 
     const responseType = renderSchemaType({
-      node: buildResponseUnionSchemaNode({ node, resolver }),
+      node: builderTs.buildResponseUnion({ node, resolver }),
       name: resolver.resolveResponseName(node),
       typedName: resolver.resolveResponseTypedName(node),
       description: 'Union of all possible responses',
     })
 
     return (
-      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={resolveBanner()} footer={resolveFooter()}>
+      <File
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
         {paramTypes}
-        {queryParamsType}
         {responseTypes}
         {requestType}
         {dataType}
@@ -227,10 +131,11 @@ export const typeGenerator = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, resolver, compatibilityPreset, transformers = [] } = options
-    const isKubbV4Compatibility = compatibilityPreset === 'kubbV4'
-    const { mode, getFile, resolveBanner, resolveFooter } = useKubb<PluginTs>()
+  Schema({ node, adapter, options, config }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
 
     if (!node.name) {
       return
@@ -240,21 +145,28 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
       name: resolver.default(schemaName, 'type'),
-      path: getFile({ name: schemaName, extname: '.ts', mode }).path,
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
 
-    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name)
+    const typedName =
+      ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node, enumTypeSuffix) : resolver.resolveTypedName(node.name)
 
     const type = {
       name: resolver.resolveName(node.name),
       typedName,
-      file: getFile({ name: node.name, extname: '.ts', mode }),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
     return (
-      <File baseName={type.file.baseName} path={type.file.path} meta={type.file.meta} banner={resolveBanner()} footer={resolveFooter()}>
+      <File
+        baseName={type.file.baseName}
+        path={type.file.path}
+        meta={type.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
         {mode === 'split' &&
           imports.map((imp) => (
             <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />
@@ -264,12 +176,12 @@ export const typeGenerator = defineGenerator<PluginTs>({
           typedName={type.typedName}
           node={transformedNode}
           enumType={enumType}
+          enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
           optionalType={optionalType}
           arrayType={arrayType}
           syntaxType={syntaxType}
           resolver={resolver}
-          legacy={isKubbV4Compatibility}
         />
       </File>
     )