@kubb/plugin-ts 5.0.0-beta.3 → 5.0.0-beta.31

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-beta.3",
-  "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
+  "version": "5.0.0-beta.31",
+  "description": "Generate TypeScript types, interfaces, and enums from your OpenAPI specification. The foundational plugin that powers type safety across the entire Kubb ecosystem.",
   "keywords": [
-    "code-generator",
+    "code-generation",
     "codegen",
+    "enums",
     "interfaces",
     "kubb",
-    "oas",
     "openapi",
-    "plugins",
     "swagger",
-    "type-definitions",
     "type-generation",
-    "type-safe",
     "types",
     "typescript"
   ],
@@ -27,7 +24,7 @@
   "files": [
     "src",
     "dist",
-    "plugin.json",
+    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -49,17 +46,18 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.3",
-    "@kubb/parser-ts": "5.0.0-beta.3",
-    "@kubb/renderer-jsx": "5.0.0-beta.3",
-    "remeda": "^2.34.0",
+    "@kubb/core": "5.0.0-beta.31",
+    "@kubb/parser-ts": "5.0.0-beta.31",
+    "@kubb/renderer-jsx": "5.0.0-beta.31",
+    "remeda": "^2.34.1",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
+    "@internals/shared": "0.0.0",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.3"
+    "@kubb/renderer-jsx": "5.0.0-beta.31"
   },
   "size-limit": [
     {

package/src/components/Enum.tsx

@@ -1,6 +1,6 @@
 import { camelCase, trimQuotes } from '@internals/utils'
 import type { ast } from '@kubb/core'
-import { safePrint } from '@kubb/parser-ts'
+import { parserTs } from '@kubb/parser-ts'
 import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import { ENUM_TYPES_WITH_KEY_SUFFIX, ENUM_TYPES_WITH_RUNTIME_VALUE, ENUM_TYPES_WITH_TYPE_ONLY } from '../constants.ts'
@@ -72,11 +72,11 @@ export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }
     <>
       {nameNode && (
         <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>
-          {safePrint(nameNode)}
+          {parserTs.print(nameNode)}
         </File.Source>
       )}
       <File.Source name={typeName} isIndexable isExportable={ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType)} isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumType)}>
-        {safePrint(typeNode)}
+        {parserTs.print(typeNode)}
       </File.Source>
     </>
   )

package/src/factory.ts

@@ -27,6 +27,10 @@ export const syntaxKind = {
   stringLiteral: SyntaxKind.StringLiteral,
 } as const
 
