@kubb/plugin-ts 5.0.0-beta.4 → 5.0.0-beta.56

package/src/generators/typeGenerator.tsx

@@ -1,3 +1,4 @@
+import { resolveContentTypeVariants } from '@internals/shared'
 import { ast, defineGenerator } from '@kubb/core'
 import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Type } from '../components/Type.tsx'
@@ -6,45 +7,52 @@ import { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types'
 import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
 
+/**
+ * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
+ * schema in the spec plus per-operation request, response, and parameter
+ * types. Drop-replace with a custom `Generator<PluginTs>` to change how
+ * TypeScript output is produced.
+ */
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   renderer: jsxRenderer,
   schema(node, ctx) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
+    const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
     const { adapter, config, resolver, root } = ctx
 
     if (!node.name) {
       return
     }
-    const mode = ctx.getMode(output)
     // Build a set of schema names that are enums so the ref handler and getImports
     // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
+    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)
 
     function resolveImportName(schemaName: string): string {
-      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
-        return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) {
+        return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix)
       }
       return resolver.resolveTypeName(schemaName)
     }
 
     const imports = adapter.getImports(node, (schemaName) => ({
       name: resolveImportName(schemaName),
-      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
     }))
 
     const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
 
     const meta = {
-      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
-      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
+      name:
+        ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema
+          ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix)
+          : resolver.resolveTypeName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group: group ?? undefined }),
     } as const
 
     const schemaPrinter = printerTs({
       optionalType,
       arrayType,
-      enumType,
-      enumTypeSuffix,
+      enum: enumOptions,
       name: meta.name,
       syntaxType,
       description: node.description,
@@ -58,61 +66,52 @@ export const typeGenerator = defineGenerator<PluginTs>({
         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 })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
-        {mode === 'split' &&
-          imports.map((imp) => (
-            <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
-          ))}
-        <Type
-          name={meta.name}
-          node={node}
-          enumType={enumType}
-          enumTypeSuffix={enumTypeSuffix}
-          enumKeyCasing={enumKeyCasing}
-          resolver={resolver}
-          printer={schemaPrinter}
-        />
+        {imports.map((imp) => (
+          <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
+        ))}
+        <Type name={meta.name} node={node} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />
       </File>
     )
   },
   operation(node, ctx) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options
+    const { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options
     const { adapter, config, resolver, root } = ctx
 
-    const mode = ctx.getMode(output)
-
     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 }),
+      file: resolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output, group: group ?? undefined },
+      ),
     } as const
 
     // Build a set of schema names that are enums so the ref handler and getImports
     // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
+    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)
 
     function resolveImportName(schemaName: string): string {
-      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
-        return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) {
+        return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix)
       }
       return resolver.resolveTypeName(schemaName)
     }
 
