@kubb/plugin-ts 5.0.0-alpha.11 → 5.0.0-alpha.13

package/dist/resolvers.d.ts

@@ -0,0 +1,51 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { r as ResolverTs } from "./types-BSRhtbGl.js";
+
+//#region src/resolvers/resolverTs.d.ts
+/**
+ * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
+ * helpers used by the plugin. Import this in other plugins to resolve the exact names and
+ * paths that `plugin-ts` generates without hardcoding the conventions.
+ *
+ * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
+ * for identifiers/files and `pascalCase` for type names.
+ *
+ * @example
+ * ```ts
+ * import { resolver } from '@kubb/plugin-ts'
+ *
+ * resolver.default('list pets', 'type')              // → 'ListPets'
+ * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
+ * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
+ * resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+ * ```
+ */
+declare const resolverTs: ResolverTs;
+//#endregion
+//#region src/resolvers/resolverTsLegacy.d.ts
+/**
+ * Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions
+ * used before the v2 resolver refactor. Enable via `legacy: true` in plugin options.
+ *
+ * Key differences from the default resolver:
+ * - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`
+ * - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`
+ * - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)
+ * - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`
+ * - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`
+ *
+ * @example
+ * ```ts
+ * import { resolverTsLegacy } from '@kubb/plugin-ts'
+ *
+ * resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'
+ * resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'
+ * resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)
+ * resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)
+ * resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)
+ * ```
+ */
+declare const resolverTsLegacy: ResolverTs;
+//#endregion
+export { resolverTs, resolverTsLegacy };
+//# sourceMappingURL=resolvers.d.ts.map

package/dist/resolvers.js

@@ -0,0 +1,2 @@
+import { n as resolverTs, t as resolverTsLegacy } from "./resolvers-CH7hINyz.js";
+export { resolverTs, resolverTsLegacy };

package/dist/{types-mSXmB8WU.d.ts → types-BSRhtbGl.d.ts}

@@ -1,9 +1,9 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
 import { Group, Output, PluginFactoryOptions, ResolveNameParams, Resolver } from "@kubb/core";
-import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
-import { Generator as Generator$1 } from "@kubb/plugin-oas/generators";
-import { Oas, contentType } from "@kubb/oas";
 import { OperationNode, ParameterNode, SchemaNode, StatusCode } from "@kubb/ast/types";
+import { Oas, contentType } from "@kubb/oas";
+import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
+import { Generator } from "@kubb/plugin-oas/generators";
 
 //#region src/types.d.ts
 /**
@@ -135,6 +135,60 @@ type ResolverTs = Resolver & {
    * resolver.resolveEnumKeyTypedName(node) // → 'PetStatusKey'
    */
   resolveEnumKeyTypedName(node: SchemaNode): string;