+function isNonNullable<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined
+}
+
 function isValidIdentifier(str: string): boolean {
   if (!str.length || str.trim() !== str) {
     return false
@@ -158,7 +162,9 @@ export function createPropertySignature({
   type?: ts.TypeNode
 }) {
   return factory.createPropertySignature(
-    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),
+    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(
+      (modifier): modifier is ts.Modifier => modifier !== undefined,
+    ),
     propertyName(name),
     createQuestionToken(questionToken),
     type,
@@ -192,7 +198,7 @@ export function createParameterSignature(
  * Creates a JSDoc comment node from an array of comment strings.
  * Returns null if no comments are provided.
  */
-export function createJSDoc({ comments }: { comments: string[] }) {
+export function createJSDoc({ comments }: { comments: Array<string> }) {
   if (!comments.length) {
     return null
   }
@@ -332,7 +338,7 @@ export function createTypeDeclaration({
 /**
  * Creates a TypeScript namespace declaration (exported module).
  */
-export function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {
+export function createNamespaceDeclaration({ statements, name }: { name: string; statements: Array<ts.Statement> }) {
   return factory.createModuleDeclaration(
     [factory.createToken(ts.SyntaxKind.ExportKeyword)],
     factory.createIdentifier(name),
@@ -366,13 +372,8 @@ export function createImportDeclaration({
   isNameSpace?: boolean
 }) {
   if (!Array.isArray(name)) {
-    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)
-    let importName: ts.NamedImportBindings | undefined
-
-    if (isNameSpace) {
-      importPropertyName = undefined
-      importName = factory.createNamespaceImport(factory.createIdentifier(name))
-    }
+    const importPropertyName = isNameSpace ? undefined : factory.createIdentifier(name)
+    const importName = isNameSpace ? factory.createNamespaceImport(factory.createIdentifier(name)) : undefined
 
     return factory.createImportDeclaration(
       undefined,
@@ -518,7 +519,7 @@ export function createEnumDeclaration({
    * Enum name in PascalCase.
    */
   typeName: string
-  enums: [key: string | number, value: string | number | boolean][]
+  enums: Array<[key: string | number, value: string | number | boolean]>
   /**
    * Choose the casing for enum key names.
    * @default 'none'
@@ -553,7 +554,7 @@ export function createEnumDeclaration({
 
               return undefined
             })
-            .filter(Boolean),
+            .filter((node): node is ts.LiteralTypeNode => node !== undefined),
         ),
       ),
     ]
@@ -563,7 +564,9 @@ export function createEnumDeclaration({
     return [
       undefined,
       factory.createEnumDeclaration(
-        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),
+        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(
+          (modifier): modifier is ts.ModifierToken<ts.SyntaxKind.ExportKeyword> | ts.ModifierToken<ts.SyntaxKind.ConstKeyword> => modifier !== undefined,
+        ),
         factory.createIdentifier(typeName),
         enums
           .map(([key, value]) => {
@@ -594,7 +597,7 @@ export function createEnumDeclaration({
 
             return undefined
           })
-          .filter(Boolean),
+          .filter((member): member is ts.EnumMember => member !== undefined),
       ),
     ]
   }
@@ -657,7 +660,7 @@ export function createEnumDeclaration({
 
                     return undefined
                   })
-                  .filter(Boolean),
+                  .filter((property): property is ts.PropertyAssignment => property !== undefined),
                 true,
               ),
               factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),
@@ -737,8 +740,8 @@ export function createUrlTemplateType(path: string): ts.TypeNode {
   }
 
   const segments = normalized.split(/(\{[^}]+\})/)
-  const parts: string[] = []
-  const parameterIndices: number[] = []
+  const parts: Array<string> = []
+  const parameterIndices: Array<number> = []
 
   segments.forEach((segment) => {
     if (segment.startsWith('{') && segment.endsWith('}')) {
@@ -750,7 +753,7 @@ export function createUrlTemplateType(path: string): ts.TypeNode {
   })
 
   const head = ts.factory.createTemplateHead(parts[0] || '')
-  const templateSpans: ts.TemplateLiteralTypeSpan[] = []
+  const templateSpans: Array<ts.TemplateLiteralTypeSpan> = []
 
   parameterIndices.forEach((paramIndex, i) => {
     const isLast = i === parameterIndices.length - 1
@@ -885,7 +888,7 @@ export function buildMemberNodes(
   members: Array<ast.SchemaNode> | undefined,
   print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined,
 ): Array<ts.TypeNode> {
-  return (members ?? []).map(print).filter(Boolean)
+  return (members ?? []).map(print).filter(isNonNullable)
 }
 
 /**
@@ -893,7 +896,7 @@ export function buildMemberNodes(
  * applying min/max slice and optional/rest element rules.
  */
 export function buildTupleNode(node: ast.ArraySchemaNode, print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined): ts.TypeNode | undefined {
-  let items = (node.items ?? []).map(print).filter(Boolean)
+  let items = (node.items ?? []).map(print).filter(isNonNullable)
 
   const restNode = node.rest ? (print(node.rest) ?? undefined) : undefined
   const { min, max } = node

package/src/generators/typeGenerator.tsx

@@ -1,14 +1,21 @@
+import { resolveContentTypeVariants } from '@internals/shared'
 import { ast, defineGenerator } from '@kubb/core'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
 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,
+  renderer: jsxRendererSync,
   schema(node, ctx) {
     const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
     const { adapter, config, resolver, root } = ctx
@@ -19,7 +26,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
     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)) {
@@ -30,14 +37,14 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     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 }),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group: group ?? undefined }),
     } as const
 
     const schemaPrinter = printerTs({
@@ -58,8 +65,8 @@ 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) => (
@@ -86,12 +93,15 @@ export const typeGenerator = defineGenerator<PluginTs>({
     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)) {
@@ -100,12 +110,12 @@ export const typeGenerator = defineGenerator<PluginTs>({
       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({
@@ -141,6 +151,34 @@ export const typeGenerator = defineGenerator<PluginTs>({
       )
     }
 
+    /**
+     * 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 })}
+        </>
+      )
+    }
+
     const paramTypes = params.map((param) =>
       renderSchemaType({
         schema: param.schema,
@@ -148,24 +186,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 +235,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 +270,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,27 +1,36 @@
-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' },
+ *       enumType: 'asConst',
+ *       optionalType: 'questionTokenAndUndefined',
+ *     }),
+ *   ],
  * })
  * ```
  */
@@ -45,17 +54,7 @@ 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, { suffix: 'Controller' })
 
   return {
     name: pluginTsName,

package/src/printers/printerTs.ts

@@ -1,11 +1,15 @@
 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.
  *
@@ -85,7 +89,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.
    */
@@ -163,7 +167,7 @@ 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
@@ -191,7 +195,7 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
           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
         }
@@ -224,7 +228,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 +236,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 +279,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 +320,7 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
         }),
       })
 
-      return safePrint(typeNode)
+      return parserTs.print(typeNode)
     },
   }
 })