@kubb/plugin-ts 5.0.0-alpha.21 → 5.0.0-alpha.23

package/src/generators/typeGenerator.tsx

@@ -3,16 +3,16 @@ import { caseParams, composeTransformers, narrowSchema, schemaTypes, transform }
 import type { SchemaNode } from '@kubb/ast/types'
 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 { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
-  Operation({ node, adapter, options, config }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
+  Operation({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -24,13 +24,11 @@ export const typeGenerator = defineGenerator<PluginTs>({
     function renderSchemaType({
       node: schemaNode,
       name,
-      typedName,
       description,
       keysToOmit,
     }: {
       node: SchemaNode | null
       name: string
-      typedName: string
       description?: string
       keysToOmit?: Array<string>
     }) {
@@ -51,10 +49,10 @@ export const typeGenerator = defineGenerator<PluginTs>({
             imports.map((imp) => <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
           <Type
             name={name}
-            typedName={typedName}
             node={transformedNode}
             description={description}
             enumType={enumType}
+            enumTypeSuffix={enumTypeSuffix}
             enumKeyCasing={enumKeyCasing}
             optionalType={optionalType}
             arrayType={arrayType}
@@ -70,7 +68,6 @@ export const typeGenerator = defineGenerator<PluginTs>({
       renderSchemaType({
         node: param.schema,
         name: resolver.resolveParamName(node, param),
-        typedName: resolver.resolveParamTypedName(node, param),
       }),
     )
 
@@ -78,7 +75,6 @@ export const typeGenerator = defineGenerator<PluginTs>({
       ? renderSchemaType({
           node: node.requestBody.schema,
           name: resolver.resolveDataName(node),
-          typedName: resolver.resolveDataTypedName(node),
           description: node.requestBody.description ?? node.requestBody.schema.description,
           keysToOmit: node.requestBody.keysToOmit,
         })
@@ -88,28 +84,24 @@ export const typeGenerator = defineGenerator<PluginTs>({
       renderSchemaType({
         node: res.schema,
         name: resolver.resolveResponseStatusName(node, res.statusCode),
-        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
         description: res.description,
         keysToOmit: res.keysToOmit,
       }),
     )
 
     const dataType = renderSchemaType({
-      node: builderTs.buildData({ node: { ...node, parameters: params }, resolver }),
+      node: buildData({ node: { ...node, parameters: params }, resolver }),
       name: resolver.resolveRequestConfigName(node),
-      typedName: resolver.resolveRequestConfigTypedName(node),
     })
 
     const responsesType = renderSchemaType({
-      node: builderTs.buildResponses({ node, resolver }),
+      node: buildResponses({ node, resolver }),
       name: resolver.resolveResponsesName(node),
-      typedName: resolver.resolveResponsesTypedName(node),
     })
 
     const responseType = renderSchemaType({
-      node: builderTs.buildResponseUnion({ node, resolver }),
+      node: buildResponseUnion({ node, resolver }),
       name: resolver.resolveResponseName(node),
-      typedName: resolver.resolveResponseTypedName(node),
       description: 'Union of all possible responses',
     })
 
@@ -130,8 +122,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ node, adapter, options, config }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
+  Schema({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -149,11 +141,10 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
 
-    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name)
+    const name = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name)
 
     const type = {
-      name: resolver.resolveName(node.name),
-      typedName,
+      name,
       file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
@@ -171,9 +162,9 @@ export const typeGenerator = defineGenerator<PluginTs>({
           ))}
         <Type
           name={type.name}
-          typedName={type.typedName}
           node={transformedNode}
           enumType={enumType}
+          enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
           optionalType={optionalType}
           arrayType={arrayType}

package/src/generators/typeGeneratorLegacy.tsx

@@ -47,20 +47,20 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
   const responseSchema =
     successResponses.length > 0
       ? successResponses.length === 1
-        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, successResponses[0]!.statusCode) })
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
         : createSchema({
             type: 'union',
-            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
       : createSchema({ type: 'any' })
 
   const errorsSchema =
     errorResponses.length > 0
       ? errorResponses.length === 1
-        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, errorResponses[0]!.statusCode) })
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, errorResponses[0]!.statusCode) })
         : createSchema({
             type: 'union',
-            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
       : createSchema({ type: 'any' })
 
@@ -71,37 +71,40 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
       createProperty({
         name: 'Request',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolveDataName(node) }),
       }),
     )
   }
 
-  if (node.parameters.some((p) => p.in === 'query') && resolver.resolveQueryParamsTypedName) {
+  const queryParam = node.parameters.find((p) => p.in === 'query')
+  if (queryParam) {
     properties.push(
       createProperty({
         name: 'QueryParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsName(node, queryParam) }),
       }),
     )
   }
 
-  if (node.parameters.some((p) => p.in === 'path') && resolver.resolvePathParamsTypedName) {
+  const pathParam = node.parameters.find((p) => p.in === 'path')
+  if (pathParam) {
     properties.push(
       createProperty({
         name: 'PathParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsName(node, pathParam) }),
       }),
     )
   }
 
-  if (node.parameters.some((p) => p.in === 'header') && resolver.resolveHeaderParamsTypedName) {
+  const headerParam = node.parameters.find((p) => p.in === 'header')
+  if (headerParam) {
     properties.push(
       createProperty({
         name: 'HeaderParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsName(node, headerParam) }),
       }),
     )
   }
@@ -122,12 +125,12 @@ function buildLegacyResponseUnionSchemaNode({ node, resolver }: BuildOperationSc
   }
 
   if (successResponses.length === 1) {
-    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, successResponses[0]!.statusCode) })
+    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
   }
 
   return createSchema({
     type: 'union',
-    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
   })
 }
 
@@ -156,8 +159,8 @@ function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
 export const typeGeneratorLegacy = defineGenerator<PluginTs>({
   name: 'typescript-legacy',
   type: 'react',
-  Operation({ node, adapter, options, config }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
+  Operation({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -168,13 +171,11 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     function renderSchemaType({
       node: schemaNode,
       name,
-      typedName,
       description,
       keysToOmit,
     }: {
       node: SchemaNode | null
       name: string
-      typedName: string
       description?: string
       keysToOmit?: Array<string>
     }) {
@@ -195,10 +196,10 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
             imports.map((imp) => <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
           <Type
             name={name}
-            typedName={typedName}
             node={transformedNode}
             description={description}
             enumType={enumType}
+            enumTypeSuffix={enumTypeSuffix}
             enumKeyCasing={enumKeyCasing}
             optionalType={optionalType}
             arrayType={arrayType}
@@ -221,7 +222,6 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       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,
       })
@@ -231,7 +231,6 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       ? renderSchemaType({
           node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
           name: resolver.resolveDataName(node),
-          typedName: resolver.resolveDataTypedName(node),
           description: node.requestBody.description ?? node.requestBody.schema.description,
           keysToOmit: node.requestBody.keysToOmit,
         })
@@ -240,23 +239,20 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     const legacyParamTypes = [
       pathParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName!(node) }),
-            name: resolver.resolvePathParamsName!(node),
-            typedName: resolver.resolvePathParamsTypedName!(node),
+            node: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0]!) }),
+            name: resolver.resolvePathParamsName(node, pathParams[0]!),
           })
         : null,
       queryParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName!(node) }),
