@kubb/plugin-zod 4.4.0 → 4.5.0

package/src/generators/__snapshots__/createPetWithUnknownTypeUnknown_wrapOutput.ts

@@ -12,18 +12,16 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const createPetsError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
 export const createPetsMutationRequest = z.object({
   name: z.string().openapi({ example: 'Baxter' }),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/createPetWithUnknownTypeUnknown_wrapOutput_entire_.ts

@@ -12,19 +12,16 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = extendApi(
-  z.lazy(() => error),
-  {
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  },
-)
+export const createPetsError = extendApi(error, {
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
 export const createPetsMutationRequest = z.object({
   name: extendApi(z.string(), { example: 'Baxter' }),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/createPet_wrapOutput.ts

@@ -12,18 +12,16 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const createPetsError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
 export const createPetsMutationRequest = z.object({
   name: z.string().openapi({ example: 'Baxter' }),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/discriminator.ts

@@ -5,32 +5,24 @@
 import { z } from 'zod'
 
 export const advanced = z.union([
-  z
-    .lazy(() => enumerationValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('enum'),
-      }),
-    ),
-  z
-    .lazy(() => rangeValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('range'),
-      }),
-    ),
-  z
-    .lazy(() => regexValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('regex'),
-      }),
-    ),
-  z
-    .lazy(() => sliderValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('slider'),
-      }),
-    ),
+  enumerationValueSpecificationDto.and(
+    z.object({
+      type: z.literal('enum'),
+    }),
+  ),
+  rangeValueSpecificationDto.and(
+    z.object({
+      type: z.literal('range'),
+    }),
+  ),
+  regexValueSpecificationDto.and(
+    z.object({
+      type: z.literal('regex'),
+    }),
+  ),
+  sliderValueSpecificationDto.and(
+    z.object({
+      type: z.literal('slider'),
+    }),
+  ),
 ])

package/src/generators/__snapshots__/getPets.ts

