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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "5.0.0-alpha.34",
+  "version": "5.0.0-alpha.35",
   "description": "API client generator plugin for Kubb, creating type-safe HTTP clients (Axios, Fetch) from OpenAPI specifications for making API requests.",
   "keywords": [
     "api-client",
@@ -94,19 +94,18 @@
     }
   ],
   "dependencies": {
-    "@kubb/ast": "5.0.0-alpha.34",
-    "@kubb/core": "5.0.0-alpha.34",
-    "@kubb/plugin-ts": "5.0.0-alpha.34",
-    "@kubb/plugin-zod": "5.0.0-alpha.34",
-    "@kubb/renderer-jsx": "5.0.0-alpha.34"
+    "@kubb/core": "5.0.0-alpha.35",
+    "@kubb/plugin-ts": "5.0.0-alpha.35",
+    "@kubb/plugin-zod": "5.0.0-alpha.35",
+    "@kubb/renderer-jsx": "5.0.0-alpha.35"
   },
   "devDependencies": {
-    "axios": "^1.14.0",
+    "axios": "^1.15.0",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
     "axios": "^1.7.2",
-    "@kubb/renderer-jsx": "5.0.0-alpha.34"
+    "@kubb/renderer-jsx": "5.0.0-alpha.35"
   },
   "peerDependenciesMeta": {
     "axios": {

package/src/components/ClassClient.tsx

@@ -1,5 +1,5 @@
 import { buildJSDoc, URLPath } from '@internals/utils'
-import type { OperationNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
 import type { PluginZod } from '@kubb/plugin-zod'
@@ -7,11 +7,10 @@ import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginClient } from '../types.ts'
 import { buildClassClientParams, buildFormDataLine, buildGenerics, buildHeaders, buildRequestDataLine, buildReturnStatement, getComments } from '../utils.ts'
-
 import { Client } from './Client.tsx'
 
 type OperationData = {
-  node: OperationNode
+  node: ast.OperationNode
   name: string
   tsResolver: PluginTs['resolver']
   zodResolver?: PluginZod['resolver']
@@ -32,7 +31,7 @@ type Props = {
 }
 
 type GenerateMethodProps = {
-  node: OperationNode
+  node: ast.OperationNode
   name: string
   tsResolver: PluginTs['resolver']
   zodResolver?: PluginZod['resolver']

package/src/components/Client.tsx

@@ -1,7 +1,5 @@
 import { isValidVarName, URLPath } from '@internals/utils'
-import { caseParams, createFunctionParameter, createOperationParams, createParamsType } from '@kubb/ast'
-import type { FunctionParametersNode, OperationNode } from '@kubb/ast/types'
-import { FunctionParams } from '@kubb/core'
+import { ast, FunctionParams } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
 import type { PluginZod } from '@kubb/plugin-zod'
@@ -25,7 +23,7 @@ type Props = {
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
-  node: OperationNode
+  node: ast.OperationNode
   tsResolver: PluginTs['resolver']
   zodResolver?: PluginZod['resolver']
   children?: KubbReactNode
@@ -35,26 +33,26 @@ type GetParamsProps = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['paramsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  node: OperationNode
+  node: ast.OperationNode
   tsResolver: PluginTs['resolver']
   isConfigurable: boolean
 }
 
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }: GetParamsProps): FunctionParametersNode {
+function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }: GetParamsProps): ast.FunctionParametersNode {
   const requestName = node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined
 
-  return createOperationParams(node, {
+  return ast.createOperationParams(node, {
     paramsType,
     pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
     paramsCasing,
     resolver: tsResolver,
     extraParams: isConfigurable
       ? [
-          createFunctionParameter({
+          ast.createFunctionParameter({
             name: 'config',
-            type: createParamsType({
+            type: ast.createParamsType({
               variant: 'reference',
               name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }',
             }),
@@ -88,11 +86,11 @@ export function Client({
   const isFormData = contentType === 'multipart/form-data'
 
   const originalPathParams = node.parameters.filter((p) => p.in === 'path')
-  const casedPathParams = caseParams(originalPathParams, paramsCasing)
+  const casedPathParams = ast.caseParams(originalPathParams, paramsCasing)
   const originalQueryParams = node.parameters.filter((p) => p.in === 'query')
-  const casedQueryParams = caseParams(originalQueryParams, paramsCasing)
+  const casedQueryParams = ast.caseParams(originalQueryParams, paramsCasing)
   const originalHeaderParams = node.parameters.filter((p) => p.in === 'header')
-  const casedHeaderParams = caseParams(originalHeaderParams, paramsCasing)
+  const casedHeaderParams = ast.caseParams(originalHeaderParams, paramsCasing)
 
   const pathParamsMapping = paramsCasing && !urlName ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
   const queryParamsMapping = paramsCasing ? buildParamsMapping(originalQueryParams, casedQueryParams) : undefined

package/src/components/Operations.tsx

@@ -1,11 +1,11 @@
 import { URLPath } from '@internals/utils'
-import type { OperationNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import { Const, File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 
 type OperationsProps = {
   name: string
-  nodes: Array<OperationNode>
+  nodes: Array<ast.OperationNode>
 }
 
 export function Operations({ name, nodes }: OperationsProps): KubbReactNode {

package/src/components/StaticClassClient.tsx

@@ -1,5 +1,5 @@
 import { buildJSDoc, URLPath } from '@internals/utils'
-import type { OperationNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
 import type { PluginZod } from '@kubb/plugin-zod'
@@ -10,7 +10,7 @@ import { buildClassClientParams, buildFormDataLine, buildGenerics, buildHeaders,
 import { Client } from './Client.tsx'
 
 type OperationData = {
-  node: OperationNode
+  node: ast.OperationNode
   name: string
   tsResolver: PluginTs['resolver']
   zodResolver?: PluginZod['resolver']
@@ -31,7 +31,7 @@ type Props = {
 }
 
 type GenerateMethodProps = {
-  node: OperationNode
+  node: ast.OperationNode
   name: string
   tsResolver: PluginTs['resolver']
   zodResolver?: PluginZod['resolver']

package/src/components/Url.tsx

@@ -1,6 +1,5 @@
 import { isValidVarName, URLPath } from '@internals/utils'
-import { caseParams, createOperationParams } from '@kubb/ast'
-import type { FunctionParametersNode, OperationNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
 import { Const, File, Function } from '@kubb/renderer-jsx'
@@ -17,7 +16,7 @@ type Props = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  node: OperationNode
+  node: ast.OperationNode
   tsResolver: PluginTs['resolver']
 }
 
@@ -25,21 +24,21 @@ type GetParamsProps = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['paramsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  node: OperationNode
+  node: ast.OperationNode
   tsResolver: PluginTs['resolver']
 }
 
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): FunctionParametersNode {
+function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): ast.FunctionParametersNode {
   // Build a URL-only node with only path params (no body, query, header)
-  const urlNode: OperationNode = {
+  const urlNode: ast.OperationNode = {
     ...node,
     parameters: node.parameters.filter((p) => p.in === 'path'),
     requestBody: undefined,
   }
 
-  return createOperationParams(urlNode, {
+  return ast.createOperationParams(urlNode, {
     paramsType: paramsType === 'object' ? 'object' : 'inline',
     pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
     paramsCasing,
@@ -70,7 +69,7 @@ export function Url({
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
   const originalPathParams = node.parameters.filter((p) => p.in === 'path')
-  const casedPathParams = caseParams(originalPathParams, paramsCasing)
+  const casedPathParams = ast.caseParams(originalPathParams, paramsCasing)
   const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
 
   return (

package/src/generators/classClientGenerator.tsx

@@ -1,32 +1,32 @@
 import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
-import type { FileNode, OperationNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import { defineGenerator } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import { pluginTsName } from '@kubb/plugin-ts'
 import type { PluginZod } from '@kubb/plugin-zod'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { ClassClient } from '../components/ClassClient'
 import { WrapperClient } from '../components/WrapperClient'
 import type { PluginClient } from '../types'
 
 type OperationData = {
-  node: OperationNode
+  node: ast.OperationNode
   name: string
   tsResolver: PluginTs['resolver']
   zodResolver: PluginZod['resolver'] | undefined
-  typeFile: FileNode
-  zodFile: FileNode | undefined
+  typeFile: ast.FileNode
+  zodFile: ast.FileNode | undefined
 }
 
 type Controller = {
   name: string
-  file: FileNode
+  file: ast.FileNode
   operations: Array<OperationData>
 }
 
-function resolveTypeImportNames(node: OperationNode, tsResolver: PluginTs['resolver']): Array<string> {
+function resolveTypeImportNames(node: ast.OperationNode, tsResolver: PluginTs['resolver']): Array<string> {
   const names: Array<string | undefined> = [
     node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined,
     tsResolver.resolveResponseName(node),
@@ -38,17 +38,18 @@ function resolveTypeImportNames(node: OperationNode, tsResolver: PluginTs['resol
   return names.filter((n): n is string => Boolean(n))
 }
 
-function resolveZodImportNames(node: OperationNode, zodResolver: PluginZod['resolver']): Array<string> {
+function resolveZodImportNames(node: ast.OperationNode, zodResolver: PluginZod['resolver']): Array<string> {
   const names: Array<string | undefined> = [zodResolver.resolveResponseName?.(node), node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : undefined]
   return names.filter((n): n is string => Boolean(n))
 }
 
 export const classClientGenerator = defineGenerator<PluginClient>({
   name: 'classClient',
-  operations(nodes, options) {
-    const { adapter, config, driver, resolver, root } = this
-    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, wrapper } = options
-    const baseURL = options.baseURL ?? adapter.inputNode?.meta?.baseURL
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, wrapper } = ctx.options
+    const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL
 
     const pluginTs = driver.getPlugin(pluginTsName)
     if (!pluginTs?.resolver) return null
@@ -58,7 +59,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
     const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
     const zodResolver = pluginZod?.resolver
 
-    function buildOperationData(node: OperationNode): OperationData {
+    function buildOperationData(node: ast.OperationNode): OperationData {
       const typeFile = tsResolver.resolveFile(
         { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
         { root, output: tsPluginOptions?.output ?? output, group: tsPluginOptions?.group },
@@ -117,7 +118,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
 
     function collectTypeImports(ops: Array<OperationData>) {
       const typeImportsByFile = new Map<string, Set<string>>()
-      const typeFilesByPath = new Map<string, FileNode>()
+      const typeFilesByPath = new Map<string, ast.FileNode>()
 
       ops.forEach((op) => {
         const names = resolveTypeImportNames(op.node, tsResolver)
@@ -136,7 +137,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
 
     function collectZodImports(ops: Array<OperationData>) {
       const zodImportsByFile = new Map<string, Set<string>>()
-      const zodFilesByPath = new Map<string, FileNode>()
+      const zodFilesByPath = new Map<string, ast.FileNode>()
 
       ops.forEach((op) => {
         if (!op.zodFile || !zodResolver) return
@@ -157,7 +158,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
     const files = controllers.map(({ name, file, operations: ops }) => {
       const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
       const { zodImportsByFile, zodFilesByPath } =
-        parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, FileNode>() }
+        parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, ast.FileNode>() }
       const hasFormData = ops.some((op) => op.node.requestBody?.contentType === 'multipart/form-data')
 
       return (

package/src/generators/clientGenerator.tsx

@@ -1,19 +1,20 @@
 import path from 'node:path'
-import { caseParams } from '@kubb/ast'
-import { defineGenerator } from '@kubb/core'
+
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Client } from '../components/Client'
 import { Url } from '../components/Url.tsx'
 import type { PluginClient } from '../types'
 
 export const clientGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  operation(node, options) {
-    const { adapter, config, driver, resolver, root } = this
-    const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = options
-    const baseURL = options.baseURL ?? adapter.inputNode?.meta?.baseURL
+  renderer: jsxRenderer,
+  operation(node, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = ctx.options
+    const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL
 
     const pluginTs = driver.getPlugin(pluginTsName)
 
@@ -26,7 +27,7 @@ export const clientGenerator = defineGenerator<PluginClient>({
     const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
     const zodResolver = pluginZod?.resolver
 
-    const casedParams = caseParams(node.parameters, paramsCasing)
+    const casedParams = ast.caseParams(node.parameters, paramsCasing)
     const pathParams = casedParams.filter((p) => p.in === 'path')
     const queryParams = casedParams.filter((p) => p.in === 'query')
     const headerParams = casedParams.filter((p) => p.in === 'header')

package/src/generators/groupedClientGenerator.tsx

@@ -1,14 +1,15 @@
 import { camelCase } from '@internals/utils'
-import type { FileNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import { defineGenerator } from '@kubb/core'
-import { File, Function } from '@kubb/renderer-jsx'
+import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
 import type { PluginClient } from '../types'
 
 export const groupedClientGenerator = defineGenerator<PluginClient>({
   name: 'groupedClient',
-  operations(nodes, options) {
-    const { config, resolver, adapter, root } = this
-    const { output, group } = options
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { config, resolver, adapter, root } = ctx
+    const { output, group } = ctx.options
 
     const controllers = nodes.reduce(
       (acc, operationNode) => {
@@ -42,7 +43,7 @@ export const groupedClientGenerator = defineGenerator<PluginClient>({
 
         return acc
       },
-      [] as Array<{ name: string; file: FileNode; clients: Array<{ name: string; file: FileNode }> }>,
+      [] as Array<{ name: string; file: ast.FileNode; clients: Array<{ name: string; file: ast.FileNode }> }>,
     )
 
     return (

package/src/generators/operationsGenerator.tsx

@@ -1,13 +1,14 @@
 import { defineGenerator } from '@kubb/core'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Operations } from '../components/Operations'
 import type { PluginClient } from '../types'
 
 export const operationsGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  operations(nodes, options) {
-    const { config, resolver, adapter, root } = this
-    const { output, group } = options
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { config, resolver, adapter, root } = ctx
+    const { output, group } = ctx.options
 
     const name = 'operations'
     const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group })

package/src/generators/staticClassClientGenerator.tsx

@@ -1,31 +1,31 @@
 import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
-import type { FileNode, OperationNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import { defineGenerator } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import { pluginTsName } from '@kubb/plugin-ts'
 import type { PluginZod } from '@kubb/plugin-zod'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { StaticClassClient } from '../components/StaticClassClient'
 import type { PluginClient } from '../types'
 
 type OperationData = {
-  node: OperationNode
+  node: ast.OperationNode
   name: string
   tsResolver: PluginTs['resolver']
   zodResolver: PluginZod['resolver'] | undefined
-  typeFile: FileNode
-  zodFile: FileNode | undefined
+  typeFile: ast.FileNode
+  zodFile: ast.FileNode | undefined
 }
 
 type Controller = {
   name: string
-  file: FileNode
+  file: ast.FileNode
   operations: Array<OperationData>
 }
 
-function resolveTypeImportNames(node: OperationNode, tsResolver: PluginTs['resolver']): Array<string> {
+function resolveTypeImportNames(node: ast.OperationNode, tsResolver: PluginTs['resolver']): Array<string> {
   const names: Array<string | undefined> = [
     node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined,
     tsResolver.resolveResponseName(node),
@@ -37,17 +37,18 @@ function resolveTypeImportNames(node: OperationNode, tsResolver: PluginTs['resol
   return names.filter((n): n is string => Boolean(n))
 }
 
-function resolveZodImportNames(node: OperationNode, zodResolver: PluginZod['resolver']): Array<string> {
+function resolveZodImportNames(node: ast.OperationNode, zodResolver: PluginZod['resolver']): Array<string> {
   const names: Array<string | undefined> = [zodResolver.resolveResponseName?.(node), node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : undefined]
   return names.filter((n): n is string => Boolean(n))
 }
 
 export const staticClassClientGenerator = defineGenerator<PluginClient>({
   name: 'staticClassClient',
-  operations(nodes, options) {
-    const { adapter, config, driver, resolver, root } = this
-    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = options
-    const baseURL = options.baseURL ?? adapter.inputNode?.meta?.baseURL
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = ctx.options
+    const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL
 
     const pluginTs = driver.getPlugin(pluginTsName)
     if (!pluginTs?.resolver) return null
@@ -57,7 +58,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
     const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
     const zodResolver = pluginZod?.resolver
 
-    function buildOperationData(node: OperationNode): OperationData {
+    function buildOperationData(node: ast.OperationNode): OperationData {
       const typeFile = tsResolver.resolveFile(
         { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
         { root, output: tsPluginOptions?.output ?? output, group: tsPluginOptions?.group },
@@ -116,7 +117,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
 
     function collectTypeImports(ops: Array<OperationData>) {
       const typeImportsByFile = new Map<string, Set<string>>()
-      const typeFilesByPath = new Map<string, FileNode>()
+      const typeFilesByPath = new Map<string, ast.FileNode>()
 
       ops.forEach((op) => {
         const names = resolveTypeImportNames(op.node, tsResolver)
@@ -135,7 +136,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
 
     function collectZodImports(ops: Array<OperationData>) {
       const zodImportsByFile = new Map<string, Set<string>>()
-      const zodFilesByPath = new Map<string, FileNode>()
+      const zodFilesByPath = new Map<string, ast.FileNode>()
 
       ops.forEach((op) => {
         if (!op.zodFile || !zodResolver) return
@@ -158,7 +159,7 @@ export const staticClassClientGenerator = defineGenerator<PluginClient>({
         {controllers.map(({ name, file, operations: ops }) => {
           const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
           const { zodImportsByFile, zodFilesByPath } =
-            parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, FileNode>() }
+            parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, ast.FileNode>() }
           const hasFormData = ops.some((op) => op.node.requestBody?.contentType === 'multipart/form-data')
 
           return (

package/src/index.ts

@@ -6,7 +6,6 @@ export { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
 export { operationsGenerator } from './generators/operationsGenerator.tsx'
 export { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
 export { pluginClient, pluginClientName } from './plugin.ts'
-export { presets } from './presets.ts'
 export { resolverClient } from './resolvers/resolverClient.ts'
 export { resolverClientLegacy } from './resolvers/resolverClientLegacy.ts'
 export type { ClientImportPath, PluginClient, ResolverClient } from './types.ts'