@kubb/plugin-zod 5.0.0-beta.10 → 5.0.0-beta.103

package/src/generators/zodGenerator.tsx

@@ -1,216 +0,0 @@
-import type { Adapter } from '@kubb/core'
-import { ast, defineGenerator } from '@kubb/core'
-import type { AdapterOas } from '@kubb/adapter-oas'
-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'
-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',
-  renderer: jsxRenderer,
-  schema(node, ctx) {
-    const { adapter, config, resolver, root } = ctx
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options
-    const dateType = (adapter as Adapter<AdapterOas>).options.dateType
-
-    if (!node.name) {
-      return
-    }
-
-    const mode = ctx.getMode(output)
-    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
-
-    const imports = adapter.getImports(node, (schemaName) => ({
-      name: resolver.resolveSchemaName(schemaName),
-      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
-    }))
-
-    const meta = {
-      name: resolver.resolveSchemaName(node.name),
-      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
-    } as const
-
-    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : undefined
-
-    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
-
-    const schemaPrinter = mini
-      ? printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
-      : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {mode === 'split' && imports.map((imp) => <File.Import key={[node.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
-
-        <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
-      </File>
-    )
-  },
-  operation(node, ctx) {
-    const { adapter, config, resolver, root } = ctx
-    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
-    const dateType = (adapter as Adapter<AdapterOas>).options.dateType
-
-    const mode = ctx.getMode(output)
-    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
-
-    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
-
-    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
-
-    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
-
-      const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolver.resolveSchemaName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
-      }))
-
-      const schemaPrinter = mini
-        ? printerZodMini({ guidType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
-        : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, keysToOmit, cyclicSchemas, 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} />)}
-          <Zod name={name} node={schema} printer={schemaPrinter} inferTypeName={inferTypeName} />
-        </>
-      )
-    }
-
-    const paramSchemas = params.map((param) => renderSchemaEntry({ schema: param.schema, name: resolver.resolveParamName(node, param) }))
-
-    const responseSchemas = node.responses.map((res) =>
-      renderSchemaEntry({
-        schema: res.schema,
-        name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.keysToOmit,
-      }),
-    )
-
-    const responsesWithSchema = node.responses.filter((res) => res.schema)
-    const responseUnionSchema =
-      responsesWithSchema.length > 0
-        ? (() => {
-            const responseUnionName = resolver.resolveResponseName(node)
-
-            // Collect all import names from response schemas to detect naming collisions.
-            // When a response is a $ref to a component schema whose resolved name matches
-            // the response union name, skip generation to avoid redeclaration errors.
-            const importedNames = new Set(
-              responsesWithSchema.flatMap((res) =>
-                res.schema
-                  ? adapter
-                      .getImports(res.schema, (schemaName) => ({
-                        name: resolver.resolveSchemaName(schemaName),
-                        path: '',
-                      }))
-                      .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
-                  : [],
-              ),
-            )
-
-            if (importedNames.has(responseUnionName)) {
-              return null
-            }
-
-            const members = responsesWithSchema.map((res) => ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) }))
-            const unionNode = members.length === 1 ? members[0]! : ast.createSchema({ type: 'union', members })
-
-            return renderSchemaEntry({
-              schema: unionNode,
-              name: responseUnionName,
-            })
-          })()
-        : null
-
-    const requestSchema = node.requestBody?.content?.[0]?.schema
-      ? renderSchemaEntry({
-          schema: {
-            ...node.requestBody.content![0]!.schema!,
-            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
-          },
-          name: resolver.resolveDataName(node),
-          keysToOmit: node.requestBody.content![0]!.keysToOmit,
-        })
-      : null
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {paramSchemas}
-        {responseSchemas}
-        {responseUnionSchema}
-        {requestSchema}
-      </File>
-    )
-  },
-  operations(nodes, ctx) {
-    const { adapter, config, resolver, root } = ctx
-    const { output, importPath, group, operations, paramsCasing } = ctx.options
-
-    if (!operations) {
-      return
-    }
-    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
-
-    const meta = {
-      file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group }),
-    } as const
-
-    const transformedOperations = nodes.map((node) => {
-      const params = ast.caseParams(node.parameters, paramsCasing)
-
-      return {
-        node,
-        data: buildSchemaNames(node, { params, resolver }),
-      }
-    })
-
-    const imports = transformedOperations.flatMap(({ node, data }) => {
-      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean) as string[]
-      const opFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
-
-      return names.map((name) => <File.Import key={[name, opFile.path].join('-')} name={[name]} root={meta.file.path} path={opFile.path} />)
-    })
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        <File.Import isTypeOnly name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {imports}
-        <Operations name="operations" operations={transformedOperations} />
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,11 +0,0 @@
-export { zodGenerator } from './generators/zodGenerator.tsx'
-
-export { default, 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'
-
-export type { PluginZod, ResolverZod } from './types.ts'

package/src/plugin.ts

@@ -1,94 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
-import { zodGenerator } from './generators/zodGenerator.tsx'
-import { resolverZod } from './resolvers/resolverZod.ts'
-import type { PluginZod } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
- */
-export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
-
-/**
- * Generates Zod validation schemas from an OpenAPI specification.
- * Walks schemas and operations, delegates to generators, and writes barrel files
- * based on the configured `barrelType`.
- *
- * @example Zod schema generator
- * ```ts
- * import pluginZod from '@kubb/plugin-zod'
- * export default defineConfig({
- *   plugins: [pluginZod({ output: { path: 'zod' } })]
- * })
- * ```
- */
-export const pluginZod = definePlugin<PluginZod>((options) => {
-  const {
-    output = { path: 'zod', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    typed = false,
-    operations = false,
-    mini = false,
-    guidType = 'uuid',
-    importPath = mini ? 'zod/mini' : 'zod',
-    coercion = false,
-    inferred = false,
-    wrapOutput = undefined,
-    paramsCasing,
-    printer,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  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,
-    options,
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        ctx.setOptions({
-          output,
-          exclude,
-          include,
-          override,
-          group: groupConfig,
-          typed,
-          importPath,
-          coercion,
-          operations,
-          inferred,
-          guidType,
-          mini,
-          wrapOutput,
-          paramsCasing,
-          printer,
-        })
-        ctx.setResolver(userResolver ? { ...resolverZod, ...userResolver } : resolverZod)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        ctx.addGenerator(zodGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-      },
-    },
-  }
-})
-
-export default pluginZod

package/src/printers/printerZod.ts

@@ -1,365 +0,0 @@
-import { stringify } from '@internals/utils'
-
-import { ast } from '@kubb/core'
-import type { PluginZod, ResolverZod } from '../types.ts'
-import { applyModifiers, formatLiteral, lengthConstraints, numberConstraints, shouldCoerce } from '../utils.ts'
-import type { AdapterOas } from '@kubb/adapter-oas'
-
-/**
- * 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 = ast.PrinterPartial<string, PrinterZodOptions>
-
-export type PrinterZodOptions = {
-  /**
-   * Enable automatic type coercion for strings, numbers, and dates.
-   */
-  coercion?: PluginZod['resolvedOptions']['coercion']
-  /**
-   * Use `z.guid()` or `z.uuid()` for UUID/GUID validation.
-   *
-   * @default 'uuid'
-   */
-  guidType?: PluginZod['resolvedOptions']['guidType']
-  /**
-   * Date format in the OpenAPI spec (`'date'` or `'date-time'`).
-   */
-  dateType?: AdapterOas['resolvedOptions']['dateType']
-  /**
-   * Hook to transform generated Zod schema before output.
-   */
-  wrapOutput?: PluginZod['resolvedOptions']['wrapOutput']
-  /**
-   * Transforms raw schema names into valid JavaScript identifiers.
-   */
-  resolver?: ResolverZod
-  /**
-   * Properties to exclude using `.omit({ key: true })`.
-   */
-  keysToOmit?: Array<string>
-  /**
-   * Schema names that form circular dependency chains.
-   * Properties referencing these emit lazy getters wrapping refs in `z.lazy(() => …)`.
-   */
-  cyclicSchemas?: ReadonlySet<string>
-  /**
-   * Custom handler map for node type overrides.
-   */
-  nodes?: PrinterZodNodes
-}
-
-/**
- * Factory options for the Zod printer, defining input/output types and configuration.
- */
-export type PrinterZodFactory = ast.PrinterFactoryOptions<'zod', PrinterZodOptions, string, string>
-
-function strictOneOfMember(member: string, node: ast.SchemaNode): string {
-  if (node.type === 'object' && node.additionalProperties === undefined) {
-    return `${member}.strict()`
-  }
-
-  if (node.type === 'ref') {
-    if (member.startsWith('z.lazy(')) {
-      return member
-    }
-
-    const schema = ast.syncSchemaRef(node)
-
-    if (schema.type === 'object' && (schema.additionalProperties === undefined || schema.additionalProperties === false)) {
-      return `${member}.strict()`
-    }
-  }
-
-  return member
-}
-
-/**
- * Zod v4 printer built with `definePrinter`.
- *
- * Converts a `SchemaNode` AST into a Zod v4 code string using the chainable API
- * (`.optional()`, `.nullable()`, `.omit()`, etc.). For improved tree-shaking, see {@link printerZodMini}.
- *
- * @example Chainable API
- * ```ts
- * const printer = printerZod({ coercion: false })
- * const code = printer.print(stringNode) // "z.string()"
- * ```
- */
-export const printerZod = ast.definePrinter<PrinterZodFactory>((options) => {
-  return {
-    name: 'zod',
-    options,
-    nodes: {
-      any: () => 'z.any()',
-      unknown: () => 'z.unknown()',
-      void: () => 'z.void()',
-      never: () => 'z.never()',
-      boolean: () => 'z.boolean()',
-      null: () => 'z.null()',
-      string(node) {
-        const base = shouldCoerce(this.options.coercion, 'strings') ? 'z.coerce.string()' : 'z.string()'
-
-        return `${base}${lengthConstraints(node)}`
-      },
-      number(node) {
-        const base = shouldCoerce(this.options.coercion, 'numbers') ? 'z.coerce.number()' : 'z.number()'
-
-        return `${base}${numberConstraints(node)}`
-      },
-      integer(node) {
-        const base = shouldCoerce(this.options.coercion, 'numbers') ? 'z.coerce.number().int()' : 'z.int()'
-
-        return `${base}${numberConstraints(node)}`
-      },
-      bigint() {
-        return shouldCoerce(this.options.coercion, 'numbers') ? 'z.coerce.bigint()' : 'z.bigint()'
-      },
-      date(node) {
-        if (node.representation === 'string') {
-          return 'z.iso.date()'
-        }
-
-        return shouldCoerce(this.options.coercion, 'dates') ? 'z.coerce.date()' : 'z.date()'
-      },
-      datetime(node) {
-        const offset = node.offset || this.options.dateType === 'stringOffset'
-        const local = node.local || this.options.dateType === 'stringLocal'
-
-        if (offset) return 'z.iso.datetime({ offset: true })'
-        if (local) return 'z.iso.datetime({ local: true })'
-
-        return 'z.iso.datetime()'
-      },
-      time(node) {
-        if (node.representation === 'string') {
-          return 'z.iso.time()'
-        }
-
-        return shouldCoerce(this.options.coercion, 'dates') ? 'z.coerce.date()' : 'z.date()'
-      },
-      uuid(node) {
-        const base = this.options.guidType === 'guid' ? 'z.guid()' : 'z.uuid()'
-
-        return `${base}${lengthConstraints(node)}`
-      },
-      email(node) {
-        return `z.email()${lengthConstraints(node)}`
-      },
-      url(node) {
-        return `z.url()${lengthConstraints(node)}`
-      },
-      ipv4: () => 'z.ipv4()',
-      ipv6: () => 'z.ipv6()',
-      blob: () => 'z.instanceof(File)',
-      enum(node) {
-        const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []
-        const nonNullValues = values.filter((v): v is string | number | boolean => v !== null)
-
-        // asConst-style enum: use z.union([z.literal(…), …])
-        if (node.namedEnumValues?.length) {
-          const literals = nonNullValues.map((v) => `z.literal(${formatLiteral(v)})`)
-
-          if (literals.length === 1) return literals[0]!
-          return `z.union([${literals.join(', ')}])`
-        }
-
-        // Regular enum: use z.enum([…])
-        return `z.enum([${nonNullValues.map(formatLiteral).join(', ')}])`
-      },
-      ref(node) {
-        if (!node.name) return undefined
-        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
-
-        if (node.ref && this.options.cyclicSchemas?.has(refName)) {
-          return `z.lazy(() => ${resolvedName})`
-        }
-
-        return resolvedName
-      },
-      object(node) {
-        const properties = node.properties
-          .map((prop) => {
-            const { name: propName, schema } = prop
-
-            const meta = ast.syncSchemaRef(schema)
-
-            const isNullable = meta.nullable
-            const isOptional = schema.optional
-            const isNullish = schema.nullish
-
-            const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas })
-            // Inside a getter the getter itself defers evaluation, so suppress
-            // z.lazy() wrapping on nested refs by temporarily clearing cyclicSchemas.
-            if (hasSelfRef) this.options.cyclicSchemas = undefined
-            const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: 'unknown' }))!
-            if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas
-
-            const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({ output: baseOutput, schema }) || baseOutput : baseOutput
-
-            // When a property schema is not a ref but the metadata is from a ref (e.g., discriminator
-            // property override), skip applying the description from the ref target to avoid applying
-            // metadata from a replaced schema.
-            let descriptionToApply = meta.description
-            if (schema.type !== 'ref' && meta.type === 'ref') {
-              descriptionToApply = undefined
-            }
-
-            const value = applyModifiers({
-              value: wrappedOutput,
-              nullable: isNullable,
-              optional: isOptional,
-              nullish: isNullish,
-              defaultValue: meta.default,
-              description: descriptionToApply,
-            })
-
-            if (hasSelfRef) {
-              return `get "${propName}"() { return ${value} }`
-            }
-            return `"${propName}": ${value}`
-          })
-          .join(',\n    ')
-
-        let result = `z.object({\n    ${properties}\n    })`
-
-        // Handle additionalProperties as .catchall() or .strict()
-        if (node.additionalProperties && node.additionalProperties !== true) {
-          const catchallType = this.transform(node.additionalProperties)
-          if (catchallType) {
-            result += `.catchall(${catchallType})`
-          }
-        } else if (node.additionalProperties === true) {
-          result += `.catchall(${this.transform(ast.createSchema({ type: 'unknown' }))})`
-        } else if (node.additionalProperties === false) {
-          result += '.strict()'
-        }
-
-        return result
-      },
-      array(node) {
-        const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
-        const inner = items.join(', ') || this.transform(ast.createSchema({ type: 'unknown' }))!
-        let result = `z.array(${inner})${lengthConstraints(node)}`
-
-        if (node.unique) {
-          result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`
-        }
-
-        return result
-      },
-      tuple(node) {
-        const items = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
-
-        return `z.tuple([${items.join(', ')}])`
-      },
-      union(node) {
-        const nodeMembers = node.members ?? []
-        const members = nodeMembers
-          .map((memberNode) => {
-            const member = this.transform(memberNode)
-
-            return member && node.strategy === 'one' ? strictOneOfMember(member, memberNode) : member
-          })
-          .filter(Boolean)
-        if (members.length === 0) return ''
-        if (members.length === 1) return members[0]!
-        if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === 'intersection')) {
-          // z.discriminatedUnion requires ZodObject members; intersections (ZodIntersection) are not
-          // assignable to $ZodDiscriminant, so fall back to z.union when any member is an intersection.
-          return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(', ')}])`
-        }
-
-        return `z.union([${members.join(', ')}])`
-      },
-      intersection(node) {
-        const members = node.members ?? []
-        if (members.length === 0) return ''
-
-        const [first, ...rest] = members
-        if (!first) return ''
-
-        let base = this.transform(first)
-        if (!base) return ''
-
-        for (const member of rest) {
-          if (member.primitive === '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 = ast.narrowSchema(member, 'number') ?? ast.narrowSchema(member, 'integer')
-            const c = numberConstraints(n ?? {})
-            if (c) {
-              base += c
-              continue
-            }
-          } else if (member.primitive === 'array') {
-            const a = ast.narrowSchema(member, 'array')
-            const c = lengthConstraints(a ?? {})
-            if (c) {
-              base += c
-              continue
-            }
-          }
-          const transformed = this.transform(member)
-          if (transformed) base = `${base}.and(${transformed})`
-        }
-
-        return base
-      },
-      ...options.nodes,
-    },
-    print(node) {
-      const { keysToOmit } = this.options
-
-      let base = this.transform(node)
-      if (!base) return null
-
-      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
-        // schema is a new non-nullable object type — skip optional/nullable/nullish.
-        // Discriminated unions (z.discriminatedUnion) do not support .omit(), so skip them.
-
-        // If this is a lazy reference, apply omit inside the lazy function
-        const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/)
-        if (lazyMatch) {
-          base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k: string) => `"${k}": true`).join(', ')} }))`
-        } else {
-          base = `${base}.omit({ ${keysToOmit.map((k: string) => `"${k}": true`).join(', ')} })`
-        }
-      }
-
-      return applyModifiers({
-        value: base,
-        nullable: meta.nullable,
-        optional: meta.optional,
-        nullish: meta.nullish,
-        defaultValue: meta.default,
-        description: meta.description,
-      })
-    },
-  }
-})