@kubb/plugin-ts 5.0.0 → 5.0.2

package/dist/index.d.ts

@@ -110,7 +110,7 @@ type PrinterTsFactory = ast.PrinterFactoryOptions<'typescript', PrinterTsOptions
  * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
  * ```
  */
-declare const printerTs: (options?: PrinterTsOptions | undefined) => ast.Printer<PrinterTsFactory>;
+export declare const printerTs: (options?: PrinterTsOptions | undefined) => ast.Printer<PrinterTsFactory>;
 //#endregion
 //#region src/types.d.ts
 /**
@@ -457,7 +457,7 @@ type Props$1 = {
  * The emitted `File.Source` nodes carry the resolved names so that the barrel
  * index picks up the correct export identifiers.
  */
-declare function Enum({ node, enum: enumOptions, resolver }: Props$1): KubbReactNode;
+export declare function Enum({ node, enum: enumOptions, resolver }: Props$1): KubbReactNode;
 //#endregion
 //#region src/components/Type.d.ts
 type Props = {
@@ -471,7 +471,7 @@ type Props = {
   enum: PluginTs['resolvedOptions']['enum'];
   resolver: ResolverTs;
 };
-declare function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode;
+export declare function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
 /**
@@ -480,14 +480,14 @@ declare function Type({ name, node, printer, enum: enumOptions, resolver }: Prop
  * types. Drop-replace with a custom `Generator<PluginTs>` to change how
  * TypeScript output is produced.
  */
-declare const typeGenerator: import("kubb/kit").Generator<PluginTs, unknown>;
+export declare const typeGenerator: import("kubb/kit").Generator<PluginTs, unknown>;
 //#endregion
 //#region src/plugin.d.ts
 /**
  * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
  * cross-plugin dependency references.
  */
-declare const pluginTsName = "plugin-ts";
+export declare const pluginTsName = "plugin-ts";
 /**
  * Generates TypeScript `type` aliases and `interface` declarations from an
  * OpenAPI spec. The foundation that every other Kubb plugin builds on:
@@ -512,7 +512,7 @@ declare const pluginTsName = "plugin-ts";
  * })
  * ```
  */
-declare const pluginTs: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginTs>;
+export declare const pluginTs: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginTs>;
 //#endregion
 //#region src/printers/functionParams.d.ts
 /**
@@ -646,7 +646,7 @@ type FunctionParametersNode = {
  * // { petId: string }
  * ```
  */
-declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode;
+export declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode;
 /**
  * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
  *
@@ -656,7 +656,7 @@ declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLi
  * // DeletePetPathParams['petId']
  * ```
  */
-declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode;
+export declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode;
 /**
  * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
  *
@@ -666,7 +666,7 @@ declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kin
  * // { id, name }
  * ```
  */
-declare function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode;
+export declare function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode;
 /**
  * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
  */