-            name: resolver.resolveQueryParamsName!(node),
-            typedName: resolver.resolveQueryParamsTypedName!(node),
+            node: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0]!) }),
+            name: resolver.resolveQueryParamsName(node, queryParams[0]!),
           })
         : null,
       headerParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName!(node) }),
-            name: resolver.resolveHeaderParamsName!(node),
-            typedName: resolver.resolveHeaderParamsTypedName!(node),
+            node: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0]!) }),
+            name: resolver.resolveHeaderParamsName(node, headerParams[0]!),
           })
         : null,
     ]
@@ -264,13 +260,11 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     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 (
@@ -289,8 +283,8 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ node, adapter, options, config }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
+  Schema({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -308,11 +302,10 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
 
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
 
-    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name)
+    const name = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name)
 
     const type = {
-      name: resolver.resolveName(node.name),
-      typedName,
+      name,
       file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
@@ -330,9 +323,9 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
           ))}
         <Type
           name={type.name}
-          typedName={type.typedName}
           node={transformedNode}
           enumType={enumType}
+          enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
           optionalType={optionalType}
           arrayType={arrayType}

package/src/index.ts

@@ -1,2 +1,14 @@
+export { Enum } from './components/Enum.tsx'
+export { Type } from './components/Type.tsx'
+
+export { typeGenerator } from './generators/typeGenerator.tsx'
+
 export { pluginTs, pluginTsName } from './plugin.ts'
