@kubb/plugin-zod 5.0.0-alpha.26 → 5.0.0-alpha.27

package/src/components/Zod.tsx

@@ -1,22 +1,23 @@
+import type { Printer } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
 import { Const, File, Type } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import { printerZod } from '../printers/printerZod.ts'
-import type { PluginZod, ResolverZod } from '../types.ts'
+import type { PrinterZodFactory } from '../printers/printerZod.ts'
+import type { PrinterZodMiniFactory } from '../printers/printerZodMini.ts'
 
 type Props = {
   name: string
   node: SchemaNode
-  coercion: PluginZod['resolvedOptions']['coercion']
-  guidType: PluginZod['resolvedOptions']['guidType']
-  wrapOutput: PluginZod['resolvedOptions']['wrapOutput']
+  /**
+   * Pre-configured printer instance created by the generator.
+   * The generator selects `printerZod` or `printerZodMini` based on the `mini` option,
+   * then merges in any user-supplied `printer.nodes` overrides.
+   */
+  printer: Printer<PrinterZodFactory> | Printer<PrinterZodMiniFactory>
   inferTypeName?: string
-  resolver?: ResolverZod
-  keysToOmit?: Array<string>
 }
 
-export function Zod({ name, node, coercion, guidType, wrapOutput, inferTypeName, resolver, keysToOmit }: Props): FabricReactNode {
-  const printer = printerZod({ coercion, guidType, wrapOutput, resolver, schemaName: name, keysToOmit })
+export function Zod({ name, node, printer, inferTypeName }: Props): FabricReactNode {
   const output = printer.print(node)
 
   if (!output) {

package/src/generators/zodGenerator.tsx

@@ -1,22 +1,23 @@
 import path from 'node:path'
-import { caseParams, composeTransformers, transform } from '@kubb/ast'
+import { caseParams, transform } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
 import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
-import { ZodMini } from '../components/ZodMini.tsx'
 import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
+import { printerZod } from '../printers/printerZod.ts'
+import { printerZodMini } from '../printers/printerZodMini.ts'
 import type { PluginZod } from '../types'
 import { buildSchemaNames } from '../utils.ts'
 
 export const zodGenerator = defineGenerator<PluginZod>({
   name: 'zod',
   type: 'react',
-  Schema({ node, adapter, options, config, resolver }) {
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, transformers = [] } = options
+  Schema({ node, adapter, options, config, resolver, plugin }) {
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     if (!transformedNode.name) {
       return
@@ -27,17 +28,21 @@ export const zodGenerator = defineGenerator<PluginZod>({
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
-      name: resolver.default(schemaName, 'function'),
+      name: resolver.resolveSchemaName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const inferTypeName = inferred ? resolver.resolveInferName(resolver.resolveName(transformedNode.name)) : undefined
-
     const meta = {
-      name: resolver.default(transformedNode.name, 'function'),
+      name: resolver.resolveSchemaName(transformedNode.name),
       file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
     } as const
 
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(transformedNode.name) : undefined
+
+    const schemaPrinter = mini
+      ? printerZodMini({ guidType, wrapOutput, resolver, schemaName: meta.name, nodes: printer?.nodes })
+      : printerZod({ coercion, guidType, wrapOutput, resolver, schemaName: meta.name, nodes: printer?.nodes })
+
     return (
       <File
         baseName={meta.file.baseName}
@@ -50,26 +55,14 @@ export const zodGenerator = defineGenerator<PluginZod>({
         {mode === 'split' &&
           imports.map((imp) => <File.Import key={[transformedNode.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
 
-        {mini ? (
-          <ZodMini name={meta.name} node={transformedNode} guidType={guidType} wrapOutput={wrapOutput} inferTypeName={inferTypeName} resolver={resolver} />
-        ) : (
-          <Zod
-            name={meta.name}
-            node={transformedNode}
-            coercion={coercion}
-            guidType={guidType}
-            wrapOutput={wrapOutput}
-            inferTypeName={inferTypeName}
-            resolver={resolver}
-          />
-        )}
+        <Zod name={meta.name} node={transformedNode} printer={schemaPrinter} inferTypeName={inferTypeName} />
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver }) {
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, transformers } = options
+  Operation({ node, adapter, options, config, resolver, plugin }) {
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -87,39 +80,22 @@ export const zodGenerator = defineGenerator<PluginZod>({
     function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
       if (!schema) return null
 
-      const inferTypeName = inferred ? resolver.resolveInferName(name) : undefined
+      const inferTypeName = inferred ? resolver.resolveTypeName(name) : undefined
 
       const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolver.default(schemaName, 'function'),
+        name: resolver.resolveSchemaName(schemaName),
         path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
 
+      const schemaPrinter = mini
+        ? printerZodMini({ guidType, wrapOutput, resolver, schemaName: name, keysToOmit, nodes: printer?.nodes })
+        : printerZod({ coercion, guidType, wrapOutput, resolver, schemaName: name, keysToOmit, nodes: printer?.nodes })
+
       return (
         <>
           {mode === 'split' &&
             imports.map((imp) => <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
-          {mini ? (
-            <ZodMini
-              name={name}
-              node={schema}
-              guidType={guidType}
-              wrapOutput={wrapOutput}
-              inferTypeName={inferTypeName}
-              resolver={resolver}
-              keysToOmit={keysToOmit}
-            />
-          ) : (
-            <Zod
-              name={name}
-              node={schema}
-              coercion={coercion}
-              guidType={guidType}
-              wrapOutput={wrapOutput}
-              inferTypeName={inferTypeName}
-              resolver={resolver}
-              keysToOmit={keysToOmit}
-            />
-          )}
+          <Zod name={name} node={schema} printer={schemaPrinter} inferTypeName={inferTypeName} />
         </>
       )
     }
@@ -160,8 +136,8 @@ export const zodGenerator = defineGenerator<PluginZod>({
       </File>
     )
   },
-  Operations({ nodes, adapter, options, config, resolver }) {
-    const { output, importPath, group, operations, paramsCasing, transformers } = options
+  Operations({ nodes, adapter, options, config, resolver, plugin }) {
+    const { output, importPath, group, operations, paramsCasing } = options
 
     if (!operations) {
       return
@@ -175,7 +151,7 @@ export const zodGenerator = defineGenerator<PluginZod>({
     } as const
 
     const transformedOperations = nodes.map((node) => {
-      const transformedNode = transform(node, composeTransformers(...transformers))
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
       const params = caseParams(transformedNode.parameters, paramsCasing)
 

package/src/generators/zodGeneratorLegacy.tsx

@@ -1,12 +1,13 @@
 import path from 'node:path'
-import { caseParams, composeTransformers, createProperty, createSchema, transform } from '@kubb/ast'
+import { caseParams, createProperty, createSchema, transform } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
 import { defineGenerator, getMode } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
-import { ZodMini } from '../components/ZodMini.tsx'
 import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
+import { printerZod } from '../printers/printerZod.ts'
+import { printerZodMini } from '../printers/printerZodMini.ts'
 import type { PluginZod, ResolverZod } from '../types'
 
 type BuildGroupedParamsSchemaOptions = {
@@ -167,9 +168,9 @@ function buildLegacySchemaNames(node: OperationNode, params: Array<ParameterNode
 export const zodGeneratorLegacy = defineGenerator<PluginZod>({
   name: 'zod-legacy',
   type: 'react',
-  Schema({ node, adapter, options, config, resolver }) {
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, transformers = [] } = options
-    const transformedNode = transform(node, composeTransformers(...transformers))
+  Schema({ node, adapter, options, config, resolver, plugin }) {
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     if (!transformedNode.name) {
       return
@@ -180,17 +181,21 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
-      name: resolver.default(schemaName, 'function'),
+      name: resolver.resolveSchemaName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const inferTypeName = inferred ? resolver.resolveInferName(resolver.resolveName(transformedNode.name)) : undefined
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(transformedNode.name) : undefined
 
     const meta = {
-      name: resolver.default(transformedNode.name, 'function'),
+      name: resolver.resolveSchemaName(transformedNode.name),
       file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
     } as const
 
+    const schemaPrinter = mini
+      ? printerZodMini({ guidType, wrapOutput, resolver, schemaName: meta.name, nodes: printer?.nodes })
+      : printerZod({ coercion, guidType, wrapOutput, resolver, schemaName: meta.name, nodes: printer?.nodes })
+
     return (
       <File
         baseName={meta.file.baseName}
@@ -203,26 +208,14 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
         {mode === 'split' &&
           imports.map((imp) => <File.Import key={[transformedNode.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
 
-        {mini ? (
-          <ZodMini name={meta.name} node={transformedNode} guidType={guidType} wrapOutput={wrapOutput} inferTypeName={inferTypeName} resolver={resolver} />
-        ) : (
-          <Zod
-            name={meta.name}
-            node={transformedNode}
-            coercion={coercion}
-            guidType={guidType}
-            wrapOutput={wrapOutput}
-            inferTypeName={inferTypeName}
-            resolver={resolver}
-          />
-        )}
+        <Zod name={meta.name} node={transformedNode} printer={schemaPrinter} inferTypeName={inferTypeName} />
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver }) {
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, transformers } = options
+  Operation({ node, adapter, options, config, resolver, plugin }) {
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options
 
-    const transformedNode = transform(node, composeTransformers(...transformers))
+    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -240,39 +233,22 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
     function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
       if (!schema) return null
 
-      const inferTypeName = inferred ? resolver.resolveInferName(name) : undefined
+      const inferTypeName = inferred ? resolver.resolveTypeName(name) : undefined
 
       const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolver.default(schemaName, 'function'),
+        name: resolver.resolveSchemaName(schemaName),
         path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
 
+      const schemaPrinter = mini
+        ? printerZodMini({ guidType, wrapOutput, resolver, schemaName: name, keysToOmit, nodes: printer?.nodes })
+        : printerZod({ coercion, guidType, wrapOutput, resolver, schemaName: name, keysToOmit, nodes: printer?.nodes })
+
       return (
         <>
           {mode === 'split' &&
             imports.map((imp) => <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
-          {mini ? (
-            <ZodMini
-              name={name}
-              node={schema}
-              guidType={guidType}
-              wrapOutput={wrapOutput}
-              inferTypeName={inferTypeName}
-              resolver={resolver}
-              keysToOmit={keysToOmit}
-            />
-          ) : (
-            <Zod
-              name={name}
-              node={schema}
-              coercion={coercion}
-              guidType={guidType}
-              wrapOutput={wrapOutput}
-              inferTypeName={inferTypeName}
-              resolver={resolver}
-              keysToOmit={keysToOmit}
-            />
-          )}
+          <Zod name={name} node={schema} printer={schemaPrinter} inferTypeName={inferTypeName} />
         </>
       )
     }
@@ -352,8 +328,8 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
       </File>
     )
   },
-  Operations({ nodes, adapter, options, config, resolver }) {
-    const { output, importPath, group, operations, paramsCasing, transformers } = options
+  Operations({ nodes, adapter, options, config, resolver, plugin }) {
+    const { output, importPath, group, operations, paramsCasing } = options
 
     if (!operations) {
       return
@@ -367,7 +343,7 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
     } as const
 
     const transformedOperations = nodes.map((node) => {
-      const transformedNode = transform(node, composeTransformers(...transformers))
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
       const params = caseParams(transformedNode.parameters, paramsCasing)
 

package/src/index.ts

@@ -2,8 +2,9 @@ export { zodGenerator } from './generators/zodGenerator.tsx'
 export { zodGeneratorLegacy } from './generators/zodGeneratorLegacy.tsx'
 
 export { pluginZod, pluginZodName } from './plugin.ts'
-
+export type { PrinterZodFactory, PrinterZodNodes, PrinterZodOptions } from './printers/printerZod.ts'
 export { printerZod } from './printers/printerZod.ts'
+export type { PrinterZodMiniFactory, PrinterZodMiniNodes, PrinterZodMiniOptions } from './printers/printerZodMini.ts'
 export { printerZodMini } from './printers/printerZodMini.ts'
 
 export { resolverZod } from './resolvers/resolverZod.ts'

package/src/plugin.ts

@@ -44,17 +44,18 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     inferred = false,
     wrapOutput = undefined,
     paramsCasing,
+    printer,
     compatibilityPreset = 'default',
-    resolvers: userResolvers = [],
-    transformers: userTransformers = [],
+    resolver: userResolver,
+    transformer: userTransformer,
     generators: userGenerators = [],
   } = options
 
   const preset = getPreset({
     preset: compatibilityPreset,
     presets: presets,
-    resolvers: userResolvers,
-    transformers: userTransformers,
+    resolver: userResolver,
+    transformer: userTransformer,
     generators: userGenerators,
   })
 
@@ -66,6 +67,9 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     get resolver() {
       return preset.resolver
     },
+    get transformer() {
+      return preset.transformer
+    },
     get options() {
       return {
         output,
@@ -90,7 +94,7 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
         mini,
         wrapOutput,
         paramsCasing,
-        transformers: preset.transformers,
+        printer,
       }
     },
     resolvePath(baseName, pathMode, options) {

package/src/presets.ts

@@ -1,6 +1,7 @@
 import { definePresets } from '@kubb/core'
 import { zodGenerator } from './generators/zodGenerator.tsx'
 import { zodGeneratorLegacy } from './generators/zodGeneratorLegacy.tsx'
+import { printerZod } from './printers/printerZod.ts'
 import { resolverZod } from './resolvers/resolverZod.ts'
 import { resolverZodLegacy } from './resolvers/resolverZodLegacy.ts'
 import type { ResolverZod } from './types.ts'
@@ -10,16 +11,20 @@ import type { ResolverZod } from './types.ts'
  *
  * - `default` — uses `resolverZod` and `zodGenerator` (current naming conventions).
  * - `kubbV4` — uses `resolverZodLegacy` and `zodGeneratorLegacy` (Kubb v4 naming conventions).
+ *
+ * Note: `printerZodMini` is selected at runtime by the generator when `mini: true` is set.
  */
 export const presets = definePresets<ResolverZod>({
   default: {
     name: 'default',
-    resolvers: [resolverZod],
+    resolver: resolverZod,
     generators: [zodGenerator],
+    printer: printerZod,
   },
   kubbV4: {
     name: 'kubbV4',
-    resolvers: [resolverZodLegacy],
+    resolver: resolverZodLegacy,
     generators: [zodGeneratorLegacy],
+    printer: printerZod,
   },
 })

package/src/printers/printerZod.ts

@@ -1,11 +1,33 @@
 import { stringify } from '@internals/utils'
 import { createSchema, extractRefName, narrowSchema, syncSchemaRef } from '@kubb/ast'
-import type { PrinterFactoryOptions } from '@kubb/core'
+import type { PrinterFactoryOptions, PrinterPartial } from '@kubb/core'
 import { definePrinter } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
 import { applyModifiers, containsSelfRef, formatLiteral, lengthConstraints, numberConstraints, shouldCoerce } from '../utils.ts'
 
-export type ZodOptions = {
+/**
+ * Partial map of node-type overrides for the Zod printer.
+ *
+ * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function
+ * replaces the built-in handler for that node type. Use `this.transform` to
+ * recurse into nested schema nodes, and `this.options` to read printer options.
+ *
+ * @example Override the `date` handler
+ * ```ts
+ * pluginZod({
+ *   printer: {
+ *     nodes: {
+ *       date(node) {
+ *         return 'z.string().date()'
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export type PrinterZodNodes = PrinterPartial<string, PrinterZodOptions>
+
+export type PrinterZodOptions = {
   coercion?: PluginZod['resolvedOptions']['coercion']
   guidType?: PluginZod['resolvedOptions']['guidType']
   wrapOutput?: PluginZod['resolvedOptions']['wrapOutput']
@@ -15,9 +37,13 @@ export type ZodOptions = {
    * Property keys to exclude from the generated object schema via `.omit({ key: true })`.
    */
   keysToOmit?: Array<string>
+  /**
+   * Partial map of node-type overrides. Each entry replaces the built-in handler for that node type.
+   */
+  nodes?: PrinterZodNodes
 }
 
-type ZodPrinterFactory = PrinterFactoryOptions<'zod', ZodOptions, string, string>
+export type PrinterZodFactory = PrinterFactoryOptions<'zod', PrinterZodOptions, string, string>
 
 /**
  * Zod v4 printer built with `definePrinter`.
@@ -33,7 +59,7 @@ type ZodPrinterFactory = PrinterFactoryOptions<'zod', ZodOptions, string, string
  * const code = printer.print(stringSchemaNode) // "z.string()"
  * ```
  */
-export const printerZod = definePrinter<ZodPrinterFactory>((options) => {
+export const printerZod = definePrinter<PrinterZodFactory>((options) => {
   return {
     name: 'zod',
     options,
@@ -242,6 +268,7 @@ export const printerZod = definePrinter<ZodPrinterFactory>((options) => {
 
         return base
       },
+      ...options.nodes,
     },
     print(node) {
       const { keysToOmit } = this.options

package/src/printers/printerZodMini.ts

@@ -1,11 +1,34 @@
 import { stringify } from '@internals/utils'
 import { createSchema, extractRefName, narrowSchema, syncSchemaRef } from '@kubb/ast'
-import type { PrinterFactoryOptions } from '@kubb/core'
+import type { PrinterFactoryOptions, PrinterPartial } from '@kubb/core'
 import { definePrinter } from '@kubb/core'
 import type { PluginZod, ResolverZod } from '../types.ts'
 import { applyMiniModifiers, containsSelfRef, formatLiteral, lengthChecksMini, numberChecksMini } from '../utils.ts'
 
-export type ZodMiniOptions = {
+/**
+ * Partial map of node-type overrides for the Zod Mini printer.
+ *
+ * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function
+ * replaces the built-in handler for that node type. Use `this.transform` to
+ * recurse into nested schema nodes, and `this.options` to read printer options.
+ *
+ * @example Override the `date` handler
+ * ```ts
+ * pluginZod({
+ *   mini: true,
+ *   printer: {
+ *     nodes: {
+ *       date(node) {
+ *         return 'z.iso.date()'
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export type PrinterZodMiniNodes = PrinterPartial<string, PrinterZodMiniOptions>
+
+export type PrinterZodMiniOptions = {
   guidType?: PluginZod['resolvedOptions']['guidType']
   wrapOutput?: PluginZod['resolvedOptions']['wrapOutput']
   resolver?: ResolverZod
@@ -14,9 +37,13 @@ export type ZodMiniOptions = {
    * Property keys to exclude from the generated object schema via `.omit({ key: true })`.
    */
   keysToOmit?: Array<string>
+  /**
+   * Partial map of node-type overrides. Each entry replaces the built-in handler for that node type.
+   */
+  nodes?: PrinterZodMiniNodes
 }
 
-type ZodMiniPrinterFactory = PrinterFactoryOptions<'zod-mini', ZodMiniOptions, string, string>
+export type PrinterZodMiniFactory = PrinterFactoryOptions<'zod-mini', PrinterZodMiniOptions, string, string>
 /**
  * Zod v4 **Mini** printer built with `definePrinter`.
  *
@@ -31,7 +58,7 @@ type ZodMiniPrinterFactory = PrinterFactoryOptions<'zod-mini', ZodMiniOptions, s
  * const code = printer.print(optionalStringNode) // "z.optional(z.string())"
  * ```
  */
-export const printerZodMini = definePrinter<ZodMiniPrinterFactory>((options) => {
+export const printerZodMini = definePrinter<PrinterZodMiniFactory>((options) => {
   return {
     name: 'zod-mini',
     options,
@@ -217,8 +244,8 @@ export const printerZodMini = definePrinter<ZodMiniPrinterFactory>((options) =>
 
         return base
       },
+      ...options.nodes,
     },
-
     print(node) {
       const { keysToOmit } = this.options
 

package/src/resolvers/resolverZod.ts

@@ -2,19 +2,6 @@ import { camelCase, pascalCase } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginZod } from '../types.ts'
 
-function toSchemaName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string {
-  const resolved = camelCase(name, {
-    suffix: type ? 'schema' : undefined,
-    isFile: type === 'file',
-  })
-
-  if (type === 'type') {
-    return pascalCase(resolved)
-  }
-
-  return resolved
-}
-
 /**
  * Default resolver for `@kubb/plugin-zod`.
  *
@@ -32,31 +19,34 @@ export const resolverZod = defineResolver<PluginZod>(() => {
     name: 'default',
     pluginName: 'plugin-zod',
     default(name, type) {
-      return toSchemaName(name, type)
+      return camelCase(name, { isFile: type === 'file', suffix: type ? 'schema' : undefined })
+    },
+    resolveSchemaName(name) {
+      return camelCase(name, { suffix: 'schema' })
     },
-    resolveName(name) {
-      return this.default(name, 'function')
+    resolveSchemaTypeName(name) {
+      return pascalCase(name, { suffix: 'schema' })
     },
-    resolveInferName(name) {
+    resolveTypeName(name) {
       return pascalCase(name)
     },
     resolvePathName(name, type) {
       return this.default(name, type)
     },
     resolveParamName(node, param) {
-      return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+      return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`)
     },
     resolveResponseStatusName(node, statusCode) {
-      return this.resolveName(`${node.operationId} Status ${statusCode}`)
+      return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`)
     },
     resolveDataName(node) {
-      return this.resolveName(`${node.operationId} Data`)
+      return this.resolveSchemaName(`${node.operationId} Data`)
     },
     resolveResponsesName(node) {
-      return this.resolveName(`${node.operationId} Responses`)
+      return this.resolveSchemaName(`${node.operationId} Responses`)
     },
     resolveResponseName(node) {
-      return this.resolveName(`${node.operationId} Response`)
+      return this.resolveSchemaName(`${node.operationId} Response`)
     },
     resolvePathParamsName(node, param) {
       return this.resolveParamName(node, param)

package/src/resolvers/resolverZodLegacy.ts

@@ -31,30 +31,30 @@ export const resolverZodLegacy = defineResolver<PluginZod>(() => {
     pluginName: 'plugin-zod',
     resolveResponseStatusName(node, statusCode) {
       if (statusCode === 'default') {
-        return this.resolveName(`${node.operationId} Error`)
+        return this.resolveSchemaName(`${node.operationId} Error`)
       }
-      return this.resolveName(`${node.operationId} ${statusCode}`)
+      return this.resolveSchemaName(`${node.operationId} ${statusCode}`)
     },
     resolveDataName(node) {
       const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
-      return this.resolveName(`${node.operationId} ${suffix}`)
+      return this.resolveSchemaName(`${node.operationId} ${suffix}`)
     },
     resolveResponsesName(node) {
       const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
-      return this.resolveName(`${node.operationId} ${suffix}`)
+      return this.resolveSchemaName(`${node.operationId} ${suffix}`)
     },
     resolveResponseName(node) {
       const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
-      return this.resolveName(`${node.operationId} ${suffix}`)
+      return this.resolveSchemaName(`${node.operationId} ${suffix}`)
     },
     resolvePathParamsName(node, _param) {
-      return this.resolveName(`${node.operationId} PathParams`)
+      return this.resolveSchemaName(`${node.operationId} PathParams`)
     },
     resolveQueryParamsName(node, _param) {
-      return this.resolveName(`${node.operationId} QueryParams`)
+      return this.resolveSchemaName(`${node.operationId} QueryParams`)
     },
     resolveHeaderParamsName(node, _param) {
-      return this.resolveName(`${node.operationId} HeaderParams`)
+      return this.resolveSchemaName(`${node.operationId} HeaderParams`)
     },
   }
 })