@@ -703,7 +703,7 @@ type FunctionParameterInput = {
  * // → { id, name }: { id: string; name?: string } = {}
  * ```
  */
-declare function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode;
+export declare function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode;
 /**
  * Creates a {@link FunctionParametersNode} from an ordered list of parameters.
  *
@@ -713,7 +713,7 @@ declare function createFunctionParameter(input: FunctionParameterInput): Functio
  * // { params: [] }
  * ```
  */
-declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+export declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
 //#endregion
 //#region src/printers/functionPrinter.d.ts
 /**
@@ -726,7 +726,7 @@ declare function createFunctionParameters(props?: Partial<Omit<FunctionParameter
  * `transformType` is applied once to the fully rendered type, matching how the
  * printer wrapped reference types before the `ts.factory` model.
  */
-declare function renderType(type: TypeExpression, transformType?: (type: string) => string): string;
+export declare function renderType(type: TypeExpression, transformType?: (type: string) => string): string;
 type FunctionPrinterOptions = {
   /**
    * Rendering modes supported by `functionPrinter`.
@@ -764,7 +764,7 @@ type FunctionPrinterOptions = {
  * printer.print(sig)  // → "petId: string, config: Config = {}"
  * ```
  */
-declare function functionPrinter(options: FunctionPrinterOptions): {
+export declare function functionPrinter(options: FunctionPrinterOptions): {
   name: "functionParameters";
   options: FunctionPrinterOptions;
   print(node: FunctionParametersNode): string;
@@ -911,7 +911,7 @@ type CreateOperationParamsOptions = {
  * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
  * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
  */
-declare function createOperationParams(node: ast.OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
+export declare function createOperationParams(node: ast.OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
 //#endregion
 //#region src/resolvers/resolverTs.d.ts
 /**
@@ -933,7 +933,7 @@ declare function createOperationParams(node: ast.OperationNode, options: CreateO
  * resolverTs.response.status(node, 200)            // 'ListPetsStatus200'
  * ```
  */
-declare const resolverTs: ResolverTs;
+export declare const resolverTs: ResolverTs;
 //#endregion
 //#region src/utils.d.ts
 type BuildParamsSchemaOptions = {
@@ -944,7 +944,7 @@ type BuildParamsSchemaOptions = {
  * header), embedding each param's own schema (and JSDoc) directly rather than referencing a
  * separate per-param type — the group itself is the only type these params get exported as.
  */
-declare function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode;
+export declare function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode;
 //#endregion
-export { type CreateOperationParamsOptions, Enum, type FunctionParameterNode, type FunctionParametersNode, type IndexedAccessTypeNode, type ObjectBindingPatternNode, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, type TypeExpression, type TypeLiteralNode, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
+export { type CreateOperationParamsOptions, type FunctionParameterNode, type FunctionParametersNode, type IndexedAccessTypeNode, type ObjectBindingPatternNode, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, type TypeExpression, type TypeLiteralNode, pluginTs as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -626,8 +626,10 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 	}).filter((node) => node !== void 0)))];
 	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
-		if (Number.parseInt(value.toString(), 10) === value && isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
-		else initializer = factory.createNumericLiteral(value);
+		if (Number.parseInt(value.toString(), 10) === value && isNumber(value)) {
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			else initializer = factory.createNumericLiteral(value);
+		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (isNumber(Number.parseInt(key.toString(), 10))) {
 			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
@@ -648,8 +650,10 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword))];
 	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
-		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
-		else initializer = factory.createNumericLiteral(value);
+		if (isNumber(value)) {
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			else initializer = factory.createNumericLiteral(value);
+		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
@@ -911,6 +915,115 @@ function Enum({ node, enum: enumOptions, resolver }) {
 	})] });
 }
 //#endregion
+//#region src/utils.ts
+/**
+* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
+* rather than a named enum reference or a runtime enum declaration.
+*
+* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
+* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
+* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
+* a named enum, which keeps the declaration and its references in sync across adapter versions.
+*/
+function isInlineConstEnum(node, enumSchemaNames) {
+	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
+}
+/**
+* Collects JSDoc annotation strings for a schema node.
+*
+* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
+* Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
+
+*/
+function isSchemaOptional(schema) {
+	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
+}
+function formatExample(value) {
+	if (value === null || typeof value !== "object") return String(value);
+	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
+}
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = syncSchemaRef(schema);
+	const isArray = meta?.primitive === "array";
+	const hasDescription = meta && "description" in meta && meta.description;
+	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
+	const exampleValues = meta?.examples ?? [];
+	const comments = [
+		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
+		...formatComment,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
+		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
+		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
+		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
+		...exampleValues.map((example) => `@example ${formatExample(example)}`)
+	].filter(Boolean);
+	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
+	return [...comments, typeTag].filter(Boolean);
+}
+/**
+* Builds the object schema for a group of parameters sharing one `in` location (path, query, or
+* header), embedding each param's own schema (and JSDoc) directly rather than referencing a
+* separate per-param type — the group itself is the only type these params get exported as.
+*/
+function buildParams({ params }) {
+	return ast.factory.createSchema({
+		type: "object",
+		properties: params.map((param) => ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: ast.factory.createSchema({
+				...param.schema,
+				optional: !param.required
+			})
+		}))
+	});
+}
+function buildResponseUnion(node, { resolver }) {
+	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
+	if (responsesWithSchema.length === 0) return null;
+	return ast.factory.createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => ast.factory.createSchema({
+			type: "ref",
+			name: resolver.response.status(node, res.statusCode)
+		}))
+	});
+}
+//#endregion
+//#region src/components/Type.tsx
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
+	const enumSchemaNodes = ast.collectSync(node, { schema(n) {
+		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
+		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
+	} });
+	const output = printer.print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enum: enumOptions,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enum: enumOptions,
+		resolver
+	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
+}
+//#endregion
 //#region ../../internals/shared/src/params.ts
 /**
 * Drops parameters that share the same name, keeping the first.
@@ -1054,6 +1167,62 @@ function buildOptionsSchema(node, resolver) {
 		})]
 	});
 }
+/**
+* The schema a status occupies in the `<Name>Responses` record. A status that documents several
+* content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
+* on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the
+* query hooks and `result.data` use.
+*/
+function buildResponseRecordEntry(node, res, resolver) {
+	const statusName = resolver.response.status(node, res.statusCode);
+	const variants = (res.content ?? []).filter((entry) => entry.schema);
+	if (variants.length <= 1) return ast.factory.createSchema({
+		type: "ref",
+		name: statusName
+	});
+	return ast.factory.createSchema({
+		type: "union",
+		members: resolveContentTypeVariants(variants, statusName).map((variant) => ast.factory.createSchema({
+			type: "object",
+			primitive: "object",
+			properties: [ast.factory.createProperty({
+				name: "contentType",
+				required: true,
+				schema: ast.factory.createSchema({
+					type: "enum",
+					enumValues: [variant.contentType]
+				})
+			}), ast.factory.createProperty({
+				name: "data",
+				required: true,
+				schema: ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				})
+			})]
+		}))
+	});
+}
+/**
+* Builds the per-status `<Name>Responses` record for an operation, referencing the already-resolved
+* `<Name>StatusNNN` names. Shared by `@kubb/plugin-ts`'s `Responses` type and `@kubb/plugin-zod`'s
+* inferred responses schema, so both emit the same shape from the same inputs.
+*
+* Always emits the keyed record, even when an operation declares no responses. An operation with no
+* responses renders as an empty object, which keeps every consumer's import (for example the axios
+* SDK's `RequestResult<XResponses>`) resolvable instead of pointing at a missing export.
+*/
+function buildResponses(node, resolver) {
+	return ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		properties: node.responses.map((res) => ast.factory.createProperty({
+			name: String(res.statusCode),
+			required: true,
+			schema: buildResponseRecordEntry(node, res, resolver)
+		}))
+	});
+}
 //#endregion
 //#region ../../internals/shared/src/resolver.ts
 /**
@@ -1204,160 +1373,6 @@ function mapSchemaItems(node, transform) {
 	}));
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
-* rather than a named enum reference or a runtime enum declaration.
-*
-* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
-* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
-* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
-* a named enum, which keeps the declaration and its references in sync across adapter versions.
-*/
-function isInlineConstEnum(node, enumSchemaNames) {
-	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
-}
-/**
-* Collects JSDoc annotation strings for a schema node.
-*
-* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
-* Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
-
-*/
-function isSchemaOptional(schema) {
-	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
-}
-function formatExample(value) {
-	if (value === null || typeof value !== "object") return String(value);
-	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
-}
-function buildPropertyJSDocComments(schema, optional) {
-	const meta = syncSchemaRef(schema);
-	const isArray = meta?.primitive === "array";
-	const hasDescription = meta && "description" in meta && meta.description;
-	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
-	const exampleValues = meta?.examples ?? [];
-	const comments = [
-		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
-		...formatComment,
-		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
-		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
-		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
-		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
-		...exampleValues.map((example) => `@example ${formatExample(example)}`)
-	].filter(Boolean);
-	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
-	return [...comments, typeTag].filter(Boolean);
-}
-/**
-* Builds the object schema for a group of parameters sharing one `in` location (path, query, or
-* header), embedding each param's own schema (and JSDoc) directly rather than referencing a
-* separate per-param type — the group itself is the only type these params get exported as.
-*/
-function buildParams({ params }) {
-	return ast.factory.createSchema({
-		type: "object",
-		properties: params.map((param) => ast.factory.createProperty({
-			name: param.name,
-			required: param.required,
-			schema: ast.factory.createSchema({
-				...param.schema,
-				optional: !param.required
-			})
-		}))
-	});
-}
-/**
-* The schema a status occupies in the `<Name>Responses` record. A status that documents several
-* content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
-* on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the
-* query hooks and `result.data` use.
-*/
-function buildResponseRecordEntry(node, res, resolver) {
-	const statusName = resolver.response.status(node, res.statusCode);
-	const variants = (res.content ?? []).filter((entry) => entry.schema);
-	if (variants.length <= 1) return ast.factory.createSchema({
-		type: "ref",
-		name: statusName
-	});
-	return ast.factory.createSchema({
-		type: "union",
-		members: resolveContentTypeVariants(variants, statusName).map((variant) => ast.factory.createSchema({
-			type: "object",
-			properties: [ast.factory.createProperty({
-				name: "contentType",
-				required: true,
-				schema: ast.factory.createSchema({
-					type: "enum",
-					enumValues: [variant.contentType]
-				})
-			}), ast.factory.createProperty({
-				name: "data",
-				required: true,
-				schema: ast.factory.createSchema({
-					type: "ref",
-					name: variant.name
-				})
-			})]
-		}))
-	});
-}
-function buildResponses(node, { resolver }) {
-	return ast.factory.createSchema({
-		type: "object",
-		properties: node.responses.map((res) => ast.factory.createProperty({
-			name: String(res.statusCode),
-			required: true,
-			schema: buildResponseRecordEntry(node, res, resolver)
-		}))
-	});
-}
-function buildResponseUnion(node, { resolver }) {
-	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
-	if (responsesWithSchema.length === 0) return null;
-	return ast.factory.createSchema({
-		type: "union",
-		members: responsesWithSchema.map((res) => ast.factory.createSchema({
-			type: "ref",
-			name: resolver.response.status(node, res.statusCode)
-		}))
-	});
-}
-//#endregion
-//#region src/components/Type.tsx
-function Type({ name, node, printer, enum: enumOptions, resolver }) {
-	const enumSchemaNodes = ast.collectSync(node, { schema(n) {
-		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
-		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
-	} });
-	const output = printer.print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames({
-				node,
-				enum: enumOptions,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
-	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enum: enumOptions,
-		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
 //#region src/printers/printerTs.ts
 const { isNonNullable } = factory_exports;
 /**
@@ -1419,7 +1434,7 @@ const printerTs = ast.createPrinter((options) => {
 				return createTypeReferenceNode(name, void 0);
 			},
 			enum(node) {
-				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
+				const values = ast.getSchemaLiteralValues(node);
 				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable)
@@ -1751,7 +1766,7 @@ const typeGenerator = defineGenerator({
 			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
-			schema: buildResponses(node, { resolver }),
+			schema: buildResponses(node, resolver),
 			name: resolver.response.responses(node)
 		});
 		function buildResponseType() {