+  /**
+   * Resolves the variable/function name for an operation's grouped path parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamName` per individual parameter instead.
+   * @example
+   * resolver.resolvePathParamsName(node) // → 'GetPetByIdPathParams'
+   */
+  resolvePathParamsName?(node: OperationNode): string;
+  /**
+   * Resolves the TypeScript type alias name for an operation's grouped path parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamTypedName` per individual parameter instead.
+   * @example
+   * resolver.resolvePathParamsTypedName(node) // → 'GetPetByIdPathParams'
+   */
+  resolvePathParamsTypedName?(node: OperationNode): string;
+  /**
+   * Resolves the variable/function name for an operation's grouped query parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamName` per individual parameter instead.
+   * @example
+   * resolver.resolveQueryParamsName(node) // → 'FindPetsByStatusQueryParams'
+   */
+  resolveQueryParamsName?(node: OperationNode): string;
+  /**
+   * Resolves the TypeScript type alias name for an operation's grouped query parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamTypedName` per individual parameter instead.
+   * @example
+   * resolver.resolveQueryParamsTypedName(node) // → 'FindPetsByStatusQueryParams'
+   */
+  resolveQueryParamsTypedName?(node: OperationNode): string;
+  /**
+   * Resolves the variable/function name for an operation's grouped header parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamName` per individual parameter instead.
+   * @example
+   * resolver.resolveHeaderParamsName(node) // → 'DeletePetHeaderParams'
+   */
+  resolveHeaderParamsName?(node: OperationNode): string;
+  /**
+   * Resolves the TypeScript type alias name for an operation's grouped header parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamTypedName` per individual parameter instead.
+   * @example
+   * resolver.resolveHeaderParamsTypedName(node) // → 'DeletePetHeaderParams'
+   */
+  resolveHeaderParamsTypedName?(node: OperationNode): string;
 };
 type Options = {
   /**
@@ -192,52 +246,6 @@ type Options = {
    * @default 'type'
    */
   syntaxType?: 'type' | 'interface';
-  /**
-   * Set a suffix for the generated enums.
-   * @default 'enum'
-   * @deprecated Set `enumSuffix` on the adapter (`adapterOas({ enumSuffix })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  enumSuffix?: string;
-  /**
-   * Choose to use date or datetime as JavaScript Date instead of string.
-   * - 'string' represents dates as string values.
-   * - 'date' represents dates as JavaScript Date objects.
-   * @default 'string'
-   * @deprecated Set `dateType` on the adapter (`adapterOas({ dateType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  dateType?: 'string' | 'date';
-  /**
-   * Choose to use `number` or `bigint` for integer fields with `int64` format.
-   * - 'number' uses the TypeScript `number` type (matches JSON.parse() runtime behavior).
-   * - 'bigint' uses the TypeScript `bigint` type (accurate for values exceeding Number.MAX_SAFE_INTEGER).
-   * @note in v5 of Kubb 'bigint' will become the default to better align with OpenAPI's int64 specification.
-   * @default 'number'
-   * @deprecated Set `integerType` on the adapter (`adapterOas({ integerType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  integerType?: 'number' | 'bigint';
-  /**
-   * Which type to use when the Swagger/OpenAPI file is not providing more information.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default 'any'
-   * @deprecated Set `unknownType` on the adapter (`adapterOas({ unknownType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  unknownType?: 'any' | 'unknown' | 'void';
-  /**
-   * Which type to use for empty schema values.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default `unknownType`
-   * @deprecated Set `emptySchemaType` on the adapter (`adapterOas({ emptySchemaType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void';
   /**
    * Choose what to use as mode for an optional value.
    * - 'questionToken' marks the property as optional with ? (e.g., type?: string).
@@ -269,11 +277,22 @@ type Options = {
   /**
    * Define some generators next to the ts generators
    */
-  generators?: Array<Generator$1<PluginTs>>;
+  generators?: Array<Generator<PluginTs>>;
   /**
    * Unstable naming for v5
    */
   UNSTABLE_NAMING?: true;
+  /**
+   * Enable legacy naming conventions for backwards compatibility.
+   * When enabled, operation-level types use the old naming scheme:
+   * - GET responses → `<OperationId>QueryResponse`, `<OperationId>Query`
+   * - Non-GET responses → `<OperationId>MutationResponse`, `<OperationId>Mutation`
+   * - Request body → `<OperationId>QueryRequest` / `<OperationId>MutationRequest`
+   * - Response status codes → `<OperationId><StatusCode>` (e.g. `CreatePets201`)
+   * - Default/error response → `<OperationId>Error`
+   * @default false
+   */
+  legacy?: boolean;
 };
 type ResolvedOptions = {
   output: Output<Oas>;
@@ -281,18 +300,22 @@ type ResolvedOptions = {
   override: NonNullable<Options['override']>;
   enumType: NonNullable<Options['enumType']>;
   enumKeyCasing: NonNullable<Options['enumKeyCasing']>;
-  enumSuffix: NonNullable<Options['enumSuffix']>;
-  dateType: NonNullable<Options['dateType']>;
-  integerType: NonNullable<Options['integerType']>;
-  unknownType: NonNullable<Options['unknownType']>;
-  emptySchemaType: NonNullable<Options['emptySchemaType']>;
   optionalType: NonNullable<Options['optionalType']>;
   arrayType: NonNullable<Options['arrayType']>;
   transformers: NonNullable<Options['transformers']>;
   syntaxType: NonNullable<Options['syntaxType']>;
   paramsCasing: Options['paramsCasing'];
+  legacy: NonNullable<Options['legacy']>;
+  resolver: ResolverTs;
+  /**
+   * The base resolver without any `transformers.name` wrapping.
+   * Used internally to derive enum prefix names so that user-defined
+   * name transformations (e.g. appending `Type`) are not embedded in
+   * the middle of inline-enum identifiers.
+   */
+  baseResolver?: ResolverTs;
 };
 type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>;
 //#endregion
-export { PluginTs as n, Options as t };
-//# sourceMappingURL=types-mSXmB8WU.d.ts.map
+export { PluginTs as n, ResolverTs as r, Options as t };
+//# sourceMappingURL=types-BSRhtbGl.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.11",
+  "version": "5.0.0-alpha.13",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -39,6 +39,10 @@
       "import": "./dist/generators.js",
       "require": "./dist/generators.cjs"
     },
