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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-beta.42",
+  "version": "5.0.0-beta.56",
   "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-generation",
@@ -24,7 +24,6 @@
   "files": [
     "src",
     "dist",
-    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -46,9 +45,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.42",
-    "@kubb/parser-ts": "5.0.0-beta.42",
-    "@kubb/renderer-jsx": "5.0.0-beta.42",
+    "@kubb/ast": "5.0.0-beta.55",
+    "@kubb/core": "5.0.0-beta.55",
+    "@kubb/parser-ts": "5.0.0-beta.55",
+    "@kubb/renderer-jsx": "5.0.0-beta.55",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
@@ -56,21 +56,14 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.42"
+    "@kubb/renderer-jsx": "5.0.0-beta.55"
   },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
-    }
-  ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsdown && size-limit",
-    "clean": "npx rimraf ./dist",
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",

package/src/components/Enum.tsx

@@ -1,4 +1,5 @@
-import { camelCase, trimQuotes } from '@internals/utils'
+import { camelCase } from '@internals/utils'
+import { trimQuotes } from '@kubb/ast/utils'
 import type { ast } from '@kubb/core'
 import { parserTs } from '@kubb/parser-ts'
 import { File } from '@kubb/renderer-jsx'
@@ -7,11 +8,11 @@ import { ENUM_TYPES_WITH_KEY_SUFFIX, ENUM_TYPES_WITH_RUNTIME_VALUE, ENUM_TYPES_W
 import * as factory from '../factory.ts'
 import type { PluginTs, ResolverTs } from '../types.ts'
 
+type EnumOptions = PluginTs['resolvedOptions']['enum']
+
 type Props = {
   node: ast.EnumSchemaNode
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
+  enum: EnumOptions
   resolver: ResolverTs
   key?: string | number | null
 }
@@ -20,26 +21,19 @@ type Props = {
  * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
  *
  * The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
- * valid TypeScript identifier. The resolver normalizes it; for inline enum
- * properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
+ * valid TypeScript identifier. The resolver normalizes it. For inline enum properties the adapter
+ * already emits a PascalCase+suffix name, so resolution is typically a no-op.
+ *
+ * When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type
+ * resolve to the same name, which TypeScript merges into a single value+type declaration.
  */
-export function getEnumNames({
-  node,
-  enumType,
-  enumTypeSuffix,
-  resolver,
-}: {
-  node: ast.EnumSchemaNode
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  resolver: ResolverTs
-}): {
+export function getEnumNames({ node, enum: enumOptions, resolver }: { node: ast.EnumSchemaNode; enum: EnumOptions; resolver: ResolverTs }): {
   enumName: string
   typeName: string
 } {
   const resolved = resolver.default(node.name!, 'type')
-  const enumName = enumType === 'asPascalConst' ? resolved : camelCase(node.name!)
-  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
+  const enumName = enumOptions.constCasing === 'pascalCase' ? resolved : camelCase(node.name!)
+  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolved
 
   return { enumName, typeName }
 }
@@ -47,16 +41,16 @@ export function getEnumNames({
 /**
  * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
  *
- * Depending on `enumType` this may emit:
- * - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
+ * Depending on `enum.type` this may emit:
+ * - A runtime object (`asConst`) plus a `typeof` type alias
  * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
  * - A union literal type alias (`literal`)
  *
  * The emitted `File.Source` nodes carry the resolved names so that the barrel
  * index picks up the correct export identifiers.
  */
-export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): KubbReactNode {
-  const { enumName, typeName } = getEnumNames({ node, enumType, enumTypeSuffix, resolver })
+export function Enum({ node, enum: enumOptions, resolver }: Props): KubbReactNode {
+  const { enumName, typeName } = getEnumNames({ node, enum: enumOptions, resolver })
 
   const [nameNode, typeNode] = factory.createEnumDeclaration({
     name: enumName,
@@ -64,10 +58,15 @@ export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }
     enums: (node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ??
       node.enumValues?.filter((v): v is NonNullable<typeof v> => v !== null && v !== undefined).map((v) => [trimQuotes(v.toString()), v]) ??
       []) as Array<[string | number, string | number | boolean]>,
-    type: enumType,
-    enumKeyCasing,
+    type: enumOptions.type,
+    enumKeyCasing: enumOptions.keyCasing,
   })
 
+  // When the const and the type share a name (pascalCase const + empty typeSuffix) they merge into
+  // one declaration. The const carries the barrel export, so keep the type alias in the file but out
+  // of the barrel to avoid re-exporting the name a second time as `export type { … }`.
+  const namesMerge = !!nameNode && enumName === typeName
+
   return (
     <>
       {nameNode && (
@@ -75,7 +74,12 @@ export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }
           {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)}>
+      <File.Source
+        name={typeName}
+        isIndexable={!namesMerge}
+        isExportable={!namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type)}
+        isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type)}
+      >
         {parserTs.print(typeNode)}
       </File.Source>
     </>

package/src/components/Type.tsx

@@ -13,13 +13,11 @@ type Props = {
    * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
    */
   printer: ast.Printer<PrinterTsFactory>
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
+  enum: PluginTs['resolvedOptions']['enum']
   resolver: ResolverTs
 }
 
-export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): KubbReactNode {
+export function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode {
   const enumSchemaNodes = ast.collect<ast.EnumSchemaNode>(node, {
     schema(n): ast.EnumSchemaNode | undefined {
       const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum)
@@ -36,20 +34,17 @@ export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCas
   const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
     return {
       node,
-      ...getEnumNames({ node, enumType, enumTypeSuffix, resolver }),
+      ...getEnumNames({ node, enum: enumOptions, resolver }),
     }
   })
 
   // Skip enum exports when using inlineLiteral
-  const shouldExportEnums = enumType !== 'inlineLiteral'
-  const shouldExportType = enumType === 'inlineLiteral' || enums.every((item) => item.typeName !== name)
+  const shouldExportEnums = enumOptions.type !== 'inlineLiteral'
+  const shouldExportType = enumOptions.type === 'inlineLiteral' || enums.every((item) => item.typeName !== name)
 
   return (
     <>
-      {shouldExportEnums &&
-        enums.map(({ node }) => (
-          <Enum key={node.name} node={node} enumType={enumType} enumTypeSuffix={enumTypeSuffix} enumKeyCasing={enumKeyCasing} resolver={resolver} />
-        ))}
+      {shouldExportEnums && enums.map(({ node }) => <Enum key={node.name} node={node} enum={enumOptions} resolver={resolver} />)}
       {shouldExportType && (
         <File.Source name={name} isTypeOnly isExportable isIndexable>
           {output}

package/src/constants.ts

@@ -1,7 +1,7 @@
 import type { PluginTs } from './types.ts'
 
 type OptionalType = PluginTs['resolvedOptions']['optionalType']
-type EnumType = PluginTs['resolvedOptions']['enumType']
+type EnumType = PluginTs['resolvedOptions']['enum']['type']
 
 /**
  * `optionalType` values that cause a property's type to include `| undefined`.
@@ -14,19 +14,19 @@ export const OPTIONAL_ADDS_UNDEFINED = new Set<OptionalType>(['undefined', 'ques
 export const OPTIONAL_ADDS_QUESTION_TOKEN = new Set<OptionalType>(['questionToken', 'questionTokenAndUndefined'] as const)
 
 /**
- * `enumType` values that append a `Key` suffix to the generated enum type alias.
+ * `enum.type` values that append a `typeSuffix` to the generated enum type alias.
  */
-export const ENUM_TYPES_WITH_KEY_SUFFIX = new Set<EnumType>(['asConst', 'asPascalConst'] as const)
+export const ENUM_TYPES_WITH_KEY_SUFFIX = new Set<EnumType>(['asConst'] as const)
 
 /**
- * `enumType` values that require a runtime value declaration (object, enum, or literal).
+ * `enum.type` values that require a runtime value declaration (object, enum, or literal).
  */
-export const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set<EnumType | undefined>(['enum', 'asConst', 'asPascalConst', 'constEnum', 'literal', undefined] as const)
+export const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set<EnumType | undefined>(['enum', 'asConst', 'constEnum', 'literal', undefined] as const)
 
 /**
- * `enumType` values whose type declaration is type-only (no runtime value emitted for the type alias).
+ * `enum.type` values whose type declaration is type-only (no runtime value emitted for the type alias).
  */
-export const ENUM_TYPES_WITH_TYPE_ONLY = new Set<EnumType | undefined>(['asConst', 'asPascalConst', 'literal', undefined] as const)
+export const ENUM_TYPES_WITH_TYPE_ONLY = new Set<EnumType | undefined>(['asConst', 'literal', undefined] as const)
 
 /**
  * Ordering priority for function parameters: lower = sorted earlier.

package/src/factory.ts

@@ -361,18 +361,6 @@ export function createTypeDeclaration({
   })
 }
 
-/**
- * Creates a TypeScript namespace declaration (exported module).
- */
-export function createNamespaceDeclaration({ statements, name }: { name: string; statements: Array<ts.Statement> }) {
-  return factory.createModuleDeclaration(
-    [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-    factory.createIdentifier(name),
-    factory.createModuleBlock(statements),
-    ts.NodeFlags.Namespace,
-  )
-}
-
 /**
  * Creates an import declaration with support for default imports, named imports, namespace imports, and type-only imports.
  * Optionally rename imported members with `propertyName` and `name` pairs.
@@ -528,15 +516,14 @@ export function createEnumDeclaration({
   enumKeyCasing = 'none',
 }: {
   /**
-   * Choose to use `enum`, `asConst`, `asPascalConst`, `constEnum`, or `literal` for enums.
+   * Choose to use `enum`, `asConst`, `constEnum`, or `literal` for enums.
    * - `enum`: TypeScript enum
-   * - `asConst`: const with camelCase name (e.g., `petType`)
-   * - `asPascalConst`: const with PascalCase name (e.g., `PetType`)
+   * - `asConst`: const object asserted with `as const` (the caller decides the const name casing)
    * - `constEnum`: const enum
    * - `literal`: literal union type
    * @default `'enum'`
    */
-  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'
+  type?: 'enum' | 'asConst' | 'constEnum' | 'literal' | 'inlineLiteral'
   /**
    * Enum name in camelCase.
    */
@@ -629,8 +616,8 @@ export function createEnumDeclaration({
   }
 
   // used when using `as const` instead of an TypeScript enum.
-  // name is already PascalCase for asPascalConst and camelCase for asConst (set in Type.tsx)
-  // typeName has the Key suffix for type alias, so we use name for the const identifier
+  // name is already cased by the caller (camelCase or pascalCase, driven by enum.constCasing).
+  // typeName carries the typeSuffix for the type alias, so we use name for the const identifier.
   const identifierName = name
 
   // When there are no enum items (empty or all-null enum), don't generate a runtime const.
@@ -816,21 +803,11 @@ export const createStringLiteral = factory.createStringLiteral
  */
 export const createArrayTypeNode = factory.createArrayTypeNode
 
-/**
- * Creates a parenthesized type node to control operator precedence.
- */
-export const createParenthesizedType = factory.createParenthesizedType
-
 /**
  * Creates a literal type node (e.g., `'hello'`, `42`, `true`).
  */
 export const createLiteralTypeNode = factory.createLiteralTypeNode
 
-/**
- * Creates a null literal type node.
- */
-export const createNull = factory.createNull
-
 /**
  * Creates an identifier node.
  */
@@ -861,16 +838,6 @@ export const createTrue = factory.createTrue
  */
 export const createFalse = factory.createFalse
 
-/**
- * Creates an indexed access type node (e.g., `T[K]`).
- */
-export const createIndexedAccessTypeNode = factory.createIndexedAccessTypeNode
-
-/**
- * Creates a type operator node (e.g., `keyof T`, `readonly T[]`).
- */
-export const createTypeOperatorNode = factory.createTypeOperatorNode
-
 /**
  * Creates a prefix unary expression (e.g., negative numbers, logical not).
  */

package/src/generators/typeGenerator.tsx

@@ -1,6 +1,6 @@
 import { resolveContentTypeVariants } from '@internals/shared'
 import { ast, defineGenerator } from '@kubb/core'
-import { File, jsxRendererSync } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } 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'
@@ -15,22 +15,21 @@ import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
  */
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
-  renderer: jsxRendererSync,
+  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<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)
     }
@@ -43,15 +42,17 @@ export const typeGenerator = defineGenerator<PluginTs>({
     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),
+      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,
@@ -68,28 +69,17 @@ export const typeGenerator = defineGenerator<PluginTs>({
         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 = {
@@ -104,8 +94,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
     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)
     }
@@ -121,8 +111,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       const schemaPrinter = printerTs({
         optionalType,
         arrayType,
-        enumType,
-        enumTypeSuffix,
+        enum: enumOptions,
         name,
         syntaxType,
         description: schema.description,
@@ -134,19 +123,10 @@ 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} />
         </>
       )
     }

package/src/plugin.ts

@@ -27,7 +27,7 @@ export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
  *   plugins: [
  *     pluginTs({
  *       output: { path: './types' },
- *       enumType: 'asConst',
+ *       enum: { type: 'asConst' },
  *       optionalType: 'questionTokenAndUndefined',
  *     }),
  *   ],
@@ -36,14 +36,12 @@ export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
  */
 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',
@@ -54,7 +52,14 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
+  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,
@@ -69,9 +74,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
           optionalType,
           group: groupConfig,
           arrayType,
-          enumType,
-          enumTypeSuffix,
-          enumKeyCasing,
+          enum: resolvedEnum,
           syntaxType,
           paramsCasing,
           printer,

package/src/printers/printerTs.ts

@@ -1,3 +1,4 @@
+import { extractRefName } from '@kubb/ast/utils'
 import { ast } from '@kubb/core'
 import { parserTs } from '@kubb/parser-ts'
 import type ts from 'typescript'
@@ -50,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
@@ -124,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
  * ```
  */
@@ -173,15 +162,15 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
         // 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
@@ -191,7 +180,7 @@ 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'))
@@ -201,8 +190,8 @@ export const printerTs = ast.definePrinter<PrinterTs>((options) => {
         }
 
         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)

package/src/resolvers/resolverTs.ts

@@ -1,4 +1,4 @@
-import { ensureValidVarName, pascalCase } from '@internals/utils'
+import { ensureValidVarName, pascalCase, toFilePath } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginTs } from '../types.ts'
 
@@ -9,7 +9,7 @@ import type { PluginTs } from '../types.ts'
  * casing/file-layout rules.
  *
  * The `default` method is supplied by `defineResolver`. It uses PascalCase for
- * type names and PascalCase-with-isFile for files.
+ * type names and PascalCase file paths (dotted names become `/`-joined) for files.
  *
  * @example Resolve a type and file name
  * ```ts
@@ -25,15 +25,15 @@ export const resolverTs = defineResolver<PluginTs>(() => {
     name: 'default',
     pluginName: 'plugin-ts',
     default(name, type) {
-      const resolved = pascalCase(name, { isFile: type === 'file' })
-      return type === 'file' ? resolved : ensureValidVarName(resolved)
+      if (type === 'file') return toFilePath(name, pascalCase)
+      return ensureValidVarName(pascalCase(name))
     },
     resolveTypeName(name) {
       return ensureValidVarName(pascalCase(name))
     },
     resolvePathName(name, type) {
-      const resolved = pascalCase(name, { isFile: type === 'file' })
-      return type === 'file' ? resolved : ensureValidVarName(resolved)
+      if (type === 'file') return toFilePath(name, pascalCase)
+      return ensureValidVarName(pascalCase(name))
     },
     resolveParamName(node, param) {
       return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`)