-    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {
       if (!schema) return null
 
       const imports = adapter.getImports(schema, (schemaName) => ({
         name: resolveImportName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
       }))
 
       const schemaPrinter = printerTs({
         optionalType,
         arrayType,
-        enumType,
-        enumTypeSuffix,
+        enum: enumOptions,
         name,
         syntaxType,
         description: schema.description,
@@ -124,19 +123,38 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
       return (
         <>
-          {mode === 'split' &&
-            imports.map((imp) => (
-              <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
-            ))}
-          <Type
-            name={name}
-            node={schema}
-            enumType={enumType}
-            enumTypeSuffix={enumTypeSuffix}
-            enumKeyCasing={enumKeyCasing}
-            resolver={resolver}
-            printer={schemaPrinter}
-          />
+          {imports.map((imp) => (
+            <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
+          ))}
+          <Type name={name} node={schema} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />
+        </>
+      )
+    }
+
+    /**
+     * Emits an individual type per content type plus a union alias under `baseName`.
+     * Shared by the request body and multi-content-type responses.
+     */
+    function buildContentTypeVariants(
+      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,
+      baseName: string,
+      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,
+    ) {
+      const variants = resolveContentTypeVariants(entries, baseName)
+      const unionSchema = ast.createSchema({
+        type: 'union',
+        members: variants.map((variant) => ast.createSchema({ type: 'ref', name: variant.name })),
+      })
+      return (
+        <>
+          {variants.map((variant) =>
+            renderSchemaType({
+              schema: decorate ? decorate(variant.schema) : variant.schema,
+              name: variant.name,
+              keysToOmit: variant.keysToOmit,
+            }),
+          )}
+          {renderSchemaType({ schema: unionSchema, name: baseName })}
         </>
       )
     }
@@ -148,24 +166,44 @@ export const typeGenerator = defineGenerator<PluginTs>({
       }),
     )
 
-    const requestType = node.requestBody?.content?.[0]?.schema
-      ? renderSchemaType({
+    const requestBodyContent = node.requestBody?.content ?? []
+
+    function buildRequestType() {
+      if (requestBodyContent.length === 0) return null
+      if (requestBodyContent.length === 1) {
+        const entry = requestBodyContent[0]!
+        if (!entry.schema) return null
+        return renderSchemaType({
           schema: {
-            ...node.requestBody.content![0]!.schema!,
-            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+            ...entry.schema,
+            description: node.requestBody!.description ?? entry.schema.description,
           },
           name: resolver.resolveDataName(node),
-          keysToOmit: node.requestBody.content![0]!.keysToOmit,
+          keysToOmit: entry.keysToOmit,
         })
-      : null
+      }
+      // Multiple content types — generate individual types + union alias
+      return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+        ...schema,
+        description: node.requestBody!.description ?? schema.description,
+      }))
+    }
 
-    const responseTypes = node.responses.map((res) =>
-      renderSchemaType({
-        schema: res.schema,
+    const requestType = buildRequestType()
+
+    const responseTypes = node.responses.map((res) => {
+      const variants = (res.content ?? []).filter((entry) => entry.schema)
+      // Multiple content types for a single status code — generate a union of the variants.
+      if (variants.length > 1) {
+        return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode))
+      }
+      const primary = variants[0] ?? res.content?.[0]
+      return renderSchemaType({
+        schema: primary?.schema ?? null,
         name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.keysToOmit,
-      }),
-    )
+        keysToOmit: primary?.keysToOmit,
+      })
+    })
 
     const dataType = renderSchemaType({
       schema: buildData({ ...node, parameters: params }, { resolver }),
@@ -177,26 +215,27 @@ export const typeGenerator = defineGenerator<PluginTs>({
       name: resolver.resolveResponsesName(node),
     })
 
-    const responseType = (() => {
-      if (!node.responses.some((res) => res.schema)) {
+    function buildResponseType() {
+      const hasSchema = (res: ast.ResponseNode) => (res.content ?? []).some((entry) => entry.schema)
+      if (!node.responses.some(hasSchema)) {
         return null
       }
 
       const responseName = resolver.resolveResponseName(node)
 
-      // Skip generating the response union type when an imported component schema
-      // has the same resolved name to avoid redeclaration errors.
-      const responsesWithSchema = node.responses.filter((res) => res.schema)
+      const responsesWithSchema = node.responses.filter(hasSchema)
       const importedNames = new Set(
         responsesWithSchema.flatMap((res) =>
-          res.schema
-            ? adapter
-                .getImports(res.schema, (schemaName) => ({
-                  name: resolveImportName(schemaName),
-                  path: '',
-                }))
-                .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
-            : [],
+          (res.content ?? []).flatMap((entry) =>
+            entry.schema
+              ? adapter
+                  .getImports(entry.schema, (schemaName) => ({
+                    name: resolveImportName(schemaName),
+                    path: '',
+                  }))
+                  .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
+              : [],
+          ),
         ),
       )
 
@@ -211,15 +250,17 @@ export const typeGenerator = defineGenerator<PluginTs>({
         },
         name: responseName,
       })
-    })()
+    }
+
+    const responseType = buildResponseType()
 
     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 })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
         {paramTypes}
         {responseTypes}

package/src/plugin.ts

