@kubb/plugin-ts 5.0.0-alpha.21 → 5.0.0-alpha.23

package/src/types.ts

@@ -1,6 +1,6 @@
+import type { OperationParamsResolver } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from '@kubb/ast/types'
 import type {
-  Builder,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -11,213 +11,94 @@ import type {
   PluginFactoryOptions,
   ResolvePathOptions,
   Resolver,
+  UserGroup,
 } from '@kubb/core'
 /**
  * The concrete resolver type for `@kubb/plugin-ts`.
  * Extends the base `Resolver` (which provides `default` and `resolveOptions`) with
  * plugin-specific naming helpers for operations, parameters, responses, and schemas.
  */
-export type ResolverTs = Resolver & {
-  /**
-   * Resolves the variable/function name for a given raw name (equivalent to `default(name, 'function')`).
-   * Use this shorthand when matching the `name` field produced by the v2 TypeGenerator,
-   * so call-sites don't need to repeat the `'function'` type literal.
-   *
-   * @example
-   * resolver.resolveName('list pets status 200') // → 'listPetsStatus200'
-   */
-  resolveName(name: string): string
-  /**
-   * Resolves the TypeScript type name for a given raw name (equivalent to `default(name, 'type')`).
-   * Use this shorthand when matching the `typedName` field produced by the v2 TypeGenerator,
-   * so call-sites don't need to repeat the `'type'` type literal.
-   *
-   * @example
-   * resolver.resolveTypedName('list pets status 200') // → 'ListPetsStatus200'
-   */
-  resolveTypedName(name: string): string
-  /**
-   * Resolves the file/path name for a given identifier using PascalCase.
-   *
-   * @example
-   * resolver.resolvePathName('list pets', 'file') // → 'ListPets'
-   */
-  resolvePathName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-  /**
-   * Resolves the variable/function name for an operation parameter.
-   * Encapsulates the `<operationId> <PascalCase(paramIn)> <paramName>` naming convention.
-   *
-   * @example
-   * resolver.resolveParamName(node, param) // → 'ListPetsQueryLimit'
-   */
-  resolveParamName(node: OperationNode, param: ParameterNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation parameter
-   * (equivalent to `resolveParamName` with `type: 'type'`).
-   * In the default implementation both return the same PascalCase string;
-   * the distinction is preserved so overrides can diverge the two forms.
-   *
-   * @example
-   * resolver.resolveParamTypedName(node, param) // → 'ListPetsQueryLimit'
-   */
-  resolveParamTypedName(node: OperationNode, param: ParameterNode): string
-  /**
-   * Resolves the variable/function name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example
-   * resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'
-   */
-  resolveResponseStatusName(node: OperationNode, statusCode: StatusCode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example
-   * resolver.resolveResponseStatusTypedName(node, 200) // → 'ListPetsStatus200'
-   */
-  resolveResponseStatusTypedName(node: OperationNode, statusCode: StatusCode): string
-  /**
-   * Resolves the variable/function name for an operation's request body (`Data`).
-   *
-   * @example
-   * resolver.resolveDataName(node) // → 'ListPetsData'
-   */
-  resolveDataName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's request body (`Data`).
-   *
-   * @example
-   * resolver.resolveDataTypedName(node) // → 'ListPetsData'
-   */
-  resolveDataTypedName(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for an operation's request config (`RequestConfig`).
-   *
-   * @example
-   * resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'
-   */
-  resolveRequestConfigName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an operation's request config (`RequestConfig`).
-   *
-   * @example
-   * resolver.resolveRequestConfigTypedName(node) // → 'ListPetsRequestConfig'
-   */
-  resolveRequestConfigTypedName(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for the collection of all operation responses (`Responses`).
-   *
-   * @example
-   * resolver.resolveResponsesName(node) // → 'ListPetsResponses'
-   */
-  resolveResponsesName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for the collection of all operation responses.
-   *
-   * @example
-   * resolver.resolveResponsesTypedName(node) // → 'ListPetsResponses'
-   */
-  resolveResponsesTypedName(node: OperationNode): string
-  /**
-   * Resolves the variable/function name for the union of all operation responses (`Response`).
-   *
-   * @example
-   * resolver.resolveResponseName(node) // → 'ListPetsResponse'
-   */
-  resolveResponseName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for the union of all operation responses.
-   *
-   * @example
-   * resolver.resolveResponseTypedName(node) // → 'ListPetsResponse'
-   */
-  resolveResponseTypedName(node: OperationNode): string
-  /**
-   * Resolves the TypeScript type alias name for an enum schema's key variant.
-   * Appends the `Key` suffix after applying the default naming convention.
-   *
-   * @example
-   * resolver.resolveEnumKeyTypedName(node) // → 'PetStatusKey'
-   */
-  resolveEnumKeyTypedName(node: SchemaNode): string
-  /**
-   * Resolves the variable/function name for an operation's grouped path parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — 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 with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — 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 with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — 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 with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — 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 with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — 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 with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolveHeaderParamsTypedName(node) // → 'DeletePetHeaderParams'
-   */
-  resolveHeaderParamsTypedName?(node: OperationNode): string
-}
+export type ResolverTs = Resolver &
+  OperationParamsResolver & {
+    /**
+     * Resolves the name for a given raw name (equivalent to `default(name, 'function')`).
+     * Since TypeScript only emits types, this is the canonical naming method.
+     *
+     * @example
+     * resolver.resolveName('list pets status 200') // → 'ListPetsStatus200'
+     */
+    resolveName(name: string): string
+    /**
+     * Resolves the file/path name for a given identifier using PascalCase.
+     *
+     * @example
+     * resolver.resolvePathName('list pets', 'file') // → 'ListPets'
+     */
+    resolvePathName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+    /** Resolves the request body type name (required on ResolverTs). */
+    resolveDataName(node: OperationNode): string
 
-type BuildParamsSchemaOptions = {
-  params: Array<ParameterNode>
-  node: OperationNode
-  resolver: ResolverTs
-}
-
-type BuildOperationSchemaOptions = {
-  node: OperationNode
-  resolver: ResolverTs
-}
-
-/**
- * The concrete builder type for `@kubb/plugin-ts`.
- * Extends the base `Builder` with schema-building helpers used by the v5 type generator.
- */
-export type BuilderTs = Builder & {
-  buildParams(options: BuildParamsSchemaOptions): SchemaNode
-  buildData(options: BuildOperationSchemaOptions): SchemaNode
-  buildResponses(options: BuildOperationSchemaOptions): SchemaNode | null
-  buildResponseUnion(options: BuildOperationSchemaOptions): SchemaNode | null
-}
+    /**
+     * Resolves the name for an operation response by status code.
+     * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
+     *
+     * @example
+     * resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'
+     */
+    resolveResponseStatusName(node: OperationNode, statusCode: StatusCode): string
+    /**
+     * Resolves the name for an operation's request config (`RequestConfig`).
+     *
+     * @example
+     * resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'
+     */
+    resolveRequestConfigName(node: OperationNode): string
+    /**
+     * Resolves the name for the collection of all operation responses (`Responses`).
+     *
+     * @example
+     * resolver.resolveResponsesName(node) // → 'ListPetsResponses'
+     */
+    resolveResponsesName(node: OperationNode): string
+    /**
+     * Resolves the name for the union of all operation responses (`Response`).
+     *
+     * @example
+     * resolver.resolveResponseName(node) // → 'ListPetsResponse'
+     */
+    resolveResponseName(node: OperationNode): string
+    /**
+     * Resolves the TypeScript type alias name for an enum schema's key variant.
+     * Appends `enumTypeSuffix` (default `'Key'`) after applying the default naming convention.
+     *
+     * @example
+     * resolver.resolveEnumKeyName(node, 'Key')   // → 'PetStatusKey'
+     * resolver.resolveEnumKeyName(node, 'Value') // → 'PetStatusValue'
+     * resolver.resolveEnumKeyName(node, '')      // → 'PetStatus'
+     */
+    resolveEnumKeyName(node: SchemaNode, enumTypeSuffix: string): string
+    /**
+     * Resolves the name for an operation's grouped path parameters type.
+     *
+     * @example
+     * resolver.resolvePathParamsName(node, param) // → 'GetPetByIdPathParams'
+     */
+    resolvePathParamsName(node: OperationNode, param: ParameterNode): string
+    /**
+     * Resolves the name for an operation's grouped query parameters type.
+     *
+     * @example
+     * resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'
+     */
+    resolveQueryParamsName(node: OperationNode, param: ParameterNode): string
+    /**
+     * Resolves the name for an operation's grouped header parameters type.
+     *
+     * @example
+     * resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'
+     */
+    resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string
+  }
 
 export type Options = {
   /**
@@ -233,7 +114,7 @@ export type Options = {
   /**
    * Group the clients based on the provided name.
    */
-  group?: Group
+  group?: UserGroup
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
    */
@@ -258,6 +139,15 @@ export type Options = {
    * @note In Kubb v5, 'inlineLiteral' becomes the default.
    */
   enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'
+  /**
+   * Suffix appended to the generated type alias name when `enumType` is `asConst` or `asPascalConst`.
+   *
+   * Only affects the type alias — the const object name is unchanged.
+   *
+   * @default 'Key'
+   * @example enumTypeSuffix: 'Value' → `export type PetStatusValue = …`
+   */
+  enumTypeSuffix?: string
   /**
    * Choose the casing for enum key names.
    * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
@@ -342,15 +232,15 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
-  group: Options['group']
+  group: Group | undefined
   enumType: NonNullable<Options['enumType']>
+  enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>
   enumKeyCasing: NonNullable<Options['enumKeyCasing']>
   optionalType: NonNullable<Options['optionalType']>
   arrayType: NonNullable<Options['arrayType']>
   syntaxType: NonNullable<Options['syntaxType']>
   paramsCasing: Options['paramsCasing']
-  resolver: ResolverTs
   transformers: Array<Visitor>
 }
 
-export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs, BuilderTs>
+export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>

package/src/utils.ts

@@ -0,0 +1,103 @@
+import { createProperty, createSchema } from '@kubb/ast'
+import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import type { ResolverTs } from './types.ts'
+
+type BuildParamsSchemaOptions = {
+  params: Array<ParameterNode>
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+type BuildOperationSchemaOptions = {
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+export function buildParams({ params, node, resolver }: BuildParamsSchemaOptions): SchemaNode {
+  return createSchema({
+    type: 'object',
+    properties: params.map((param) =>
+      createProperty({
+        name: param.name,
+        required: param.required,
+        schema: createSchema({
+          type: 'ref',
+          name: resolver.resolveParamName(node, param),
+        }),
+      }),
+    ),
+  })
+}
+
+export function buildData({ node, resolver }: BuildOperationSchemaOptions): SchemaNode {
+  const pathParams = node.parameters.filter((p) => p.in === 'path')
+  const queryParams = node.parameters.filter((p) => p.in === 'query')
+  const headerParams = node.parameters.filter((p) => p.in === 'header')
+
+  return createSchema({
+    type: 'object',
+    deprecated: node.deprecated,
+    properties: [
+      createProperty({
+        name: 'data',
+        schema: node.requestBody?.schema
+          ? createSchema({ type: 'ref', name: resolver.resolveDataName(node), optional: true })
+          : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'pathParams',
+        required: pathParams.length > 0,
+        schema: pathParams.length > 0 ? buildParams({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
+      }),
+      createProperty({
+        name: 'queryParams',
+        schema:
+          queryParams.length > 0
+            ? createSchema({ ...buildParams({ params: queryParams, node, resolver }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'headerParams',
+        schema:
+          headerParams.length > 0
+            ? createSchema({ ...buildParams({ params: headerParams, node, resolver }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'url',
+        required: true,
+        schema: createSchema({ type: 'url', path: node.path }),
+      }),
+    ],
+  })
+}
+
+export function buildResponses({ node, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  if (node.responses.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'object',
+    properties: node.responses.map((res) =>
+      createProperty({
+        name: String(res.statusCode),
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) }),
+      }),
+    ),
+  })
+}
+
+export function buildResponseUnion({ node, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  const responsesWithSchema = node.responses.filter((res) => res.schema)
+
+  if (responsesWithSchema.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'union',
+    members: responsesWithSchema.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+  })
+}

package/dist/Type-B6fo0gSk.js

@@ -1,120 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { t as camelCase } from "./casing-BJHFg-zZ.js";
-import { a as ENUM_TYPES_WITH_TYPE_ONLY, i as ENUM_TYPES_WITH_RUNTIME_VALUE, n as createEnumDeclaration, o as trimQuotes, r as ENUM_TYPES_WITH_KEY_SUFFIX, t as printerTs } from "./printerTs-BgZucv4T.js";
-import { collect, narrowSchema, schemaTypes } from "@kubb/ast";
-import { File } from "@kubb/react-fabric";
-import { safePrint } from "@kubb/fabric-core/parsers/typescript";
-import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-//#region src/components/Enum.tsx
-/**
-* 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.
-*/
-function getEnumNames({ node, enumType, resolver }) {
-	const resolved = resolver.default(node.name, "type");
-	return {
-		enumName: enumType === "asPascalConst" ? resolved : camelCase(node.name),
-		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : resolved,
-		refName: resolved
-	};
-}
-/**
-* 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
-* - 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.
-*/
-function Enum({ node, enumType, enumKeyCasing, resolver }) {
-	const { enumName, typeName, refName } = getEnumNames({
-		node,
-		enumType,
-		resolver
-	});
-	const [nameNode, typeNode] = createEnumDeclaration({
-		name: enumName,
-		typeName,
-		enums: node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
-		type: enumType,
-		enumKeyCasing
-	});
-	const needsRefAlias = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && refName !== typeName;
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		nameNode && /* @__PURE__ */ jsx(File.Source, {
-			name: enumName,
-			isExportable: true,
-			isIndexable: true,
-			isTypeOnly: false,
-			children: safePrint(nameNode)
-		}),
-		/* @__PURE__ */ jsx(File.Source, {
-			name: typeName,
-			isIndexable: true,
-			isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
-			isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
-			children: safePrint(typeNode)
-		}),
-		needsRefAlias && /* @__PURE__ */ jsx(File.Source, {
-			name: refName,
-			isExportable: true,
-			isIndexable: true,
-			isTypeOnly: true,
-			children: `export type ${refName} = ${typeName}`
-		})
-	] });
-}
-//#endregion
-//#region src/components/Type.tsx
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description, resolver }) {
-	const resolvedDescription = description || node?.description;
-	const enumSchemaNodes = collect(node, { schema(n) {
-		const enumNode = narrowSchema(n, schemaTypes.enum);
-		if (enumNode?.name) return enumNode;
-	} });
-	const output = printerTs({
-		optionalType,
-		arrayType,
-		enumType,
-		typeName: name,
-		syntaxType,
-		description: resolvedDescription,
-		keysToOmit,
-		resolver
-	}).print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames({
-				node,
-				enumType,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumType !== "inlineLiteral";
-	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enumType,
-		enumKeyCasing,
-		resolver
-	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-		name: typedName,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
-export { Enum as n, Type as t };
-
-//# sourceMappingURL=Type-B6fo0gSk.js.map

package/dist/Type-B6fo0gSk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Type-B6fo0gSk.js","names":["factory.createEnumDeclaration"],"sources":["../src/components/Enum.tsx","../src/components/Type.tsx"],"sourcesContent":["import { camelCase, trimQuotes } from '@internals/utils'\nimport type { EnumSchemaNode } from '@kubb/ast/types'\nimport { safePrint } from '@kubb/fabric-core/parsers/typescript'\nimport { File } from '@kubb/react-fabric'\nimport type { FabricReactNode } from '@kubb/react-fabric/types'\nimport { ENUM_TYPES_WITH_KEY_SUFFIX, ENUM_TYPES_WITH_RUNTIME_VALUE, ENUM_TYPES_WITH_TYPE_ONLY } from '../constants.ts'\nimport * as factory from '../factory.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\n\ntype Props = {\n  node: EnumSchemaNode\n  enumType: PluginTs['resolvedOptions']['enumType']\n  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']\n  resolver: ResolverTs\n}\n\n/**\n * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.\n *\n * The raw `node.name` may be a YAML key such as `\"enumNames.Type\"` which is not a\n * valid TypeScript identifier. The resolver normalizes it; for inline enum\n * properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.\n */\nexport function getEnumNames({ node, enumType, resolver }: { node: EnumSchemaNode; enumType: PluginTs['resolvedOptions']['enumType']; resolver: ResolverTs }): {\n  enumName: string\n  typeName: string\n  /**\n   * The PascalCase name that `$ref` importers will use to reference this enum type.\n   * For `asConst`/`asPascalConst` this differs from `typeName` (which has a `Key` suffix).\n   */\n  refName: string\n} {\n  const resolved = resolver.default(node.name!, 'type')\n  const enumName = enumType === 'asPascalConst' ? resolved : camelCase(node.name!)\n  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : resolved\n\n  return { enumName, typeName, refName: resolved }\n}\n\n/**\n * Renders the enum declaration(s) for a single named `EnumSchemaNode`.\n *\n * Depending on `enumType` this may emit:\n * - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias\n * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)\n * - A union literal type alias (`literal`)\n *\n * The emitted `File.Source` nodes carry the resolved names so that the barrel\n * index picks up the correct export identifiers.\n */\nexport function Enum({ node, enumType, enumKeyCasing, resolver }: Props): FabricReactNode {\n  const { enumName, typeName, refName } = getEnumNames({ node, enumType, resolver })\n\n  const [nameNode, typeNode] = factory.createEnumDeclaration({\n    name: enumName,\n    typeName,\n    enums: (node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ??\n      node.enumValues?.filter((v): v is NonNullable<typeof v> => v !== null && v !== undefined).map((v) => [trimQuotes(v.toString()), v]) ??\n      []) as unknown as Array<[string, string]>,\n    type: enumType,\n    enumKeyCasing,\n  })\n\n  const needsRefAlias = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && refName !== typeName\n\n  return (\n    <>\n      {nameNode && (\n        <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>\n          {safePrint(nameNode)}\n        </File.Source>\n      )}\n      <File.Source name={typeName} isIndexable isExportable={ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType)} isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumType)}>\n        {safePrint(typeNode)}\n      </File.Source>\n      {needsRefAlias && (\n        <File.Source name={refName} isExportable isIndexable isTypeOnly>\n          {`export type ${refName} = ${typeName}`}\n        </File.Source>\n      )}\n    </>\n  )\n}\n","import { collect, narrowSchema, schemaTypes } from '@kubb/ast'\nimport type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'\nimport { File } from '@kubb/react-fabric'\nimport type { FabricReactNode } from '@kubb/react-fabric/types'\nimport { printerTs } from '../printers/printerTs.ts'\nimport type { PluginTs } from '../types.ts'\nimport { Enum, getEnumNames } from './Enum.tsx'\n\ntype Props = {\n  name: string\n  typedName: string\n  node: SchemaNode\n  optionalType: PluginTs['resolvedOptions']['optionalType']\n  arrayType: PluginTs['resolvedOptions']['arrayType']\n  enumType: PluginTs['resolvedOptions']['enumType']\n  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']\n  syntaxType: PluginTs['resolvedOptions']['syntaxType']\n  resolver: PluginTs['resolvedOptions']['resolver']\n  description?: string\n  keysToOmit?: string[]\n}\n\nexport function Type({\n  name,\n  typedName,\n  node,\n  keysToOmit,\n  optionalType,\n  arrayType,\n  syntaxType,\n  enumType,\n  enumKeyCasing,\n  description,\n  resolver,\n}: Props): FabricReactNode {\n  const resolvedDescription = description || node?.description\n  const enumSchemaNodes = collect<EnumSchemaNode>(node, {\n    schema(n): EnumSchemaNode | undefined {\n      const enumNode = narrowSchema(n, schemaTypes.enum)\n      if (enumNode?.name) return enumNode\n    },\n  })\n\n  const printer = printerTs({ optionalType, arrayType, enumType, typeName: name, syntaxType, description: resolvedDescription, keysToOmit, resolver })\n  const output = printer.print(node)\n\n  if (!output) {\n    return\n  }\n\n  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {\n    return {\n      node,\n      ...getEnumNames({ node, enumType, resolver }),\n    }\n  })\n\n  // Skip enum exports when using inlineLiteral\n  const shouldExportEnums = enumType !== 'inlineLiteral'\n  const shouldExportType = enumType === 'inlineLiteral' || enums.every((item) => item.typeName !== name)\n\n  return (\n    <>\n      {shouldExportEnums && enums.map(({ node }) => <Enum node={node} enumType={enumType} enumKeyCasing={enumKeyCasing} resolver={resolver} />)}\n      {shouldExportType && (\n        <File.Source name={typedName} isTypeOnly isExportable isIndexable>\n          {output}\n        </File.Source>\n      )}\n    </>\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,SAAgB,aAAa,EAAE,MAAM,UAAU,YAQ7C;CACA,MAAM,WAAW,SAAS,QAAQ,KAAK,MAAO,OAAO;AAIrD,QAAO;EAAE,UAHQ,aAAa,kBAAkB,WAAW,UAAU,KAAK,KAAM;EAG7D,UAFF,2BAA2B,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO;EAElD,SAAS;EAAU;;;;;;;;;;;;;AAclD,SAAgB,KAAK,EAAE,MAAM,UAAU,eAAe,YAAoC;CACxF,MAAM,EAAE,UAAU,UAAU,YAAY,aAAa;EAAE;EAAM;EAAU;EAAU,CAAC;CAElF,MAAM,CAAC,UAAU,YAAYA,sBAA8B;EACzD,MAAM;EACN;EACA,OAAQ,KAAK,iBAAiB,KAAK,MAAM,CAAC,WAAW,EAAE,KAAK,UAAU,CAAC,EAAE,EAAE,MAAM,CAAC,IAChF,KAAK,YAAY,QAAQ,MAAkC,MAAM,QAAQ,MAAM,KAAA,EAAU,CAAC,KAAK,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,IACnI,EAAE;EACJ,MAAM;EACN;EACD,CAAC;CAEF,MAAM,gBAAgB,2BAA2B,IAAI,SAAS,IAAI,YAAY;AAE9E,QACE,qBAAA,UAAA,EAAA,UAAA;EACG,YACC,oBAAC,KAAK,QAAN;GAAa,MAAM;GAAU,cAAA;GAAa,aAAA;GAAY,YAAY;aAC/D,UAAU,SAAS;GACR,CAAA;EAEhB,oBAAC,KAAK,QAAN;GAAa,MAAM;GAAU,aAAA;GAAY,cAAc,8BAA8B,IAAI,SAAS;GAAE,YAAY,0BAA0B,IAAI,SAAS;aACpJ,UAAU,SAAS;GACR,CAAA;EACb,iBACC,oBAAC,KAAK,QAAN;GAAa,MAAM;GAAS,cAAA;GAAa,aAAA;GAAY,YAAA;aAClD,eAAe,QAAQ,KAAK;GACjB,CAAA;EAEf,EAAA,CAAA;;;;AC1DP,SAAgB,KAAK,EACnB,MACA,WACA,MACA,YACA,cACA,WACA,YACA,UACA,eACA,aACA,YACyB;CACzB,MAAM,sBAAsB,eAAe,MAAM;CACjD,MAAM,kBAAkB,QAAwB,MAAM,EACpD,OAAO,GAA+B;EACpC,MAAM,WAAW,aAAa,GAAG,YAAY,KAAK;AAClD,MAAI,UAAU,KAAM,QAAO;IAE9B,CAAC;CAGF,MAAM,SADU,UAAU;EAAE;EAAc;EAAW;EAAU,UAAU;EAAM;EAAY,aAAa;EAAqB;EAAY;EAAU,CAAC,CAC7H,MAAM,KAAK;AAElC,KAAI,CAAC,OACH;CAGF,MAAM,QAAQ,CAAC,GAAG,IAAI,IAAI,gBAAgB,KAAK,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,SAAS;AACzF,SAAO;GACL;GACA,GAAG,aAAa;IAAE;IAAM;IAAU;IAAU,CAAC;GAC9C;GACD;CAGF,MAAM,oBAAoB,aAAa;CACvC,MAAM,mBAAmB,aAAa,mBAAmB,MAAM,OAAO,SAAS,KAAK,aAAa,KAAK;AAEtG,QACE,qBAAA,UAAA,EAAA,UAAA,CACG,qBAAqB,MAAM,KAAK,EAAE,WAAW,oBAAC,MAAD;EAAY;EAAgB;EAAyB;EAAyB;EAAY,CAAA,CAAC,EACxI,oBACC,oBAAC,KAAK,QAAN;EAAa,MAAM;EAAW,YAAA;EAAW,cAAA;EAAa,aAAA;YACnD;EACW,CAAA,CAEf,EAAA,CAAA"}