@kubb/plugin-ts 5.0.0-alpha.34 → 5.0.0-alpha.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.34",
+  "version": "5.0.0-alpha.35",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -51,13 +51,12 @@
   "dependencies": {
     "remeda": "^2.33.7",
     "typescript": "5.9.3",
-    "@kubb/ast": "5.0.0-alpha.34",
-    "@kubb/core": "5.0.0-alpha.34",
-    "@kubb/parser-ts": "5.0.0-alpha.34",
-    "@kubb/renderer-jsx": "5.0.0-alpha.34"
+    "@kubb/core": "5.0.0-alpha.35",
+    "@kubb/parser-ts": "5.0.0-alpha.35",
+    "@kubb/renderer-jsx": "5.0.0-alpha.35"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-alpha.34"
+    "@kubb/renderer-jsx": "5.0.0-alpha.35"
   },
   "engines": {
     "node": ">=22"

package/src/components/Enum.tsx

@@ -1,5 +1,5 @@
 import { camelCase, trimQuotes } from '@internals/utils'
-import type { EnumSchemaNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import { safePrint } from '@kubb/parser-ts'
 import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
@@ -8,7 +8,7 @@ import * as factory from '../factory.ts'
 import type { PluginTs, ResolverTs } from '../types.ts'
 
 type Props = {
-  node: EnumSchemaNode
+  node: ast.EnumSchemaNode
   enumType: PluginTs['resolvedOptions']['enumType']
   enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
@@ -28,7 +28,7 @@ export function getEnumNames({
   enumTypeSuffix,
   resolver,
 }: {
-  node: EnumSchemaNode
+  node: ast.EnumSchemaNode
   enumType: PluginTs['resolvedOptions']['enumType']
   enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
   resolver: ResolverTs

package/src/components/Type.tsx

@@ -1,6 +1,4 @@
-import type { Printer } from '@kubb/ast'
-import { collect, narrowSchema, schemaTypes } from '@kubb/ast'
-import type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PrinterTsFactory } from '../printers/printerTs.ts'
@@ -9,12 +7,12 @@ import { Enum, getEnumNames } from './Enum.tsx'
 
 type Props = {
   name: string
-  node: SchemaNode
+  node: ast.SchemaNode
   /**
    * Pre-configured printer instance created by the generator.
    * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
    */
-  printer: Printer<PrinterTsFactory>
+  printer: ast.Printer<PrinterTsFactory>
   enumType: PluginTs['resolvedOptions']['enumType']
   enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
@@ -22,9 +20,9 @@ type Props = {
 }
 
 export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): KubbReactNode {
-  const enumSchemaNodes = collect<EnumSchemaNode>(node, {
-    schema(n): EnumSchemaNode | undefined {
-      const enumNode = narrowSchema(n, schemaTypes.enum)
+  const enumSchemaNodes = ast.collect<ast.EnumSchemaNode>(node, {
+    schema(n): ast.EnumSchemaNode | undefined {
+      const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum)
       if (enumNode?.name) return enumNode
     },
   })

package/src/factory.ts

@@ -1,6 +1,5 @@
 import { camelCase, pascalCase, screamingSnakeCase, snakeCase } from '@internals/utils'
-import { syncSchemaRef } from '@kubb/ast'
-import type { ArraySchemaNode, SchemaNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import { isNumber, sortBy } from 'remeda'
 import ts from 'typescript'
 import { OPTIONAL_ADDS_UNDEFINED } from './constants.ts'
@@ -725,7 +724,10 @@ export function dateOrStringNode(node: { representation?: string }): ts.TypeNode
 /**
  * Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
  */
-export function buildMemberNodes(members: Array<SchemaNode> | undefined, print: (node: SchemaNode) => ts.TypeNode | null | undefined): Array<ts.TypeNode> {
+export function buildMemberNodes(
+  members: Array<ast.SchemaNode> | undefined,
+  print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined,
+): Array<ts.TypeNode> {
   return (members ?? []).map(print).filter(Boolean)
 }
 
@@ -733,7 +735,7 @@ export function buildMemberNodes(members: Array<SchemaNode> | undefined, print:
  * Builds a TypeScript tuple type node from an array schema's `items`,
  * applying min/max slice and optional/rest element rules.
  */
-export function buildTupleNode(node: ArraySchemaNode, print: (node: SchemaNode) => ts.TypeNode | null | undefined): ts.TypeNode | undefined {
+export function buildTupleNode(node: ast.ArraySchemaNode, print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined): ts.TypeNode | undefined {
   let items = (node.items ?? []).map(print).filter(Boolean)
 
   const restNode = node.rest ? (print(node.rest) ?? undefined) : undefined
@@ -761,12 +763,12 @@ export function buildTupleNode(node: ArraySchemaNode, print: (node: SchemaNode)
  * Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
  */
 export function buildPropertyType(
-  schema: SchemaNode,
+  schema: ast.SchemaNode,
   baseType: ts.TypeNode,
   optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined',
 ): ts.TypeNode {
   const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType)
-  const meta = syncSchemaRef(schema)
+  const meta = ast.syncSchemaRef(schema)
 
   let type = baseType
 
@@ -785,9 +787,9 @@ export function buildPropertyType(
  * Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
  */
 export function buildIndexSignatures(
-  node: { additionalProperties?: SchemaNode | boolean; patternProperties?: Record<string, SchemaNode> },
+  node: { additionalProperties?: ast.SchemaNode | boolean; patternProperties?: Record<string, ast.SchemaNode> },
   propertyCount: number,
-  print: (node: SchemaNode) => ts.TypeNode | null | undefined,
+  print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined,
 ): Array<ts.TypeElement> {
   const elements: Array<ts.TypeElement> = []
 

package/src/generators/typeGenerator.tsx

@@ -1,7 +1,5 @@
-import { caseParams, narrowSchema, schemaTypes } from '@kubb/ast'
-import type { SchemaNode } from '@kubb/ast/types'
-import { defineGenerator } from '@kubb/core'
-import { File } from '@kubb/renderer-jsx'
+import { ast, defineGenerator } from '@kubb/core'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
 import { printerTs } from '../printers/printerTs.ts'
@@ -10,17 +8,18 @@ import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
-  schema(node, options) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = options
-    const { adapter, config, resolver, root } = this
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
+    const { adapter, config, resolver, root } = ctx
 
     if (!node.name) {
       return
     }
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
     // Build a set of schema names that are enums so the ref handler and getImports
     // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name!))
+    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
 
     function resolveImportName(schemaName: string): string {
       if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
@@ -34,7 +33,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
+    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
 
     const meta = {
       name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
@@ -78,13 +77,13 @@ export const typeGenerator = defineGenerator<PluginTs>({
       </File>
     )
   },
-  operation(node, options) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = options
-    const { adapter, config, resolver, root } = this
+  operation(node, ctx) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options
+    const { adapter, config, resolver, root } = ctx
 
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
 
-    const params = caseParams(node.parameters, paramsCasing)
+    const params = ast.caseParams(node.parameters, paramsCasing)
 
     const meta = {
       file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
@@ -92,7 +91,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     // Build a set of schema names that are enums so the ref handler and getImports
     // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name!))
+    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
 
     function resolveImportName(schemaName: string): string {
       if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
@@ -101,7 +100,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       return resolver.resolveTypeName(schemaName)
     }
 
-    function renderSchemaType({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
       if (!schema) return null
 
       const imports = adapter.getImports(schema, (schemaName) => ({

package/src/generators/typeGeneratorLegacy.tsx

@@ -1,8 +1,6 @@
 import { pascalCase } from '@internals/utils'
-import { caseParams, createProperty, createSchema, narrowSchema, schemaTypes, transform } from '@kubb/ast'
-import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
-import { defineGenerator } from '@kubb/core'
-import { File } from '@kubb/renderer-jsx'
+import { ast, defineGenerator } from '@kubb/core'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
 import { printerTs } from '../printers/printerTs.ts'
@@ -10,19 +8,19 @@ import { resolverTsLegacy } from '../resolvers/resolverTsLegacy.ts'
 import type { PluginTs, ResolverTs } from '../types'
 
 type BuildGroupedParamsSchemaOptions = {
-  params: Array<ParameterNode>
+  params: Array<ast.ParameterNode>
   parentName?: string
 }
 
-function buildGroupedParamsSchema({ params, parentName }: BuildGroupedParamsSchemaOptions): SchemaNode {
-  return createSchema({
+function buildGroupedParamsSchema({ params, parentName }: BuildGroupedParamsSchemaOptions): ast.SchemaNode {
+  return ast.createSchema({
     type: 'object',
     properties: params.map((param) => {
       let schema = param.schema
-      if (narrowSchema(schema, 'enum') && !schema.name && parentName) {
+      if (ast.narrowSchema(schema, 'enum') && !schema.name && parentName) {
         schema = { ...schema, name: pascalCase([parentName, param.name, 'enum'].join(' ')) }
       }
-      return createProperty({
+      return ast.createProperty({
         name: param.name,
         required: param.required,
         schema,
@@ -35,7 +33,7 @@ type BuildOperationSchemaOptions = {
   resolver: ResolverTs
 }
 
-function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+function buildLegacyResponsesSchemaNode(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode | null {
   const isGet = node.method.toLowerCase() === 'get'
   const successResponses = node.responses.filter((res) => {
     const code = Number(res.statusCode)
@@ -46,31 +44,31 @@ function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: Build
   const responseSchema =
     successResponses.length > 0
       ? successResponses.length === 1
-        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
-        : createSchema({
+        ? ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
+        : ast.createSchema({
             type: 'union',
-            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+            members: successResponses.map((res) => ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
-      : createSchema({ type: 'any', primitive: undefined })
+      : ast.createSchema({ type: 'any', primitive: undefined })
 
   const errorsSchema =
     errorResponses.length > 0
       ? errorResponses.length === 1
-        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, errorResponses[0]!.statusCode) })
-        : createSchema({
+        ? ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, errorResponses[0]!.statusCode) })
+        : ast.createSchema({
             type: 'union',
-            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+            members: errorResponses.map((res) => ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
-      : createSchema({ type: 'any', primitive: undefined })
+      : ast.createSchema({ type: 'any', primitive: undefined })
 
-  const properties = [createProperty({ name: 'Response', required: true, schema: responseSchema })]
+  const properties = [ast.createProperty({ name: 'Response', required: true, schema: responseSchema })]
 
   if (!isGet && node.requestBody?.schema) {
     properties.push(
-      createProperty({
+      ast.createProperty({
         name: 'Request',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveDataName(node) }),
+        schema: ast.createSchema({ type: 'ref', name: resolver.resolveDataName(node) }),
       }),
     )
   }
@@ -78,10 +76,10 @@ function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: Build
   const queryParam = node.parameters.find((p) => p.in === 'query')
   if (queryParam) {
     properties.push(
-      createProperty({
+      ast.createProperty({
         name: 'QueryParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsName(node, queryParam) }),
+        schema: ast.createSchema({ type: 'ref', name: resolver.resolveQueryParamsName(node, queryParam) }),
       }),
     )
   }
@@ -89,10 +87,10 @@ function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: Build
   const pathParam = node.parameters.find((p) => p.in === 'path')
   if (pathParam) {
     properties.push(
-      createProperty({
+      ast.createProperty({
         name: 'PathParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsName(node, pathParam) }),
+        schema: ast.createSchema({ type: 'ref', name: resolver.resolvePathParamsName(node, pathParam) }),
       }),
     )
   }
@@ -100,50 +98,50 @@ function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: Build
   const headerParam = node.parameters.find((p) => p.in === 'header')
   if (headerParam) {
     properties.push(
-      createProperty({
+      ast.createProperty({
         name: 'HeaderParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsName(node, headerParam) }),
+        schema: ast.createSchema({ type: 'ref', name: resolver.resolveHeaderParamsName(node, headerParam) }),
       }),
     )
   }
 
-  properties.push(createProperty({ name: 'Errors', required: true, schema: errorsSchema }))
+  properties.push(ast.createProperty({ name: 'Errors', required: true, schema: errorsSchema }))
 
-  return createSchema({ type: 'object', properties })
+  return ast.createSchema({ type: 'object', properties })
 }
 
-function buildLegacyResponseUnionSchemaNode(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode {
+function buildLegacyResponseUnionSchemaNode(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode {
   const successResponses = node.responses.filter((res) => {
     const code = Number(res.statusCode)
     return !Number.isNaN(code) && code >= 200 && code < 300
   })
 
   if (successResponses.length === 0) {
-    return createSchema({ type: 'any', primitive: undefined })
+    return ast.createSchema({ type: 'any', primitive: undefined })
   }
 
   if (successResponses.length === 1) {
-    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
+    return ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
   }
 
-  return createSchema({
+  return ast.createSchema({
     type: 'union',
-    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+    members: successResponses.map((res) => ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
   })
 }
 
-function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
-  return transform(node, {
+function nameUnnamedEnums(node: ast.SchemaNode, parentName: string): ast.SchemaNode {
+  return ast.transform(node, {
     schema(n) {
-      const enumNode = narrowSchema(n, 'enum')
+      const enumNode = ast.narrowSchema(n, 'enum')
       if (enumNode && !enumNode.name) {
         return { ...enumNode, name: pascalCase([parentName, 'enum'].join(' ')) }
       }
       return undefined
     },
     property(p) {
-      const enumNode = narrowSchema(p.schema, 'enum')
+      const enumNode = ast.narrowSchema(p.schema, 'enum')
       if (enumNode && !enumNode.name) {
         return {
           ...p,
@@ -157,22 +155,23 @@ function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
 
 export const typeGeneratorLegacy = defineGenerator<PluginTs>({
   name: 'typescript-legacy',
-  schema(node, options) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = options
-    const { adapter, config, resolver, root } = this
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = ctx.options
+    const { adapter, config, resolver, root } = ctx
 
     if (!node.name) {
       return
     }
 
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
 
     const imports = adapter.getImports(node, (schemaName) => ({
       name: resolver.resolveTypeName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
+    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
 
     const meta = {
       name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
@@ -214,12 +213,12 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       </File>
     )
   },
-  operation(node, options) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = options
-    const { adapter, config, resolver, root } = this
+  operation(node, ctx) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = ctx.options
+    const { adapter, config, resolver, root } = ctx
 
-    const mode = this.getMode(output)
-    const params = caseParams(node.parameters, paramsCasing)
+    const mode = ctx.getMode(output)
+    const params = ast.caseParams(node.parameters, paramsCasing)
 
     const meta = {
       file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
@@ -231,7 +230,7 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       description,
       keysToOmit,
     }: {
-      schema: SchemaNode | null
+      schema: ast.SchemaNode | null
       name: string
       description?: string
       keysToOmit?: Array<string>

package/src/plugin.ts

@@ -1,7 +1,9 @@
 import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
-import { version } from '../package.json'
-import { presets } from './presets.ts'
+import { definePlugin, type Group } 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 { PluginTs } from './types.ts'
 
 /**
@@ -25,7 +27,7 @@ export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
  * })
  * ```
  */
-export const pluginTs = createPlugin<PluginTs>((options) => {
+export const pluginTs = definePlugin<PluginTs>((options) => {
   const {
     output = { path: 'types', barrelType: 'named' },
     group,
@@ -40,92 +42,56 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     syntaxType = 'type',
     paramsCasing,
     printer,
-    compatibilityPreset = 'default',
     resolver: userResolver,
     transformer: userTransformer,
     generators: userGenerators = [],
+    compatibilityPreset = 'default',
   } = options
 
-  const preset = getPreset({
-    preset: compatibilityPreset,
-    presets: presets,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators,
-  })
-
-  const generators = preset.generators ?? []
-  const mergedGenerator = mergeGenerators(generators)
+  const defaultResolver = compatibilityPreset === 'kubbV4' ? resolverTsLegacy : resolverTs
+  const defaultGenerator = compatibilityPreset === 'kubbV4' ? typeGeneratorLegacy : typeGenerator
 
-  let resolveNameWarning = false
-  let resolvePathWarning = false
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: (ctx) => {
+          if (group.type === 'path') {
+            return `${ctx.group.split('/')[1]}`
+          }
+          return `${camelCase(ctx.group)}Controller`
+        },
+      } satisfies Group)
+    : undefined
 
   return {
     name: pluginTsName,
-    version,
-    get resolver() {
-      return preset.resolver
-    },
-    get transformer() {
-      return preset.transformer
-    },
-    get options() {
-      return {
-        output,
-        exclude,
-        include,
-        override,
-        optionalType,
-        group: group
-          ? ({
-              ...group,
-              name: (ctx) => {
-                if (group.type === 'path') {
-                  return `${ctx.group.split('/')[1]}`
-                }
-                return `${camelCase(ctx.group)}Controller`
-              },
-            } satisfies Group)
-          : undefined,
-        arrayType,
-        enumType,
-        enumTypeSuffix,
-        enumKeyCasing,
-        syntaxType,
-        paramsCasing,
-        printer,
-      }
-    },
-    resolvePath(baseName, pathMode, options) {
-      if (!resolvePathWarning) {
-        this.warn('Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
-        resolvePathWarning = true
-      }
-
-      return this.plugin.resolver.resolvePath(
-        { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: this.root, output, group: this.plugin.options.group },
-      )
-    },
-    resolveName(name, type) {
-      if (!resolveNameWarning) {
-        this.warn('Do not use resolveName for pluginTs, use resolverTs.default instead')
-        resolveNameWarning = true
-      }
-
-      return this.plugin.resolver.default(name, type)
-    },
-    async schema(node, options) {
-      return mergedGenerator.schema?.call(this, node, options)
-    },
-    async operation(node, options) {
-      return mergedGenerator.operation?.call(this, node, options)
-    },
-    async operations(nodes, options) {
-      return mergedGenerator.operations?.call(this, nodes, options)
-    },
-    async buildStart() {
-      await this.openInStudio({ ast: true })
+    options,
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        ctx.setOptions({
+          output,
+          exclude,
+          include,
+          override,
+          optionalType,
+          group: groupConfig,
+          arrayType,
+          enumType,
+          enumTypeSuffix,
+          enumKeyCasing,
+          syntaxType,
+          paramsCasing,
+          printer,
+        })
+        ctx.setResolver(userResolver ? { ...defaultResolver, ...userResolver } : defaultResolver)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        ctx.addGenerator(defaultGenerator)
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
+      },
     },
   }
 })