@@ -1,40 +1,47 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
+import { createGroupConfig } from '@internals/shared'
+import { definePlugin } from '@kubb/core'
 import { typeGenerator } from './generators/typeGenerator.tsx'
 import { resolverTs } from './resolvers/resolverTs.ts'
 import type { PluginTs } from './types.ts'
 
 /**
- * Canonical plugin name for `@kubb/plugin-ts`, used to identify the plugin in driver lookups and warnings.
+ * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
+ * cross-plugin dependency references.
  */
 export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
 
 /**
- * The `@kubb/plugin-ts` plugin factory.
- *
- * Generates TypeScript type declarations from an OpenAPI/AST `RootNode`.
- * Walks schemas and operations, delegates rendering to the active generators,
- * and writes barrel files based on `output.barrelType`.
+ * Generates TypeScript `type` aliases and `interface` declarations from an
+ * OpenAPI spec. The foundation that every other Kubb plugin builds on:
+ * clients, query hooks, mocks, and validators all reference the names this
+ * plugin produces.
  *
  * @example
  * ```ts
- * import pluginTs from '@kubb/plugin-ts'
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
  *
  * export default defineConfig({
- *   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs({
+ *       output: { path: './types' },
+ *       enum: { type: 'asConst' },
+ *       optionalType: 'questionTokenAndUndefined',
+ *     }),
+ *   ],
  * })
  * ```
  */
 export const pluginTs = definePlugin<PluginTs>((options) => {
   const {
-    output = { path: 'types', barrelType: 'named' },
+    output = { path: 'types', barrel: { type: 'named' } },
     group,
     exclude = [],
     include,
     override = [],
-    enumType = 'asConst',
-    enumTypeSuffix = 'Key',
-    enumKeyCasing = 'none',
+    enum: enumOptions = {},
     optionalType = 'questionToken',
     arrayType = 'array',
     syntaxType = 'type',
@@ -45,17 +52,14 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     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
+  const groupConfig = createGroupConfig(group)
+
+  const resolvedEnum = {
+    type: enumOptions.type ?? 'asConst',
+    constCasing: enumOptions.constCasing ?? 'camelCase',
+    typeSuffix: enumOptions.typeSuffix ?? 'Key',
+    keyCasing: enumOptions.keyCasing ?? 'none',
+  }
 
   return {
     name: pluginTsName,
@@ -70,9 +74,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
           optionalType,
           group: groupConfig,
           arrayType,
-          enumType,
-          enumTypeSuffix,
-          enumKeyCasing,
+          enum: resolvedEnum,
           syntaxType,
           paramsCasing,
           printer,

package/src/printers/functionPrinter.ts

@@ -64,11 +64,11 @@ function rank(param: ast.FunctionParameterNode | ast.ParameterGroupNode): number
 }
 
 function sortParams(params: ReadonlyArray<ast.FunctionParameterNode | ast.ParameterGroupNode>): Array<ast.FunctionParameterNode | ast.ParameterGroupNode> {
-  return [...params].sort((a, b) => rank(a) - rank(b))
+  return params.toSorted((a, b) => rank(a) - rank(b))
 }
 
 function sortChildParams(params: Array<ast.FunctionParameterNode>): Array<ast.FunctionParameterNode> {
-  return [...params].sort((a, b) => rank(a) - rank(b))
+  return params.toSorted((a, b) => rank(a) - rank(b))
 }
 
 /**

package/src/printers/printerTs.ts

@@ -1,11 +1,16 @@
+import { extractRefName } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
-import { safePrint } from '@kubb/parser-ts'
+import { parserTs } from '@kubb/parser-ts'
 import type ts from 'typescript'
 import { ENUM_TYPES_WITH_KEY_SUFFIX, OPTIONAL_ADDS_QUESTION_TOKEN, OPTIONAL_ADDS_UNDEFINED } from '../constants.ts'
 import * as factory from '../factory.ts'
 import type { PluginTs, ResolverTs } from '../types.ts'
 import { buildPropertyJSDocComments } from '../utils.ts'
 
+function isNonNullable<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined
+}
+
 /**
  * Partial map of node-type overrides for the TypeScript printer.
  *
@@ -46,23 +51,11 @@ export type PrinterTsOptions = {
    */
   arrayType: PluginTs['resolvedOptions']['arrayType']
   /**
-   * Enum output format.
-   * - `'inlineLiteral'` embeds literal unions inline
-   * - `'asPascalConst'` generates named const unions
-   * - `'asConst'` generates as const declarations
-   *
-   * @default `'inlineLiteral'`
-   */
-  enumType: PluginTs['resolvedOptions']['enumType']
-  /**
-   * Suffix appended to enum key reference names.
-   *
-   * @example Enum key naming
-   * `StatusKey` when `enumType` is `'asConst'`
-   *
-   * @default `'Key'`
+   * Grouped enum settings. The printer emits references to enums, not the enum declarations, so only
+   * `type` (the output format) and `typeSuffix` (the enum key reference suffix) matter here.
+   * `constCasing` and `keyCasing` are ignored.
    */
-  enumTypeSuffix?: PluginTs['resolvedOptions']['enumTypeSuffix']
+  enum: PluginTs['resolvedOptions']['enum']
   /**
    * Syntax for generated declarations.
    * - `'type'` generates type aliases
@@ -85,7 +78,7 @@ export type PrinterTsOptions = {
    * Properties to exclude using `Omit<Type, Keys>`.
    * Forces type alias syntax regardless of `syntaxType` setting.
    */
-  keysToOmit?: Array<string>
+  keysToOmit?: Array<string> | null
   /**
    * Transforms raw schema names into valid TypeScript identifiers.
    */
@@ -120,13 +113,13 @@ type PrinterTs = PrinterTsFactory
  *
  * @example Raw type node (no `typeName`)
  * ```ts
- * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral' })
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })
  * const typeNode = printer.print(schemaNode) // ts.TypeNode
  * ```
  *
  * @example Full declaration (with `typeName`)
  * ```ts
- * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral', typeName: 'MyType' })
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
  * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
  * ```
  */
@@ -163,21 +156,21 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
       time: factory.dateOrStringNode,
       ref(node) {
         if (!node.name) {
-          return undefined
+          return null
         }
         // Parser-generated refs (with $ref) carry raw schema names that need resolving.
         // Use the canonical name from the $ref path — node.name may have been overridden
         // (e.g. by single-member allOf flatten using the property-derived child name).
         // Inline refs (without $ref) from utils already carry resolved type names.
-        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name) : node.name
+        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
 
         // When a Key suffix is configured, enum refs must use the suffixed name (e.g. `StatusKey`)
         // so the reference matches what the enum file actually exports.
         const isEnumRef =
-          node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && this.options.enumSchemaNames?.has(refName)
+          node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName)
 
         const name = isEnumRef
-          ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix!)
+          ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enum.typeSuffix)
           : node.ref
             ? this.options.resolver.default(refName, 'type')
             : refName