+    "./resolvers": {
+      "import": "./dist/resolvers.js",
+      "require": "./dist/resolvers.cjs"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
@@ -49,6 +53,9 @@
       ],
       "generators": [
         "./dist/generators.d.ts"
+      ],
+      "resolvers": [
+        "./dist/resolvers.d.ts"
       ]
     }
   },
@@ -71,10 +78,10 @@
     "@kubb/react-fabric": "0.14.0",
     "remeda": "^2.33.6",
     "typescript": "5.9.3",
-    "@kubb/ast": "5.0.0-alpha.11",
-    "@kubb/core": "5.0.0-alpha.11",
-    "@kubb/oas": "5.0.0-alpha.11",
-    "@kubb/plugin-oas": "5.0.0-alpha.11"
+    "@kubb/ast": "5.0.0-alpha.13",
+    "@kubb/core": "5.0.0-alpha.13",
+    "@kubb/oas": "5.0.0-alpha.13",
+    "@kubb/plugin-oas": "5.0.0-alpha.13"
   },
   "peerDependencies": {
     "@kubb/react-fabric": "0.14.0"

package/src/components/{v2/Enum.tsx → Enum.tsx}

@@ -1,31 +1,40 @@
-import { camelCase, pascalCase, trimQuotes } from '@internals/utils'
+import { camelCase, trimQuotes } from '@internals/utils'
 import type { EnumSchemaNode } from '@kubb/ast/types'
 import { safePrint } from '@kubb/fabric-core/parsers/typescript'
 import { File } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import { ENUM_TYPES_WITH_KEY_SUFFIX, ENUM_TYPES_WITH_RUNTIME_VALUE, ENUM_TYPES_WITH_TYPE_ONLY } from '../../constants.ts'
-import * as factory from '../../factory.ts'
-import type { PluginTs } from '../../types.ts'
+import { ENUM_TYPES_WITH_KEY_SUFFIX, ENUM_TYPES_WITH_RUNTIME_VALUE, ENUM_TYPES_WITH_TYPE_ONLY } from '../constants.ts'
+import * as factory from '../factory.ts'
+import type { PluginTs, ResolverTs } from '../types.ts'
 
 type Props = {
   node: EnumSchemaNode
   enumType: PluginTs['resolvedOptions']['enumType']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
+  resolver: ResolverTs
 }
 
 /**
  * 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. `pascalCase` normalizes it unconditionally; for inline enum
- * properties the adapter already emits a PascalCase+suffix name so `pascalCase` is 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.
  */
-export function getEnumNames(node: EnumSchemaNode, enumType: PluginTs['resolvedOptions']['enumType']): { enumName: string; typeName: string } {
-  const resolved = pascalCase(node.name!)
+export function getEnumNames({ node, enumType, resolver }: { node: EnumSchemaNode; enumType: PluginTs['resolvedOptions']['enumType']; resolver: ResolverTs }): {
+  enumName: string
+  typeName: string
+  /**
+   * The PascalCase name that `$ref` importers will use to reference this enum type.
+   * For `asConst`/`asPascalConst` this differs from `typeName` (which has a `Key` suffix).
+   */
+  refName: 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) ? `${resolved}Key` : resolved
 
-  return { enumName, typeName }
+  return { enumName, typeName, refName: resolved }
 }
 
 /**
@@ -39,8 +48,8 @@ export function getEnumNames(node: EnumSchemaNode, enumType: PluginTs['resolvedO
  * 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, enumKeyCasing }: Props): FabricReactNode {
-  const { enumName, typeName } = getEnumNames(node, enumType)
+export function Enum({ node, enumType, enumKeyCasing, resolver }: Props): FabricReactNode {
+  const { enumName, typeName, refName } = getEnumNames({ node, enumType, resolver })
 
   const [nameNode, typeNode] = factory.createEnumDeclaration({
     name: enumName,
@@ -52,6 +61,8 @@ export function Enum({ node, enumType, enumKeyCasing }: Props): FabricReactNode
     enumKeyCasing,
   })
 
+  const needsRefAlias = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && refName !== typeName
+
   return (
     <>
       {nameNode && (
@@ -62,6 +73,11 @@ export function Enum({ node, enumType, enumKeyCasing }: Props): FabricReactNode
       <File.Source name={typeName} isIndexable isExportable={ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType)} isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumType)}>
         {safePrint(typeNode)}
       </File.Source>
+      {needsRefAlias && (
+        <File.Source name={refName} isExportable isIndexable isTypeOnly>
+          {`export type ${refName} = ${typeName}`}
+        </File.Source>
+      )}
     </>
   )
 }

package/src/components/Type.tsx

@@ -1,24 +1,23 @@
-import { camelCase, jsStringEscape, pascalCase, trimQuotes } from '@internals/utils'
+import { collect } from '@kubb/ast'
+import type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'
 import { safePrint } from '@kubb/fabric-core/parsers/typescript'
-import type { SchemaObject } from '@kubb/oas'
-import { isKeyword, type Schema, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
 import { File } from '@kubb/react-fabric'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type ts from 'typescript'
-import * as factory from '../factory.ts'
-import { parse, typeKeywordMapper } from '../parser.ts'
+import { printerTs } from '../printer.ts'
 import type { PluginTs } from '../types.ts'
+import { Enum, getEnumNames } from './Enum.tsx'
 
 type Props = {
   name: string
   typedName: string
-  schema: SchemaObject
-  tree: Array<Schema>
+  node: SchemaNode
   optionalType: PluginTs['resolvedOptions']['optionalType']
   arrayType: PluginTs['resolvedOptions']['arrayType']
   enumType: PluginTs['resolvedOptions']['enumType']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
   syntaxType: PluginTs['resolvedOptions']['syntaxType']
+  resolver: PluginTs['resolvedOptions']['resolver']
+  legacy?: boolean
   description?: string
   keysToOmit?: string[]
 }
@@ -26,131 +25,34 @@ type Props = {
 export function Type({
   name,
   typedName,
-  tree,
+  node,
   keysToOmit,
-  schema,
   optionalType,
   arrayType,
   syntaxType,
   enumType,
   enumKeyCasing,
   description,
+  resolver,
 }: Props): FabricReactNode {
-  const typeNodes: ts.Node[] = []
-
-  if (!tree.length) {
-    return ''
-  }
-
-  const schemaFromTree = tree.find((item) => item.keyword === schemaKeywords.schema)
-  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum)
-
-  let type =
-    (tree
-      .map((current, _index, siblings) =>
-        parse(
-          { name, schema, parent: undefined, current, siblings },
-          {
-            optionalType,
-            arrayType,
-            enumType,
-          },
-        ),
-      )
-      .filter(Boolean)
-      .at(0) as ts.TypeNode) || typeKeywordMapper.undefined()
-
-  // Add a "Key" suffix to avoid collisions where necessary
-  if (['asConst', 'asPascalConst'].includes(enumType) && enumSchemas.length > 0) {
-    const isDirectEnum = schema.type === 'array' && schema.items !== undefined
-    const isEnumOnly = 'enum' in schema && schema.enum
-
-    if (isDirectEnum || isEnumOnly) {
-      const enumSchema = enumSchemas[0]!
-      const typeNameWithKey = `${enumSchema.args.typeName}Key`
-
-      type = factory.createTypeReferenceNode(typeNameWithKey)
-
-      if (schema.type === 'array') {
-        if (arrayType === 'generic') {
-          type = factory.createTypeReferenceNode(factory.createIdentifier('Array'), [type])
-        } else {
-          type = factory.createArrayTypeNode(type)
-        }
-      }
-    }
-  }
-
-  if (schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.schema)) {
-    const isNullish = tree.some((item) => item.keyword === schemaKeywords.nullish)
-    const isNullable = tree.some((item) => item.keyword === schemaKeywords.nullable)
-    const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional)
+  const resolvedDescription = description || node?.description
+  const enumSchemaNodes = collect<EnumSchemaNode>(node, {
+    schema(n): EnumSchemaNode | undefined {
+      if (n.type === 'enum' && n.name) return n as EnumSchemaNode
+    },
+  })
 
-    if (isNullable) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.null],
-      }) as ts.TypeNode
-    }
+  const printer = printerTs({ optionalType, arrayType, enumType, typeName: name, syntaxType, description: resolvedDescription, keysToOmit, resolver })
+  const typeNode = printer.print(node)
 
-    if (isNullish && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.undefined],
-      }) as ts.TypeNode
-    }
-
-    if (isOptional && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.undefined],
-      }) as ts.TypeNode
-    }
+  if (!typeNode) {
+    return
   }
 
-  const useTypeGeneration = syntaxType === 'type' || [factory.syntaxKind.union].includes(type.kind as typeof factory.syntaxKind.union) || !!keysToOmit?.length
-
-  typeNodes.push(
-    factory.createTypeDeclaration({
-      name,
-      isExportable: true,
-      type: keysToOmit?.length
-        ? factory.createOmitDeclaration({
-            keys: keysToOmit,
-            type,
-            nonNullable: true,
-          })
-        : type,
-      syntax: useTypeGeneration ? 'type' : 'interface',
-      comments: [
-        schema.title ? `${jsStringEscape(schema.title)}` : undefined,
-        description ? `@description ${jsStringEscape(description)}` : undefined,
-        schema.deprecated ? '@deprecated' : undefined,
-        schema.minLength ? `@minLength ${schema.minLength}` : undefined,
-        schema.maxLength ? `@maxLength ${schema.maxLength}` : undefined,
-        schema.pattern ? `@pattern ${schema.pattern}` : undefined,
-        schema.default ? `@default ${schema.default}` : undefined,
-        schema.example ? `@example ${schema.example}` : undefined,
-      ],
-    }),
-  )
-
-  const enums = [...new Set(enumSchemas)].map((enumSchema) => {
-    const name = enumType === 'asPascalConst' ? pascalCase(enumSchema.args.name) : camelCase(enumSchema.args.name)
-    const typeName = ['asConst', 'asPascalConst'].includes(enumType) ? `${enumSchema.args.typeName}Key` : enumSchema.args.typeName
-
-    const [nameNode, typeNode] = factory.createEnumDeclaration({
-      name,
-      typeName,
-      enums: enumSchema.args.items
-        .map((item) => (item.value === undefined ? undefined : [trimQuotes(item.name?.toString()), item.value]))
-        .filter(Boolean) as unknown as Array<[string, string]>,
-      type: enumType,
-      enumKeyCasing,
-    })
-
+  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
     return {
-      nameNode,
-      typeNode,
-      name,
-      typeName,
+      node,
+      ...getEnumNames({ node, enumType, resolver }),
     }
   })
 
@@ -160,29 +62,10 @@ export function Type({
 
   return (
     <>
-      {shouldExportEnums &&
-        enums.map(({ name, nameNode, typeName, typeNode }) => (
-          <>
-            {nameNode && (
-              <File.Source name={name} isExportable isIndexable isTypeOnly={false}>
-                {safePrint(nameNode)}
-              </File.Source>
-            )}
-            {
-              <File.Source
-                name={typeName}
-                isIndexable
-                isExportable={['enum', 'asConst', 'asPascalConst', 'constEnum', 'literal', undefined].includes(enumType)}
-                isTypeOnly={['asConst', 'asPascalConst', 'literal', undefined].includes(enumType)}
-              >
-                {safePrint(typeNode)}
-              </File.Source>
-            }
-          </>
-        ))}
+      {shouldExportEnums && enums.map(({ node }) => <Enum node={node} enumType={enumType} enumKeyCasing={enumKeyCasing} resolver={resolver} />)}
       {shouldExportType && (
         <File.Source name={typedName} isTypeOnly isExportable isIndexable>
-          {safePrint(...typeNodes)}
+          {safePrint(typeNode)}
         </File.Source>
       )}
     </>

package/src/components/index.ts

@@ -1 +1,2 @@
+export { Enum } from './Enum.tsx'
 export { Type } from './Type.tsx'

package/src/generators/index.ts

@@ -1,2 +1 @@
 export { typeGenerator } from './typeGenerator.tsx'
-export { typeGenerator as typeGeneratorV2 } from './v2/typeGenerator.tsx'