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

package/src/generators/zodGenerator.tsx

@@ -1,7 +1,5 @@
-import { caseParams } 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 { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
 import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
@@ -12,15 +10,16 @@ import { buildSchemaNames } from '../utils.ts'
 
 export const zodGenerator = defineGenerator<PluginZod>({
   name: 'zod',
-  schema(node, options) {
-    const { adapter, config, resolver, root } = this
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options
 
     if (!node.name) {
       return
     }
 
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const imports = adapter.getImports(node, (schemaName) => ({
@@ -54,20 +53,20 @@ export const zodGenerator = defineGenerator<PluginZod>({
       </File>
     )
   },
-  operation(node, options) {
-    const { adapter, config, resolver, root } = this
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options
+  operation(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
 
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    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 }),
     } as const
 
-    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
       if (!schema) return null
 
       const inferTypeName = inferred ? resolver.resolveTypeName(name) : undefined
@@ -126,9 +125,9 @@ export const zodGenerator = defineGenerator<PluginZod>({
       </File>
     )
   },
-  operations(nodes, options) {
-    const { adapter, config, resolver, root } = this
-    const { output, importPath, group, operations, paramsCasing } = options
+  operations(nodes, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, importPath, group, operations, paramsCasing } = ctx.options
 
     if (!operations) {
       return
@@ -140,7 +139,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
     } as const
 
     const transformedOperations = nodes.map((node) => {
-      const params = caseParams(node.parameters, paramsCasing)
+      const params = ast.caseParams(node.parameters, paramsCasing)
 
       return {
         node,

package/src/generators/zodGeneratorLegacy.tsx

@@ -1,7 +1,5 @@
-import { caseParams, createProperty, createSchema } 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 { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
 import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
@@ -10,16 +8,16 @@ import { printerZodMini } from '../printers/printerZodMini.ts'
 import type { PluginZod, ResolverZod } from '../types'
 
 type BuildGroupedParamsSchemaOptions = {
-  params: Array<ParameterNode>
+  params: Array<ast.ParameterNode>
 }
 
-function buildGroupedParamsSchema({ params, optional }: BuildGroupedParamsSchemaOptions & { optional?: boolean }): SchemaNode {
-  return createSchema({
+function buildGroupedParamsSchema({ params, optional }: BuildGroupedParamsSchemaOptions & { optional?: boolean }): ast.SchemaNode {
+  return ast.createSchema({
     type: 'object',
     optional,
     primitive: 'object',
     properties: params.map((param) => {
-      return createProperty({
+      return ast.createProperty({
         name: param.name,
         required: param.required,
         schema: param.schema,
@@ -32,7 +30,7 @@ type BuildOperationSchemaOptions = {
   resolver: ResolverZod
 }
 
-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)
@@ -43,31 +41,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' })
+      : ast.createSchema({ type: 'any' })
 
   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' })
+      : ast.createSchema({ type: 'any' })
 
-  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) }),
       }),
     )
   }
@@ -75,10 +73,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) }),
       }),
     )
   }
@@ -86,10 +84,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) }),
       }),
     )
   }
@@ -97,40 +95,40 @@ 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', primitive: 'object', properties })
+  return ast.createSchema({ type: 'object', primitive: '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' })
+    return ast.createSchema({ type: 'any' })
   }
 
   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 buildLegacySchemaNames(node: OperationNode, params: Array<ParameterNode>, resolver: ResolverZod) {
+function buildLegacySchemaNames(node: ast.OperationNode, params: Array<ast.ParameterNode>, resolver: ResolverZod) {
   const pathParam = params.find((p) => p.in === 'path')
   const queryParam = params.find((p) => p.in === 'query')
   const headerParam = params.find((p) => p.in === 'header')
@@ -166,15 +164,16 @@ function buildLegacySchemaNames(node: OperationNode, params: Array<ParameterNode
 
 export const zodGeneratorLegacy = defineGenerator<PluginZod>({
   name: 'zod-legacy',
-  schema(node, options) {
-    const { adapter, config, resolver, root } = this
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options
 
     if (!node.name) {
       return
     }
 
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const imports = adapter.getImports(node, (schemaName) => ({
@@ -208,20 +207,20 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
       </File>
     )
   },
-  operation(node, options) {
-    const { adapter, config, resolver, root } = this
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options
+  operation(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
 
-    const mode = this.getMode(output)
+    const mode = ctx.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    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 }),
     } as const
 
-    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
       if (!schema) return null
 
       const inferTypeName = inferred ? resolver.resolveTypeName(name) : undefined
@@ -319,9 +318,9 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
       </File>
     )
   },
-  operations(nodes, options) {
-    const { adapter, config, resolver, root } = this
-    const { output, importPath, group, operations, paramsCasing } = options
+  operations(nodes, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, importPath, group, operations, paramsCasing } = ctx.options
 
     if (!operations) {
       return
@@ -333,7 +332,7 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
     } as const
 
     const transformedOperations = nodes.map((node) => {
-      const params = caseParams(node.parameters, paramsCasing)
+      const params = ast.caseParams(node.parameters, paramsCasing)
 
       return {
         node,

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 { zodGenerator } from './generators/zodGenerator.tsx'
+import { zodGeneratorLegacy } from './generators/zodGeneratorLegacy.tsx'
+import { resolverZod } from './resolvers/resolverZod.ts'
+import { resolverZodLegacy } from './resolvers/resolverZodLegacy.ts'
 import type { PluginZod } from './types.ts'
 
 /**
@@ -25,7 +27,7 @@ export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
  * })
  * ```
  */
-export const pluginZod = createPlugin<PluginZod>((options) => {
+export const pluginZod = definePlugin<PluginZod>((options) => {
   const {
     output = { path: 'zod', barrelType: 'named' },
     group,
@@ -43,95 +45,59 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     wrapOutput = undefined,
     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' ? resolverZodLegacy : resolverZod
+  const defaultGenerator = compatibilityPreset === 'kubbV4' ? zodGeneratorLegacy : zodGenerator
 
-  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: pluginZodName,
-    version,
-    get resolver() {
-      return preset.resolver
-    },
-    get transformer() {
-      return preset.transformer
-    },
-    get options() {
-      return {
-        output,
-        exclude,
-        include,
-        override,
-        group: group
-          ? ({
-              ...group,
-              name: (ctx) => {
-                if (group.type === 'path') {
-                  return `${ctx.group.split('/')[1]}`
-                }
-                return `${camelCase(ctx.group)}Controller`
-              },
-            } satisfies Group)
-          : undefined,
-        dateType,
-        typed,
-        importPath,
-        coercion,
-        operations,
-        inferred,
-        guidType,
-        mini,
-        wrapOutput,
-        paramsCasing,
-        printer,
-      }
-    },
-    resolvePath(baseName, pathMode, options) {
-      if (!resolvePathWarning) {
-        this.warn('Do not use resolvePath for pluginZod, use resolverZod.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 pluginZod, use resolverZod.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,
+          group: groupConfig,
+          dateType,
+          typed,
+          importPath,
+          coercion,
+          operations,
+          inferred,
+          guidType,
+          mini,
+          wrapOutput,
+          paramsCasing,
+          printer,
+        })
+        ctx.setResolver(userResolver ? { ...defaultResolver, ...userResolver } : defaultResolver)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        ctx.addGenerator(defaultGenerator)
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
+      },
     },
   }
 })

package/src/printers/printerZod.ts

@@ -1,7 +1,7 @@
 import { stringify } from '@internals/utils'
-import { createSchema, extractRefName, narrowSchema, syncSchemaRef } from '@kubb/ast'
+
 import type { PrinterFactoryOptions, PrinterPartial } from '@kubb/core'
-import { definePrinter } from '@kubb/core'
+import { ast, definePrinter } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
 import { applyModifiers, containsSelfRef, formatLiteral, lengthConstraints, numberConstraints, shouldCoerce } from '../utils.ts'
 
@@ -139,7 +139,7 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
       },
       ref(node) {
         if (!node.name) return undefined
-        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
+        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name) : node.name
         const resolvedName = node.ref ? (this.options.resolver?.default(refName, 'function') ?? refName) : node.name
         const isSelfRef = node.ref && this.options.schemaName != null && resolvedName === this.options.schemaName
 
@@ -154,7 +154,7 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
           .map((prop) => {
             const { name: propName, schema } = prop
 
-            const meta = syncSchemaRef(schema)
+            const meta = ast.syncSchemaRef(schema)
 
             const isNullable = meta.nullable
             const isOptional = schema.optional
@@ -162,7 +162,7 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
 
             const hasSelfRef =
               this.options.schemaName != null && containsSelfRef(schema, { schemaName: this.options.schemaName, resolver: this.options.resolver })
-            const baseOutput = this.transform(schema) ?? this.transform(createSchema({ type: 'unknown' }))!
+            const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
             // Strip z.lazy() wrappers inside object getters — the getter itself provides deferred evaluation
             const resolvedOutput = hasSelfRef ? baseOutput.replaceAll(`z.lazy(() => ${this.options.schemaName})`, this.options.schemaName!) : baseOutput
 
@@ -193,7 +193,7 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
             result += `.catchall(${catchallType})`
           }
         } else if (node.additionalProperties === true) {
-          result += `.catchall(${this.transform(createSchema({ type: 'unknown' }))})`
+          result += `.catchall(${this.transform(ast.createSchema({ type: 'unknown' }))})`
         } else if (node.additionalProperties === false) {
           result += '.strict()'
         }
@@ -202,7 +202,7 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
       },
       array(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
-        const inner = items.join(', ') || this.transform(createSchema({ type: 'unknown' }))!
+        const inner = items.join(', ') || this.transform(ast.createSchema({ type: 'unknown' }))!
         let result = `z.array(${inner})${lengthConstraints(node)}`
 
         if (node.unique) {
@@ -241,21 +241,21 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
 
         for (const member of rest) {
           if (member.primitive === 'string') {
-            const s = narrowSchema(member, 'string')
+            const s = ast.narrowSchema(member, 'string')
             const c = lengthConstraints(s ?? {})
             if (c) {
               base += c
               continue
             }
           } else if (member.primitive === 'number' || member.primitive === 'integer') {
-            const n = narrowSchema(member, 'number') ?? narrowSchema(member, 'integer')
+            const n = ast.narrowSchema(member, 'number') ?? ast.narrowSchema(member, 'integer')
             const c = numberConstraints(n ?? {})
             if (c) {
               base += c
               continue
             }
           } else if (member.primitive === 'array') {
-            const a = narrowSchema(member, 'array')
+            const a = ast.narrowSchema(member, 'array')
             const c = lengthConstraints(a ?? {})
             if (c) {
               base += c
@@ -276,7 +276,7 @@ export const printerZod = definePrinter<PrinterZodFactory>((options) => {
       let base = this.transform(node)
       if (!base) return null
 
-      const meta = syncSchemaRef(node)
+      const meta = ast.syncSchemaRef(node)
 
       if (keysToOmit?.length && meta.primitive === 'object' && !(meta.type === 'union' && meta.discriminatorPropertyName)) {
         // Mirror printerTs `nonNullable: true`: when omitting keys, the resulting

package/src/printers/printerZodMini.ts

@@ -1,7 +1,7 @@
 import { stringify } from '@internals/utils'
-import { createSchema, extractRefName, narrowSchema, syncSchemaRef } from '@kubb/ast'
+
 import type { PrinterFactoryOptions, PrinterPartial } from '@kubb/core'
-import { definePrinter } from '@kubb/core'
+import { ast, definePrinter } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
 import { applyMiniModifiers, containsSelfRef, formatLiteral, lengthChecksMini, numberChecksMini } from '../utils.ts'
 
@@ -130,7 +130,7 @@ export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) =>
 
       ref(node) {
         if (!node.name) return undefined
-        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
+        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name) : node.name
         const resolvedName = node.ref ? (this.options.resolver?.default(refName, 'function') ?? refName) : node.name
         const isSelfRef = node.ref && this.options.schemaName != null && resolvedName === this.options.schemaName
 
@@ -145,7 +145,7 @@ export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) =>
           .map((prop) => {
             const { name: propName, schema } = prop
 
-            const meta = syncSchemaRef(schema)
+            const meta = ast.syncSchemaRef(schema)
 
             const isNullable = meta.nullable
             const isOptional = schema.optional
@@ -153,7 +153,7 @@ export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) =>
 
             const hasSelfRef =
               this.options.schemaName != null && containsSelfRef(schema, { schemaName: this.options.schemaName, resolver: this.options.resolver })
-            const baseOutput = this.transform(schema) ?? this.transform(createSchema({ type: 'unknown' }))!
+            const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
             // Strip z.lazy() wrappers inside object getters — the getter itself provides deferred evaluation
             const resolvedOutput = hasSelfRef ? baseOutput.replaceAll(`z.lazy(() => ${this.options.schemaName})`, this.options.schemaName!) : baseOutput
 
@@ -178,7 +178,7 @@ export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) =>
       },
       array(node) {
         const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
-        const inner = items.join(', ') || this.transform(createSchema({ type: 'unknown' }))!
+        const inner = items.join(', ') || this.transform(ast.createSchema({ type: 'unknown' }))!
         let result = `z.array(${inner})${lengthChecksMini(node)}`
 
         if (node.unique) {
@@ -217,21 +217,21 @@ export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) =>
 
         for (const member of rest) {
           if (member.primitive === 'string') {
-            const s = narrowSchema(member, 'string')
+            const s = ast.narrowSchema(member, 'string')
             const c = lengthChecksMini(s ?? {})
             if (c) {
               base += c
               continue
             }
           } else if (member.primitive === 'number' || member.primitive === 'integer') {
-            const n = narrowSchema(member, 'number') ?? narrowSchema(member, 'integer')
+            const n = ast.narrowSchema(member, 'number') ?? ast.narrowSchema(member, 'integer')
             const c = numberChecksMini(n ?? {})
             if (c) {
               base += c
               continue
             }
           } else if (member.primitive === 'array') {
-            const a = narrowSchema(member, 'array')
+            const a = ast.narrowSchema(member, 'array')
             const c = lengthChecksMini(a ?? {})
             if (c) {
               base += c
@@ -252,7 +252,7 @@ export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) =>
       let base = this.transform(node)
       if (!base) return null
 
-      const meta = syncSchemaRef(node)
+      const meta = ast.syncSchemaRef(node)
 
       if (keysToOmit?.length && meta.primitive === 'object' && !(meta.type === 'union' && meta.discriminatorPropertyName)) {
         // Mirror printerTs `nonNullable: true`: when omitting keys, the resulting