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

package/dist/printerTs-BcHudagv.cjs

@@ -1,594 +0,0 @@
-const require_chunk = require("./chunk-ByKO4r7w.cjs");
-const require_casing = require("./casing-DHfdqpLi.cjs");
-let _kubb_ast = require("@kubb/ast");
-let _kubb_core = require("@kubb/core");
-let _kubb_fabric_core_parsers_typescript = require("@kubb/fabric-core/parsers/typescript");
-let remeda = require("remeda");
-let typescript = require("typescript");
-typescript = require_chunk.__toESM(typescript);
-//#region ../../internals/utils/src/string.ts
-/**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
-*
-* @example
-* trimQuotes('"hello"') // 'hello'
-* trimQuotes('hello')   // 'hello'
-*/
-function trimQuotes(text) {
-	if (text.length >= 2) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
-}
-/**
-* Escapes characters that are not allowed inside JS string literals.
-* Handles quotes, backslashes, and Unicode line terminators (U+2028 / U+2029).
-*
-* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-*
-* @example
-* ```ts
-* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
-* ```
-*/
-function jsStringEscape(input) {
-	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-		switch (character) {
-			case "\"":
-			case "'":
-			case "\\": return `\\${character}`;
-			case "\n": return "\\n";
-			case "\r": return "\\r";
-			case "\u2028": return "\\u2028";
-			case "\u2029": return "\\u2029";
-			default: return "";
-		}
-	});
-}
-//#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 } = typescript.default;
-const modifiers = {
-	async: factory.createModifier(typescript.default.SyntaxKind.AsyncKeyword),
-	export: factory.createModifier(typescript.default.SyntaxKind.ExportKeyword),
-	const: factory.createModifier(typescript.default.SyntaxKind.ConstKeyword),
-	static: factory.createModifier(typescript.default.SyntaxKind.StaticKeyword)
-};
-const syntaxKind = {
-	union: SyntaxKind.UnionType,
-	literalType: SyntaxKind.LiteralType,
-	stringLiteral: SyntaxKind.StringLiteral
-};
-function isValidIdentifier(str) {
-	if (!str.length || str.trim() !== str) return false;
-	const node = typescript.default.parseIsolatedEntityName(str, typescript.default.ScriptTarget.Latest);
-	return !!node && node.kind === typescript.default.SyntaxKind.Identifier && typescript.default.identifierToKeywordKind(node.kind) === void 0;
-}
-function propertyName(name) {
-	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
-	return name;
-}
-const questionToken = factory.createToken(typescript.default.SyntaxKind.QuestionToken);
-function createQuestionToken(token) {
-	if (!token) return;
-	if (token === true) return questionToken;
-	return token;
-}
-function createIntersectionDeclaration({ nodes, withParentheses }) {
-	if (!nodes.length) return null;
-	if (nodes.length === 1) return nodes[0] || null;
-	const node = factory.createIntersectionTypeNode(nodes);
-	if (withParentheses) return factory.createParenthesizedType(node);
-	return node;
-}
-function createArrayDeclaration({ nodes, arrayType = "array" }) {
-	if (!nodes.length) return factory.createTupleTypeNode([]);
-	if (nodes.length === 1) {
-		const node = nodes[0];
-		if (!node) return null;
-		if (arrayType === "generic") return factory.createTypeReferenceNode(factory.createIdentifier("Array"), [node]);
-		return factory.createArrayTypeNode(node);
-	}
-	const unionType = factory.createUnionTypeNode(nodes);
-	if (arrayType === "generic") return factory.createTypeReferenceNode(factory.createIdentifier("Array"), [unionType]);
-	return factory.createArrayTypeNode(factory.createParenthesizedType(unionType));
-}
-/**
-* Minimum nodes length of 2
-* @example `string | number`
-*/
-function createUnionDeclaration({ nodes, withParentheses }) {
-	if (!nodes.length) return keywordTypeNodes.any;
-	if (nodes.length === 1) return nodes[0];
-	const node = factory.createUnionTypeNode(nodes);
-	if (withParentheses) return factory.createParenthesizedType(node);
-	return node;
-}
-function createPropertySignature({ readOnly, modifiers = [], name, questionToken, type }) {
-	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.default.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean), propertyName(name), createQuestionToken(questionToken), type);
-}
-function createParameterSignature(name, { modifiers, dotDotDotToken, questionToken, type, initializer }) {
-	return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer);
-}
-/**
-* @link https://github.com/microsoft/TypeScript/issues/44151
-*/
-function appendJSDocToNode({ node, comments }) {
-	const filteredComments = comments.filter(Boolean);
-	if (!filteredComments.length) return node;
-	const text = filteredComments.reduce((acc = "", comment = "") => {
-		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
-	}, "*");
-	return typescript.default.addSyntheticLeadingComment(node, typescript.default.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
-}
-function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.default.SyntaxKind.StringKeyword) } = {}) {
-	return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type);
-}
-function createTypeAliasDeclaration({ modifiers, name, typeParameters, type }) {
-	return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type);
-}
-function createInterfaceDeclaration({ modifiers, name, typeParameters, members }) {
-	return factory.createInterfaceDeclaration(modifiers, name, typeParameters, void 0, members);
-}
-function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
-	if (syntax === "interface" && "members" in type) return appendJSDocToNode({
-		node: createInterfaceDeclaration({
-			members: type.members,
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		}),
-		comments
-	});
-	return appendJSDocToNode({
-		node: createTypeAliasDeclaration({
-			type,
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		}),
-		comments
-	});
-}
-/**
-* Apply casing transformation to enum keys
-*/
-function applyEnumKeyCasing(key, casing = "none") {
-	if (casing === "none") return key;
-	if (casing === "screamingSnakeCase") return require_casing.screamingSnakeCase(key);
-	if (casing === "snakeCase") return require_casing.snakeCase(key);
-	if (casing === "pascalCase") return require_casing.pascalCase(key);
-	if (casing === "camelCase") return require_casing.camelCase(key);
-	return key;
-}
-function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCasing = "none" }) {
-	if (type === "literal" || type === "inlineLiteral") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
-		if ((0, remeda.isNumber)(value)) {
-			if (value < 0) return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))));
-			return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
-		}
-		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
-		if (value) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
-	}).filter(Boolean)))];
-	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.default.SyntaxKind.ConstKeyword) : void 0].filter(Boolean), factory.createIdentifier(typeName), enums.map(([key, value]) => {
-		let initializer = factory.createStringLiteral(value?.toString());
-		if (Number.parseInt(value.toString(), 10) === value && (0, remeda.isNumber)(Number.parseInt(value.toString(), 10))) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
-		else initializer = factory.createNumericLiteral(value);
-		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
-		if ((0, remeda.isNumber)(Number.parseInt(key.toString(), 10))) {
-			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
-			return factory.createEnumMember(propertyName(casingKey), initializer);
-		}
-		if (key) {
-			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return factory.createEnumMember(propertyName(casingKey), initializer);
-		}
-	}).filter(Boolean))];
-	const identifierName = name;
-	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(typescript.default.SyntaxKind.NeverKeyword))];
-	return [factory.createVariableStatement([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
-		let initializer = factory.createStringLiteral(value?.toString());
-		if ((0, remeda.isNumber)(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
-		else initializer = factory.createNumericLiteral(value);
-		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
-		if (key) {
-			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return factory.createPropertyAssignment(propertyName(casingKey), initializer);
-		}
-	}).filter(Boolean), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.default.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.default.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
-}
-function createOmitDeclaration({ keys, type, nonNullable }) {
-	const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier("NonNullable"), [type]) : type;
-	if (Array.isArray(keys)) return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createUnionTypeNode(keys.map((key) => {
-		return factory.createLiteralTypeNode(factory.createStringLiteral(key));
-	}))]);
-	return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))]);
-}
-const keywordTypeNodes = {
-	any: factory.createKeywordTypeNode(typescript.default.SyntaxKind.AnyKeyword),
-	unknown: factory.createKeywordTypeNode(typescript.default.SyntaxKind.UnknownKeyword),
-	void: factory.createKeywordTypeNode(typescript.default.SyntaxKind.VoidKeyword),
-	number: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NumberKeyword),
-	integer: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NumberKeyword),
-	bigint: factory.createKeywordTypeNode(typescript.default.SyntaxKind.BigIntKeyword),
-	object: factory.createKeywordTypeNode(typescript.default.SyntaxKind.ObjectKeyword),
-	string: factory.createKeywordTypeNode(typescript.default.SyntaxKind.StringKeyword),
-	boolean: factory.createKeywordTypeNode(typescript.default.SyntaxKind.BooleanKeyword),
-	undefined: factory.createKeywordTypeNode(typescript.default.SyntaxKind.UndefinedKeyword),
-	null: factory.createLiteralTypeNode(factory.createToken(typescript.default.SyntaxKind.NullKeyword)),
-	never: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NeverKeyword)
-};
-/**
-* Converts a path like '/pet/{petId}/uploadImage' to a template literal type
-* like `/pet/${string}/uploadImage`
-*/
-/**
-* Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path
-* (e.g. `/pets/:petId`) to a TypeScript template literal type
-* like `` `/pets/${string}` ``.
-*/
-function createUrlTemplateType(path) {
-	const normalized = path.replace(/:([^/]+)/g, "{$1}");
-	if (!normalized.includes("{")) return factory.createLiteralTypeNode(factory.createStringLiteral(normalized));
-	const segments = normalized.split(/(\{[^}]+\})/);
-	const parts = [];
-	const parameterIndices = [];
-	segments.forEach((segment) => {
-		if (segment.startsWith("{") && segment.endsWith("}")) {
-			parameterIndices.push(parts.length);
-			parts.push(segment);
-		} else if (segment) parts.push(segment);
-	});
-	const head = typescript.default.factory.createTemplateHead(parts[0] || "");
-	const templateSpans = [];
-	parameterIndices.forEach((paramIndex, i) => {
-		const isLast = i === parameterIndices.length - 1;
-		const nextPart = parts[paramIndex + 1] || "";
-		const literal = isLast ? typescript.default.factory.createTemplateTail(nextPart) : typescript.default.factory.createTemplateMiddle(nextPart);
-		templateSpans.push(typescript.default.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
-	});
-	return typescript.default.factory.createTemplateLiteralType(head, templateSpans);
-}
-const createTypeLiteralNode = factory.createTypeLiteralNode;
-const createTypeReferenceNode = factory.createTypeReferenceNode;
-const createNumericLiteral = factory.createNumericLiteral;
-const createStringLiteral = factory.createStringLiteral;
-const createArrayTypeNode = factory.createArrayTypeNode;
-factory.createParenthesizedType;
-const createLiteralTypeNode = factory.createLiteralTypeNode;
-factory.createNull;
-const createIdentifier = factory.createIdentifier;
-const createOptionalTypeNode = factory.createOptionalTypeNode;
-const createTupleTypeNode = factory.createTupleTypeNode;
-const createRestTypeNode = factory.createRestTypeNode;
-const createTrue = factory.createTrue;
-const createFalse = factory.createFalse;
-factory.createIndexedAccessTypeNode;
-factory.createTypeOperatorNode;
-const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
-//#endregion
-//#region src/printers/printerTs.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) {
-	const isArray = schema.type === "array";
-	return [
-		"description" in schema && schema.description ? `@description ${jsStringEscape(schema.description)}` : void 0,
-		"deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
-		!isArray && "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
-		!isArray && "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));
-		}
-	}
-	return elements;
-}
-/**
-* TypeScript type printer built with `definePrinter`.
-*
-* 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.
-*
-* 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 printerTs = (0, _kubb_core.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;
-				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix ? this.options.resolver.resolveEnumKeyTypedName(node, this.options.enumTypeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
-			},
-			union(node) {
-				const members = node.members ?? [];
-				const hasStringLiteral = members.some((m) => {
-					return (0, _kubb_ast.narrowSchema)(m, _kubb_ast.schemaTypes.enum)?.primitive === "string";
-				});
-				const hasPlainString = members.some((m) => (0, _kubb_ast.isStringType)(m));
-				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
-					withParentheses: true,
-					nodes: members.map((m) => {
-						if ((0, _kubb_ast.isStringType)(m)) return createIntersectionDeclaration({
-							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
-							withParentheses: true
-						});
-						return this.transform(m);
-					}).filter(Boolean)
-				}) ?? void 0;
-				return createUnionDeclaration({
-					withParentheses: true,
-					nodes: buildMemberNodes(members, this.transform)
-				}) ?? void 0;
-			},
-			intersection(node) {
-				return createIntersectionDeclaration({
-					withParentheses: true,
-					nodes: buildMemberNodes(node.members, this.transform)
-				}) ?? void 0;
-			},
-			array(node) {
-				return createArrayDeclaration({
-					nodes: (node.items ?? []).map((item) => this.transform(item)).filter(Boolean),
-					arrayType: this.options.arrayType
-				}) ?? void 0;
-			},
-			tuple(node) {
-				return buildTupleNode(node, this.transform);
-			},
-			object(node) {
-				const { transform, options } = this;
-				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = node.properties.map((prop) => {
-					const baseType = transform(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)
-					});
-				});
-				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
-				if (!allElements.length) return keywordTypeNodes.object;
-				return createTypeLiteralNode(allElements);
-			}
-		},
-		print(node) {
-			let type = this.transform(node);
-			if (!type) return null;
-			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 (0, _kubb_fabric_core_parsers_typescript.safePrint)(type);
-			const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!keysToOmit?.length;
-			return (0, _kubb_fabric_core_parsers_typescript.safePrint)(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
-Object.defineProperty(exports, "ENUM_TYPES_WITH_KEY_SUFFIX", {
-	enumerable: true,
-	get: function() {
-		return ENUM_TYPES_WITH_KEY_SUFFIX;
-	}
-});
-Object.defineProperty(exports, "ENUM_TYPES_WITH_RUNTIME_VALUE", {
-	enumerable: true,
-	get: function() {
-		return ENUM_TYPES_WITH_RUNTIME_VALUE;
-	}
-});
-Object.defineProperty(exports, "ENUM_TYPES_WITH_TYPE_ONLY", {
-	enumerable: true,
-	get: function() {
-		return ENUM_TYPES_WITH_TYPE_ONLY;
-	}
-});
-Object.defineProperty(exports, "createEnumDeclaration", {
-	enumerable: true,
-	get: function() {
-		return createEnumDeclaration;
-	}
-});
-Object.defineProperty(exports, "printerTs", {
-	enumerable: true,
-	get: function() {
-		return printerTs;
-	}
-});
-Object.defineProperty(exports, "trimQuotes", {
-	enumerable: true,
-	get: function() {
-		return trimQuotes;
-	}
-});
-
-//# sourceMappingURL=printerTs-BcHudagv.cjs.map