@@ -187,18 +180,18 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
       enum(node) {
         const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []
 
-        if (this.options.enumType === 'inlineLiteral' || !node.name) {
+        if (this.options.enum.type === 'inlineLiteral' || !node.name) {
           const literalNodes = values
             .filter((v): v is string | number | boolean => v !== null && v !== undefined)
             .map((value) => factory.constToTypeNode(value, typeof value as 'string' | 'number' | 'boolean'))
-            .filter(Boolean)
+            .filter(isNonNullable)
 
           return factory.createUnionDeclaration({ withParentheses: true, nodes: literalNodes }) ?? undefined
         }
 
         const resolvedName =
-          ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix
-            ? this.options.resolver.resolveEnumKeyName(node, this.options.enumTypeSuffix)
+          ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix
+            ? this.options.resolver.resolveEnumKeyName(node, this.options.enum.typeSuffix)
             : this.options.resolver.default(node.name, 'type')
 
         return factory.createTypeReferenceNode(resolvedName, undefined)
@@ -224,7 +217,7 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
 
               return this.transform(m)
             })
-            .filter(Boolean)
+            .filter(isNonNullable)
 
           return factory.createUnionDeclaration({ withParentheses: true, nodes: memberNodes }) ?? undefined
         }
@@ -232,15 +225,15 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
         return factory.createUnionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(members, this.transform) }) ?? undefined
       },
       intersection(node) {
-        return factory.createIntersectionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(node.members, this.transform) }) ?? undefined
+        return factory.createIntersectionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(node.members, this.transform) }) ?? null
       },
       array(node) {
-        const itemNodes = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
+        const itemNodes = (node.items ?? []).map((item) => this.transform(item)).filter(isNonNullable)
 
-        return factory.createArrayDeclaration({ nodes: itemNodes, arrayType: this.options.arrayType }) ?? undefined
+        return factory.createArrayDeclaration({ nodes: itemNodes, arrayType: this.options.arrayType }) ?? null
       },
       tuple(node) {
-        return factory.buildTupleNode(node, this.transform)
+        return factory.buildTupleNode(node, this.transform) ?? null
       },
       object(node) {
         const { transform, options } = this
@@ -275,36 +268,33 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
     print(node) {
       const { name, syntaxType = 'type', description, keysToOmit } = this.options
 
-      let base = this.transform(node)
-      if (!base) return null
+      const transformed = this.transform(node)
+      if (!transformed) return null
 
       // For ref nodes, structural metadata lives on node.schema rather than the ref node itself.
       const meta = ast.syncSchemaRef(node)
 
       // Without name, apply modifiers inline and return.
       if (!name) {
-        if (meta.nullable) {
-          base = factory.createUnionDeclaration({ nodes: [base, factory.keywordTypeNodes.null] })
-        }
-        if ((meta.nullish || meta.optional) && addsUndefined) {
-          base = factory.createUnionDeclaration({ nodes: [base, factory.keywordTypeNodes.undefined] })
-        }
-        return safePrint(base)
+        const withNullable = meta.nullable ? factory.createUnionDeclaration({ nodes: [transformed, factory.keywordTypeNodes.null] }) : transformed
+        const result =
+          (meta.nullish || meta.optional) && addsUndefined
+            ? factory.createUnionDeclaration({ nodes: [withNullable, factory.keywordTypeNodes.undefined] })
+            : withNullable
+        return parserTs.print(result)
       }
 
       // When keysToOmit is present, wrap with Omit first, then apply nullable/optional
       // modifiers so they are not swallowed by NonNullable inside createOmitDeclaration.
-      let inner: ts.TypeNode = keysToOmit?.length ? factory.createOmitDeclaration({ keys: keysToOmit, type: base, nonNullable: true }) : base
-
-      if (meta.nullable) {
-        inner = factory.createUnionDeclaration({ nodes: [inner, factory.keywordTypeNodes.null] })
-      }
-
-      // For named type declarations (type aliases), optional/nullish always produces | undefined
-      // regardless of optionalType — the questionToken ? modifier only applies to object properties.
-      if (meta.nullish || meta.optional) {
-        inner = factory.createUnionDeclaration({ nodes: [inner, factory.keywordTypeNodes.undefined] })
-      }
+      const inner = (() => {
+        const omitted: ts.TypeNode = keysToOmit?.length
+          ? factory.createOmitDeclaration({ keys: keysToOmit, type: transformed, nonNullable: true })
+          : transformed
+        const withNullable = meta.nullable ? factory.createUnionDeclaration({ nodes: [omitted, factory.keywordTypeNodes.null] }) : omitted
+        // For named type declarations (type aliases), optional/nullish always produces | undefined
+        // regardless of optionalType — the questionToken ? modifier only applies to object properties.
+        return meta.nullish || meta.optional ? factory.createUnionDeclaration({ nodes: [withNullable, factory.keywordTypeNodes.undefined] }) : withNullable
+      })()
 
       const useTypeGeneration = syntaxType === 'type' || inner.kind === factory.syntaxKind.union || !!keysToOmit?.length
 
@@ -319,7 +309,7 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
         }),
       })
 
-      return safePrint(typeNode)
+      return parserTs.print(typeNode)
     },
   }
 })