@@ -12,11 +12,11 @@ export const listPetsQueryParams = z.object({
 /**
  * @description A paged array of pets
  */
-export const listPets200 = z.lazy(() => pets)
+export const listPets200 = pets
 
 /**
  * @description unexpected error
  */
-export const listPetsError = z.lazy(() => error)
+export const listPetsError = error
 
-export const listPetsQueryResponse = z.lazy(() => listPets200)
+export const listPetsQueryResponse = listPets200

package/src/generators/__snapshots__/getPets_wrapOutput.ts

@@ -12,18 +12,16 @@ export const listPetsQueryParams = z.object({
 /**
  * @description A paged array of pets
  */
-export const listPets200 = z.lazy(() => pets)
+export const listPets200 = pets
 
 /**
  * @description unexpected error
  */
-export const listPetsError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const listPetsError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
-export const listPetsQueryResponse = z.lazy(() => listPets200)
+export const listPetsQueryResponse = listPets200

package/src/generators/__snapshots__/petArray.ts

@@ -7,8 +7,4 @@ import { z } from 'zod'
 /**
  * @description List of Pet object
  */
-export const petArray = z
-  .array(z.lazy(() => pet))
-  .min(1)
-  .max(3)
-  .describe('List of Pet object')
+export const petArray = z.array(pet).min(1).max(3).describe('List of Pet object')

package/src/generators/__snapshots__/queryAllDefaulted.ts

@@ -16,4 +16,4 @@ export const getThings200 = z.object({
   items: z.array(z.lazy(() => thing)),
 })
 
-export const getThingsQueryResponse = z.lazy(() => getThings200)
+export const getThingsQueryResponse = getThings200

package/src/generators/__snapshots__/queryAllDefaulted_wrapOutput.ts

@@ -13,7 +13,7 @@ export const getThingsQueryParams = z.object({
  * @description A list of things
  */
 export const getThings200 = z.object({
-  items: z.array(z.lazy(() => thing)),
+  items: z.array(thing),
 })
 
-export const getThingsQueryResponse = z.lazy(() => getThings200)
+export const getThingsQueryResponse = getThings200

package/src/generators/__snapshots__/showPetById.ts

@@ -12,11 +12,11 @@ export const showPetByIdPathParams = z.object({
 /**
  * @description Expected response to a valid request
  */
-export const showPetById200 = z.lazy(() => pet)
+export const showPetById200 = pet
 
 /**
  * @description unexpected error
  */
-export const showPetByIdError = z.lazy(() => error)
+export const showPetByIdError = error
 
-export const showPetByIdQueryResponse = z.lazy(() => showPetById200)
+export const showPetByIdQueryResponse = showPetById200

package/src/generators/__snapshots__/showPetById_wrapOutput.ts

@@ -12,18 +12,16 @@ export const showPetByIdPathParams = z.object({
 /**
  * @description Expected response to a valid request
  */
-export const showPetById200 = z.lazy(() => pet)
+export const showPetById200 = pet
 
 /**
  * @description unexpected error
  */
-export const showPetByIdError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const showPetByIdError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
-export const showPetByIdQueryResponse = z.lazy(() => showPetById200)
+export const showPetByIdQueryResponse = showPetById200

package/src/generators/index.ts

@@ -1,2 +1,2 @@
-export { zodGenerator } from './zodGenerator.tsx'
 export { operationsGenerator } from './operationsGenerator.tsx'
+export { zodGenerator } from './zodGenerator.tsx'

package/src/generators/operationsGenerator.tsx

@@ -1,5 +1,5 @@
-import { usePlugin, usePluginManager } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas'
+import { usePluginManager } from '@kubb/core/hooks'
+import { createReactGenerator } from '@kubb/plugin-oas/generators'
 import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
 import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
 import { File } from '@kubb/react-fabric'
@@ -8,15 +8,15 @@ import type { PluginZod } from '../types'
 
 export const operationsGenerator = createReactGenerator<PluginZod>({
   name: 'operations',
-  Operations({ operations }) {
+  Operations({ operations, generator, plugin }) {
     const {
       key: pluginKey,
       options: { output, importPath },
-    } = usePlugin<PluginZod>()
+    } = plugin
     const pluginManager = usePluginManager()
 
     const oas = useOas()
-    const { getFile, groupSchemasByName } = useOperationManager()
+    const { getFile, groupSchemasByName } = useOperationManager(generator)
 
     const name = 'operations'
     const file = pluginManager.getFile({ name, extname: '.ts', pluginKey })

package/src/generators/zodGenerator.tsx

@@ -1,30 +1,33 @@
-import { useMode, usePlugin, usePluginManager } from '@kubb/core/hooks'
-import { createReactGenerator, type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { Oas } from '@kubb/plugin-oas/components'
+import path from 'node:path'
+import { useMode, usePluginManager } from '@kubb/core/hooks'
+import { type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
+import { createReactGenerator } from '@kubb/plugin-oas/generators'
 import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
 import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
+import { File, Fragment } from '@kubb/react-fabric'
 import { Zod } from '../components'
 import type { PluginZod } from '../types'
 
 export const zodGenerator = createReactGenerator<PluginZod>({
   name: 'zod',
-  Operation({ operation, options, instance }) {
-    const { coercion: globalCoercion, inferred, typed, mapper, wrapOutput } = options
+  Operation({ config, operation, generator, plugin }) {
+    const {
+      options,
+      options: { coercion: globalCoercion, inferred, typed, mapper, wrapOutput, version },
+    } = plugin
 
-    const plugin = usePlugin<PluginZod>()
     const mode = useMode()
     const pluginManager = usePluginManager()
 
     const oas = useOas()
-    const { getSchemas, getFile, getGroup } = useOperationManager()
+    const { getSchemas, getFile, getGroup } = useOperationManager(generator)
     const schemaManager = useSchemaManager()
 
     const file = getFile(operation)
     const schemas = getSchemas(operation)
     const schemaGenerator = new SchemaGenerator(options, {
-      fabric: instance.context.fabric,
+      fabric: generator.context.fabric,
       oas,
       plugin,
       pluginManager,
@@ -36,7 +39,7 @@ export const zodGenerator = createReactGenerator<PluginZod>({
       .flat()
       .filter(Boolean)
 
-    const mapOperationSchema = ({ name, schema: schemaObject, description, keysToOmit, ...options }: OperationSchemaType, i: number) => {
+    const mapOperationSchema = ({ name, schema: schemaObject, description, keysToOmit, ...options }: OperationSchemaType) => {
       // hack so Params can be optional when needed
       const required = Array.isArray(schemaObject?.required) ? !!schemaObject.required.length : !!schemaObject?.required
       const someDefaults = Object.values(schemaObject.properties || {}).some((property) => Object.hasOwn(property, 'default') && property.default !== undefined)
@@ -66,9 +69,9 @@ export const zodGenerator = createReactGenerator<PluginZod>({
       }
 
       return (
-        <Oas.Schema key={i} name={name} schemaObject={schemaObject} tree={tree}>
+        <Fragment>
           {typed && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
-          {typed && plugin.options.version === '3' && <File.Import isTypeOnly path={'@kubb/plugin-zod/utils'} name={['ToZod']} />}
+          {typed && version === '3' && <File.Import name={['ToZod']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')} />}
           {imports.map((imp) => (
             <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} />
           ))}
@@ -78,7 +81,7 @@ export const zodGenerator = createReactGenerator<PluginZod>({
             inferTypeName={inferred ? zod.inferTypeName : undefined}
             description={description}
             tree={tree}
-            rawSchema={schemaObject}
+            schema={schemaObject}
             mapper={mapper}
             coercion={coercion}
             keysToOmit={keysToOmit}
@@ -86,7 +89,7 @@ export const zodGenerator = createReactGenerator<PluginZod>({
             version={plugin.options.version}
             emptySchemaType={plugin.options.emptySchemaType}
           />
-        </Oas.Schema>
+        </Fragment>
       )
     }
 
@@ -103,13 +106,11 @@ export const zodGenerator = createReactGenerator<PluginZod>({
       </File>
     )
   },
-  Schema({ schema, options }) {
-    const { coercion, inferred, typed, mapper, importPath, wrapOutput, version } = options
-
+  Schema({ config, schema, plugin }) {
     const { getName, getFile, getImports } = useSchemaManager()
     const {
-      options: { output, emptySchemaType },
-    } = usePlugin<PluginZod>()
+      options: { output, emptySchemaType, coercion, inferred, typed, mapper, importPath, wrapOutput, version },
+    } = plugin
     const pluginManager = usePluginManager()
     const oas = useOas()
 
@@ -136,7 +137,9 @@ export const zodGenerator = createReactGenerator<PluginZod>({
       >
         <File.Import name={['z']} path={importPath} />
         {typed && <File.Import isTypeOnly root={zod.file.path} path={type.file.path} name={[type.name]} />}
-        {typed && <File.Import isTypeOnly path={options.version === '4' ? '@kubb/plugin-zod/utils/v4' : '@kubb/plugin-zod/utils'} name={['ToZod']} />}
+        {typed && version === '3' && (
+          <File.Import name={['ToZod']} root={zod.file.path} path={path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')} />
+        )}
         {imports.map((imp) => (
           <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={zod.file.path} path={imp.path} name={imp.name} />
         ))}
@@ -147,7 +150,7 @@ export const zodGenerator = createReactGenerator<PluginZod>({
           inferTypeName={inferred ? zod.inferTypeName : undefined}
           description={schema.value.description}
           tree={schema.tree}
-          rawSchema={schema.value}
+          schema={schema.value}
           mapper={mapper}
           coercion={coercion}
           wrapOutput={wrapOutput}

package/src/parser.ts

@@ -1,5 +1,4 @@
 import transformers from '@kubb/core/transformers'
-import type { SchemaObject } from '@kubb/oas'
 
 import type { Schema, SchemaKeywordBase, SchemaMapper } from '@kubb/plugin-oas'
 import { isKeyword, SchemaGenerator, type SchemaKeywordMapper, type SchemaTree, schemaKeywords } from '@kubb/plugin-oas'
@@ -191,12 +190,12 @@ const zodKeywordMapper = {
   phone: undefined,
   readOnly: undefined,
   writeOnly: undefined,
-  ref: (value?: string, version: '3' | '4' = '3') => {
+  ref: (value?: string, lazy = true) => {
     if (!value) {
       return undefined
     }
 
-    return version === '4' ? value : `z.lazy(() => ${value})`
+    return lazy ? `z.lazy(() => ${value})` : value
   },
   blob: () => 'z.instanceof(File)',
   deprecated: undefined,
@@ -258,18 +257,14 @@ const shouldCoerce = (coercion: ParserOptions['coercion'] | undefined, type: 'da
 }
 
 type ParserOptions = {
-  name: string
-  typeName?: string
-  description?: string
-  keysToOmit?: string[]
+  lazy?: boolean
   mapper?: Record<string, string>
   coercion?: boolean | { dates?: boolean; strings?: boolean; numbers?: boolean }
   wrapOutput?: (opts: { output: string; schema: any }) => string | undefined
-  rawSchema: SchemaObject
   version: '3' | '4'
 }
 
-export function parse({ parent, current, name, siblings }: SchemaTree, options: ParserOptions): string | undefined {
+export function parse({ schema, parent, current, name, siblings }: SchemaTree, options: ParserOptions): string | undefined {
   const value = zodKeywordMapper[current.keyword as keyof typeof zodKeywordMapper]
 
   // Early exit: if siblings contain both matches and ref → skip matches entirely
@@ -287,7 +282,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
   if (isKeyword(current, schemaKeywords.union)) {
     // zod union type needs at least 2 items
     if (Array.isArray(current.args) && current.args.length === 1) {
-      return parse({ parent, name: name, current: current.args[0] as Schema, siblings }, options)
+      return parse({ schema, parent, name, current: current.args[0] as Schema, siblings }, options)
     }
     if (Array.isArray(current.args) && !current.args.length) {
       return ''
@@ -295,7 +290,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
 
     return zodKeywordMapper.union(
       sort(current.args)
-        .map((schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options))
+        .map((it, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options))
         .filter(Boolean),
     )
   }
@@ -305,7 +300,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
       .filter((schema: Schema) => {
         return ![schemaKeywords.optional, schemaKeywords.describe].includes(schema.keyword as typeof schemaKeywords.describe)
       })
-      .map((schema: Schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options))
+      .map((it: Schema, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options))
       .filter(Boolean)
 
     return `${items.slice(0, 1)}${zodKeywordMapper.and(items.slice(1))}`
@@ -314,7 +309,9 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
   if (isKeyword(current, schemaKeywords.array)) {
     return zodKeywordMapper.array(
       sort(current.args.items)
-        .map((schemas, _index, siblings) => parse({ parent: current, name: name, current: schemas, siblings }, options))
+        .map((it, _index, siblings) => {
+          return parse({ schema, parent: current, name, current: it, siblings }, options)
+        })
         .filter(Boolean),
       current.args.min,
       current.args.max,
@@ -329,7 +326,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
           keyword: schemaKeywords.const,
           args: current.args.items[0],
         }
-        return parse({ parent: current, name: name, current: child, siblings: [child] }, options)
+        return parse({ schema, parent: current, name, current: child, siblings: [child] }, options)
       }
 
       return zodKeywordMapper.union(
@@ -338,8 +335,8 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
             keyword: schemaKeywords.const,
             args: schema,
           }))
-          .map((schema, _index, siblings) => {
-            return parse({ parent: current, name: name, current: schema, siblings }, options)
+          .map((it, _index, siblings) => {
+            return parse({ schema, parent: current, name, current: it, siblings }, options)
           })
           .filter(Boolean),
       )
@@ -360,7 +357,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
   }
 
   if (isKeyword(current, schemaKeywords.ref)) {
-    return zodKeywordMapper.ref(current.args?.name, options.version)
+    return zodKeywordMapper.ref(current.args?.name, options.lazy ?? name === current.args.name)
   }
 
   if (isKeyword(current, schemaKeywords.object)) {
@@ -370,80 +367,84 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
     })
 
     const properties = propertyEntries
-      .map(([name, schemas]) => {
+      .map(([propertyName, schemas]) => {
         const nameSchema = schemas.find((it) => it.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
         const isNullable = schemas.some((it) => isKeyword(it, schemaKeywords.nullable))
         const isNullish = schemas.some((it) => isKeyword(it, schemaKeywords.nullish))
         const isOptional = schemas.some((it) => isKeyword(it, schemaKeywords.optional))
+        const hasRef = !!SchemaGenerator.find(schemas, schemaKeywords.ref)
 
-        const mappedName = nameSchema?.args || name
+        const mappedName = nameSchema?.args || propertyName
 
         // custom mapper(pluginOptions)
         if (options.mapper?.[mappedName]) {
-          return `"${name}": ${options.mapper?.[mappedName]}`
+          return `"${propertyName}": ${options.mapper?.[mappedName]}`
         }
 
         const baseSchemaOutput = sort(schemas)
           .filter((schema) => {
             return !isKeyword(schema, schemaKeywords.optional) && !isKeyword(schema, schemaKeywords.nullable) && !isKeyword(schema, schemaKeywords.nullish)
           })
-          .map((schema) => parse({ parent: current, name, current: schema, siblings: schemas }, options))
+          .map((it) => {
+            const lazy = !(options.version === '4' && hasRef)
+            return parse({ schema, parent: current, name, current: it, siblings: schemas }, { ...options, lazy })
+          })
           .filter(Boolean)
           .join('')
 
         const objectValue = options.wrapOutput
-          ? options.wrapOutput({ output: baseSchemaOutput, schema: options.rawSchema?.properties?.[name] }) || baseSchemaOutput
+          ? options.wrapOutput({ output: baseSchemaOutput, schema: schema?.properties?.[propertyName] }) || baseSchemaOutput
           : baseSchemaOutput
 
-        if (options.version === '4' && SchemaGenerator.find(schemas, schemaKeywords.ref)) {
+        if (options.version === '4' && hasRef) {
           // both optional and nullable
           if (isNullish) {
-            return `get "${name}"(){
-                return ${zodKeywordMapper.nullish(objectValue)}
+            return `get "${propertyName}"(){
+                return ${objectValue}${zodKeywordMapper.nullish()}
               }`
           }
 
           // undefined
           if (isOptional) {
-            return `get "${name}"(){
-                return ${zodKeywordMapper.optional(objectValue)}
+            return `get "${propertyName}"(){
+                return ${objectValue}${zodKeywordMapper.optional()}
               }`
           }
 
           // null
           if (isNullable) {
-            return `get "${name}"(){
-                return ${zodKeywordMapper.nullable(objectValue)}
+            return `get "${propertyName}"(){
+               return ${objectValue}${zodKeywordMapper.nullable()}
               }`
           }
 
-          return `get "${name}"(){
+          return `get "${propertyName}"(){
                 return ${objectValue}
               }`
         }
 
         // both optional and nullable
         if (isNullish) {
-          return `"${name}": ${objectValue}${zodKeywordMapper.nullish()}`
+          return `"${propertyName}": ${objectValue}${zodKeywordMapper.nullish()}`
         }
 
         // undefined
         if (isOptional) {
-          return `"${name}": ${zodKeywordMapper.optional(objectValue)}`
+          return `"${propertyName}": ${zodKeywordMapper.optional(objectValue)}`
         }
 
         // null
         if (isNullable) {
-          return `"${name}": ${zodKeywordMapper.nullable(objectValue)}`
+          return `"${propertyName}": ${zodKeywordMapper.nullable(objectValue)}`
         }
 
-        return `"${name}": ${objectValue}`
+        return `"${propertyName}": ${objectValue}`
       })
       .join(',\n')
 
     const additionalProperties = current.args?.additionalProperties?.length
       ? current.args.additionalProperties
-          .map((schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options))
+          .map((it, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options))
           .filter(Boolean)
           .join('')
       : undefined
@@ -458,7 +459,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
 
   if (isKeyword(current, schemaKeywords.tuple)) {
     return zodKeywordMapper.tuple(
-      current.args.items.map((schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options)).filter(Boolean),
+      current.args.items.map((it, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean),
     )
   }
 

package/src/plugin.ts

@@ -1,6 +1,7 @@
 import path from 'node:path'
 import { createPlugin, type Group, getBarrelFiles, getMode, PackageManager, type Plugin, PluginManager } from '@kubb/core'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
+import { resolveModuleSource } from '@kubb/core/utils'
 import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
 import { OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
 import { pluginTsName } from '@kubb/plugin-ts'
@@ -112,6 +113,20 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
       const root = path.resolve(this.config.root, this.config.output.path)
       const mode = getMode(path.resolve(root, output.path))
 
+      if (this.plugin.options.typed && this.plugin.options.version === '3') {
+        // pre add bundled fetcher
+        await this.addFile({
+          baseName: 'ToZod.ts',
+          path: path.resolve(root, '.kubb/ToZod.ts'),
+          sources: [
+            {
+              name: 'ToZod',
+              value: resolveModuleSource('@kubb/plugin-zod/templates/ToZod').source,
+            },
+          ],
+        })
+      }
+
       const schemaGenerator = new SchemaGenerator(this.plugin.options, {
         fabric: this.fabric,
         oas,