-export type { PluginTs } from './types.ts'
+
+export { functionPrinter } from './printers/functionPrinter.ts'
+export { printerTs } from './printers/printerTs.ts'
+
+export { resolverTs } from './resolvers/resolverTs.ts'
+export { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
+
+export type { PluginTs, ResolverTs } from './types.ts'

package/src/plugin.ts

@@ -1,11 +1,31 @@
 import path from 'node:path'
+import { camelCase } from '@internals/utils'
 import { walk } from '@kubb/ast'
-import { createPlugin, getBarrelFiles, renderOperation, renderSchema } from '@kubb/core'
-import { getPreset } from './presets.ts'
+import { createPlugin, type Group, getBarrelFiles, getPreset, renderOperation, renderSchema } from '@kubb/core'
+import { presets } from './presets.ts'
 import type { PluginTs } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-ts`, used to identify the plugin in driver lookups and warnings.
+ */
 export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
 
+/**
+ * The `@kubb/plugin-ts` plugin factory.
+ *
+ * Generates TypeScript type declarations from an OpenAPI/AST `RootNode`.
+ * Walks schemas and operations, delegates rendering to the active generators,
+ * and writes barrel files based on `output.barrelType`.
+ *
+ * @example
+ * ```ts
+ * import { pluginTs } from '@kubb/plugin-ts'
+ *
+ * export default defineConfig({
+ *   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+ * })
+ * ```
+ */
 export const pluginTs = createPlugin<PluginTs>((options) => {
   const {
     output = { path: 'types', barrelType: 'named' },
@@ -14,6 +34,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     include,
     override = [],
     enumType = 'asConst',
+    enumTypeSuffix = 'Key',
     enumKeyCasing = 'none',
     optionalType = 'questionToken',
     arrayType = 'array',
@@ -25,7 +46,9 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const { resolver, transformers, generators } = getPreset(compatibilityPreset, {
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets: presets,
     resolvers: userResolvers,
     transformers: userTransformers,
     generators: userGenerators,
@@ -36,39 +59,54 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
 
   return {
     name: pluginTsName,
-    options: {
-      output,
-      optionalType,
-      group,
-      arrayType,
-      enumType,
-      enumKeyCasing,
-      syntaxType,
-      paramsCasing,
-      resolver,
-      transformers,
+    get resolver() {
+      return preset.resolver
+    },
+    get options() {
+      return {
+        output,
+        optionalType,
+        group: group
+          ? ({
+              ...options.group,
+              name: (ctx) => {
+                if (options.group?.type === 'path') {
+                  return `${ctx.group.split('/')[1]}`
+                }
+                return `${camelCase(ctx.group)}Controller`
+              },
+            } as Group)
+          : undefined,
+        arrayType,
+        enumType,
+        enumTypeSuffix,
+        enumKeyCasing,
+        syntaxType,
+        paramsCasing,
+        transformers: preset.transformers,
+      }
     },
     resolvePath(baseName, pathMode, options) {
       if (!resolvePathWarning) {
-        this.driver.events.emit('warn', 'Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
+        this.events.emit('warn', 'Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
         resolvePathWarning = true
       }
 
-      return resolver.resolvePath(
+      return this.plugin.resolver.resolvePath(
         { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: path.resolve(this.config.root, this.config.output.path), output, group },
+        { root: path.resolve(this.config.root, this.config.output.path), output, group: this.plugin.options.group },
       )
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.driver.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs.default instead')
+        this.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs.default instead')
         resolveNameWarning = true
       }
 
-      return resolver.default(name, type)
+      return this.plugin.resolver.default(name, type)
     },
     async install() {
-      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this
+      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this
 
       const root = path.resolve(config.root, config.output.path)
 
@@ -81,7 +119,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
       await walk(rootNode, {
         depth: 'shallow',
         async schema(schemaNode) {
-          const writeTasks = generators.map(async (generator) => {
+          const writeTasks = preset.generators.map(async (generator) => {
             if (generator.type === 'react' && generator.version === '2') {
               const options = resolver.resolveOptions(schemaNode, { options: plugin.options, exclude, include, override })
 
@@ -91,6 +129,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
 
               await renderSchema(schemaNode, {
                 options,
+                resolver,
                 adapter,
                 config,
                 fabric,
@@ -104,7 +143,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
           await Promise.all(writeTasks)
         },
         async operation(operationNode) {
-          const writeTasks = generators.map(async (generator) => {
+          const writeTasks = preset.generators.map(async (generator) => {
             if (generator.type === 'react' && generator.version === '2') {
               const options = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
 
@@ -114,6 +153,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
 
               await renderOperation(operationNode, {
                 options,
+                resolver,
                 adapter,
                 config,
                 fabric,

package/src/presets.ts

@@ -1,26 +1,25 @@
-import type { Visitor } from '@kubb/ast/types'
-import { type CompatibilityPreset, definePreset, definePresets, type Generator, getPreset as getCorePreset } from '@kubb/core'
-import { typeGenerator, typeGeneratorLegacy } from './generators/index.ts'
-import { resolverTs, resolverTsLegacy } from './resolvers/index.ts'
-import type { PluginTs, ResolverTs } from './types.ts'
+import { definePresets } from '@kubb/core'
+import { typeGenerator } from './generators/typeGenerator.tsx'
+import { typeGeneratorLegacy } from './generators/typeGeneratorLegacy.tsx'
+import { resolverTs } from './resolvers/resolverTs.ts'
+import { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
+import type { ResolverTs } from './types.ts'
 
+/**
+ * Built-in preset registry for `@kubb/plugin-ts`.
+ *
+ * - `default` — uses `resolverTs` and `typeGenerator` (current naming conventions).
+ * - `kubbV4` — uses `resolverTsLegacy` and `typeGeneratorLegacy` (Kubb v4 naming conventions).
+ */
 export const presets = definePresets<ResolverTs>({
-  default: definePreset('default', { resolvers: [resolverTs], generators: [typeGenerator] }),
-  kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy], generators: [typeGeneratorLegacy] }),
+  default: {
+    name: 'default',
+    resolvers: [resolverTs],
+    generators: [typeGenerator],
+  },
+  kubbV4: {
+    name: 'kubbV4',
+    resolvers: [resolverTsLegacy],
+    generators: [typeGeneratorLegacy],
+  },
 })
-
-type GetPresetOptions = {
-  resolvers: Array<ResolverTs>
-  transformers: Array<Visitor>
-  generators: Array<Generator<PluginTs>>
-}
-
-export function getPreset(preset: CompatibilityPreset, { resolvers, transformers, generators }: GetPresetOptions) {
-  return getCorePreset({
-    preset,
-    presets,
-    resolvers: [resolverTs, ...(resolvers ?? [])],
-    transformers,
-    generators,
-  })
-}