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

package/dist/{components-CRu8IKY3.js → Type-CX1HRooG.js}

@@ -1,9 +1,10 @@
 import "./chunk--u3MIqq1.js";
-import { SchemaGenerator, createParser, isKeyword, schemaKeywords } from "@kubb/plugin-oas";
-import { safePrint } from "@kubb/fabric-core/parsers/typescript";
+import { collect, isPlainStringType } from "@kubb/ast";
+import { definePrinter } from "@kubb/core";
 import { File } from "@kubb/react-fabric";
-import ts from "typescript";
+import { safePrint } from "@kubb/fabric-core/parsers/typescript";
 import { isNumber } from "remeda";
+import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -24,9 +25,12 @@ function toCamelOrPascal(text, pascal) {
 * Splits `text` on `.` and applies `transformPart` to each segment.
 * The last segment receives `isLast = true`, all earlier segments receive `false`.
 * Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
 */
 function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
+	const parts = text.split(/\.(?=[a-zA-Z])/);
 	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 /**
@@ -120,6 +124,53 @@ function jsStringEscape(input) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/object.ts
+/**
+* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+*
+* @example
+* stringify('hello')   // '"hello"'
+* stringify('"hello"') // '"hello"'
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "\"\"";
+	return JSON.stringify(trimQuotes(value.toString()));
+}
+//#endregion
+//#region src/constants.ts
+/**
+* `optionalType` values that cause a property's type to include `| undefined`.
+*/
+const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined"]);
+/**
+* `optionalType` values that render the property key with a `?` token.
+*/
+const OPTIONAL_ADDS_QUESTION_TOKEN = new Set(["questionToken", "questionTokenAndUndefined"]);
+/**
+* `enumType` values that append a `Key` suffix to the generated enum type alias.
+*/
+const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst", "asPascalConst"]);
+/**
+* `enumType` values that require a runtime value declaration (object, enum, or literal).
+*/
+const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set([
+	"enum",
+	"asConst",
+	"asPascalConst",
+	"constEnum",
+	"literal",
+	void 0
+]);
+/**
+* `enumType` values whose type declaration is type-only (no runtime value emitted for the type alias).
+*/
+const ENUM_TYPES_WITH_TYPE_ONLY = new Set([
+	"asConst",
+	"asPascalConst",
+	"literal",
+	void 0
+]);
+//#endregion
 //#region src/factory.ts
 const { SyntaxKind, factory } = ts;
 const modifiers = {
@@ -133,11 +184,6 @@ const syntaxKind = {
 	literalType: SyntaxKind.LiteralType,
 	stringLiteral: SyntaxKind.StringLiteral
 };
-function getUnknownType(unknownType) {
-	if (unknownType === "any") return keywordTypeNodes.any;
-	if (unknownType === "void") return keywordTypeNodes.void;
-	return keywordTypeNodes.unknown;
-}
 function isValidIdentifier(str) {
 	if (!str.length || str.trim() !== str) return false;
 	const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);
@@ -342,388 +388,354 @@ const createTupleTypeNode = factory.createTupleTypeNode;
 const createRestTypeNode = factory.createRestTypeNode;
 const createTrue = factory.createTrue;
 const createFalse = factory.createFalse;
-const createIndexedAccessTypeNode = factory.createIndexedAccessTypeNode;
-const createTypeOperatorNode = factory.createTypeOperatorNode;
+factory.createIndexedAccessTypeNode;
+factory.createTypeOperatorNode;
 const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
 //#endregion
-//#region src/parser.ts
-const typeKeywordMapper = {
-	any: () => keywordTypeNodes.any,
-	unknown: () => keywordTypeNodes.unknown,
-	void: () => keywordTypeNodes.void,
-	number: () => keywordTypeNodes.number,
-	integer: () => keywordTypeNodes.number,
-	bigint: () => keywordTypeNodes.bigint,
-	object: (nodes) => {
-		if (!nodes || !nodes.length) return keywordTypeNodes.object;
-		return createTypeLiteralNode(nodes);
-	},
-	string: () => keywordTypeNodes.string,
-	boolean: () => keywordTypeNodes.boolean,
-	undefined: () => keywordTypeNodes.undefined,
-	nullable: void 0,
-	null: () => keywordTypeNodes.null,
-	nullish: void 0,
-	array: (nodes, arrayType) => {
-		if (!nodes) return;
-		return createArrayDeclaration({
-			nodes,
-			arrayType
-		});
-	},
-	tuple: (nodes, rest, min, max) => {
-		if (!nodes) return;
-		if (max) {
-			nodes = nodes.slice(0, max);
-			if (nodes.length < max && rest) nodes = [...nodes, ...Array(max - nodes.length).fill(rest)];
-		}
-		if (min) nodes = nodes.map((node, index) => index >= min ? createOptionalTypeNode(node) : node);
-		if (typeof max === "undefined" && rest) nodes.push(createRestTypeNode(createArrayTypeNode(rest)));
-		return createTupleTypeNode(nodes);
-	},
-	enum: (name) => {
-		if (!name) return;
-		return createTypeReferenceNode(name, void 0);
-	},
-	union: (nodes) => {
-		if (!nodes) return;
-		return createUnionDeclaration({
-			withParentheses: true,
-			nodes
-		});
-	},
-	const: (name, format) => {
-		if (name === null || name === void 0 || name === "") return;
-		if (format === "boolean") {
-			if (name === true) return createLiteralTypeNode(createTrue());
-			return createLiteralTypeNode(createFalse());
+//#region src/printer.ts
+/**
+* Converts a primitive const value to a TypeScript literal type node.
+* Handles negative numbers via a prefix unary expression.
+*/
+function constToTypeNode(value, format) {
+	if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
+	if (format === "number" && typeof value === "number") {
+		if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
+		return createLiteralTypeNode(createNumericLiteral(value));
+	}
+	return createLiteralTypeNode(createStringLiteral(String(value)));
+}
+/**
+* Returns a `Date` reference type node when `representation` is `'date'`, otherwise falls back to `string`.
+*/
+function dateOrStringNode(node) {
+	return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
+}
+/**
+* Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
+*/
+function buildMemberNodes(members, print) {
+	return (members ?? []).map(print).filter(Boolean);
+}
+/**
+* Builds a TypeScript tuple type node from an array schema's `items`,
+* applying min/max slice and optional/rest element rules.
+*/
+function buildTupleNode(node, print) {
+	let items = (node.items ?? []).map(print).filter(Boolean);
+	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
+	const { min, max } = node;
+	if (max !== void 0) {
+		items = items.slice(0, max);
+		if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
+	}
+	if (min !== void 0) items = items.map((item, i) => i >= min ? createOptionalTypeNode(item) : item);
+	if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
+	return createTupleTypeNode(items);
+}
+/**
+* Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
+*/
+function buildPropertyType(schema, baseType, optionalType) {
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
+	let type = baseType;
+	if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+	if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+	return type;
+}
+/**
+* Collects JSDoc annotation strings (description, deprecated, min/max, pattern, default, example, type) for a schema node.
+*/
+function buildPropertyJSDocComments(schema) {
+	return [
+		"description" in schema && schema.description ? `@description ${jsStringEscape(schema.description)}` : void 0,
+		"deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
+		"min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
+		"max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
+		"pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
+		"default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify(schema.default) : schema.default}` : void 0,
+		"example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
+		"primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+	];
+}
+/**
+* Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
+*/
+function buildIndexSignatures(node, propertyCount, print) {
+	const elements = [];
+	if (node.additionalProperties && node.additionalProperties !== true) {
+		const additionalType = print(node.additionalProperties) ?? keywordTypeNodes.unknown;
+		elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
+	} else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
+	if (node.patternProperties) {
+		const first = Object.values(node.patternProperties)[0];
+		if (first) {
+			let patternType = print(first) ?? keywordTypeNodes.unknown;
+			if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
+			elements.push(createIndexSignature(patternType));
 		}
-		if (format === "number" && typeof name === "number") return createLiteralTypeNode(createNumericLiteral(name));
-		return createLiteralTypeNode(createStringLiteral(name.toString()));
-	},
-	datetime: () => keywordTypeNodes.string,
-	date: (type = "string") => type === "string" ? keywordTypeNodes.string : createTypeReferenceNode(createIdentifier("Date")),
-	time: (type = "string") => type === "string" ? keywordTypeNodes.string : createTypeReferenceNode(createIdentifier("Date")),
-	uuid: () => keywordTypeNodes.string,
-	url: () => keywordTypeNodes.string,
-	default: void 0,
-	and: (nodes) => {
-		if (!nodes) return;
-		return createIntersectionDeclaration({
-			withParentheses: true,
-			nodes
-		});
-	},
-	describe: void 0,
-	min: void 0,
-	max: void 0,
-	optional: void 0,
-	matches: () => keywordTypeNodes.string,
-	email: () => keywordTypeNodes.string,
-	firstName: void 0,
-	lastName: void 0,
-	password: void 0,
-	phone: void 0,
-	readOnly: void 0,
-	writeOnly: void 0,
-	ref: (propertyName) => {
-		if (!propertyName) return;
-		return createTypeReferenceNode(propertyName, void 0);
-	},
-	blob: () => createTypeReferenceNode("Blob", []),
-	deprecated: void 0,
-	example: void 0,
-	schema: void 0,
-	catchall: void 0,
-	name: void 0,
-	interface: void 0,
-	exclusiveMaximum: void 0,
-	exclusiveMinimum: void 0
-};
+	}
+	return elements;
+}
 /**
-* Recursively parses a schema tree node into a corresponding TypeScript AST node.
+* TypeScript type printer built with `definePrinter`.
 *
-* Maps OpenAPI schema keywords to TypeScript AST nodes using the `typeKeywordMapper`, handling complex types such as unions, intersections, arrays, tuples (with optional/rest elements and length constraints), enums, constants, references, and objects with property modifiers and documentation annotations.
+* Converts a `SchemaNode` AST node into a TypeScript AST node:
+* - **`printer.print(node)`** — when `options.typeName` is set, returns a full
+*   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).
+*   Without `typeName`, returns the raw `ts.TypeNode` for the schema.
 *
-* @param current - The schema node to parse.
-* @param siblings - Sibling schema nodes, used for context in certain mappings.
-* @param name - The name of the schema or property being parsed.
-* @param options - Parsing options controlling output style, property handling.
-* @returns The generated TypeScript AST node, or `undefined` if the schema keyword is not mapped.
+* Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
+* over per printer instance, so each call to `printerTs(options)` produces an independent printer.
+*
+* @example Raw type node (no `typeName`)
+* ```ts
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: '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 declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
+* ```
 */
-const parse = createParser({
-	mapper: typeKeywordMapper,
-	handlers: {
-		union(tree, options) {
-			const { current, schema, name } = tree;
-			return typeKeywordMapper.union(current.args.map((it) => this.parse({
-				schema,
-				parent: current,
-				name,
-				current: it,
-				siblings: []
-			}, options)).filter(Boolean));
-		},
-		and(tree, options) {
-			const { current, schema, name } = tree;
-			return typeKeywordMapper.and(current.args.map((it) => this.parse({
-				schema,
-				parent: current,
-				name,
-				current: it,
-				siblings: []
-			}, options)).filter(Boolean));
-		},
-		array(tree, options) {
-			const { current, schema, name } = tree;
-			return typeKeywordMapper.array(current.args.items.map((it) => this.parse({
-				schema,
-				parent: current,
-				name,
-				current: it,
-				siblings: []
-			}, options)).filter(Boolean), options.arrayType);
-		},
-		enum(tree, options) {
-			const { current } = tree;
-			if (options.enumType === "inlineLiteral") {
-				const enumValues = current.args.items.map((item) => item.value).filter((value) => value !== void 0 && value !== null).map((value) => {
-					const format = typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string";
-					return typeKeywordMapper.const(value, format);
-				}).filter(Boolean);
-				return typeKeywordMapper.union(enumValues);
-			}
-			return typeKeywordMapper.enum(["asConst", "asPascalConst"].includes(options.enumType) ? `${current.args.typeName}Key` : current.args.typeName);
-		},
-		ref(tree, _options) {
-			const { current } = tree;
-			return typeKeywordMapper.ref(current.args.name);
-		},
-		blob() {
-			return typeKeywordMapper.blob();
-		},
-		tuple(tree, options) {
-			const { current, schema, name } = tree;
-			return typeKeywordMapper.tuple(current.args.items.map((it) => this.parse({
-				schema,
-				parent: current,
-				name,
-				current: it,
-				siblings: []
-			}, options)).filter(Boolean), current.args.rest && (this.parse({
-				schema,
-				parent: current,
-				name,
-				current: current.args.rest,
-				siblings: []
-			}, options) ?? void 0), current.args.min, current.args.max);
-		},
-		const(tree, _options) {
-			const { current } = tree;
-			return typeKeywordMapper.const(current.args.name, current.args.format);
-		},
-		object(tree, options) {
-			const { current, schema, name } = tree;
-			const properties = Object.entries(current.args?.properties || {}).filter((item) => {
-				const schemas = item[1];
-				return schemas && typeof schemas.map === "function";
-			}).map(([name, schemas]) => {
-				const mappedName = schemas.find((schema) => schema.keyword === schemaKeywords.name)?.args || name;
-				const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish);
-				const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable);
-				const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional);
-				const isReadonly = schemas.some((schema) => schema.keyword === schemaKeywords.readOnly);
-				const describeSchema = schemas.find((schema) => schema.keyword === schemaKeywords.describe);
-				const deprecatedSchema = schemas.find((schema) => schema.keyword === schemaKeywords.deprecated);
-				const defaultSchema = schemas.find((schema) => schema.keyword === schemaKeywords.default);
-				const exampleSchema = schemas.find((schema) => schema.keyword === schemaKeywords.example);
-				const schemaSchema = schemas.find((schema) => schema.keyword === schemaKeywords.schema);
-				const minSchema = schemas.find((schema) => schema.keyword === schemaKeywords.min);
-				const maxSchema = schemas.find((schema) => schema.keyword === schemaKeywords.max);
-				const matchesSchema = schemas.find((schema) => schema.keyword === schemaKeywords.matches);
-				let type = schemas.map((it) => this.parse({
-					schema,
-					parent: current,
-					name,
-					current: it,
-					siblings: schemas
-				}, options)).filter(Boolean)[0];
-				if (isNullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-				if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-				if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-				return appendJSDocToNode({
-					node: createPropertySignature({
-						questionToken: isOptional || isNullish ? ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType) : false,
-						name: mappedName,
-						type,
-						readOnly: isReadonly
-					}),
-					comments: [
-						describeSchema ? `@description ${jsStringEscape(describeSchema.args)}` : void 0,
-						deprecatedSchema ? "@deprecated" : void 0,
-						minSchema ? `@minLength ${minSchema.args}` : void 0,
-						maxSchema ? `@maxLength ${maxSchema.args}` : void 0,
-						matchesSchema ? `@pattern ${matchesSchema.args}` : void 0,
-						defaultSchema ? `@default ${defaultSchema.args}` : void 0,
-						exampleSchema ? `@example ${exampleSchema.args}` : void 0,
-						schemaSchema?.args?.type || schemaSchema?.args?.format ? [`@type ${schemaSchema?.args?.type || "unknown"}${!isOptional ? "" : " | undefined"}`, schemaSchema?.args?.format].filter(Boolean).join(", ") : void 0
-					].filter(Boolean)
+const printerTs = definePrinter((options) => {
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+	return {
+		name: "typescript",
+		options,
+		nodes: {
+			any: () => keywordTypeNodes.any,
+			unknown: () => keywordTypeNodes.unknown,
+			void: () => keywordTypeNodes.void,
+			never: () => keywordTypeNodes.never,
+			boolean: () => keywordTypeNodes.boolean,
+			null: () => keywordTypeNodes.null,
+			blob: () => createTypeReferenceNode("Blob", []),
+			string: () => keywordTypeNodes.string,
+			uuid: () => keywordTypeNodes.string,
+			email: () => keywordTypeNodes.string,
+			url: (node) => {
+				if (node.path) return createUrlTemplateType(node.path);
+				return keywordTypeNodes.string;
+			},
+			datetime: () => keywordTypeNodes.string,
+			number: () => keywordTypeNodes.number,
+			integer: () => keywordTypeNodes.number,
+			bigint: () => keywordTypeNodes.bigint,
+			date: dateOrStringNode,
+			time: dateOrStringNode,
+			ref(node) {
+				if (!node.name) return;
+				const refName = node.ref ? node.ref.split("/").at(-1) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+			},
+			enum(node) {
+				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
+				if (this.options.enumType === "inlineLiteral" || !node.name) return createUnionDeclaration({
+					withParentheses: true,
+					nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+				}) ?? void 0;
+				const resolvedName = this.options.resolver.default(node.name, "type");
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) ? `${resolvedName}Key` : resolvedName, void 0);
+			},
+			union(node) {
+				const members = node.members ?? [];
+				const hasStringLiteral = members.some((m) => m.type === "enum" && (m.enumType === "string" || m.primitive === "string"));
+				const hasPlainString = members.some((m) => isPlainStringType(m));
+				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
+					withParentheses: true,
+					nodes: members.map((m) => {
+						if (isPlainStringType(m)) return createIntersectionDeclaration({
+							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
+							withParentheses: true
+						});
+						return this.print(m);
+					}).filter(Boolean)
+				}) ?? void 0;
+				return createUnionDeclaration({
+					withParentheses: true,
+					nodes: buildMemberNodes(members, this.print)
+				}) ?? void 0;
+			},
+			intersection(node) {
+				return createIntersectionDeclaration({
+					withParentheses: true,
+					nodes: buildMemberNodes(node.members, this.print)
+				}) ?? void 0;
+			},
+			array(node) {
+				return createArrayDeclaration({
+					nodes: (node.items ?? []).map((item) => this.print(item)).filter(Boolean),
+					arrayType: this.options.arrayType
+				}) ?? void 0;
+			},
+			tuple(node) {
+				return buildTupleNode(node, this.print);
+			},
+			object(node) {
+				const { print, options } = this;
+				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
+				const propertyNodes = node.properties.map((prop) => {
+					const baseType = print(prop.schema) ?? keywordTypeNodes.unknown;
+					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
+					return appendJSDocToNode({
+						node: createPropertySignature({
+							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
+							name: prop.name,
+							type,
+							readOnly: prop.schema.readOnly
+						}),
+						comments: buildPropertyJSDocComments(prop.schema)
+					});
 				});
-			});
-			let additionalProperties;
-			if (current.args?.additionalProperties?.length) {
-				let additionalPropertiesType = current.args.additionalProperties.map((it) => this.parse({
-					schema,
-					parent: current,
-					name,
-					current: it,
-					siblings: []
-				}, options)).filter(Boolean).at(0);
-				if (current.args?.additionalProperties.some((schema) => isKeyword(schema, schemaKeywords.nullable))) additionalPropertiesType = createUnionDeclaration({ nodes: [additionalPropertiesType, keywordTypeNodes.null] });
-				additionalProperties = createIndexSignature(properties.length > 0 ? keywordTypeNodes.unknown : additionalPropertiesType);
+				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
+				if (!allElements.length) return keywordTypeNodes.object;
+				return createTypeLiteralNode(allElements);
 			}
-			let patternProperties;
-			if (current.args?.patternProperties) {
-				const allPatternSchemas = Object.values(current.args.patternProperties).flat();
-				if (allPatternSchemas.length > 0) {
-					patternProperties = allPatternSchemas.map((it) => this.parse({
-						schema,
-						parent: current,
-						name,
-						current: it,
-						siblings: []
-					}, options)).filter(Boolean).at(0);
-					if (allPatternSchemas.some((schema) => isKeyword(schema, schemaKeywords.nullable))) patternProperties = createUnionDeclaration({ nodes: [patternProperties, keywordTypeNodes.null] });
-					patternProperties = createIndexSignature(patternProperties);
-				}
-			}
-			return typeKeywordMapper.object([
-				...properties,
-				additionalProperties,
-				patternProperties
-			].filter(Boolean));
-		},
-		datetime() {
-			return typeKeywordMapper.datetime();
-		},
-		date(tree) {
-			const { current } = tree;
-			return typeKeywordMapper.date(current.args.type);
 		},
-		time(tree) {
-			const { current } = tree;
-			return typeKeywordMapper.time(current.args.type);
+		print(node) {
+			let type = this.print(node);
+			if (!type) return;
+			if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+			if ((node.nullish || node.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+			const { typeName, syntaxType = "type", description, keysToOmit } = this.options;
+			if (!typeName) return type;
+			const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!keysToOmit?.length;
+			return createTypeDeclaration({
+				name: typeName,
+				isExportable: true,
+				type: keysToOmit?.length ? createOmitDeclaration({
+					keys: keysToOmit,
+					type,
+					nonNullable: true
+				}) : type,
+				syntax: useTypeGeneration ? "type" : "interface",
+				comments: [
+					node?.title ? jsStringEscape(node.title) : void 0,
+					description ? `@description ${jsStringEscape(description)}` : void 0,
+					node?.deprecated ? "@deprecated" : void 0,
+					node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
+					node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
+					node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
+					node?.default ? `@default ${node.default}` : void 0,
+					node?.example ? `@example ${node.example}` : void 0
+				]
+			});
 		}
-	}
+	};
 });
 //#endregion
+//#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, tree, keysToOmit, schema, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description }) {
-	const typeNodes = [];
-	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: void 0,
-		current,
-		siblings
-	}, {
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description, resolver }) {
+	const resolvedDescription = description || node?.description;
+	const enumSchemaNodes = collect(node, { schema(n) {
+		if (n.type === "enum" && n.name) return n;
+	} });
+	const typeNode = printerTs({
 		optionalType,
 		arrayType,
-		enumType
-	})).filter(Boolean).at(0) || typeKeywordMapper.undefined();
-	if (["asConst", "asPascalConst"].includes(enumType) && enumSchemas.length > 0) {
-		const isDirectEnum = schema.type === "array" && schema.items !== void 0;
-		const isEnumOnly = "enum" in schema && schema.enum;
-		if (isDirectEnum || isEnumOnly) {
-			type = createTypeReferenceNode(`${enumSchemas[0].args.typeName}Key`);
-			if (schema.type === "array") if (arrayType === "generic") type = createTypeReferenceNode(createIdentifier("Array"), [type]);
-			else type = 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);
-		if (isNullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-		if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-		if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-	}
-	const useTypeGeneration = syntaxType === "type" || [syntaxKind.union].includes(type.kind) || !!keysToOmit?.length;
-	typeNodes.push(createTypeDeclaration({
-		name,
-		isExportable: true,
-		type: keysToOmit?.length ? createOmitDeclaration({
-			keys: keysToOmit,
-			type,
-			nonNullable: true
-		}) : type,
-		syntax: useTypeGeneration ? "type" : "interface",
-		comments: [
-			schema.title ? `${jsStringEscape(schema.title)}` : void 0,
-			description ? `@description ${jsStringEscape(description)}` : void 0,
-			schema.deprecated ? "@deprecated" : void 0,
-			schema.minLength ? `@minLength ${schema.minLength}` : void 0,
-			schema.maxLength ? `@maxLength ${schema.maxLength}` : void 0,
-			schema.pattern ? `@pattern ${schema.pattern}` : void 0,
-			schema.default ? `@default ${schema.default}` : void 0,
-			schema.example ? `@example ${schema.example}` : void 0
-		]
-	}));
-	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] = createEnumDeclaration({
-			name,
-			typeName,
-			enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
-			type: enumType,
-			enumKeyCasing
-		});
+		enumType,
+		typeName: name,
+		syntaxType,
+		description: resolvedDescription,
+		keysToOmit,
+		resolver
+	}).print(node);
+	if (!typeNode) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
 		return {
-			nameNode,
-			typeNode,
-			name,
-			typeName
+			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(({ name, nameNode, typeName, typeNode }) => /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: false,
-		children: safePrint(nameNode)
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isIndexable: true,
-		isExportable: [
-			"enum",
-			"asConst",
-			"asPascalConst",
-			"constEnum",
-			"literal",
-			void 0
-		].includes(enumType),
-		isTypeOnly: [
-			"asConst",
-			"asPascalConst",
-			"literal",
-			void 0
-		].includes(enumType),
-		children: safePrint(typeNode)
-	})] })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+	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: safePrint(...typeNodes)
+		children: safePrint(typeNode)
 	})] });
 }
 //#endregion
-export { keywordTypeNodes as A, createTypeDeclaration as C, createUnionDeclaration as D, createTypeReferenceNode as E, camelCase as F, pascalCase as I, syntaxKind as M, jsStringEscape as N, createUrlTemplateType as O, trimQuotes as P, createTypeAliasDeclaration as S, createTypeOperatorNode as T, createPropertySignature as _, createArrayTypeNode as a, createTrue as b, createIdentifier as c, createIntersectionDeclaration as d, createLiteralTypeNode as f, createPrefixUnaryExpression as g, createOptionalTypeNode as h, createArrayDeclaration as i, modifiers as j, getUnknownType as k, createIndexSignature as l, createOmitDeclaration as m, SyntaxKind as n, createEnumDeclaration as o, createNumericLiteral as p, appendJSDocToNode as r, createFalse as s, Type as t, createIndexedAccessTypeNode as u, createRestTypeNode as v, createTypeLiteralNode as w, createTupleTypeNode as x, createStringLiteral as y };
+export { pascalCase as a, camelCase as i, Enum as n, ENUM_TYPES_WITH_KEY_SUFFIX as r, Type as t };
 
-//# sourceMappingURL=components-CRu8IKY3.js.map
+//# sourceMappingURL=Type-CX1HRooG.js.map